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 wp_block post type in the database

Yes, by users with the right capabilities

Synced or not synced, chosen at creation

Theme patterns

PHP files in the active theme’s /patterns folder, or registered with register_block_pattern()

No; edit the theme (or copy the pattern into a user pattern)

Never; inserting copies the blocks

Plugin patterns

Registered by a plugin with register_block_pattern()

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/block block 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:

  1. Select the block or blocks to save. For a multi-block pattern, wrapping them in a Group first keeps the layout together.

  2. Open the block toolbar’s Options menu (three dots) and choose Create pattern.

  3. Enter a name, pick one or more categories (or type a new one) and switch Synced on or off.

  4. 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

edit_posts

Contributor and above

Create a pattern

publish_posts

Author, Editor, Administrator

Edit or delete someone else’s pattern

edit_others_posts, delete_others_posts

Editor, Administrator

Open the Patterns screen of the Site Editor (Appearance > Editor or Appearance > Patterns)

edit_theme_options

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 (core/paragraph)

content

Heading (core/heading)

content

List item (core/list-item)

content (since 7.1)

Image (core/image)

id, url, title, alt, caption

Button (core/button)

url, text, linkTarget, rel

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 editor-styles or ships a theme.json

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 with post_type = 'wp_block', the name in post_title, the block markup in post_content; post_status is publish for usable patterns. The type is not public and has no permalink.

  • wp_postmeta: the meta key wp_pattern_sync_status. It is absent for synced patterns and set to unsynced for unsynced ones. The REST schema also allows the value partial, which no current screen writes.

  • wp_terms and wp_term_taxonomy: categories of user patterns are terms of the non-hierarchical wp_pattern_category taxonomy (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
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.' );

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}." );
}
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
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/patterns endpoint and lists them with the theme’s patterns. A theme can also request specific directory patterns by slug in the patterns key of theme.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 /patterns (see Theme Patterns)

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 disableContentOnlyForUnsyncedPatterns.

A custom block’s text is not editable or not visible in List View inside a pattern

The block declares no attribute with "role": "content" in block.json; content-only mode hides it. Fix the block.

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 publish_posts. An Author or Editor must create it.

"Invalid pattern JSON file" on import

The file lacks "__file": "wp_block" or a string title/content (for example a theme pattern or a template part export).

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 ref or migrate pages and patterns together.

No directory patterns in the inserter

The server cannot reach api.wordpress.org, or should_load_remote_block_patterns returns false, or the theme removed core-block-patterns.