Patterns for Site Builders
|
This content was generated with the assistance of AI and should be verified against the official documentation before being relied on in production. This sub-section’s WordPress bibliography lists the reference material consulted while preparing these pages. |
A pattern is a saved arrangement of blocks (a heading, a paragraph and a button inside a group, say) that can be inserted
anywhere the block editor runs. Site owners use patterns so that recurring sections look the same everywhere and so that
authors fill in content instead of rebuilding layouts. This page covers patterns from the point of view of the people who
build and run a site in the admin screens: creating patterns from blocks, choosing between synced and unsynced, letting
authors override parts of a synced pattern, organising patterns into categories, moving them between sites as JSON, and
using the WordPress.org Pattern Directory. Registering patterns from a theme’s /patterns folder is a developer task
covered in Theme Patterns.
This page was written against WordPress 7.1.3 (released 2026-10-06; 7.1.4, a security release of 2026-10-28, is the version to run in production), PHP 7.4 minimum and 8.3+ recommended, MariaDB 11.8 and WP-CLI 2.12.0, and checked on 2026-10-28. The storage details, rendered output and REST responses below come from a fresh 7.1.3 site. WordPress 7.2 (in beta, planned for 2026-12-08) brings no announced change to user patterns so far.
Kinds of patterns
Every pattern in the inserter comes from one of four places, and where it comes from decides whether the site owner can edit it.
| Kind | Where it is stored | Editable in the admin? | Synced? |
|---|---|---|---|
User patterns ("My patterns") |
A post of the |
Yes, by users with the right capabilities |
Synced or not synced, chosen at creation |
Theme patterns |
PHP files in the active theme’s |
No; edit the theme (or copy the pattern into a user pattern) |
Never; inserting copies the blocks |
Plugin patterns |
Registered by a plugin with |
No |
Never |
Directory patterns |
Fetched from the WordPress.org Pattern Directory at editor load (core, featured and theme-requested patterns) |
No; copy the blocks |
Never |
Inside user patterns there are two behaviours:
-
An unsynced (also called "not synced" or "standard") pattern is a template. Inserting it copies its blocks into the post; later changes to the pattern do not affect posts that already used it.
-
A synced pattern is inserted as a single
core/blockblock that points to the pattern by ID. Its content is rendered from the pattern at every request, so editing the pattern changes every page that uses it. A footer disclaimer, an opening-hours notice or a "submissions are open" box are typical synced patterns.
Synced patterns are the old reusable blocks. WordPress 6.3 (August 2023) merged reusable blocks into patterns, added the sync choice when saving a pattern, and let users create unsynced patterns from the editor for the first time. Older books and tutorials still describe "reusable blocks" and a "Manage reusable blocks" link; both are now called patterns, and nothing was lost in the rename: existing reusable blocks became synced patterns with the same IDs. One older handbook aimed at 6.4–6.6 still uses the reusable block terminology throughout; another written for 6.3–6.4 describes patterns correctly but predates pattern overrides (6.6), the content-only editing of unsynced patterns (7.0) and the current location of the Patterns screen.
Creating a pattern in the editor
The workflow is the same in the post editor and the Site Editor:
-
Select the block or blocks to save. For a multi-block pattern, wrapping them in a Group first keeps the layout together.
-
Open the block toolbar’s Options menu (three dots) and choose Create pattern.
-
Enter a name, pick one or more categories (or type a new one) and switch Synced on or off.
-
Click Create.
For a synced pattern the selected blocks are replaced by the new core/block instance at once. For an unsynced pattern
the blocks stay as they are and the pattern is just saved for later. Both appear in the inserter: unsynced patterns under
Patterns > My patterns and in their categories, synced ones also under the Synced patterns filter. Typing / and the
pattern name in an empty paragraph inserts it as well.
A synced pattern placed on 40 pages is referenced by ID from each of those pages. To stop syncing a single use, select it and choose Detach in the toolbar: the instance is replaced by a copy of the blocks, and any override values it carried (next section) are written into the copied blocks.
Who may create and edit patterns
The wp_block post type maps its capabilities onto the post capabilities rather than defining new ones. In WordPress
7.1.3 the mapping is:
| Action | Capability required | Default roles that have it |
|---|---|---|
See patterns in raw form, insert them |
|
Contributor and above |
Create a pattern |
|
Author, Editor, Administrator |
Edit or delete someone else’s pattern |
|
Editor, Administrator |
Open the Patterns screen of the Site Editor (Appearance > Editor or Appearance > Patterns) |
|
Administrator |
The capabilities were read from the post type object as three test users:
for u in casey ana ed; do # a contributor, an author and an editor
wp eval --user=$u '$t = get_post_type_object( "wp_block" )->cap;
printf( "%-6s create=%d edit_others=%d edit_theme_options=%d\n", wp_get_current_user()->user_login,
current_user_can( $t->create_posts ), current_user_can( $t->edit_others_posts ),
current_user_can( "edit_theme_options" ) );'
done
casey create=0 edit_others=0 edit_theme_options=0
ana create=1 edit_others=0 edit_theme_options=0
ed create=1 edit_others=1 edit_theme_options=0
A Contributor can use existing patterns but not save new ones, and an Editor can change everyone’s patterns from the post editor without having access to the Site Editor. Because a synced pattern edited by one Editor changes every page that embeds it, sites with many Editors sometimes restrict pattern editing with a role plugin; see Users, Roles and Profiles.
Pattern overrides
A plain synced pattern is all or nothing: every instance shows the same text. Pattern overrides, added in WordPress 6.6, let selected blocks inside a synced pattern take different content on each page while the layout and styles stay synced. Lumen Press uses this for a "Book spotlight" pattern: the heading, the blurb and the button change per book, the group, colours and spacing do not.
To enable an override, open the synced pattern with Edit original (or from the Patterns screen), select a supported block, open Advanced in the block settings sidebar and click Enable overrides. A dialog asks for a name, which must be unique inside the pattern because it is the key that links the page’s values to the block. Disable overrides in the same place reverses it. In a page, an overridable block shows its pattern content until an author types over it; the toolbar’s Reset button returns the instance to the pattern’s content.
In WordPress 7.1.3 overrides work on these block attributes, which are the attributes core supports for block bindings:
| Block | Attributes that can be overridden |
|---|---|
Paragraph ( |
|
Heading ( |
|
List item ( |
|
Image ( |
|
Button ( |
|
Before 7.0 the list was hard-coded to core blocks. WordPress 7.0 opened overrides to any block attribute that supports
block bindings, so a plugin can make its own block overridable through the block_bindings_supported_attributes filter
(a developer topic, covered in Block Bindings API). Containers cannot be
overridden: an author cannot add a third button or a second paragraph to one instance.
How overrides are stored
Overrides are built on the Block Bindings API. Each overridable block in the pattern carries a binding named
__default to the core/pattern-overrides source plus a metadata.name. This is the Lumen Press "Book spotlight"
pattern as it is saved in post_content of its wp_block post:
<!-- wp:group {"layout":{"type":"constrained"}} -->
<div class="wp-block-group"><!-- wp:heading {"level":3,"metadata":{"bindings":{"__default":{"source":"core/pattern-overrides"}},"name":"Book title"}} -->
<h3 class="wp-block-heading">Book title</h3>
<!-- /wp:heading -->
<!-- wp:paragraph {"metadata":{"bindings":{"__default":{"source":"core/pattern-overrides"}},"name":"Blurb"}} -->
<p>A one-sentence blurb.</p>
<!-- /wp:paragraph -->
<!-- wp:buttons -->
<div class="wp-block-buttons"><!-- wp:button {"metadata":{"bindings":{"__default":{"source":"core/pattern-overrides"}},"name":"Buy link"}} -->
<div class="wp-block-button"><a class="wp-block-button__link wp-element-button" href="https://lumenpress.test/books/">Find it at your local bookshop</a></div>
<!-- /wp:button --></div>
<!-- /wp:buttons --></div>
<!-- /wp:group -->
The __default binding means "every supported attribute of this block". The page that uses the pattern stores only
the reference and the values that differ, keyed by override name and attribute, in the content attribute of the
core/block block. The "Spring list" page uses the spotlight twice and the synced "Submissions are open" pattern once
(pattern IDs 5 and 4 on the test site):
<!-- wp:block {"ref":5,"content":{"Book title":{"content":"The Glass Orchard"},"Blurb":{"content":"A botanist inherits an orchard that only fruits in winter."},"Buy link":{"url":"https://lumenpress.test/books/the-glass-orchard/","text":"Buy The Glass Orchard"}}} /-->
<!-- wp:block {"ref":5,"content":{"Book title":{"content":"Salt Roads"},"Blurb":{"content":"Three generations of a salt-trading family on the Atlantic coast."}}} /-->
<!-- wp:block {"ref":4} /-->
Rendering the page shows both mechanisms. The second spotlight overrides only the title and blurb, so its button falls back to the pattern’s link and label:
wp eval 'echo apply_filters( "the_content", get_post( 7 )->post_content );' | grep -E 'h3|href'
Source: WP-CLI: wp eval
<h3 class="wp-block-heading">The Glass Orchard</h3>
<div class="wp-block-button"><a class="wp-block-button__link wp-element-button" href="https://lumenpress.test/books/the-glass-orchard/">Buy The Glass Orchard</a></div>
<h3 class="wp-block-heading">Salt Roads</h3>
<div class="wp-block-button"><a class="wp-block-button__link wp-element-button" href="https://lumenpress.test/books/">Find it at your local bookshop</a></div>
<h3 class="wp-block-heading">Submissions are open</h3>
Two practical consequences follow. Renaming an override in the pattern orphans the values already saved under the old
name on every page (they stay in the markup but no block reads them), so choose names once. And because the values live
in the page, not the pattern, a search-and-replace on the pattern does not touch them. An earlier iteration of the feature in the
Gutenberg plugin called the page attribute overrides; the render callback still renames a legacy overrides attribute to content,
so markup saved by early Gutenberg plugin versions keeps working.
Content-only editing of patterns (7.0)
WordPress 7.0 changed what happens after an unsynced pattern is inserted. The inserted blocks keep a record of the pattern they came from, and the editor treats the whole section as one unit in content-only mode: authors can change text, links and images, but block structure, styles and layout controls are hidden and inner blocks without content are skipped in List View. To restyle or restructure the section, the author clicks Edit pattern in the toolbar or block sidebar (or double-clicks the section), which opens a spotlight mode with full editing. Template parts and synced patterns get the same treatment, except that their button reads Edit original and opens the source in an isolated editor, because a change there affects every use.
Content-only locking already existed since 6.1 as a templateLock value that theme authors could set on a container; the
7.0 change applies it by default to every inserted unsynced pattern. For site owners this is usually welcome (authors
stop breaking layouts), but it surprises teams whose Editors are expected to restyle sections freely, and it hides
content from custom blocks whose attributes do not declare a content role. A site can turn the default off for unsynced
patterns with the disableContentOnlyForUnsyncedPatterns block editor setting. As a must-use plugin:
<?php
/**
* Plugin Name: Lumen Pattern Editing
* Description: Lets Lumen Press editors restyle inserted unsynced patterns without first clicking "Edit pattern".
* Version: 0.1.0
* Requires at least: 7.0
* Requires PHP: 7.4
*/
defined( 'ABSPATH' ) || exit;
add_filter(
'block_editor_settings_all',
static function ( array $settings ): array {
$settings['disableContentOnlyForUnsyncedPatterns'] = true;
return $settings;
}
);
Saved as wp-content/mu-plugins/lumen-pattern-editing.php, it applies to every editor screen. The setting affects only
unsynced patterns; synced patterns and template parts remain sections that are edited through Edit original.
The Patterns screen
User patterns, theme patterns and template parts are managed in one screen of the Site Editor. How it is reached depends on the theme and has changed several times:
| Active theme (7.1.3) | Menu entry |
|---|---|
Block theme |
Appearance > Editor > Patterns |
Classic theme that supports |
Appearance > Design > Patterns (the Design entry, added in 6.8, also gives the Style Book) |
Any other classic theme |
Appearance > Patterns, which opens the same screen directly |
From any post editor |
Manage patterns in the Options menu of a selected synced pattern |
The history explains why older screenshots differ: until 6.4 classic themes reached patterns only through the list
table at edit.php?post_type=wp_block; 6.5 added Appearance > Patterns pointing at that list table; 6.6 pointed it at
the Site Editor’s Patterns screen; 6.8 introduced the Design entry for classic themes with editor styles or
theme.json. The old list table URL still works and is handy for bulk trash and for revisions (the wp_block post type
supports revisions).
The sidebar of the screen lists All patterns, My patterns, one entry per pattern category, and the template part areas (header, footer, general) of block themes. Each pattern card has an actions menu with Rename, Duplicate, Export as JSON and Delete for user patterns; theme patterns can only be duplicated, which creates an editable user copy. The add button at the top offers Add Pattern, Add Template Part and Import pattern from JSON. Choosing several patterns in the list view and exporting them downloads a ZIP of JSON files.
Deleting a synced pattern does not delete its uses. Pages keep the core/block reference; the editor shows "Block has
been deleted or is unavailable" in its place and the front end renders nothing. The same empty output appears when the
pattern is a draft, in the trash or password-protected, and a pattern that ends up including itself prints
[block rendering halted] when WP_DEBUG and WP_DEBUG_DISPLAY are on.
Where user patterns are stored
A user pattern is an ordinary post, so backups, migrations and WP-CLI handle it like any other content:
-
wp_posts: one row withpost_type = 'wp_block', the name inpost_title, the block markup inpost_content;post_statusispublishfor usable patterns. The type is not public and has no permalink. -
wp_postmeta: the meta keywp_pattern_sync_status. It is absent for synced patterns and set tounsyncedfor unsynced ones. The REST schema also allows the valuepartial, which no current screen writes. -
wp_termsandwp_term_taxonomy: categories of user patterns are terms of the non-hierarchicalwp_pattern_categorytaxonomy (6.3). Theme and plugin patterns use registered pattern categories instead, which are not terms; the inserter merges both lists by label.
The table layout itself is on Database Schema. The Lumen Press patterns used on this page were created with WP-CLI, which is also a quick way to seed a staging site:
wp term create wp_pattern_category "Lumen house" --slug=lumen-house --porcelain
wp post create submissions-open.html --post_type=wp_block --post_status=publish \
--post_title="Submissions are open" --porcelain
wp post create book-spotlight.html --post_type=wp_block --post_status=publish \
--post_title="Book spotlight" --porcelain
wp post create event-announcement.html --post_type=wp_block --post_status=publish \
--post_title="Event announcement" --meta_input='{"wp_pattern_sync_status":"unsynced"}' --porcelain
wp post term set 4 wp_pattern_category lumen-house
wp post term set 5 wp_pattern_category lumen-house
Each .html file holds the block markup of one pattern (the spotlight markup is shown in the previous section). Listing
them with their sync status:
wp db query "SELECT p.ID, p.post_title, m.meta_value AS sync_status
FROM wp_posts p
LEFT JOIN wp_postmeta m ON m.post_id = p.ID AND m.meta_key = 'wp_pattern_sync_status'
WHERE p.post_type = 'wp_block' ORDER BY p.ID"
wp term list wp_pattern_category --fields=term_id,name,slug,count
Source: WP-CLI: wp db query
ID post_title sync_status
4 Submissions are open NULL
5 Book spotlight NULL
6 Event announcement unsynced
term_id name slug count
2 Lumen house lumen-house 2
NULL means the meta row does not exist, that is, the pattern is synced.
Patterns over the REST API
The wp_block type is exposed at /wp/v2/blocks. Reading requires authentication with edit_posts (patterns are never
public over REST), and the controller copies the meta value into a top-level wp_pattern_sync_status field, which is an
empty string for synced patterns. With an application password (see
REST API: Using It):
curl -s -u "admin:$WP_APP_PASSWORD" \
"https://lumenpress.test/wp-json/wp/v2/blocks/6?context=edit&_fields=id,meta,wp_pattern_category,wp_pattern_sync_status"
curl -s -u "admin:$WP_APP_PASSWORD" -X POST "https://lumenpress.test/wp-json/wp/v2/blocks" \
-H "Content-Type: application/json" \
-d '{"title":"Newsletter sign-up",
"content":"<!-- wp:paragraph -->\n<p>One email a month: new books, events and calls for submissions.</p>\n<!-- /wp:paragraph -->",
"status":"publish","meta":{"wp_pattern_sync_status":"unsynced"},"wp_pattern_category":[2]}'
{"id":6,"meta":{"footnotes":""},"wp_pattern_category":[],"wp_pattern_sync_status":"unsynced"}
When _fields is used, include meta: the top-level wp_pattern_sync_status is derived from it, and a request with
_fields=id,wp_pattern_sync_status alone reports "" (synced) even for an unsynced pattern. The POST above is exactly
what the editor sends when a pattern is created or imported.
Exporting and importing patterns as JSON
The Export as JSON action downloads one file per pattern, named after the pattern title in lowercase with hyphens. The format is small and stable:
{
"__file": "wp_block",
"title": "Event announcement",
"content": "<!-- wp:group {\"layout\":{\"type\":\"constrained\"}} -->\n<div class=\"wp-block-group\"><!-- wp:heading {\"level\":3} -->\n<h3 class=\"wp-block-heading\">Launch evening</h3>\n<!-- /wp:heading -->\n\n<!-- wp:paragraph -->\n<p>Date, venue and author. Free entry; booking recommended.</p>\n<!-- /wp:paragraph --></div>\n<!-- /wp:group -->\n",
"syncStatus": "unsynced"
}
syncStatus is "unsynced" or an empty string for synced patterns. Import pattern from JSON (in the add menu of the
Patterns screen) rejects a file unless __file is wp_block and title and content are non-empty strings, then
creates a new published pattern through the REST API; it is synced unless syncStatus is "unsynced". The file does not
carry categories: the imported pattern is put in the category selected in the screen’s sidebar at the time (a theme
category is turned into a wp_pattern_category term on the fly), or in none when All patterns or My patterns is
selected. The file does not carry the pattern ID either:
an imported synced pattern gets a new ID on the target site, so pages copied from the source site still reference the
old ID and must be re-pointed (or the pages must be migrated together with the patterns by a full export, see
Importing, Exporting and Migrating).
For moving many patterns from staging to production, the same format can be produced and consumed with wp eval-file.
This exporter writes one file per published user pattern:
<?php
/**
* Exports every user pattern (wp_block post) to one JSON file per pattern, in the
* format of the Site Editor's "Export as JSON" action.
* Usage: wp eval-file export-patterns.php <target-directory>
*/
$target = isset( $args[0] ) ? rtrim( $args[0], '/' ) : 'patterns-export';
if ( ! is_dir( $target ) && ! mkdir( $target, 0755, true ) ) {
WP_CLI::error( "Cannot create {$target}." );
}
$patterns = get_posts(
array(
'post_type' => 'wp_block',
'post_status' => 'publish',
'numberposts' => -1,
'orderby' => 'ID',
'order' => 'ASC',
)
);
foreach ( $patterns as $pattern ) {
$data = array(
'__file' => 'wp_block',
'title' => $pattern->post_title,
'content' => $pattern->post_content,
'syncStatus' => (string) get_post_meta( $pattern->ID, 'wp_pattern_sync_status', true ),
);
$file = $target . '/' . sanitize_title( $pattern->post_title ) . '.json';
file_put_contents( $file, wp_json_encode( $data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES ) . "\n" );
WP_CLI::log( "Exported {$pattern->ID} to {$file}" );
}
WP_CLI::success( count( $patterns ) . ' pattern(s) exported.' );
Source: WP-CLI: wp eval-file
The importer applies the same checks as the editor and uses wp_slash() because wp_insert_post() expects slashed
data; without it, the backslashes in the JSON-encoded block attributes would be stripped and the bindings lost:
<?php
/**
* Imports pattern JSON files exported by the Site Editor (or export-patterns.php),
* applying the same checks as the editor's "Import from JSON".
* Usage: wp eval-file import-pattern.php <file.json> [<file.json>...]
*/
foreach ( $args as $file ) {
$data = json_decode( (string) file_get_contents( $file ), true );
if ( ! is_array( $data ) || 'wp_block' !== ( $data['__file'] ?? '' )
|| empty( $data['title'] ) || ! is_string( $data['title'] )
|| empty( $data['content'] ) || ! is_string( $data['content'] ) ) {
WP_CLI::warning( "{$file}: invalid pattern JSON file, skipped." );
continue;
}
$post_id = wp_insert_post(
array(
'post_type' => 'wp_block',
'post_status' => 'publish',
'post_title' => $data['title'],
'post_content' => wp_slash( $data['content'] ),
),
true
);
if ( is_wp_error( $post_id ) ) {
WP_CLI::warning( "{$file}: " . $post_id->get_error_message() );
continue;
}
if ( 'unsynced' === ( $data['syncStatus'] ?? '' ) ) {
update_post_meta( $post_id, 'wp_pattern_sync_status', 'unsynced' );
}
WP_CLI::log( "Imported {$file} as pattern {$post_id}." );
}
Source: Code Reference: wp_insert_post()
wp eval-file export-patterns.php lumen-patterns
wp eval-file import-pattern.php lumen-patterns/book-spotlight.json lumen-patterns/event-announcement.json bad.json
Source: WP-CLI: wp eval-file
Exported 4 to lumen-patterns/submissions-are-open.json
Exported 5 to lumen-patterns/book-spotlight.json
Exported 6 to lumen-patterns/event-announcement.json
Success: 3 pattern(s) exported.
Imported lumen-patterns/book-spotlight.json as pattern 9.
Imported lumen-patterns/event-announcement.json as pattern 10.
Warning: bad.json: invalid pattern JSON file, skipped.
Importing into the same site creates copies with new IDs and slugs (book-spotlight-2); WordPress does not de-duplicate
patterns by title. Arguments to wp eval-file are positional only: an unknown --flag makes WP-CLI stop with
"unknown --flag parameter", so categories are assigned afterwards with wp post term set.
Categorising patterns
User pattern categories are created in the Create pattern dialog, in a pattern’s details panel, or with
wp term create wp_pattern_category. There is no separate admin screen for them, so renaming or deleting a category
is done with wp term update and wp term delete. Uncategorised user patterns appear only under My patterns
and All patterns.
Theme and plugin pattern categories (Banners, Call to action, Text, Gallery and the rest) are registered in code and cannot be renamed in the admin. Lumen Press keeps its own house patterns in one Lumen house user category so that authors find them before the many theme and directory patterns.
The Pattern Directory
wordpress.org/patterns is the public directory of patterns built only from core blocks. A site uses it in three ways:
-
Copying: on the directory, Copy puts the block markup on the clipboard; pasting into the editor inserts the blocks as an unsynced copy. Images in directory patterns are loaded from external servers, so replace them or upload them to the Media Library (the editor offers "Upload external image" on such images and in the pre-publish check).
-
In the inserter: on every editor load WordPress fetches the "core" and "featured" directory patterns through the
/wp/v2/pattern-directory/patternsendpoint and lists them with the theme’s patterns. A theme can also request specific directory patterns by slug in thepatternskey oftheme.json. -
Submitting: a WordPress.org account can submit patterns, which are moderated before they appear.
The remote requests need outbound HTTPS from the server. On hosts that block it, or where only house patterns should be
offered, the should_load_remote_block_patterns filter (return false) switches all three remote sources off; theme
code can also drop core’s own bundled patterns with remove_theme_support( 'core-block-patterns' ). Both are one-line
changes in a must-use plugin or theme, described for developers in Theme Patterns.
Choosing synced, unsynced or a theme pattern
| Need | Use |
|---|---|
The same content everywhere, changed in one place (legal notice, submissions box, opening hours) |
Synced pattern |
The same layout with different content per page, layout changed in one place |
Synced pattern with overrides |
A starting point that authors adapt freely |
Unsynced pattern |
A layout that must ship with the theme, be translated or live in version control |
Theme pattern in |
A header, footer or other area of every template |
Template part (see Templates and Template Parts) |
Data from post meta, such as a book’s ISBN |
Block bindings to the meta field, not a pattern (see Block Bindings API) |
User patterns live only in the database, so they are not in Git and do not travel with a theme. A team that wants review and history for its patterns can turn the best ones into theme patterns with Create Block Theme (see Create Block Theme and Version Control).
Common errors and pitfalls
| Symptom | Cause and fix |
|---|---|
"Block has been deleted or is unavailable" in the editor, nothing on the front end |
The synced pattern was deleted, trashed, unpublished or password-protected, or the page was copied from another site where the pattern had a different ID. Restore the pattern, or select the block and replace it. |
Editing a pattern changed pages nobody meant to touch |
It is synced. Detach the instances that should differ, or convert the varying parts to overrides. |
An author cannot change colours or add blocks inside an inserted pattern (7.0 and later) |
Content-only editing of unsynced patterns. Click Edit pattern, or opt out with |
A custom block’s text is not editable or not visible in List View inside a pattern |
The block declares no attribute with |
Override values vanished after editing the pattern |
An override was renamed or disabled. Values are keyed by name; restore the old name. |
A Contributor has no Create pattern item |
Creating patterns requires |
"Invalid pattern JSON file" on import |
The file lacks |
Imported synced pattern does not update existing pages on the target site |
The pages still reference the source site’s pattern ID. Re-point the |
No directory patterns in the inserter |
The server cannot reach api.wordpress.org, or |