From 1a04ac94d807521f6fb496ce00860ea02a2f4441 Mon Sep 17 00:00:00 2001
From: James Koster <james@jameskoster.co.uk>
Date: Fri, 29 May 2026 09:23:10 +0100
Subject: [PATCH 01/60] Dashboard: Use Howdy greeting for page title (#78740)

Co-authored-by: jameskoster <jameskoster@git.wordpress.org>
Co-authored-by: simison <simison@git.wordpress.org>
Co-authored-by: retrofox <retrofox@git.wordpress.org>
---
 routes/dashboard/stage.tsx | 36 ++++++++++++++++++++++++++++++++----
 1 file changed, 32 insertions(+), 4 deletions(-)

diff --git a/routes/dashboard/stage.tsx b/routes/dashboard/stage.tsx
index e08834a556e1fb..d18272d6105e45 100644
--- a/routes/dashboard/stage.tsx
+++ b/routes/dashboard/stage.tsx
@@ -2,9 +2,10 @@
  * WordPress dependencies
  */
 import { Page } from '@wordpress/admin-ui';
+import { store as coreStore } from '@wordpress/core-data';
 import { useDispatch, useSelect } from '@wordpress/data';
 import { useState } from '@wordpress/element';
-import { __ } from '@wordpress/i18n';
+import { __, sprintf } from '@wordpress/i18n';
 import { store as noticesStore } from '@wordpress/notices';
 import { store as viewportStore } from '@wordpress/viewport';
 
@@ -34,8 +35,26 @@ function Dashboard() {
 		[]
 	);
 
-	const customizeDashboardLabel = __( 'Customize Dashboard' );
-	const dashboardLabel = __( 'Dashboard' );
+	const greetingName = useSelect( ( select ) => {
+		const user = select( coreStore ).getCurrentUser();
+		if ( ! user ) {
+			return undefined;
+		}
+
+		const displayName = user.name?.trim();
+		if ( displayName ) {
+			return displayName;
+		}
+
+		if ( 'username' in user && typeof user.username === 'string' ) {
+			const username = user.username.trim();
+			if ( username ) {
+				return username;
+			}
+		}
+
+		return user.slug;
+	}, [] );
 
 	const { createSuccessNotice } = useDispatch( noticesStore );
 
@@ -46,7 +65,16 @@ function Dashboard() {
 		} );
 	};
 
-	const pageTitle = editMode ? customizeDashboardLabel : dashboardLabel;
+	let pageTitle: string = __( 'Dashboard' );
+	if ( editMode ) {
+		pageTitle = __( 'Customize Dashboard' );
+	} else if ( greetingName ) {
+		pageTitle = sprintf(
+			/* translators: %s: current user's display name. */
+			__( 'Howdy, %s' ),
+			greetingName
+		);
+	}
 
 	return (
 		<WidgetDashboard

From 47326be7d961b3dfd14202d816385afec4ae405e Mon Sep 17 00:00:00 2001
From: George Mamadashvili <georgemamadashvili@gmail.com>
Date: Fri, 29 May 2026 10:42:37 +0200
Subject: [PATCH 02/60] Block Editor: Refactor Inserter to a function component
 (#78766)

Co-authored-by: Mamaduka <mamaduka@git.wordpress.org>
Co-authored-by: andrewserong <andrewserong@git.wordpress.org>
Co-authored-by: jsnajdr <jsnajdr@git.wordpress.org>
---
 .../src/components/inserter/index.js          | 506 ++++++++----------
 1 file changed, 224 insertions(+), 282 deletions(-)

diff --git a/packages/block-editor/src/components/inserter/index.js b/packages/block-editor/src/components/inserter/index.js
index ab1b18cdaf2513..64ad560ae834b9 100644
--- a/packages/block-editor/src/components/inserter/index.js
+++ b/packages/block-editor/src/components/inserter/index.js
@@ -9,9 +9,7 @@ import clsx from 'clsx';
 import { speak } from '@wordpress/a11y';
 import { __, _x, sprintf } from '@wordpress/i18n';
 import { Dropdown, Button } from '@wordpress/components';
-import { Component } from '@wordpress/element';
-import { withDispatch, withSelect } from '@wordpress/data';
-import { compose, ifCondition } from '@wordpress/compose';
+import { useDispatch, useRegistry, useSelect } from '@wordpress/data';
 import { createBlock, store as blocksStore } from '@wordpress/blocks';
 import { plus } from '@wordpress/icons';
 
@@ -23,7 +21,7 @@ import QuickInserter from './quick-inserter';
 import { store as blockEditorStore } from '../../store';
 import { getAppenderLabel } from './get-appender-label';
 
-const defaultRenderToggle = ( {
+function InserterToggle( {
 	onToggle,
 	disabled,
 	isOpen,
@@ -31,7 +29,8 @@ const defaultRenderToggle = ( {
 	hasSingleBlockType,
 	appenderLabel,
 	toggleProps = {},
-} ) => {
+	ref,
+} ) {
 	const {
 		as: Wrapper = Button,
 		label: labelProp,
@@ -65,6 +64,7 @@ const defaultRenderToggle = ( {
 
 	return (
 		<Wrapper
+			ref={ ref }
 			__next40pxDefaultSize={ toggleProps.as ? undefined : true }
 			icon={ plus }
 			label={ label }
@@ -78,80 +78,220 @@ const defaultRenderToggle = ( {
 			{ ...rest }
 		/>
 	);
-};
+}
+
+function Inserter( {
+	clientId,
+	rootClientId,
+	disabled,
+	isAppender,
+	position,
+	selectBlockOnInsert,
+	shouldDirectInsert = true,
+	showInserterHelpPanel,
+	// This prop is experimental to give some time for the quick inserter to mature
+	// Feel free to make them stable after a few releases.
+	__experimentalIsQuick: isQuick,
+	onSelectOrClose,
+	onToggle,
+	renderToggle: renderToggleProp,
+	toggleProps,
+	ref,
+} ) {
+	const {
+		hasItems,
+		hasSingleBlockType,
+		blockTitle,
+		allowedBlockType,
+		blockToInsert,
+		appenderLabel,
+		targetRootClientId,
+	} = useSelect(
+		( select ) => {
+			const {
+				getBlockRootClientId,
+				hasInserterItems,
+				getAllowedBlocks,
+				getDirectInsertBlock,
+				getBlockListSettings,
+			} = select( blockEditorStore );
+			const { getBlockVariations, getBlockType } = select( blocksStore );
+
+			const _targetRootClientId =
+				rootClientId || getBlockRootClientId( clientId ) || undefined;
+
+			const allowedBlocks = getAllowedBlocks( _targetRootClientId );
+			const directInsertBlock =
+				shouldDirectInsert &&
+				getDirectInsertBlock( _targetRootClientId );
+			const { defaultBlock } =
+				getBlockListSettings( _targetRootClientId ) ?? {};
+
+			const _hasSingleBlockType =
+				allowedBlocks?.length === 1 &&
+				getBlockVariations( allowedBlocks[ 0 ].name, 'inserter' )
+					?.length === 0;
+			const _allowedBlockType = _hasSingleBlockType
+				? allowedBlocks[ 0 ]
+				: null;
+
+			// Single-block-type parents get adjacent-attribute copying
+			// without needing to set `directInsert: true`.
+			let _blockToInsert = directInsertBlock || null;
+			if (
+				! _blockToInsert &&
+				_hasSingleBlockType &&
+				defaultBlock?.name === _allowedBlockType.name
+			) {
+				_blockToInsert = defaultBlock;
+			}
+
+			const defaultBlockType = directInsertBlock
+				? getBlockType( directInsertBlock.name )
+				: null;
+
+			return {
+				hasItems: hasInserterItems( _targetRootClientId ),
+				hasSingleBlockType: _hasSingleBlockType,
+				blockTitle: _allowedBlockType ? _allowedBlockType.title : '',
+				allowedBlockType: _allowedBlockType,
+				blockToInsert: _blockToInsert,
+				appenderLabel: getAppenderLabel(
+					directInsertBlock,
+					defaultBlockType
+				),
+				targetRootClientId: _targetRootClientId,
+			};
+		},
+		[ rootClientId, clientId, shouldDirectInsert ]
+	);
 
-class Inserter extends Component {
-	constructor() {
-		super( ...arguments );
+	const registry = useRegistry();
+	const { insertBlock } = useDispatch( blockEditorStore );
 
-		this.onToggle = this.onToggle.bind( this );
-		this.renderToggle = this.renderToggle.bind( this );
-		this.renderContent = this.renderContent.bind( this );
+	// The global inserter (no isAppender, no rootClientId, no clientId) should
+	// always render, even with no items.
+	if ( ! hasItems && ( isAppender || targetRootClientId || clientId ) ) {
+		return null;
 	}
 
-	onToggle( isOpen ) {
-		const { onToggle } = this.props;
+	function insertOnlyAllowedBlock() {
+		const blockName = blockToInsert?.name ?? allowedBlockType.name;
 
-		// Surface toggle callback to parent component.
-		if ( onToggle ) {
-			onToggle( isOpen );
+		function getAdjacentBlockAttributes( attributesToCopy ) {
+			if ( ! attributesToCopy?.length ) {
+				return {};
+			}
+
+			const { getBlock, getPreviousBlockClientId } =
+				registry.select( blockEditorStore );
+
+			// Find the adjacent block of the same type whose attributes
+			// should be copied: previous sibling when inserting next to
+			// an existing block, otherwise the last child of the root.
+			let adjacentAttributes;
+			if ( clientId ) {
+				const currentBlock = getBlock( clientId );
+				const previousBlock = getBlock(
+					getPreviousBlockClientId( clientId )
+				);
+				if ( currentBlock?.name === previousBlock?.name ) {
+					adjacentAttributes = previousBlock?.attributes;
+				}
+			} else if ( targetRootClientId ) {
+				const lastInnerBlock =
+					getBlock( targetRootClientId )?.innerBlocks?.at( -1 );
+				if ( lastInnerBlock?.name === blockName ) {
+					adjacentAttributes = lastInnerBlock.attributes;
+				}
+			}
+
+			if ( ! adjacentAttributes ) {
+				return {};
+			}
+
+			return Object.fromEntries(
+				attributesToCopy
+					.filter( ( attr ) => attr in adjacentAttributes )
+					.map( ( attr ) => [ attr, adjacentAttributes[ attr ] ] )
+			);
 		}
-	}
 
-	/**
-	 * Render callback to display Dropdown toggle element.
-	 *
-	 * @param {Object}   options
-	 * @param {Function} options.onToggle Callback to invoke when toggle is
-	 *                                    pressed.
-	 * @param {boolean}  options.isOpen   Whether dropdown is currently open.
-	 *
-	 * @return {Element} Dropdown toggle element.
-	 */
-	renderToggle( { onToggle, isOpen } ) {
-		const {
-			disabled,
-			blockTitle,
-			hasSingleBlockType,
-			appenderLabel,
-			toggleProps,
-			hasItems,
-			renderToggle = defaultRenderToggle,
-		} = this.props;
+		function getInsertionIndex() {
+			const {
+				getBlockIndex,
+				getBlockSelectionEnd,
+				getBlockOrder,
+				getBlockRootClientId,
+			} = registry.select( blockEditorStore );
+
+			// If the clientId is defined, we insert at the position of the block.
+			if ( clientId ) {
+				return getBlockIndex( clientId );
+			}
+
+			// If there a selected block, we insert after the selected block.
+			const end = getBlockSelectionEnd();
+			if (
+				! isAppender &&
+				end &&
+				getBlockRootClientId( end ) === targetRootClientId
+			) {
+				return getBlockIndex( end ) + 1;
+			}
+
+			// Otherwise, we insert at the end of the current rootClientId.
+			return getBlockOrder( targetRootClientId ).length;
+		}
+
+		// Attempt to augment the inserted block with attributes from an adjacent block.
+		// This ensures styling from nearby blocks is preserved in the newly inserted block.
+		// See: https://github.com/WordPress/gutenberg/issues/37904
+		const newAttributes = getAdjacentBlockAttributes(
+			blockToInsert?.attributesToCopy
+		);
+
+		const newBlock = createBlock( blockName, {
+			...blockToInsert?.attributes,
+			...newAttributes,
+		} );
+
+		insertBlock(
+			newBlock,
+			getInsertionIndex(),
+			targetRootClientId,
+			selectBlockOnInsert
+		);
+
+		onSelectOrClose?.( newBlock );
 
-		return renderToggle( {
-			onToggle,
+		const message = sprintf(
+			// translators: %s: the name of the block that has been added
+			__( '%s block added' ),
+			allowedBlockType.title
+		);
+		speak( message );
+	}
+
+	function renderToggle( { onToggle: dropdownOnToggle, isOpen } ) {
+		const toggleArgs = {
+			onToggle: dropdownOnToggle,
 			isOpen,
 			disabled: disabled || ! hasItems,
 			blockTitle,
 			hasSingleBlockType,
 			appenderLabel,
 			toggleProps,
-		} );
-	}
+		};
+
+		if ( renderToggleProp ) {
+			return renderToggleProp( toggleArgs );
+		}
 
-	/**
-	 * Render callback to display Dropdown content element.
-	 *
-	 * @param {Object}   options
-	 * @param {Function} options.onClose Callback to invoke when dropdown is
-	 *                                   closed.
-	 *
-	 * @return {Element} Dropdown content element.
-	 */
-	renderContent( { onClose } ) {
-		const {
-			rootClientId,
-			clientId,
-			isAppender,
-			showInserterHelpPanel,
-			// This prop is experimental to give some time for the quick inserter to mature
-			// Feel free to make them stable after a few releases.
-			__experimentalIsQuick: isQuick,
-			onSelectOrClose,
-			selectBlockOnInsert,
-		} = this.props;
+		return <InserterToggle ref={ ref } { ...toggleArgs } />;
+	}
 
+	function renderContent( { onClose } ) {
 		if ( isQuick ) {
 			return (
 				<QuickInserter
@@ -168,7 +308,7 @@ class Inserter extends Component {
 						}
 						onClose();
 					} }
-					rootClientId={ rootClientId }
+					rootClientId={ targetRootClientId }
 					clientId={ clientId }
 					isAppender={ isAppender }
 					selectBlockOnInsert={ selectBlockOnInsert }
@@ -182,7 +322,7 @@ class Inserter extends Component {
 					onClose();
 				} }
 				onClose={ onClose }
-				rootClientId={ rootClientId }
+				rootClientId={ targetRootClientId }
 				clientId={ clientId }
 				isAppender={ isAppender }
 				showInserterHelpPanel={ showInserterHelpPanel }
@@ -190,223 +330,25 @@ class Inserter extends Component {
 		);
 	}
 
-	render() {
-		const {
-			position,
-			hasSingleBlockType,
-			blockToInsert,
-			insertOnlyAllowedBlock,
-			__experimentalIsQuick: isQuick,
-			onSelectOrClose,
-		} = this.props;
-
-		if ( hasSingleBlockType || blockToInsert ) {
-			return this.renderToggle( { onToggle: insertOnlyAllowedBlock } );
-		}
-
-		return (
-			<Dropdown
-				className="block-editor-inserter"
-				contentClassName={ clsx( 'block-editor-inserter__popover', {
-					'is-quick': isQuick,
-				} ) }
-				popoverProps={ { position, shift: true } }
-				onToggle={ this.onToggle }
-				expandOnMobile
-				headerTitle={ __( 'Add a block' ) }
-				renderToggle={ this.renderToggle }
-				renderContent={ this.renderContent }
-				onClose={ onSelectOrClose }
-			/>
-		);
+	if ( hasSingleBlockType || blockToInsert ) {
+		return renderToggle( { onToggle: insertOnlyAllowedBlock } );
 	}
-}
-
-export default compose( [
-	withSelect(
-		( select, { clientId, rootClientId, shouldDirectInsert = true } ) => {
-			const {
-				getBlockRootClientId,
-				hasInserterItems,
-				getAllowedBlocks,
-				getDirectInsertBlock,
-				getBlockListSettings,
-			} = select( blockEditorStore );
-			const { getBlockVariations, getBlockType } = select( blocksStore );
-
-			rootClientId =
-				rootClientId || getBlockRootClientId( clientId ) || undefined;
-
-			const allowedBlocks = getAllowedBlocks( rootClientId );
-			const directInsertBlock =
-				shouldDirectInsert && getDirectInsertBlock( rootClientId );
-			const { defaultBlock } = getBlockListSettings( rootClientId ) ?? {};
-
-			const hasSingleBlockType =
-				allowedBlocks?.length === 1 &&
-				getBlockVariations( allowedBlocks[ 0 ].name, 'inserter' )
-					?.length === 0;
-			const allowedBlockType = hasSingleBlockType
-				? allowedBlocks[ 0 ]
-				: null;
 
-			// Single-block-type parents get adjacent-attribute copying
-			// without needing to set `directInsert: true`.
-			let blockToInsert = directInsertBlock || null;
-			if (
-				! blockToInsert &&
-				hasSingleBlockType &&
-				defaultBlock?.name === allowedBlockType.name
-			) {
-				blockToInsert = defaultBlock;
-			}
-
-			const defaultBlockType = directInsertBlock
-				? getBlockType( directInsertBlock.name )
-				: null;
-			const appenderLabel = getAppenderLabel(
-				directInsertBlock,
-				defaultBlockType
-			);
-
-			return {
-				hasItems: hasInserterItems( rootClientId ),
-				hasSingleBlockType,
-				blockTitle: allowedBlockType ? allowedBlockType.title : '',
-				allowedBlockType,
-				blockToInsert,
-				appenderLabel,
-				rootClientId,
-			};
-		}
-	),
-	withDispatch( ( dispatch, ownProps, { select } ) => {
-		return {
-			insertOnlyAllowedBlock() {
-				const {
-					rootClientId,
-					clientId,
-					isAppender,
-					hasSingleBlockType,
-					allowedBlockType,
-					blockToInsert,
-					onSelectOrClose,
-					selectBlockOnInsert,
-				} = ownProps;
-
-				if ( ! hasSingleBlockType && ! blockToInsert ) {
-					return;
-				}
-
-				const blockName = blockToInsert?.name ?? allowedBlockType.name;
-
-				function getAdjacentBlockAttributes( attributesToCopy ) {
-					if ( ! attributesToCopy?.length ) {
-						return {};
-					}
-
-					const { getBlock, getPreviousBlockClientId } =
-						select( blockEditorStore );
-
-					// Find the adjacent block of the same type whose attributes
-					// should be copied: previous sibling when inserting next to
-					// an existing block, otherwise the last child of the root.
-					let adjacentAttributes;
-					if ( clientId ) {
-						const currentBlock = getBlock( clientId );
-						const previousBlock = getBlock(
-							getPreviousBlockClientId( clientId )
-						);
-						if ( currentBlock?.name === previousBlock?.name ) {
-							adjacentAttributes = previousBlock?.attributes;
-						}
-					} else if ( rootClientId ) {
-						const lastInnerBlock =
-							getBlock( rootClientId )?.innerBlocks?.at( -1 );
-						if ( lastInnerBlock?.name === blockName ) {
-							adjacentAttributes = lastInnerBlock.attributes;
-						}
-					}
-
-					if ( ! adjacentAttributes ) {
-						return {};
-					}
-
-					return Object.fromEntries(
-						attributesToCopy
-							.filter( ( attr ) => attr in adjacentAttributes )
-							.map( ( attr ) => [
-								attr,
-								adjacentAttributes[ attr ],
-							] )
-					);
-				}
-
-				function getInsertionIndex() {
-					const {
-						getBlockIndex,
-						getBlockSelectionEnd,
-						getBlockOrder,
-						getBlockRootClientId,
-					} = select( blockEditorStore );
-
-					// If the clientId is defined, we insert at the position of the block.
-					if ( clientId ) {
-						return getBlockIndex( clientId );
-					}
-
-					// If there a selected block, we insert after the selected block.
-					const end = getBlockSelectionEnd();
-					if (
-						! isAppender &&
-						end &&
-						getBlockRootClientId( end ) === rootClientId
-					) {
-						return getBlockIndex( end ) + 1;
-					}
-
-					// Otherwise, we insert at the end of the current rootClientId.
-					return getBlockOrder( rootClientId ).length;
-				}
-
-				const { insertBlock } = dispatch( blockEditorStore );
-
-				// Attempt to augment the inserted block with attributes from an adjacent block.
-				// This ensures styling from nearby blocks is preserved in the newly inserted block.
-				// See: https://github.com/WordPress/gutenberg/issues/37904
-				const newAttributes = getAdjacentBlockAttributes(
-					blockToInsert?.attributesToCopy
-				);
-
-				const newBlock = createBlock( blockName, {
-					...( blockToInsert?.attributes || {} ),
-					...newAttributes,
-				} );
-
-				insertBlock(
-					newBlock,
-					getInsertionIndex(),
-					rootClientId,
-					selectBlockOnInsert
-				);
-
-				if ( onSelectOrClose ) {
-					onSelectOrClose( newBlock );
-				}
+	return (
+		<Dropdown
+			className="block-editor-inserter"
+			contentClassName={ clsx( 'block-editor-inserter__popover', {
+				'is-quick': isQuick,
+			} ) }
+			popoverProps={ { position, shift: true } }
+			onToggle={ onToggle }
+			expandOnMobile
+			headerTitle={ __( 'Add a block' ) }
+			renderToggle={ renderToggle }
+			renderContent={ renderContent }
+			onClose={ onSelectOrClose }
+		/>
+	);
+}
 
-				const message = sprintf(
-					// translators: %s: the name of the block that has been added
-					__( '%s block added' ),
-					allowedBlockType.title
-				);
-				speak( message );
-			},
-		};
-	} ),
-	// The global inserter should always be visible, we are using ( ! isAppender && ! rootClientId && ! clientId ) as
-	// a way to detect the global Inserter.
-	ifCondition(
-		( { hasItems, isAppender, rootClientId, clientId } ) =>
-			hasItems || ( ! isAppender && ! rootClientId && ! clientId )
-	),
-] )( Inserter );
+export default Inserter;

From 1dae94dbf5ed1baca3084fc2359765bc3adef1a4 Mon Sep 17 00:00:00 2001
From: James Koster <james@jameskoster.co.uk>
Date: Fri, 29 May 2026 12:32:07 +0100
Subject: [PATCH 03/60] Dashboard: Move layout settings to customize toolbar
 (#78738)

Co-authored-by: jameskoster <jameskoster@git.wordpress.org>
Co-authored-by: simison <simison@git.wordpress.org>
Co-authored-by: retrofox <retrofox@git.wordpress.org>
---
 routes/dashboard/widget-dashboard/README.md   |  2 +-
 .../components/actions/actions.tsx            | 50 +++++++-----
 .../layout-settings/layout-settings.tsx       | 24 +++---
 .../context/dashboard-context.tsx             | 34 ++++----
 .../widget-dashboard/context/ui-context.tsx   |  5 +-
 .../widget-dashboard/test/actions.test.tsx    | 80 ++++++++++++++++++-
 .../widget-dashboard/test/staging.test.tsx    | 44 +++++++++-
 routes/dashboard/widget-dashboard/types.ts    |  2 +-
 8 files changed, 183 insertions(+), 58 deletions(-)

diff --git a/routes/dashboard/widget-dashboard/README.md b/routes/dashboard/widget-dashboard/README.md
index 0de985219a6e9d..8ef714a3cf143c 100644
--- a/routes/dashboard/widget-dashboard/README.md
+++ b/routes/dashboard/widget-dashboard/README.md
@@ -88,7 +88,7 @@ Renders its children only when `layout` is empty. Pair it with `<WidgetDashboard
 
 #### `<WidgetDashboard.Actions />`
 
-Edit-mode toggle: a "Customize" button while `editMode` is off, and "Add widget", "Cancel", "Done" while it is on. Clicking "Customize" or "Done" fires `onEditChange` with the toggled value. Clicking "Add widget" opens the inserter (see below). Returns `null` when the dashboard is mounted without `onEditChange`, so hosts that don't expose edit mode can keep `Actions` in their tree unconditionally.
+Edit-mode toggle: a "Customize" button while `editMode` is off, and "Add widget", "Layout settings" (when `onGridSettingsChange` is provided), "Cancel", "Done" while it is on. Layout settings is only available in customize mode. Clicking "Customize" or "Done" fires `onEditChange` with the toggled value. Clicking "Add widget" opens the inserter (see below). Returns `null` when the dashboard is mounted without `onEditChange`, so surfaces that don't expose edit mode can keep `Actions` in their tree unconditionally.
 
 `<Page>` from `@wordpress/admin-ui` exposes an `actions` slot used across admin screens (DataViews, WidgetDashboard, …). Plug `Actions` straight into it:
 
diff --git a/routes/dashboard/widget-dashboard/components/actions/actions.tsx b/routes/dashboard/widget-dashboard/components/actions/actions.tsx
index f8f1acc5a0df6c..5a6df5c9fecf7f 100644
--- a/routes/dashboard/widget-dashboard/components/actions/actions.tsx
+++ b/routes/dashboard/widget-dashboard/components/actions/actions.tsx
@@ -4,7 +4,7 @@
 import { useSelect } from '@wordpress/data';
 import { useCallback, useEffect, useState } from '@wordpress/element';
 import { __ } from '@wordpress/i18n';
-import { plus } from '@wordpress/icons';
+import { layout as layoutIcon, plus } from '@wordpress/icons';
 import { store as viewportStore } from '@wordpress/viewport';
 // eslint-disable-next-line @wordpress/use-recommended-components
 import { AlertDialog, Button, Stack } from '@wordpress/ui';
@@ -20,18 +20,13 @@ import { MoreActionsDropdown } from '../more-actions-dropdown';
 import type { MoreActionsDropdownItem } from '../more-actions-dropdown';
 
 /**
- * Header chrome for the dashboard. Two independent flows are exposed:
- *
- * - **Customize** (layout edits): toggles edit mode, surfaces the Add
- *   widgets / Cancel / Done toolbar. Commits the layout staging buffer
- *   on Done.
- * - **Layout settings** (more-actions dropdown entry): opens a side
- *   drawer with model, column behavior, and row height. Commits the
- *   settings staging buffer on Save inside the drawer.
- *
- * The two flows are mutually exclusive: the Layout settings entry is
- * disabled while edit mode is on so the settings drawer cannot
- * accumulate changes on top of pending layout edits, and vice versa.
+ * Header chrome for the dashboard. Customize mode surfaces an edit
+ * toolbar with Add widget, Layout settings (when grid settings are
+ * editable), Cancel, and Done. Layout settings opens a side drawer
+ * for model, column behavior, and row height; Save inside the drawer
+ * commits the settings staging buffer without leaving customize mode.
+ * Widget layout edits and grid settings share the same staging layer
+ * while customize mode is active.
  *
  * Returns `null` when the dashboard is mounted without `onEditChange`
  * so hosts that don't expose edit mode can keep `Actions` in their
@@ -108,6 +103,12 @@ export function Actions(): React.ReactNode {
 		setLayoutSettingsOpen( true );
 	}, [ setLayoutSettingsOpen ] );
 
+	useEffect( () => {
+		if ( ! editMode && layoutSettingsOpen ) {
+			setLayoutSettingsOpen( false );
+		}
+	}, [ editMode, layoutSettingsOpen, setLayoutSettingsOpen ] );
+
 	const moreActionsItems: MoreActionsDropdownItem[] = [
 		{
 			label: __( 'Reset to default' ),
@@ -116,15 +117,6 @@ export function Actions(): React.ReactNode {
 		},
 	];
 
-	if ( canEditGridSettings ) {
-		moreActionsItems.unshift( {
-			label: __( 'Layout settings' ),
-			onClick: openLayoutSettings,
-			disabled: editMode,
-			disabledTooltip: __( 'Disabled while editing widgets' ),
-		} );
-	}
-
 	if ( ! onEditChange ) {
 		return null;
 	}
@@ -151,6 +143,20 @@ export function Actions(): React.ReactNode {
 						{ __( 'Add widget' ) }
 					</Button>
 
+					{ canEditGridSettings && (
+						<Button
+							variant="minimal"
+							tone="brand"
+							size="compact"
+							onClick={ openLayoutSettings }
+						>
+							{ ! isMobileViewport && (
+								<Button.Icon icon={ layoutIcon } />
+							) }
+							{ __( 'Layout settings' ) }
+						</Button>
+					) }
+
 					<div
 						className={ styles.editActionsDivider }
 						aria-hidden="true"
diff --git a/routes/dashboard/widget-dashboard/components/layout-settings/layout-settings.tsx b/routes/dashboard/widget-dashboard/components/layout-settings/layout-settings.tsx
index bf99a05f67246a..bd71e54cb20a96 100644
--- a/routes/dashboard/widget-dashboard/components/layout-settings/layout-settings.tsx
+++ b/routes/dashboard/widget-dashboard/components/layout-settings/layout-settings.tsx
@@ -195,11 +195,11 @@ interface LayoutSettingsProps {
 }
 
 /**
- * Non-modal side drawer for grid-level settings (model, column
- * behavior, row height). Reads from and writes to the staging copy
- * in `useDashboardInternalContext`, so every edit shows up live
- * behind the drawer and is committed or rolled back by the drawer's
- * Save / Cancel buttons.
+ * Modal side drawer for grid-level settings (model, column behavior,
+ * row height). Reads from and writes to the staging copy in
+ * `useDashboardInternalContext`; edits preview through the backdrop
+ * and are committed or rolled back by the drawer's Save / Cancel
+ * buttons.
  *
  * Gap is intentionally absent: the spacing between tiles is a
  * design-system concern (theme / density / viewport tokens) and
@@ -211,11 +211,9 @@ interface LayoutSettingsProps {
  * an Escape press, or any path other than the explicit Cancel/Save
  * buttons is treated as Cancel. None of these exit customize mode.
  *
- * Settings and layout-editing are kept as separate flows on the
- * dashboard (the Layout settings entry that opens this drawer is
- * disabled while edit mode is on), so the drawer's commit never
- * publishes layout edits that the user is in the middle of staging
- * through the toolbar.
+ * Opened from the customize toolbar beside Add widget. Cancel and
+ * dismiss revert only grid settings so in-progress widget layout
+ * edits in the same customize session are preserved.
  *
  * @param {LayoutSettingsProps} props Layout settings props.
  * @return {React.ReactNode} The layout settings component.
@@ -259,7 +257,7 @@ export function LayoutSettings( {
 	);
 
 	const handleCancel = useCallback( () => {
-		cancelStaging( { exitEditMode: false } );
+		cancelStaging( { exitEditMode: false, revertLayout: false } );
 		onOpenChange( false );
 	}, [ cancelStaging, onOpenChange ] );
 
@@ -271,7 +269,7 @@ export function LayoutSettings( {
 	const handleOpenChange = useCallback(
 		( nextOpen: boolean ) => {
 			if ( ! nextOpen && open ) {
-				cancelStaging( { exitEditMode: false } );
+				cancelStaging( { exitEditMode: false, revertLayout: false } );
 			}
 			onOpenChange( nextOpen );
 		},
@@ -283,8 +281,6 @@ export function LayoutSettings( {
 			open={ open }
 			onOpenChange={ handleOpenChange }
 			swipeDirection="right"
-			modal={ false }
-			disablePointerDismissal
 		>
 			<Drawer.Popup size="medium" style={ { marginTop: '32px' } }>
 				<Drawer.Header>
diff --git a/routes/dashboard/widget-dashboard/context/dashboard-context.tsx b/routes/dashboard/widget-dashboard/context/dashboard-context.tsx
index bc62fe1a668116..3a566d98029127 100644
--- a/routes/dashboard/widget-dashboard/context/dashboard-context.tsx
+++ b/routes/dashboard/widget-dashboard/context/dashboard-context.tsx
@@ -134,10 +134,16 @@ interface InternalDashboardContextValue {
 	commitGridModelChange: ( targetModel: WidgetGridModel ) => void;
 
 	/**
-	 * Reverts both staging slices. By default also exits edit mode; pass
-	 * `{ exitEditMode: false }` when dismissing the layout settings drawer.
+	 * Reverts staging slices. By default reverts both layout and grid
+	 * settings and exits edit mode. Pass `{ exitEditMode: false }` when
+	 * dismissing the layout settings drawer. Pass `{ revertLayout: false }`
+	 * to revert only grid settings (preserves in-progress widget layout
+	 * edits while customize mode is active).
 	 */
-	cancel: ( options?: { exitEditMode?: boolean } ) => void;
+	cancel: ( options?: {
+		exitEditMode?: boolean;
+		revertLayout?: boolean;
+	} ) => void;
 
 	hasUncommittedChanges: boolean;
 	editMode: boolean;
@@ -226,18 +232,10 @@ interface ProviderProps {
  * `layout` and `gridSettings`; `commit` publishes whichever slice
  * differs from its committed prop, `cancel` reverts both.
  *
- * Two invariants the provider does not enforce on its own:
- *
- * - The shared commit assumes the two slices are not edited
- *   simultaneously. The bundled `Actions` keeps the layout-edit and
- *   settings-drawer flows mutually exclusive; consumers that compose
- *   a different host must uphold the same invariant or accept the
- *   cross-publish.
- * - Staging re-syncs from the committed props on prop change.
- *   In-flight edits are dropped silently when an external update
- *   (cross-tab commit, reset, websocket push) lands. Consumers that
- *   cannot tolerate this loss should mediate the prop updates before
- *   forwarding them here.
+ * Staging re-syncs from the committed props on prop change. In-flight
+ * edits are dropped silently when an external update (cross-tab commit,
+ * reset, websocket push) lands. Consumers that cannot tolerate this
+ * loss should mediate the prop updates before forwarding them here.
  *
  * @param {ProviderProps} props Provider props
  * @return {React.ReactNode} The provider component.
@@ -315,8 +313,10 @@ export function WidgetDashboardProvider( {
 	);
 
 	const cancel = useCallback(
-		( options?: { exitEditMode?: boolean } ) => {
-			setStagingLayout( committedLayout );
+		( options?: { exitEditMode?: boolean; revertLayout?: boolean } ) => {
+			if ( options?.revertLayout !== false ) {
+				setStagingLayout( committedLayout );
+			}
 			setStagingGridSettings( committedGridSettings );
 			if ( options?.exitEditMode !== false ) {
 				onEditChange?.( false );
diff --git a/routes/dashboard/widget-dashboard/context/ui-context.tsx b/routes/dashboard/widget-dashboard/context/ui-context.tsx
index bf764882d6989b..89749f445bb642 100644
--- a/routes/dashboard/widget-dashboard/context/ui-context.tsx
+++ b/routes/dashboard/widget-dashboard/context/ui-context.tsx
@@ -16,6 +16,8 @@ import {
 interface DashboardUIContextValue {
 	inserterOpen: boolean;
 	setInserterOpen: ( next: boolean ) => void;
+
+	/** Opened by the Layout settings button in the customize toolbar. */
 	layoutSettingsOpen: boolean;
 	setLayoutSettingsOpen: ( next: boolean ) => void;
 	resetDialogOpen: boolean;
@@ -52,7 +54,8 @@ const Context = createContext< DashboardUIContextValue | null >( null );
 
 /**
  * UI-state hook used by the inserter modal and any compound that needs to
- * open or close it (today: the "Add widget" trigger in `Actions`).
+ * open or close it (today: the "Add widget" and "Layout settings"
+ * triggers in `Actions`).
  *
  * Throws when called outside `WidgetDashboard` so misuse fails loudly during
  * development.
diff --git a/routes/dashboard/widget-dashboard/test/actions.test.tsx b/routes/dashboard/widget-dashboard/test/actions.test.tsx
index 2b68440c0b0dd8..b8594e417736ea 100644
--- a/routes/dashboard/widget-dashboard/test/actions.test.tsx
+++ b/routes/dashboard/widget-dashboard/test/actions.test.tsx
@@ -14,7 +14,7 @@ import { useState } from '@wordpress/element';
  * Internal dependencies
  */
 import { WidgetDashboard } from '../widget-dashboard';
-import type { DashboardWidget } from '../types';
+import type { DashboardWidget, WidgetGridSettings } from '../types';
 import type { WidgetType } from '../../widget-primitives';
 
 const widgetTypes: WidgetType[] = [];
@@ -25,16 +25,24 @@ const layout: DashboardWidget[] = [
 	{ uuid: 'a', type: 'core/test', placement: { width: 1, height: 1 } },
 ];
 
+const gridSettings: WidgetGridSettings = {
+	model: 'grid',
+	minColumnWidth: 350,
+	rowHeight: 200,
+};
+
 interface HarnessProps {
 	initialEditMode?: boolean;
 	onEditChange?: ( next: boolean ) => void;
 	onLayoutChange?: ( next: DashboardWidget[] ) => void;
+	onGridSettingsChange?: ( next: WidgetGridSettings ) => void;
 }
 
 function Harness( {
 	initialEditMode = false,
 	onEditChange,
 	onLayoutChange = () => {},
+	onGridSettingsChange,
 }: HarnessProps ) {
 	const [ editMode, setEditMode ] = useState( initialEditMode );
 
@@ -42,6 +50,8 @@ function Harness( {
 		<WidgetDashboard
 			layout={ layout }
 			onLayoutChange={ onLayoutChange }
+			gridSettings={ gridSettings }
+			onGridSettingsChange={ onGridSettingsChange }
 			widgetTypes={ widgetTypes }
 			editMode={ editMode }
 			onEditChange={ ( next ) => {
@@ -134,6 +144,74 @@ describe( 'WidgetDashboard.Actions', () => {
 		).not.toBeInTheDocument();
 	} );
 
+	describe( 'Layout settings', () => {
+		it( 'is hidden when editMode is false', () => {
+			render( <Harness onGridSettingsChange={ () => {} } /> );
+
+			expect(
+				screen.queryByRole( 'button', { name: 'Layout settings' } )
+			).not.toBeInTheDocument();
+		} );
+
+		it( 'is visible in the edit toolbar when grid settings are editable', () => {
+			render(
+				<Harness initialEditMode onGridSettingsChange={ () => {} } />
+			);
+
+			expect(
+				screen.getByRole( 'button', { name: 'Layout settings' } )
+			).toBeInTheDocument();
+		} );
+
+		it( 'is hidden when onGridSettingsChange is not provided', () => {
+			render( <Harness initialEditMode /> );
+
+			expect(
+				screen.queryByRole( 'button', { name: 'Layout settings' } )
+			).not.toBeInTheDocument();
+		} );
+
+		it( 'opens the layout settings drawer when clicked', async () => {
+			render(
+				<Harness initialEditMode onGridSettingsChange={ () => {} } />
+			);
+
+			await userEvent.click(
+				screen.getByRole( 'button', { name: 'Layout settings' } )
+			);
+
+			expect(
+				await screen.findByRole( 'dialog', { name: 'Layout settings' } )
+			).toBeInTheDocument();
+		} );
+
+		it( 'is not in the more-actions menu', async () => {
+			const onLayoutReset = jest.fn();
+			render(
+				<WidgetDashboard
+					layout={ layout }
+					onLayoutChange={ () => {} }
+					onLayoutReset={ onLayoutReset }
+					gridSettings={ gridSettings }
+					onGridSettingsChange={ () => {} }
+					widgetTypes={ widgetTypes }
+					editMode
+					onEditChange={ () => {} }
+				>
+					<WidgetDashboard.Actions />
+				</WidgetDashboard>
+			);
+
+			await userEvent.click(
+				screen.getByRole( 'button', { name: 'More options' } )
+			);
+
+			expect(
+				screen.queryByRole( 'menuitem', { name: 'Layout settings' } )
+			).not.toBeInTheDocument();
+		} );
+	} );
+
 	it( 'throws when used outside a WidgetDashboard subtree', () => {
 		const spy = jest
 			.spyOn( console, 'error' )
diff --git a/routes/dashboard/widget-dashboard/test/staging.test.tsx b/routes/dashboard/widget-dashboard/test/staging.test.tsx
index 6e5a675b63b115..ed9f501103f8b9 100644
--- a/routes/dashboard/widget-dashboard/test/staging.test.tsx
+++ b/routes/dashboard/widget-dashboard/test/staging.test.tsx
@@ -32,7 +32,10 @@ interface ProbeApi {
 	mutate: ( next: DashboardWidget[] ) => void;
 	mutateGridSettings: ( next: WidgetGridSettings ) => void;
 	commit: ( options?: { exitEditMode?: boolean } ) => void;
-	cancel: ( options?: { exitEditMode?: boolean } ) => void;
+	cancel: ( options?: {
+		exitEditMode?: boolean;
+		revertLayout?: boolean;
+	} ) => void;
 }
 
 const probeRef: { current: ProbeApi | null } = { current: null };
@@ -402,6 +405,45 @@ describe( 'WidgetDashboard staging layer', () => {
 		} );
 	} );
 
+	it( 'reverts only grid settings when cancel passes revertLayout: false', () => {
+		const onLayoutChange = jest.fn();
+		const onGridSettingsChange = jest.fn();
+		const initialSettings: WidgetGridSettings = {
+			model: 'grid',
+			minColumnWidth: 350,
+			rowHeight: 200,
+		};
+		render(
+			<Harness
+				layout={ initialLayout }
+				onLayoutChange={ onLayoutChange }
+				gridSettings={ initialSettings }
+				onGridSettingsChange={ onGridSettingsChange }
+			/>
+		);
+
+		act( () => {
+			readProbe().mutate( [ initialLayout[ 0 ] ] );
+			readProbe().mutateGridSettings( {
+				...initialSettings,
+				minColumnWidth: 420,
+			} );
+		} );
+
+		expect( readProbe().hasUncommittedChanges ).toBe( true );
+
+		act( () => {
+			readProbe().cancel( {
+				exitEditMode: false,
+				revertLayout: false,
+			} );
+		} );
+
+		expect( readProbe().hasUncommittedChanges ).toBe( true );
+		expect( readProbe().layout ).toHaveLength( 1 );
+		expect( readProbe().gridSettings.minColumnWidth ).toBe( 350 );
+	} );
+
 	it( 'stays in edit mode when commit or cancel passes exitEditMode: false', () => {
 		const onLayoutChange = jest.fn();
 		render(
diff --git a/routes/dashboard/widget-dashboard/types.ts b/routes/dashboard/widget-dashboard/types.ts
index d68e4d9a5aeaaf..98e82f8e421531 100644
--- a/routes/dashboard/widget-dashboard/types.ts
+++ b/routes/dashboard/widget-dashboard/types.ts
@@ -248,7 +248,7 @@ export interface WidgetDashboardProps {
 	 * Called when the user commits in-progress grid-settings edits via
 	 * the Done action. The dashboard maintains a staging copy of
 	 * settings internally; mutations stay local until commit. When
-	 * omitted, the `Layout settings` entry in the more-actions menu is
+	 * omitted, the `Layout settings` button in the customize toolbar is
 	 * hidden, since there is nowhere to persist the change.
 	 */
 	onGridSettingsChange?: ( gridSettings: WidgetGridSettings ) => void;

From 46c5c66dc327c509dd5bf19d10c7bf059d68435d Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:01:59 +0200
Subject: [PATCH 04/60] chore(pipeline): bootstrap
 77199-cover-bindings-id-url-internal

Pipeline 0-prompt artifact for Cover block bindings (id+url, internal-only).
Tracks WordPress/gutenberg#77199.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .gitignore                                    |  1 +
 .../0-prompt/prompt.md                        | 80 +++++++++++++++++++
 2 files changed, 81 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/0-prompt/prompt.md

diff --git a/.gitignore b/.gitignore
index 2278f2afa61882..c172e34b4d279e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -61,3 +61,4 @@ packages/react-native-editor/src/setup-local.js
 # Files related to applying patches
 *.rej
 *.orig
+/.pipelines/
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/0-prompt/prompt.md b/.pipelines/77199-cover-bindings-id-url-internal/0-prompt/prompt.md
new file mode 100644
index 00000000000000..6043519976ec93
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/0-prompt/prompt.md
@@ -0,0 +1,80 @@
+# Cover block bindings — internal-only support for `id` and `url`
+
+## Source
+
+- Tracking issue: [WordPress/gutenberg#77199](https://github.com/WordPress/gutenberg/issues/77199) — *Block Bindings in WordPress 7.1*
+- Open draft PR (architectural reference, not basis): [WordPress/gutenberg#74610](https://github.com/WordPress/gutenberg/pull/74610)
+- Prior stalled PR (lessons): [WordPress/gutenberg#74109](https://github.com/WordPress/gutenberg/pull/74109)
+
+## Background
+
+The `core/cover` block has never shipped Block Bindings support. Two release cycles have produced draft PRs that stalled, despite Block Bindings working well for `core/image`, `core/paragraph`, and other content-bearing blocks. The current iteration issue (#77199) explicitly scopes Cover block bindings for the WordPress 7.1 cycle.
+
+Prior attempts failed for two distinct reasons:
+
+1. **Architectural complexity** (#74109) — reviewer @ockham rejected an event-driven approach in which multiple `useEffect` hooks reacted to specific user interactions (replace media, focus, blur). Logic for deriving overlay color, dim ratio, and visible controls was scattered across handlers, making behavior unpredictable. The reviewer asked for a single reactive observer that derives all dependent state from the bound `id`+`url` values themselves.
+
+2. **CSS-in-HTML rewrite** (#74610) — when `hasParallax` is true, Cover emits `style="background-image: url(...)"` on the wrapper div. The WordPress HTML API cannot safely modify CSS values inside `style` attributes (there is no CSS Processor yet, and one was deferred). Bound `url` substitution therefore breaks under parallax.
+
+3. **External image scope creep** (#74109) — the prior PR tried to also support binding `url` to an arbitrary external URL with no media-library `id`. That created cascading edge cases (overlay color derivation, alt text, featured image interactions, `isRepeated`, parallax) and ballooned the diff.
+
+## Goal
+
+Ship Block Bindings support for the `id` and `url` attributes of `core/cover`, scoped narrowly so it lands cleanly in one PR. The headline use case is **Pattern Overrides** for the Cover block.
+
+## Scope — In
+
+- Bindable attributes: `id` (number, media-library attachment id) and `url` (string, media-library file URL). Both flow through Block Bindings sources (e.g., `core/pattern-overrides`, `core/post-meta`).
+- **Internal media only**: a bound `id` is required, and the bound `url` must be derivable from that `id` via the WordPress media library. External / CDN / arbitrary URLs are out of scope.
+- Pattern Overrides supported end-to-end: bind in a pattern, override per-instance, reset to default. Reset must hide cleanly when the instance value already matches the default override state.
+- When the binding is active:
+  - Hide the parallax (`hasParallax`) toggle and force `hasParallax=false` for the rendered output.
+  - Hide the repeat (`isRepeated`) toggle.
+  - Hide the media-replace control (replacement happens via the binding source, not direct edit).
+  - Hide the "Use featured image" toggle (`useFeaturedImage`).
+- The Edit component derives `dimRatio` and overlay color reactively from the bound id+url, without mutating stored attributes. `dimRatio=100` (the default) must not result in a fully opaque overlay over a bound image — derive an effective value at render time when a binding is present.
+- Server-side rendering produces the correct `<img>` / `background` markup for the resolved url and id, with parallax explicitly off.
+
+## Scope — Out
+
+- External / non-media-library URL binding. If a binding source returns a URL without an id, treat it as if no binding were set (or surface a clear "not supported in this PR" UX). Do not attempt to derive overlay/dim from external URLs.
+- Parallax interaction with bindings. Parallax UI is disabled (hidden) whenever a binding is active; no attempt at server-side `style="background-image: url()"` rewriting.
+- Featured-image binding for Cover (`useFeaturedImage` + binding). Separate follow-up PR.
+- `backgroundType: "embed-video"` interaction with bindings. Embed-video Cover is out of scope.
+- New global Block Bindings APIs. Reuse existing infrastructure; if a new filter such as `block_bindings_attribute_replaced_in_markup` is needed for non-sourced attributes, weigh it against a cover-specific server-render path during design.
+
+## Architectural constraints (preempt prior reviewer feedback)
+
+- **Single reactive observer**: one place in `packages/block-library/src/cover/edit/index.js` watches the bound `id` and `url` and derives every dependent value (effective dimRatio, overlay color, control visibility). No event-handler-keyed `useEffect` proliferation.
+- **No attribute mutation on binding detection**: do not write to attributes from inside the observer. Derived values are computed at render time. Bound values are read through the existing block bindings API; the observer only triggers re-render.
+- **Internal-only invariant enforced visibly**: when `url` is bound but `id` is missing (external), the UI must show that the binding cannot be honored, not silently render a broken Cover.
+
+## Prior art to consult, NOT to base off
+
+- Open draft PR #74610: take the architectural shape and the `block_bindings_attribute_replaced_in_markup` filter idea, but do not inherit its parallax scope.
+- Stalled PR #74109: harvest e2e test scaffolding, overlay-reset logic, and lock-control patterns if useful. Do not branch off it.
+- Local branches `add/cover-block-bindings-support` and `add/cover-block-bindings-support-v2` exist for reference only. Cherry-pick fragments at most.
+- Prior pipeline `75022-block-bindings-into-block-fields` (already landed locally on branch `try/75022-...`) handles the Block Fields UI integration. The Cover block must work with the Block Fields UI shipped there, not the legacy Attributes panel.
+
+## Key risks to address explicitly in design
+
+1. **Pattern Overrides reset semantics** — historically broke. Enumerate the states: (a) default (no override), (b) overridden, (c) reset-to-default with binding active, (d) reset-hidden when value already matches default. Each must round-trip cleanly through editor save/load and server render.
+2. **Default `dimRatio: 100`** — newly inserted Cover with binding active must not show opaque overlay. Solution lives in derived render-time value, not in attribute mutation.
+3. **`backgroundType: "embed-video"`** — added after prior PRs were drafted. Confirm bindings UI does not appear or short-circuits when this is the active background type.
+4. **Reviewer ockham gates this area** — his prior objections (architecture shape, internal-only scope, no scattered useEffects) must be preempted in the design doc itself, not discovered during review.
+
+## Acceptance criteria
+
+- The Block Fields / Block Bindings UI in the editor allows binding `id` and `url` of `core/cover` to any registered binding source whose schema matches.
+- A Cover block with bound `id`+`url` renders correctly in the editor (preview) and on the front end (server-render), using the resolved internal media.
+- Pattern Overrides on Cover round-trip cleanly: set value in pattern, override per instance, reset to default — all three states render correctly and produce the expected serialized markup.
+- The parallax toggle, repeat toggle, media-replace control, and featured-image toggle are hidden when a binding is active.
+- E2E test covers: (a) creating a Cover, binding its url+id to a Pattern Override source, (b) overriding the value on a pattern instance, (c) resetting the override, all with assertion of rendered output.
+- Unbound Cover behavior is unchanged — no regressions on any existing Cover feature (parallax, repeat, featured image, embed-video, focal point, dim ratio, overlay color).
+- PR diff is targeted (~under 500 net lines including tests). Architectural cleanliness gates scope.
+
+## Repo target
+
+- Carlos's fork (`cbravobernal/gutenberg`) → upstream PR to `WordPress/gutenberg`.
+- Branch: `worktree-77199-cover-bindings-id-url-internal` (auto-derived from the pipeline slug).
+- The PR description should link #77199 and call out explicitly which prior issues (#74109, #74610) it does and does not subsume.

From acddc4552ed550c30b535d687382c8cd5c6b1b7b Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:14:42 +0200
Subject: [PATCH 05/60] docs(pipeline): add 1-spec/requirements.md for
 77199-cover-bindings-id-url-internal

Capture the requirements for Cover block bindings (id and url, internal media only)
distilled from PR #74109 / #74610 review feedback and the existing codebase shape.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../1-spec/requirements.md                    | 541 ++++++++++++++++++
 1 file changed, 541 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/1-spec/requirements.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/requirements.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/requirements.md
new file mode 100644
index 00000000000000..1ef7bd0c9b04ff
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/requirements.md
@@ -0,0 +1,541 @@
+# Requirements
+
+## Rough Idea
+
+(Verbatim from `/Users/carlos/Developer/gutenberg/.claude/worktrees/77199-cover-bindings-id-url-internal/.pipelines/77199-cover-bindings-id-url-internal/0-prompt/prompt.md`.)
+
+### Cover block bindings — internal-only support for `id` and `url`
+
+The `core/cover` block has never shipped Block Bindings support. Tracking issue [#77199](https://github.com/WordPress/gutenberg/issues/77199) scopes Cover block bindings for the WP 7.1 cycle. Two prior draft PRs ([#74109](https://github.com/WordPress/gutenberg/pull/74109), [#74610](https://github.com/WordPress/gutenberg/pull/74610)) stalled over:
+
+1. **Architecture** — reviewer @ockham rejected event-driven `useEffect` proliferation for deriving overlay color, `dimRatio`, etc.; asked for a single reactive observer keyed on the bound `id`/`url`.
+2. **CSS-in-HTML rewrite** — when `hasParallax` is true, Cover emits `style="background-image: url(...)"`; the WP HTML API cannot safely modify CSS in `style` attributes.
+3. **External-image scope creep** — supporting arbitrary external URLs (no `id`) ballooned the diff.
+
+**Goal:** Ship bindings for `id` and `url` of `core/cover`, scoped narrowly, headline use-case = Pattern Overrides. **Internal media only** (`id` required, `url` derivable from `id`). When the binding is active: hide parallax / repeat / media-replace / use-featured-image controls; derive effective `dimRatio` and overlay color at render time without mutating attributes; server-side renders correct `<img>` markup with parallax off.
+
+The full prompt (including in-/out-of-scope lists, architectural constraints, risks, acceptance criteria) lives at the path above and is treated as the authoritative source of intent for these requirements.
+
+## Q&A
+
+### Q1: What is the current `role` declared on `core/cover`'s `url` and `id` attributes, and what does declaring `role: "content"` change downstream?
+
+**A:** In trunk, `core/cover`'s `url` attribute has `"role": "content"` (lines 10–13 of `block.json`); the `id` attribute does **not** declare a role (lines 18–20). The reference block `core/image` declares `"role": "content"` on **both** `url` and `id` (`packages/block-library/src/image/block.json` lines 25–31 and 78–81).
+
+`role: "content"` is metadata used by tooling that surfaces "content-bearing" attributes (e.g. Block Fields UI, Pattern Overrides field discovery). It is **not** what enables Block Bindings UI on its own; that gating happens via the `__experimentalBlockBindingsSupportedAttributes` editor setting, which is populated from the server-side `block_bindings_supported_attributes` filter (see Q5). The current Block Bindings panel in `packages/block-editor/src/hooks/block-bindings.js` (lines 40–80) reads `bindableAttributes` from `__experimentalBlockBindingsSupportedAttributes?.[ blockName ]` and renders one `BlockBindingsAttributeControl` per supported attribute.
+
+**Reasoning:** `role: "content"` already on `url` indicates Gutenberg considers Cover's url part of the editable content payload, but that alone has not been sufficient to enable bindings — the server-side allow-list is the gate.
+
+**Sources:** `packages/block-library/src/cover/block.json:10-13,18-20`; `packages/block-library/src/image/block.json:25-31,78-81`; `packages/block-editor/src/hooks/block-bindings.js:40-100`; `lib/compat/wordpress-6.9/block-bindings.php:118-167`.
+
+### Q2: For Cover bindings to appear in the editor UI, what server-side allow-list entry is required, and which file should it live in for WP 7.1?
+
+**A:** A PHP filter must add `'id'` and `'url'` to the list returned by `gutenberg_get_block_bindings_supported_attributes( 'core/cover' )`. There are two equivalent filter hooks:
+- `block_bindings_supported_attributes` (global, receives `$attributes, $block_type`)
+- `block_bindings_supported_attributes_core/cover` (dynamic, block-specific)
+
+The new code must live in a new file `lib/compat/wordpress-7.1/block-bindings.php`, registered via `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';` in `lib/load.php`. The existing 7.1 compat directory has no bindings file yet (verified via `ls lib/compat/wordpress-7.1/`).
+
+Wrapping the filter in a `! function_exists( ... )` / version guard is the established pattern (see `lib/compat/wordpress-6.9/block-bindings.php` lines 11–31 for the prior-version precedent).
+
+**Reasoning:** The Block Bindings panel and DataForm controls discover bindable attributes through `__experimentalBlockBindingsSupportedAttributes`, populated server-side. Without that registration, no UI for `id`/`url` will appear regardless of `role` declarations.
+
+**Sources:** `lib/compat/wordpress-6.9/block-bindings.php:11-46,118-167`; `lib/compat/wordpress-7.1/` directory listing; the prior PR #74610 placed an equivalent filter at `lib/compat/wordpress-7.0/block-bindings.php` (now to be re-targeted to 7.1).
+
+### Q3: How does the existing Block Bindings server-side resolution path actually substitute the bound value into the rendered HTML, and what is the gap for Cover's `url` (which has no `source`/`selector` declaration in `block.json`)?
+
+**A:** `gutenberg_block_bindings_render_block` (in `lib/compat/wordpress-6.9/block-bindings.php:57-108`) calls `gutenberg_process_block_bindings` to resolve source values, **merges them into `$instance->attributes`**, then runs `$instance->render()` again so the block can re-render with the new attribute values. Finally it iterates the computed attributes and calls `gutenberg_replace_html` to substitute the value into the markup.
+
+`gutenberg_replace_html` (lines 346–398) **only handles attributes that declare `source: html`, `source: rich-text`, or `source: attribute`** in `block.json`. It uses the declared `selector`/`attribute` to locate the substitution point. If `source` is unset, the function is a no-op for that attribute.
+
+`core/cover`'s `url` has no `source` declaration (it is a plain in-memory attribute serialized via React in `save.js` — see lines 84, 117–124 of `save.js`). Therefore:
+1. The `$instance->render()` re-execution can pick up the new bound `url`/`id` **if** the block's `render_callback` (`render_block_core_cover` in `packages/block-library/src/cover/index.php`) actually uses them — but today that callback only inserts an `<img>` when `useFeaturedImage` is true. For an unbound Cover with `useFeaturedImage=false`, the callback returns `$content` unmodified.
+2. The static save markup (from `save.js`) is already written with the **author-time** `url` and `id`. If the binding source provides a different `url`/`id`, the saved HTML still shows the old values unless the cover render path overrides them.
+
+The mechanism used in draft PR #74610 was to add a `block_bindings_attribute_replaced_in_markup` filter that **synthesizes** `source: attribute, selector: img, attribute: src` for `core/cover.url` at runtime, so `gutenberg_replace_html` can then rewrite `<img src="...">`. That filter does **not** handle the `<div style="background-image: url(...)">` parallax/repeat path.
+
+**Reasoning:** Cover stores `url` as an in-memory React-managed attribute, so the existing bindings infrastructure has no metadata to know where in the markup the URL appears. Either the block must declare a synthetic source (via runtime filter), or the cover-specific server render must compute and inject the image element itself.
+
+**Sources:** `lib/compat/wordpress-6.9/block-bindings.php:57-108,346-398`; `packages/block-library/src/cover/save.js:84,117-124`; `packages/block-library/src/cover/index.php:18-200`; PR #74610 diff (lib/compat/wordpress-7.0/block-bindings.php new file, lines around `block_bindings_attribute_replaced_in_markup`).
+
+### Q4: When `hasParallax` or `isRepeated` is true, what does `save.js` emit, and why does HTML-attribute rewriting break?
+
+**A:** `save.js` lines 67, 99–132 branch on `isImgElement = !(hasParallax || isRepeated)`:
+- `isImgElement === true` → emits `<img className="wp-block-cover__image-background" src={url} ... />` (line 117).
+- `isImgElement === false` → emits `<div role={alt ? 'img' : undefined} aria-label={alt} className={imgClasses} style={{ backgroundPosition, backgroundImage: 'url(' + url + ')' }} />` (lines 126–131).
+
+The `gutenberg_replace_html` path with `source: attribute, selector: img, attribute: src` (the technique used by PR #74610) cannot touch the `<div style="background-image: url(...)">` form because:
+1. The selector is `img`, not `div`.
+2. Even if we matched the `div`, we'd need to mutate a CSS value inside the `style` attribute, which the HTML Tag Processor cannot do safely — there is no CSS Processor in the HTML API yet (referenced in PR #74610 description, third TODO item).
+
+This is the documented "CSS-in-HTML rewrite" blocker that stalled PR #74610.
+
+**Reasoning:** This is structurally why the prompt insists `hasParallax` must be **forced false at render time when bindings are active** — it sidesteps the HTML rewrite problem.
+
+**Sources:** `packages/block-library/src/cover/save.js:67,99-132`; PR #74610 description (https://github.com/WordPress/gutenberg/pull/74610) "Support parallax case" TODO; `lib/compat/wordpress-6.9/block-bindings.php:346-398` (replace_html limited to attribute selectors).
+
+### Q5: What invariant must the implementation enforce when the binding source returns a `url` but no `id` (the "external URL" case)?
+
+**A:** Per the prompt's Scope-In: a bound `id` is required, and a bound `url` must be derivable from that `id`. Per Scope-Out: external/non-media-library URL binding is not supported. Per Architectural Constraint: "Internal-only invariant enforced visibly: when `url` is bound but `id` is missing (external), the UI must show that the binding cannot be honored, not silently render a broken Cover."
+
+In practice this means:
+- Both `id` and `url` are declared bindable in the supported-attributes filter, so both can be wired through a binding source.
+- The Edit component must detect the (bound url, unbound or null id) state and surface a visible "cannot resolve internal media" affordance instead of rendering the cover as if the URL were valid.
+- The reactive observer that derives `dimRatio`/overlay color must not run for url-only-bound covers (no `id` ⇒ no media-library resolution).
+- On the server side, the same constraint should hold: if `id` is empty after binding resolution, skip the substituted-image insert path and render the cover as the unbound placeholder would render (no broken image element).
+
+**Reasoning:** The Cover's overlay color, focal point and image-size derivation all require the attachment metadata (i.e. the `id`). Treating url-only bindings as best-effort would re-introduce all the edge cases that ballooned PR #74109 (alt text, sizeSlug, focal point on unknown image, average color derivation).
+
+**Sources:** `0-prompt/prompt.md` Scope-In/Out and Architectural Constraints; PR #74610 TODO "Figure out what to do if only `url` is bound (but `id` isn't), meaning that the bound image could possibly be external" (https://github.com/WordPress/gutenberg/pull/74610).
+
+### Q6: What is the architectural shape reviewer @ockham requires (and which prior approach he rejected)?
+
+**A:** From his inline comment on PR #74109 (`packages/block-library/src/cover/edit/index.js`, line 282, posted 2026-01-13):
+
+> "After working on #74610 for a while, I realize that this is a pattern that I'd like to avoid as much as possible. The block shouldn't need to care where it gets its attributes from -- i.e. if they're set manually or provided by a Block Binding. Instead, it should be as agnostic as possible. ... we should try to move that logic into one shared `useEffect` handler that will simply react to the `url`, `featuredImage`, `overlay` (and potentially other) attributes changing, and re-compute colors accordingly. This will cover both the case where the user makes a manual change, or the attribute is provided by Block Bindings."
+
+His own follow-up acknowledges the tension: "I also just found out that this would mean we'd go full circle -- after previously moving code from `useEffect` into event handlers, since `useEffect` was deemed too fragile" (link to #53253).
+
+He references the future `useEffectEvent` (React 19) as the cleanup path; `useEffectEvent` is already exported from `@wordpress/element` (verified at `packages/element/README.md:472`, `packages/element/build-module/react.mjs:23,97`).
+
+The reviewer's hard requirements are therefore:
+- **No** per-event `useEffect` proliferation (one for media-select, one for blur, one for focus, …).
+- **One** observer (or a small number of well-named ones) that derives all dependent state from the bound id/url plus existing manual-edit triggers.
+- The block must be **source-agnostic**: same derivation logic whether the URL came from a binding or a manual selection.
+
+**Reasoning:** This determines the architectural shape — design phase must produce a single observer (likely keyed on `(url, useFeaturedImage, isUserOverlayColor)`), with stable references via `useEffectEvent` to avoid stale-closure pitfalls.
+
+**Sources:** PR #74109 review comments via `gh api repos/WordPress/gutenberg/pulls/74109/comments`; `packages/element/README.md:472`; `packages/element/build-module/react.mjs:23,97`.
+
+### Q7: How does `core/image` wire up its own URL/id bindings — what is the minimum reusable pattern Cover should mirror for control-locking?
+
+**A:** `core/image` uses two patterns:
+
+1. **Detecting whether the binding source allows editing.** In `packages/block-library/src/image/image.js` lines 745–820, a `useSelect` returns `lockUrlControls`, `lockHrefControls`, `lockAltControls`, etc., each derived from `metadata?.bindings?.<attr>` plus the bound source's `canUserEditValue` function:
+   ```js
+   lockUrlControls:
+       !! urlBinding &&
+       ! urlBindingSource?.canUserEditValue?.( {
+           select, context, args: urlBinding?.args,
+       } ),
+   ```
+2. **Hiding/disabling controls.** Throughout `image.js` and `edit.js`, the URL input, MediaReplaceFlow, and related controls are gated by `!lockUrlControls && ...`. For example `MediaReplaceFlow` only mounts when `!lockUrlControls` (`image.js:834-836`).
+
+Pattern Overrides source returns `canUserEditValue: () => true` (`packages/editor/src/bindings/pattern-overrides.js:102`), so a pattern instance editing an overridden cover **does not** lock controls — the user is supposed to edit. For other sources (post-meta, etc.) where the user cannot edit the source value from inside the block, controls lock.
+
+**Reasoning:** Cover should reuse the `lockUrlControls` derivation idea. The prompt explicitly enumerates which Cover controls must hide when bindings are active (parallax, repeat, media-replace, use-featured-image); the `lockUrlControls`-style boolean is one signal, but the prompt's actual requirement is broader: hide those four controls whenever **any** binding is present on `url` (or `id`), regardless of whether the source permits editing. The two layers (`hasUrlBinding` and `lockUrlControls`) need to coexist:
+- `hasUrlBinding` → hide parallax / repeat / featured-image toggles (always).
+- `lockUrlControls` → additionally hide media-replace if the source disallows editing.
+
+For Pattern Overrides specifically, media-replace must **stay visible** (the user is supposed to override). For post-meta, it should hide.
+
+**Sources:** `packages/block-library/src/image/image.js:734-820,822-849`; `packages/block-library/src/image/edit.js:396-461`; `packages/editor/src/bindings/pattern-overrides.js:102`.
+
+### Q8: For Pattern Overrides specifically, what is the round-trip lifecycle for a Cover block (set in pattern → override per instance → reset to default → "reset hidden when default")?
+
+**A:** Pattern Overrides uses the `core/pattern-overrides` binding source (`packages/editor/src/bindings/pattern-overrides.js`).
+
+States:
+1. **Authoring the pattern (`isEditingSyncedPattern` true).** The pattern editor shows `PatternOverridesControls` (`packages/patterns/src/components/pattern-overrides-controls.js`) which lets the author "Enable overrides" via a button; this calls `updateBlockBindings({ __default: { source: 'core/pattern-overrides' } })`. The block must have `metadata.name`. Setting `__default` to `core/pattern-overrides` causes `gutenberg_process_block_bindings` (`lib/compat/wordpress-6.9/block-bindings.php:257-281`) to expand the `__default` binding into one per supported attribute server-side.
+2. **Default state on an instance (no override).** Per the source's `getValues`, the value returned is the block's own attribute value (the pattern default). On the server, `gutenberg_process_block_bindings` resolves the value the same way — no overrides means the binding returns the same value as the static save markup.
+3. **Overridden state.** Editing the block in a pattern instance triggers `setValues`, which writes into the parent `core/block`'s `content` attribute under `[blockName].[attrName]`. The next render through bindings then resolves to the override value.
+4. **Reset.** `ResetOverridesControl` (`packages/patterns/src/components/reset-overrides-control.js:14-90`) is a toolbar button: `isOverridden` is computed from `getBlockAttributes(patternClientId)?.content?.hasOwnProperty(name)`. When the user clicks Reset, it deletes that entry from `content`. The button is **disabled** (greyed) when `! isOverridden` — that is the "reset hidden when default" behavior the prompt mentions, except it's `disabled`, not `hidden`. The button toolbar always shows; only the button is disabled.
+
+For the four states:
+- (a) **default (no override):** the bound value === the block's own attribute, instance renders pattern default. ✅
+- (b) **overridden:** content key present, value === override.
+- (c) **reset-to-default with binding active:** user clicks Reset, content key deleted, attribute resolves back to pattern default.
+- (d) **reset-hidden when value already matches default:** the ResetOverridesControl is `disabled` when not overridden. The prompt may mean "Reset hidden cleanly when the instance value already matches the default" — that's the existing behavior (disabled toolbar button, not hidden, but greyed).
+
+**Reasoning:** State (d) needs design-phase clarification: prompt says "hide cleanly" but existing behavior is "disable". Either is acceptable UI; the design must pick one and stay consistent across all bindable blocks. Suggest staying with the existing `disabled` pattern unless there's a reason to diverge.
+
+**Sources:** `packages/editor/src/bindings/pattern-overrides.js:1-103`; `packages/editor/src/hooks/pattern-overrides.js:1-122`; `packages/patterns/src/components/pattern-overrides-controls.js:1-127`; `packages/patterns/src/components/reset-overrides-control.js:1-90`; `lib/compat/wordpress-6.9/block-bindings.php:257-281`.
+
+### Q9: How does Cover's `useFeaturedImage` flow currently differ from the bindings flow, and why must the two never both be active on the same block?
+
+**A:** `useFeaturedImage` is a Cover-specific dynamic-image mechanism that pre-dates Block Bindings. It is a boolean attribute (`block.json:14-17`). When true, Cover's `edit/index.js` (lines 137–154) overrides the displayed URL with `mediaUrl` derived from the post's `featured_media`, and the server (`packages/block-library/src/cover/index.php:133-199`) injects an `<img>` for the post thumbnail.
+
+The two paths are mutually exclusive by intent because:
+- Both want to dictate `url`/`id` at render time.
+- `useFeaturedImage` updates the rendered image when the post's featured image changes, **without** going through bindings.
+- A bound `url`/`id` is supposed to be source-of-truth for the displayed image; `useFeaturedImage` would conflict.
+
+Per prompt: when binding is active, the "Use featured image" toggle hides. The edit component must NOT mutate `useFeaturedImage` (no attribute mutation invariant); instead, when computing the displayed image at render time, the binding-resolved `url`/`id` must take precedence over `useFeaturedImage`'s `mediaUrl`.
+
+For previously-saved blocks where `useFeaturedImage=true` AND a binding is then attached: the design must specify the precedence rule. The simplest is: binding wins for resolved `url`/`id`; on the server, if the binding is on `id`/`url`, the `useFeaturedImage` branch in `render_block_core_cover` must NOT also fire (it would try to inject a second image). The render callback must short-circuit `useFeaturedImage` when bindings have resolved a value.
+
+**Reasoning:** Featured-image binding (`useFeaturedImage` + binding combined) is explicitly OUT of scope per prompt ("Featured-image binding for Cover (`useFeaturedImage` + binding). Separate follow-up PR."). But in-scope is hiding the toggle and preventing UI/server-render conflict when both happen to be set.
+
+**Sources:** `packages/block-library/src/cover/block.json:14-17`; `packages/block-library/src/cover/edit/index.js:119-201`; `packages/block-library/src/cover/index.php:133-200`; prompt Scope-Out item 3.
+
+### Q10: What is the precise default-`dimRatio: 100` behavior, and where must the effective value override live?
+
+**A:** `block.json:33-36` declares `"dimRatio": { "type": "number", "default": 100 }`. The save serialization in `save.js:168-186` writes a `.has-background-dim` span with `dimRatioToClass(dimRatio)`. From `shared.js:32-36`: ratio 50 or undefined → null class, else `has-background-dim-{10*round(ratio/10)}`. So `dimRatio=100` → `has-background-dim-100` → fully opaque overlay.
+
+Today, when a user inserts a Cover and then sets media, `onSelectMedia` (`edit/index.js:218-291`) downshifts `dimRatio` from 100 → 50 (line 244: `const newDimRatio = currentAttrs.url === undefined && currentAttrs.dimRatio === 100 ? 50 : currentAttrs.dimRatio;`). This is an attribute-mutating side effect of the event handler.
+
+With bindings, the same downshift cannot happen via an event handler — the URL appears via the binding, not via `onSelectMedia`. PR #74610's approach was to also downshift in a `useEffect` (lines around the `[ url ]` dep). That mutates the attribute.
+
+The prompt forbids attribute mutation from the binding-detection observer. So the implementation must instead compute an **effective `dimRatio` at render time** when:
+- A binding is active, **and**
+- The stored `dimRatio` is the default (100), **and**
+- The resolved URL is non-empty.
+
+In that case the rendered overlay should use 50 (or some configured derived value) without writing to the attribute. The editor preview uses this effective value; the server render must apply the same logic.
+
+This breaks symmetry with the static `save.js` markup (which writes `has-background-dim-100` when the attribute is 100). So on the server, `render_block_core_cover` must inspect `metadata.bindings.url` (or `id`) and rewrite the `wp-block-cover__background` span's class to use the effective value when binding is active. This is an HTML-tag-class rewrite, which the HTML Tag Processor handles cleanly (unlike CSS-in-style attributes).
+
+**Reasoning:** Centralising the effective-value derivation in render-time (both client edit preview and server render) preserves the "no attribute mutation" invariant while solving the opaque-overlay problem. The class-rewrite is mechanically straightforward because the relevant element is `<span class="wp-block-cover__background has-background-dim has-background-dim-100">` — a class change, not a style change.
+
+**Sources:** `packages/block-library/src/cover/block.json:33-36`; `packages/block-library/src/cover/save.js:168-186`; `packages/block-library/src/cover/shared.js:32-36`; `packages/block-library/src/cover/edit/index.js:218-291` (especially line 244); PR #74610 description "TODO: Binding a newly inserted Cover block ... adds an overlay that uses the `dimRatio` attribute default value of `100`".
+
+### Q11: How does overlay color "auto-derive from image average" currently work, and how does it need to change for bindings?
+
+**A:** `edit/index.js:163-201,218-291,503-547` calls `getMediaColor( imageUrl )` from `edit/color-utils.js` (returns the average colour of the image, async). The result is set as the overlay color via `setOverlayColor` (a `withColors` setter) provided `isUserOverlayColor` is false.
+
+Today this only runs in event handlers: `onSelectMedia`, `toggleUseFeaturedImage`, and one `useEffect` reacting to `mediaUrl` changes for `useFeaturedImage`.
+
+For bindings, the URL can change without an event (the bound source updates externally). Per @ockham's review (Q6), this is exactly the case the single observer should cover: react to `url` changing for any reason. The PR #74610 approach extended the `useEffect` to also fire when `attributes?.metadata?.bindings?.url` is present. The cleaner approach (per @ockham) is to make the observer source-agnostic — it observes `url` directly (the destructured value that already accounts for both `useFeaturedImage` and manual selection), guarding only against `isUserOverlayColor`.
+
+Edge cases that must NOT regress:
+- User explicitly sets overlay color (`isUserOverlayColor=true`) → auto-derive must not overwrite.
+- URL changes from binding to a different image → auto-derive must run.
+- URL clears (binding source returns undefined) → overlay returns to default (or stays where it was if user-set).
+- Concurrent async race: `getMediaColor` is async; if the URL changes again before resolution, the stale colour must not overwrite the newer one (the existing code uses a `propsRef` pattern at `edit/index.js:130-135` for this).
+
+**Reasoning:** Same observer that derives `dimRatio` also derives `overlayColor` (only when not user-set). One reactive callback keyed on the effective `url`, with a `propsRef` (or `useEffectEvent`) to read latest `isUserOverlayColor`/`dimRatio` without stale closure.
+
+**Sources:** `packages/block-library/src/cover/edit/index.js:127-201,218-291,503-547`; `packages/block-library/src/cover/edit/color-utils.js` (referenced); PR #74609 review (linked from #74109 comments).
+
+### Q12: How is the Block Bindings UI gated for Cover, and is anything blocking it from appearing today?
+
+**A:** The Block Bindings panel in `packages/block-editor/src/hooks/block-bindings.js:40-100` calls:
+```js
+bindableAttributes:
+    __experimentalBlockBindingsSupportedAttributes?.[ blockName ],
+```
+And renders one row per attribute in `bindableAttributes`. The setting is populated server-side from `gutenberg_get_block_bindings_supported_attributes(block_type)`, which returns an empty array for `core/cover` today (no entry in the 6.8 snapshot, no filter adds it; `lib/compat/wordpress-6.9/block-bindings.php:118-167`).
+
+There is also an excluded-blocks list `BLOCK_BINDINGS_PANEL_EXCLUDED_BLOCKS` introduced in branch `try/75022-block-bindings-into-block-fields` (`packages/block-editor/src/components/block-bindings/excluded-blocks.js`):
+```js
+export const BLOCK_BINDINGS_PANEL_EXCLUDED_BLOCKS = [
+    'core/post-date',
+    'core/navigation-link',
+    'core/navigation-submenu',
+];
+```
+**Cover is not in this list**, so once the supported-attributes filter adds `id`/`url`, the bindings UI will render the two attribute controls automatically.
+
+Pattern Overrides "Enable overrides" button (`PatternOverridesControls`) is also gated on `__experimentalBlockBindingsSupportedAttributes?.[blockName]` being truthy (`packages/editor/src/hooks/pattern-overrides.js:39-58`), so adding the filter entry also unlocks Pattern Overrides for Cover. No additional Pattern-Overrides allow-list exists for blocks (it's gated purely on having any bindable attribute).
+
+**Reasoning:** The single PHP filter addition is the master switch. No additional client-side allow-listing is required.
+
+**Sources:** `packages/block-editor/src/hooks/block-bindings.js:40-100`; `packages/block-editor/src/components/block-bindings/excluded-blocks.js` (on `try/75022-block-bindings-into-block-fields`); `packages/editor/src/hooks/pattern-overrides.js:37-58`; `lib/compat/wordpress-6.9/block-bindings.php:118-167`.
+
+### Q13: What does the Block Fields UI (sibling pipeline `75022-block-bindings-into-block-fields`) require from a "bindable block"?
+
+**A:** Per branch `try/75022-block-bindings-into-block-fields`, the relevant additions are:
+- `packages/block-editor/src/components/block-bindings/use-block-bindings-compatible-fields.js` — a new hook that lists compatible binding sources for a given (block, attribute) pair, filtering by attribute `type`.
+- `packages/block-editor/src/components/block-bindings/excluded-blocks.js` — excludes a small list (cover not in it).
+- `packages/block-editor/src/components/block-bindings/attribute-control.js` — refactored to use the shared hook.
+
+The Block Fields UI surfaces bindable attributes through DataForm/DataView controls. A block needing to integrate with Block Fields needs:
+- An entry in `__experimentalBlockBindingsSupportedAttributes` (server-side allow-list).
+- Attribute `type` declared in `block.json` (Cover's `url`=string, `id`=number — both already declared).
+- Not be in `BLOCK_BINDINGS_PANEL_EXCLUDED_BLOCKS`.
+- An indicator that the attribute participates in "content" via `role: "content"` (Cover has it on `url`; `id` does not — recommended to add).
+
+Beyond those, no Cover-specific changes are needed to integrate with the Block Fields UI; the integration is automatic once the supported-attributes filter is in place.
+
+**Reasoning:** The 75022 work is generic across blocks. Cover-specific bindings work needs to not regress that integration; the design must verify Block Fields renders correctly for a bound Cover.
+
+**Sources:** `git diff trunk..try/75022-block-bindings-into-block-fields --stat -- packages/block-editor/src/components/block-bindings/`; the new files on that branch listed above.
+
+### Q14: What e2e test pattern exists for Block Bindings on existing blocks?
+
+**A:** The directory `test/e2e/specs/editor/various/block-bindings/` contains:
+- `custom-sources.spec.js` — tests image/paragraph/heading bindings against a fixture source registered by `packages/e2e-tests/plugins/block-bindings.php`.
+- `post-meta.spec.js` — tests post-meta source on image/paragraph/heading/button.
+- `post-data.spec.js` — tests post-data source.
+
+The fixture source (`packages/e2e-tests/plugins/block-bindings.php`) registers a `testing/complete-source` with text and url fields, including an image URL pointing at a fixture file uploaded as media via `requestUtils.uploadMedia`.
+
+Pattern Overrides e2e lives in `test/e2e/specs/editor/various/pattern-overrides.spec.js` (no Cover/image-specific cases currently). The pattern is: create a synced pattern with a bound block, insert the pattern in a post, override one instance, assert the rendered front-end output via the post-preview / front-end navigation.
+
+PR #74610 added a Cover-specific e2e (`test/e2e/specs/editor/blocks/cover.spec.js` describe block "Block Bindings") that asserts overlay color/opacity for a bound `url` resolves correctly. The pipeline's PR should include similar coverage for:
+1. `id`+`url` bound via Pattern Overrides — instance shows pattern default.
+2. Same block, override instance → asserts the rendered image src changes.
+3. Reset override → asserts back to default.
+4. Hidden controls assertion: parallax/repeat/replace/use-featured-image toggles are not in the DOM when binding active.
+
+**Reasoning:** The infrastructure exists; the spec should land in `test/e2e/specs/editor/blocks/cover.spec.js` (extending the existing Cover describe block) and/or `test/e2e/specs/editor/various/pattern-overrides.spec.js` if a synthesis test makes sense across blocks.
+
+**Sources:** `test/e2e/specs/editor/various/block-bindings/`; `test/e2e/specs/editor/various/pattern-overrides.spec.js`; `packages/e2e-tests/plugins/block-bindings.php`; PR #74610 diff adding Cover e2e.
+
+### Q15: What about `backgroundType: "embed-video"` — does it interact with bindings?
+
+**A:** `backgroundType: "embed-video"` was added to Cover after both prior bindings PRs were drafted. The server render (`packages/block-library/src/cover/index.php:20-131`) returns the embed iframe markup and **does not pass through to the bindings branch** for embed videos. The edit flow (`packages/block-library/src/cover/edit/index.js:366-415`) treats embed URLs as a separate branch via `onSelectEmbedUrl`.
+
+Per prompt Scope-Out: embed-video × bindings is OUT of scope. Per risk #3: "Confirm bindings UI does not appear or short-circuits when this is the active background type."
+
+Concretely:
+- The Block Bindings panel does **not** know about `backgroundType` and will show the `id`/`url` controls regardless. The implementation has two choices:
+  1. Leave the panel as-is and let the user bind a URL even with `backgroundType=embed-video`; the resolved URL will be treated as an embed (existing edit code path). This is the simplest but allows nonsensical combinations.
+  2. Hide the bindings UI controls when `backgroundType=embed-video` (requires custom logic outside the generic Block Bindings panel).
+- The simpler choice (1) keeps the panel generic and lets the user bind. The bound `url` value would flow into the embed flow as-is. The risk: a Pattern Overrides scenario where the pattern's Cover has an image background and an instance override sets `backgroundType=embed-video` is not a realistic flow — `backgroundType` itself is not bindable.
+
+Recommended in-scope handling: leave the bindings panel UI as-is (show controls); but in the edit component, when `backgroundType=embed-video`, the binding-aware derivation (effective `dimRatio`, overlay colour) should short-circuit (the embed-video branch already overrides display). The "hide parallax/repeat/replace/featured-image" rule still applies but is moot because those controls are already hidden for embed-video backgrounds in `inspector-controls.js`.
+
+**Reasoning:** Embed-video is a separate background type with its own render path. Bindings on `url` for an embed-video cover would mean "bind the embed URL", which is a coherent (if narrow) use case. Out-of-scope per prompt means we don't add bespoke logic for it; we just ensure existing embed-video covers don't regress.
+
+**Sources:** `packages/block-library/src/cover/index.php:19-131`; `packages/block-library/src/cover/edit/index.js:366-415,420-422`; prompt Scope-Out item 4.
+
+### Q16: Should `id` declare `role: "content"` like `core/image` does?
+
+**A:** `core/image` declares `role: "content"` on both `url` and `id` (`packages/block-library/src/image/block.json:25-31,78-81`). `core/cover` currently has it on `url` only. To stay consistent with image and to participate cleanly in any future Block Fields / content-role tooling, the design should add `"role": "content"` to `id` as well.
+
+This is a `block.json` change. It does NOT affect deprecation (no source/save shape change for the attribute), but it does affect what tools consider "content". Deprecation tests should be checked to confirm no behavioural change.
+
+**Reasoning:** Minimal change, increases consistency with the canonical pattern set by `core/image`. The prompt does not explicitly mention it, but it's a natural part of "make `id` and `url` bindable end-to-end".
+
+**Sources:** `packages/block-library/src/cover/block.json:18-20`; `packages/block-library/src/image/block.json:78-81`.
+
+### Q17: What server-side approach should the PR use to make the rendered HTML reflect bound values + the "effective dimRatio" + the "force hasParallax=false" rule?
+
+**A:** There are two viable approaches (the design phase must choose; this Q only enumerates the constraints):
+
+**Approach A — Add a custom `render_block` filter scoped to Cover.** The new `lib/compat/wordpress-7.1/block-bindings.php` (or `packages/block-library/src/cover/index.php`) would intercept the Cover's `render_block` and, when `metadata.bindings.url` (or `id`) is set:
+1. Resolve the bound value via `gutenberg_process_block_bindings`.
+2. Use the HTML Tag Processor to find the `<img class="wp-block-cover__image-background">` (or `<div ...>` if parallax) and rewrite `src` (or, if the saved markup is the parallax div, replace the div with an `<img>`).
+3. Rewrite the `wp-block-cover__background` span's class to use the effective `dimRatio` (i.e. swap `has-background-dim-100` → `has-background-dim-50`).
+4. Strip `has-parallax` and `is-repeated` classes from any element that has them.
+
+**Approach B — Generic `block_bindings_attribute_replaced_in_markup` filter** (PR #74610's approach). Synthesize `source: attribute, selector: img, attribute: src` for Cover's `url`, and rely on `gutenberg_replace_html`. Cover's `render_block_core_cover` would additionally need to handle the dimRatio/parallax/repeat class adjustments (Approach A's points 3–4).
+
+Constraints either approach must honour:
+- The bound `url` may or may not be derivable from an `id`; if `id` resolves to nothing, the substitution must NOT proceed and the cover should render without the broken image element (Q5 invariant).
+- The featured-image branch in `render_block_core_cover` must NOT also fire when bindings have resolved a value (Q9 mutual exclusion).
+- The class rewrite for dimRatio must be idempotent and safe across `style` variations.
+- No CSS-in-style-attribute rewriting (Q4 blocker).
+
+Either approach lands in `lib/compat/wordpress-7.1/block-bindings.php`. Approach B has minor reuse value for other blocks; Approach A is simpler and entirely block-scoped (less risk of unintended interaction with other blocks).
+
+**Reasoning:** This is a design-phase decision; the requirements only need to capture the constraints. The selected approach must explicitly preempt the parallax CSS-in-HTML issue and the dimRatio default issue per Q4 and Q10.
+
+**Sources:** PR #74610 diff (Approach B precedent); `lib/compat/wordpress-6.9/block-bindings.php:57-108,346-398`; `packages/block-library/src/cover/index.php` (existing render_block_core_cover, where Approach A would extend).
+
+### Q18: What is the precise list of UI controls to hide when a binding is active, and what gates each?
+
+**A:** Per prompt Scope-In:
+1. **Parallax toggle (`hasParallax`)** — gate: any binding on `url` (or `id`). Source: `packages/block-library/src/cover/edit/inspector-controls.js` (today the toggle is unconditionally rendered when `isImageBackground`; needs `!hasUrlBinding` gate).
+2. **Repeat toggle (`isRepeated`)** — same gate as parallax. Source: same file.
+3. **Media-replace control** — gate: `hasUrlBinding && !canEdit` (i.e. `lockUrlControls` ; for Pattern Overrides source which allows edits, the control stays visible — but only via the binding's replace flow, not direct edit). Need to confirm: prompt says "Hide the media-replace control (replacement happens via the binding source, not direct edit)" — this suggests always hide when bound, even for Pattern Overrides. The Pattern Overrides override flow uses the existing media-replace UI to set the override, so we need to keep it visible for Pattern Overrides but route it through `setValues`. **This is ambiguous in the prompt** — see open question OQ-1.
+4. **"Use featured image" toggle (`useFeaturedImage`)** — gate: any binding on `url` or `id`. Source: `packages/block-library/src/cover/edit/block-controls.js` and `inspector-controls.js`.
+
+Additional implicit hides:
+- Pattern Overrides "Enable overrides" button (already gated on bindable attributes existing) → no change needed.
+- Reset toolbar button (per existing `ResetOverridesControl`) → already exists; design phase decides whether to apply the prompt's "hide cleanly when default" rule.
+
+**Reasoning:** Each control needs an explicit gate, not a generic `lockUrlControls`. The prompt's "media-replace control" hide vs. Pattern Overrides flow needs clarification — see OQ-1.
+
+**Sources:** `packages/block-library/src/cover/edit/inspector-controls.js:222-260,468`; `packages/block-library/src/cover/edit/block-controls.js`; prompt Scope-In bullet list.
+
+### Q19: What about the saved (static) HTML? Does deprecation need updating?
+
+**A:** `block.json` and `save.js` do not change shape under this PR (no new attributes; no changed serialization). Adding `role: "content"` to `id` is metadata-only.
+
+If the implementation chooses to add `role: "content"` to `id`, no deprecation entry is needed — `role` is editor-only metadata, not part of the block markup.
+
+The Cover block has an extensive `deprecated.js` (existing). Adding a deprecation is only needed if a saved-markup change is introduced. Per prompt Architectural Constraint "No attribute mutation on binding detection", and per render-time effective values, there is no saved-markup change anticipated.
+
+**Reasoning:** Confirm during design that no `save.js` shape changes are required; if any do creep in, a deprecation entry becomes necessary.
+
+**Sources:** `packages/block-library/src/cover/deprecated.js` (existing deprecations); prompt Architectural Constraints.
+
+### Q20: What is the expected acceptance test for "PR diff under ~500 net lines"?
+
+**A:** Per prompt Acceptance Criteria: "PR diff is targeted (~under 500 net lines including tests). Architectural cleanliness gates scope."
+
+Counting net additions across affected files:
+- New file `lib/compat/wordpress-7.1/block-bindings.php` — ~50-120 lines (filter + optional render_block hook).
+- Optionally update `packages/block-library/src/cover/index.php` — ~30-60 net lines (render-time class/parallax/dimRatio adjustments).
+- `packages/block-library/src/cover/block.json` — +1 line (role on id).
+- `packages/block-library/src/cover/edit/index.js` — net additions for: `hasUrlBinding`/`lockUrlControls` derivation (~30 lines), single observer (~30 lines), effective-value derivation for url and dimRatio at render (~20 lines). Aim ~80 net lines added, some replacements.
+- `packages/block-library/src/cover/edit/inspector-controls.js` — gating of parallax/repeat (~10 lines).
+- `packages/block-library/src/cover/edit/block-controls.js` — gating of media-replace/featured-image (~10 lines).
+- E2E test: extend `test/e2e/specs/editor/blocks/cover.spec.js` with a new describe block (~80-120 lines).
+- Possibly fixture image upload helper.
+
+Total estimated: ~280-450 net lines. Reasonable to land under 500 if the server-side approach is concise.
+
+**Reasoning:** The budget is achievable; the main risk is the server-side render path bloating if Approach A is chosen and includes extensive HTML processing. The design should aim for the smallest possible server-side delta.
+
+**Sources:** Estimated against file sizes from `wc -l`; prompt Acceptance Criteria.
+
+### Q21: What is the expected commit / branch / PR target metadata?
+
+**A:** Per prompt Repo Target:
+- Branch (local worktree): `worktree-77199-cover-bindings-id-url-internal` (current branch).
+- PR target: `WordPress/gutenberg` `trunk`, from `cbravobernal/gutenberg` fork.
+- PR description must link #77199 and explicitly state which prior issues (#74109, #74610) it does and does not subsume.
+- Backport-changelog entry under `backport-changelog/7.1/` (PR #74610 used `backport-changelog/7.0/10739.md` since it was 7.0-scoped; this one is 7.1).
+
+**Reasoning:** Standard pipeline metadata.
+
+**Sources:** Prompt Repo Target section.
+
+### Q22: Are there any blockers — does any premise in the prompt contradict codebase reality?
+
+**A:** No outright contradictions. Areas where the prompt is slightly under-specified but not contradicted:
+- The phrasing "force `hasParallax=false` for the rendered output" implies a server-side rewrite of the saved markup when the saved markup baked in parallax. Codebase reality (Q4) confirms parallax saved markup is `<div style="background-image: url(...)">`, and the HTML API cannot edit CSS in `style`. The implementation must either:
+  - (a) On the server, when bindings are active, *replace* the `<div style="background-image">` element with `<img src="">` entirely (no CSS edit needed, just element swap), OR
+  - (b) Rely on the fact that bound covers are typically authored in patterns where `hasParallax` is not turned on, AND hide the parallax control before the user can set it on an already-bound cover.
+  
+  Option (a) is feasible with HTML Tag Processor (the `<div>` is uniquely identifiable by its class `wp-block-cover__image-background`).
+  
+  This is not a blocker — it's an implementation choice with two viable paths. Captured as design constraint.
+
+- The phrasing "reset hidden cleanly when the instance value already matches the default" — existing `ResetOverridesControl` disables the button rather than hides it. The prompt may be using "hidden" loosely. Captured as open question OQ-2.
+
+No blockers; proceeding.
+
+**Reasoning:** Standard sanity sweep of prompt assumptions against actual code.
+
+**Sources:** Q4, Q8, Q15, Q17 above.
+
+## Research
+
+### Cover block source layout (current trunk)
+
+- `packages/block-library/src/cover/block.json` (158 lines): attribute schema. `url` (string, role: content), `id` (number, no role), `useFeaturedImage` (boolean), `hasParallax` (boolean, default false), `isRepeated` (boolean, default false), `dimRatio` (number, default **100**), `overlayColor`, `customOverlayColor`, `isUserOverlayColor`, `backgroundType` (default "image"), `focalPoint`, `minHeight`, `gradient`, `customGradient`, `contentPosition`, `isDark` (default true), `templateLock`, `tagName` (default "div"), `sizeSlug`, `poster`.
+- `packages/block-library/src/cover/save.js` (195 lines): serialises to `<Tag>` wrapper with classes; image background as `<img>` if `!hasParallax && !isRepeated` else `<div style="background-image: url(...)">`; overlay span with `has-background-dim has-background-dim-{N}` class.
+- `packages/block-library/src/cover/index.php` (216 lines): `render_block_core_cover` handles embed-video and useFeaturedImage paths; otherwise returns `$content` as-is.
+- `packages/block-library/src/cover/edit/index.js` (767 lines): main React component. Contains `useEffect` for `useFeaturedImage`-driven mediaUrl observer; event handlers `onSelectMedia`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`, `toggleUseFeaturedImage`, `onSelectEmbedUrl`. Uses `propsRef` pattern (`useLayoutEffect`) to avoid stale closures across async `getMediaColor` calls.
+- `packages/block-library/src/cover/edit/inspector-controls.js` (468 lines): ToolsPanel with fixed background (parallax), repeated background, focal point, alt, image-size, overlay color, dim ratio, min-height, tag name.
+- `packages/block-library/src/cover/edit/block-controls.js` (151 lines): BlockControls toolbar group: media-replace, focal-point, full-height, content-position, "Use featured image".
+
+### Image block bindings wiring (reference pattern)
+
+- `core/image` has `id` (number, role: content), `url` (string, role: content, source: attribute, selector: img, attribute: src), `alt`, `title`, `caption`, `href` all with bindable roles.
+- `lockUrlControls` boolean derived via `useSelect` in `image.js:745-820`, used to gate URL input, MediaReplaceFlow, and other URL-dependent controls (lines 822–849, 934–945).
+- Pattern Overrides on image: existing e2e at `test/e2e/specs/editor/various/pattern-overrides.spec.js` lacks image-specific cases (verified via grep) — i.e. image bindings are exercised by `custom-sources.spec.js` and `post-meta.spec.js` only.
+
+### Server-side bindings flow (WP 6.9 compat)
+
+`lib/compat/wordpress-6.9/block-bindings.php`:
+- Adds caption/datetime/navigation-link URL support via `block_bindings_supported_attributes` filter (lines 11-31).
+- Exposes `__experimentalBlockBindingsSupportedAttributes` editor setting (lines 33-46).
+- `gutenberg_block_bindings_render_block` (lines 57-108): processes bindings, merges resolved values into instance attributes, re-renders the block, then iterates resolved attributes calling `gutenberg_replace_html`.
+- `gutenberg_replace_html` (lines 346-398): only handles `source: html|rich-text|attribute`; uses HTML Tag Processor to swap content or attribute values per the attribute's declared selector.
+- `gutenberg_process_block_bindings` (lines 209-333): expands `__default` (pattern-overrides) into per-attribute bindings; resolves each binding via the source's `get_value`.
+
+### Prior-attempt evidence (NOT inheritance)
+
+Branch `add/cover-block-bindings-support-v2` (most recent commit `565e655b70e`, 2026-01-13):
+- 44 files changed, +775/-6038 lines (severely rotted; conflicts with current 7.0/7.1 dirs that no longer exist on this branch).
+- The cover-relevant changes: `block.json` unchanged from trunk, `index.php` adds a `has_url_binding` branch and the `block_core_cover_insert_image_before_inner_container` helper, `edit/index.js` adds `hasImageBinding` state with multiple `useEffect`s reacting to mediaUrl, originalUrl, hasImageBinding, etc., and `lockUrlControls` via `canUserEditValue`. Also adds Pattern-Overrides reset shortcut in `onClearMedia`. Adds `dimRatioInitialized` state to gate the 100→50 downshift.
+- This is the architecture @ockham rejected (Q6). Harvest fragments: the `has_url_binding` server-side branch is useful evidence for Approach A in Q17, but mutates attributes (e.g. `setAttributes({useFeaturedImage: false})` from inside `useEffect`) — violates the "no attribute mutation on binding detection" invariant.
+
+Branch `add/cover-block-bindings-support` (older, `721cefb818c` "Fix dim"):
+- 5 commits. Earlier exploration; superseded by v2.
+
+PR #74610 (draft, open as of fetch time, title "Block Bindings: Add support for Cover block id and url attrs"):
+- Body acknowledges: dimRatio 100 default issue (resolved by downshift in useEffect); url-only-bound external image not handled; parallax not supported due to CSS-in-style.
+- Adds `block_bindings_attribute_replaced_in_markup` filter to synthesise sourced-attribute metadata for Cover's url at runtime.
+- Adds Cover bindings e2e in `test/e2e/specs/editor/blocks/cover.spec.js` asserting overlay color/opacity.
+- Reviewer comments include the architectural request (Q6) and a note to move backport-changelog to `7.1/`.
+
+PR #74109 (draft, open, title "Block Bindings: Add Cover block support."):
+- Reviewer @ockham flagged the event-handler-keyed `useEffect` approach (comment at edit/index.js:282) and suggested the source-agnostic single-observer refactor (Q6).
+- Multiple TODOs around video bg, featured image, e2e, reset-hidden default. Many resolved in subsequent commits.
+
+### Pattern Overrides reset semantics
+
+- `core/pattern-overrides` source defined at `packages/editor/src/bindings/pattern-overrides.js`; `getValues` returns block's own attribute when not overridden, override value when set; `setValues` writes into the parent `core/block`'s `content` attribute.
+- `ResetOverridesControl` (toolbar button) `disabled` when not overridden — that's the existing "hidden when default" semantics. May be revisited in design phase per OQ-2.
+- Server-side `__default: core/pattern-overrides` expansion: `lib/compat/wordpress-6.9/block-bindings.php:257-281` — when a block has `metadata.bindings.__default.source = core/pattern-overrides`, all `supported_block_attributes` are auto-bound to pattern overrides.
+
+### `useEffectEvent` availability
+
+Confirmed exported from `@wordpress/element` (referenced in `packages/element/README.md:472` and `packages/element/build-module/react.mjs:23,97`). This is the recommended primitive (React 19) for letting `useEffect` body call functions whose latest props/state are read without those values being in the dep array — directly enables @ockham's single-observer pattern without the stale-closure pitfalls.
+
+### Open questions for the design phase
+
+- **OQ-1.** When a Pattern Overrides override is active, does the Cover block's MediaReplaceFlow stay visible and write the override (via `setValues`), or is it hidden in favour of editing the override only from outside the cover? Prompt says "Hide the media-replace control" but Pattern Overrides typically uses the existing replace flow to author the override. Design must resolve.
+- **OQ-2.** Should the "Reset to default" affordance be **disabled** (existing `ResetOverridesControl` behaviour) or **hidden** (prompt phrasing "hide cleanly when default")? Recommend disable, matches existing behaviour and is consistent with other bindable blocks.
+- **OQ-3.** Server-side approach: Approach A (cover-specific render filter) vs Approach B (generic `block_bindings_attribute_replaced_in_markup` filter from #74610). Design phase to pick based on simplicity and reuse value.
+- **OQ-4.** When a Cover with `hasParallax=true` and `isRepeated=true` already in saved markup gains a binding via "Enable overrides", what should happen on the server render? Option: replace the `<div style="background-image">` element with `<img>`, dropping `style` entirely, and ensure overlay span class drops `has-parallax`/`is-repeated` if present. Captured here so the design picks an explicit rule.
+- **OQ-5.** Is there any restriction on which binding sources `id`+`url` should expose (e.g. require both attributes to bind to the same source)? Prompt's "Internal-only invariant" implies yes — design phase to specify the validation.
+
+## Consolidated Requirements
+
+The following is a numbered list of all requirements the implementation must satisfy. Each captures WHAT, not HOW.
+
+### A. Block-level metadata and registration
+
+1. The `id` attribute on `core/cover` (`packages/block-library/src/cover/block.json`) MUST be marked as a content-role attribute consistent with `core/image` (i.e. declare `"role": "content"`).
+2. A new file `lib/compat/wordpress-7.1/block-bindings.php` MUST be created and required from `lib/load.php`. It MUST register a filter that adds `'id'` and `'url'` to `gutenberg_get_block_bindings_supported_attributes('core/cover')`.
+3. The implementation MUST NOT change the schema of any other attribute in `core/cover`'s `block.json`. No new attributes are introduced.
+
+### B. Editor (client) — UI gating
+
+4. When a binding is present on `core/cover`'s `url` (or `id`), the parallax toggle (`hasParallax`) in the inspector controls MUST be hidden.
+5. When a binding is present on `core/cover`'s `url` (or `id`), the repeated-background toggle (`isRepeated`) in the inspector controls MUST be hidden.
+6. When a binding is present on `core/cover`'s `url` (or `id`), the "Use featured image" toggle MUST be hidden (both in block toolbar and in any other surface where it appears).
+7. When a binding is present AND the bound source's `canUserEditValue` returns false, the media-replace control MUST be hidden. (Design phase resolves OQ-1 for the Pattern Overrides case.)
+8. The Block Bindings UI (legacy Attributes panel and any Block Fields UI) MUST render bindable rows for `id` and `url` on `core/cover` automatically, without Cover-specific UI code, by virtue of requirement 2.
+9. Pattern Overrides controls (`Enable overrides` button, `ResetOverridesControl` toolbar button) MUST work for `core/cover` without Cover-specific changes, by virtue of requirement 2.
+
+### C. Editor (client) — reactive derivation
+
+10. The Edit component MUST contain a single reactive observer (one `useEffect` or equivalent, using `useEffectEvent` to access latest non-observed values without stale closures) that derives **all** dependent state from the effective `url` (and `id` where relevant) regardless of whether the URL is provided manually, by `useFeaturedImage`, or by a binding source.
+11. The reactive observer MUST NOT write to attributes on detection that a binding is present. Specifically: it MUST NOT mutate `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, or any other attribute as a side-effect of a binding becoming active or inactive.
+12. The reactive observer MUST update the overlay colour from the resolved image's average colour when `isUserOverlayColor` is false, irrespective of how the URL was set.
+13. The reactive observer MUST be resilient to concurrent async resolution of `getMediaColor` such that a stale resolved colour does not overwrite a newer one (the existing `propsRef`/`useEffectEvent` pattern).
+
+### D. Editor (client) — effective values at render time
+
+14. When a binding is active on `url`/`id`, the `dimRatio` used to compute the displayed overlay opacity MUST be derived at render time. If the stored `dimRatio` is the default value (100) and the bound URL resolves to a non-empty value, the rendered overlay MUST use a non-opaque effective value (target: 50). The stored attribute MUST NOT be changed.
+15. The effective `url` used by the edit preview MUST give precedence to a bound `url` over `useFeaturedImage`'s `mediaUrl`. If both are present, the bound value wins; `useFeaturedImage`'s value is ignored at render.
+16. When `url` is bound but `id` is unset (or vice versa, in any combination that cannot be resolved against an attachment in the media library), the edit component MUST surface a clear "internal media required" UX — for example, a visible message in the placeholder or inspector — rather than rendering the cover with a broken image element. The chosen surface is a design decision; the visibility requirement is the constraint.
+
+### E. Server — render correctness
+
+17. The server-side rendered markup for a Cover block with bindings on `id`/`url` MUST contain an `<img>` (not a `<div style="background-image: ...">`) for the resolved internal-media image, even if the saved markup serialised the parallax/repeat path. Parallax styling MUST be effectively off in the rendered output when bindings are active.
+18. The server-side rendered overlay span MUST use the effective `dimRatio` derived per requirement 14 (i.e. swap `has-background-dim-100` → `has-background-dim-50` class when the saved attribute is 100 and bindings have resolved a value).
+19. The server render MUST short-circuit the `useFeaturedImage` branch in `render_block_core_cover` when bindings have resolved a value for `url` and/or `id`, to prevent double-insertion of an image element.
+20. The server render MUST resolve `url` and `id` consistently — if `id` cannot be resolved to a media-library attachment (or if `url` cannot be derived from the resolved `id`), the cover MUST render without an image element (no broken `<img>`).
+21. The server-side bindings-resolution mechanism (whether via the `block_bindings_attribute_replaced_in_markup` filter or a Cover-scoped render_block hook — design phase decides) MUST be additive only: it MUST NOT change the behaviour of any other block whose attribute uses `gutenberg_replace_html`.
+
+### F. Cross-cutting invariants
+
+22. Unbound Cover behaviour MUST be unchanged: no regression on parallax, repeat, focal point, featured image, embed-video, dim ratio, overlay colour, alt text, image-size selection.
+23. Pattern Overrides on Cover MUST round-trip cleanly through editor save/load and server render for the four enumerated states: (a) default (no override), (b) overridden, (c) reset-to-default with binding active, (d) reset-disabled-or-hidden when the instance value already matches the default. (OQ-2 resolves disabled vs hidden.)
+24. External (non-media-library) URL binding MUST NOT be silently honoured. If a binding source returns a `url` without a corresponding resolvable `id`, the cover MUST treat the binding as unresolvable per requirement 16 (editor) and requirement 20 (server).
+25. `backgroundType: "embed-video"` MUST continue to render correctly and MUST NOT regress. The bindings UI is allowed to expose `url` for binding even when `backgroundType=embed-video`; no Cover-specific suppression of the bindings panel is required, but the binding-aware derivations (effective dimRatio, overlay colour) SHOULD short-circuit when `backgroundType=embed-video`.
+26. The PR MUST NOT introduce new global Block Bindings APIs beyond a reused filter (`block_bindings_attribute_replaced_in_markup` if Approach B is taken). Any new filter introduced MUST be carry weight against a cover-specific render path during the design phase.
+
+### G. Tests
+
+27. A new e2e test MUST cover: creating a Cover, binding its `url`+`id` to a Pattern Overrides source, asserting the editor and rendered front-end show the pattern default.
+28. The same e2e test MUST cover: overriding the value on a pattern instance, asserting the rendered output reflects the override.
+29. The same e2e test MUST cover: resetting the override, asserting the rendered output returns to the pattern default.
+30. The e2e test MUST assert that the parallax toggle, repeat toggle, media-replace control (where lockable), and featured-image toggle are NOT in the DOM (or are NOT enabled) when a binding is active on the Cover instance.
+31. The PHP test suite SHOULD include a `phpunit` test asserting that `render_block_core_cover` substitutes the bound `url` into the rendered `<img src>` and that the dimRatio class is rewritten when the saved value is the default 100.
+32. Existing Cover tests (`packages/block-library/src/cover/test/edit.js`) MUST continue to pass.
+
+### H. Project metadata / PR shape
+
+33. The new file MUST live under `lib/compat/wordpress-7.1/block-bindings.php` (NOT 7.0). A `backport-changelog/7.1/<core-pr-number>.md` entry MUST be added when the corresponding Core PR is opened.
+34. The PR description MUST link issue #77199 and explicitly call out whether it subsumes #74109 and #74610.
+35. The net diff (including tests) SHOULD target under ~500 lines per prompt Acceptance Criteria.
+36. The PR MUST be portable: the implementation MUST gracefully degrade on a WP install that does not yet have any of the bindings infrastructure changes (the existing `! function_exists` / version-guard pattern in the 6.9 compat file is the precedent).
+
+### I. Explicitly out of scope (for traceability)
+
+37. Binding `url` to an arbitrary external URL with no `id` is OUT OF SCOPE. (Q5)
+38. Parallax + bindings combined behaviour beyond "force off" is OUT OF SCOPE. No CSS-in-style HTML rewriting. (Q4)
+39. Featured-image-as-binding (using bindings to express the use-featured-image behaviour) is OUT OF SCOPE — separate follow-up. (Q9)
+40. `backgroundType: "embed-video"` × bindings beyond non-regression is OUT OF SCOPE. (Q15)
+41. New global Block Bindings APIs beyond at most one reused filter are OUT OF SCOPE.
+42. Post-data source acquiring a `featured_media.url` / `featured_media.id` field (the "follow-up" from #74610 description) is OUT OF SCOPE.

From 521b5a4d2968714cf4ec2e99cec0fe3b9b357bd1 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:17:21 +0200
Subject: [PATCH 06/60] docs(pipeline): add 1-spec/spec.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../1-spec/spec.md                            | 171 ++++++++++++++++++
 1 file changed, 171 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
new file mode 100644
index 00000000000000..b8a5fb6cc717be
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
@@ -0,0 +1,171 @@
+# Spec: Cover block bindings — internal-only support for `id` and `url`
+
+## Overview
+
+The `core/cover` block does not support Block Bindings. Two prior draft PRs stalled over architectural objections (event-handler-driven `useEffect` proliferation), an HTML-rewrite blocker (CSS values inside `style` attributes cannot be edited by the WP HTML API), and scope creep around external URLs. This feature lands narrowly-scoped Block Bindings support for the `id` and `url` attributes of `core/cover`, restricted to internal media library items, with Pattern Overrides as the headline use case. When a binding is active, Cover-specific controls that would conflict with bindings (parallax, repeat, media-replace under non-editable sources, use-featured-image) are hidden, and dependent values (overlay color, effective dim ratio) are derived from the bound URL at render time without ever mutating stored attributes. The server render produces correct `<img>` markup with parallax effectively off.
+
+## Glossary
+
+- **Bound `url` / `id`**: a Cover attribute whose `metadata.bindings.<attr>` is set to a binding source (e.g. `core/pattern-overrides`, `core/post-meta`).
+- **Internal media**: an attachment that exists in the site's media library; identified by a numeric attachment `id` from which the `url` can be derived.
+- **Effective value**: a value computed at render time from the resolved bound values, used for display only; never written back to the stored attribute.
+- **Pattern Overrides**: the `core/pattern-overrides` binding source — pattern authors mark attributes overridable; pattern instances may override per-instance and reset to default.
+- **Reactive observer**: a single `useEffect` (using `useEffectEvent` for stable access to latest values) that derives all dependent state from the effective `url` regardless of how the URL arrived (manual, featured image, binding).
+
+## Requirements
+
+### A. Metadata and registration
+
+1. `core/cover`'s `id` attribute MUST declare `"role": "content"` (matching `core/image`). No other attribute schema changes.
+2. A new file `lib/compat/wordpress-7.1/block-bindings.php` MUST be created and required from `lib/load.php`. It MUST register a filter that adds `id` and `url` to `gutenberg_get_block_bindings_supported_attributes('core/cover')`. The filter MUST follow the established `! function_exists` / version-guard pattern.
+3. No other `block.json` shape changes for `core/cover`. No new attributes.
+
+### B. Editor — UI gating when a binding is present
+
+4. The parallax toggle (`hasParallax`) MUST be hidden whenever a binding is present on `url` or `id`.
+5. The repeated-background toggle (`isRepeated`) MUST be hidden whenever a binding is present on `url` or `id`.
+6. The "Use featured image" toggle MUST be hidden whenever a binding is present on `url` or `id`, in every surface where it appears (block toolbar, inspector).
+7. The media-replace control MUST be hidden when a binding is present AND the bound source's `canUserEditValue` returns false. (Pattern Overrides allows edits — see OQ-1.)
+8. The Block Bindings UI (legacy Attributes panel and Block Fields UI from sibling pipeline 75022) MUST surface bindable rows for `id` and `url` on `core/cover` automatically, with no Cover-specific UI code beyond requirement 2.
+9. Pattern Overrides controls (`Enable overrides` button, `ResetOverridesControl`) MUST work for `core/cover` automatically, with no Cover-specific UI code.
+
+### C. Editor — reactive derivation (single-observer architecture)
+
+10. The Edit component MUST derive all dependent state (overlay color, effective dim ratio, effective URL, lock flags) from a single reactive observer keyed on the effective `url`. The observer MUST be source-agnostic: identical behavior whether the URL arrived manually, via `useFeaturedImage`, or via a binding source.
+11. The observer MUST NOT mutate any block attribute as a side effect of a binding becoming active or inactive. Specifically: `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, `customOverlayColor` MUST NOT be written from inside the observer.
+12. The observer MUST update overlay color from the resolved image's average color when `isUserOverlayColor` is false, regardless of URL source.
+13. The observer MUST be resilient against concurrent async `getMediaColor` resolutions: a stale color MUST NOT overwrite a newer one.
+
+### D. Editor — render-time effective values
+
+14. When a binding is active on `url`/`id` AND the stored `dimRatio` equals the default value (100) AND the bound URL resolves to a non-empty value, the rendered overlay MUST use a non-opaque effective dim ratio (target: 50). The stored `dimRatio` attribute MUST NOT change.
+15. The effective `url` used by the editor preview MUST prefer the bound `url` over `useFeaturedImage`'s `mediaUrl` when both are present. The bound value wins.
+16. When `url` is bound but the binding-resolved `id` is missing or does not resolve to an attachment in the media library (the "external URL" case), the editor MUST surface a visible "internal media required" affordance (placeholder copy, notice, or equivalent) instead of rendering the cover with a broken image. The exact surface is a design choice; visibility is the requirement.
+
+### E. Server — render correctness
+
+17. When bindings have resolved `url`/`id` for a Cover, the server-rendered markup MUST contain an `<img>` element for the resolved image (NOT a `<div style="background-image: url(...)">`), even if the saved markup was the parallax/repeat form. Parallax styling MUST be effectively off in the rendered output when bindings are active.
+18. The server-rendered overlay span class MUST reflect the effective dim ratio from requirement 14: when the stored `dimRatio` is the default 100 AND a binding resolves a URL, the overlay span class MUST be rewritten from `has-background-dim-100` to `has-background-dim-50` (or equivalent non-opaque value).
+19. The server render MUST short-circuit the existing `useFeaturedImage` image-injection path in `render_block_core_cover` when bindings have resolved a value for `url` and/or `id`. Double image insertion MUST NOT occur.
+20. If the binding cannot resolve `id` to a media-library attachment (or `url` cannot be derived from the resolved `id`), the server MUST render the cover WITHOUT an image element. No broken `<img src>` / `<img src="">` may be emitted.
+21. The server-side mechanism (whether a Cover-scoped `render_block` filter or reuse of a generic `block_bindings_attribute_replaced_in_markup` filter — see OQ-3) MUST be additive: it MUST NOT change behavior for any other block.
+
+### F. Cross-cutting invariants
+
+22. Unbound Cover behavior MUST be unchanged: no regression on parallax, repeat, focal point, featured image, embed-video, dim ratio, overlay color, alt text, image-size selection, deprecation chain.
+23. Pattern Overrides MUST round-trip cleanly through editor save/load and server render for four enumerated states:
+   - (a) **default, no override**: bound value equals the block's own attribute; instance renders the pattern default.
+   - (b) **overridden**: instance value differs from pattern default; renders the override.
+   - (c) **reset-to-default with binding active**: user clicks Reset; instance returns to pattern default.
+   - (d) **reset-affordance suppressed when instance value already matches default**: Reset is disabled (existing `ResetOverridesControl` semantics) or hidden — design phase resolves; OQ-2.
+24. External URL binding MUST NOT be silently honored. A binding source returning a `url` without a resolvable internal `id` MUST be treated as unresolvable per requirement 16 (editor) and requirement 20 (server).
+25. `backgroundType: "embed-video"` MUST continue to render correctly and MUST NOT regress. The bindings panel MAY expose `url` even for embed-video covers (no Cover-specific suppression required), but the binding-aware derivations (effective dim ratio, overlay color) SHOULD short-circuit when `backgroundType === "embed-video"`.
+26. The PR MUST NOT introduce new global Block Bindings APIs. If a reused filter (e.g. `block_bindings_attribute_replaced_in_markup`) is needed, it MUST be weighed against a Cover-scoped render path during design.
+
+### G. Tests
+
+27. A new e2e test MUST create a Cover, bind its `url`+`id` to a Pattern Overrides source, and assert the editor preview AND the rendered front-end show the pattern default.
+28. The same e2e test MUST override the value on a pattern instance and assert the rendered output reflects the override (different `<img src>`, correct dim ratio class).
+29. The same e2e test MUST reset the override and assert the rendered output returns to the pattern default.
+30. The e2e test MUST assert that the parallax toggle, repeat toggle, media-replace control (where the source disallows editing), and featured-image toggle are NOT present (or NOT enabled) when a binding is active.
+31. A PHPUnit test SHOULD assert that `render_block_core_cover` substitutes the bound `url` into the rendered `<img src>` AND rewrites the dim ratio class when the saved value is the default 100.
+32. Existing Cover unit tests (`packages/block-library/src/cover/test/edit.js`) MUST continue to pass; existing Cover e2e tests MUST continue to pass.
+
+### H. PR shape and project metadata
+
+33. The new compat file MUST live at `lib/compat/wordpress-7.1/block-bindings.php` (NOT 7.0). A `backport-changelog/7.1/<core-pr-number>.md` entry MUST be added when the corresponding Core PR exists.
+34. The PR description MUST link issue #77199 and explicitly state whether it subsumes prior PRs #74109 and #74610.
+35. The net diff (including tests) SHOULD target under ~500 lines.
+36. The implementation MUST gracefully degrade on a WP install lacking the bindings infrastructure changes (use the existing `! function_exists` / version-guard pattern).
+
+## Out of Scope
+
+The following are explicitly excluded from this work. They are not deferred-but-acknowledged inside this PR; they are non-goals:
+
+- **External / non-media-library URL binding.** Binding `url` to an arbitrary URL with no resolvable internal `id` is not supported. The cover surfaces an "internal media required" UX instead.
+- **Parallax × bindings interaction beyond "force off".** No CSS-in-style HTML rewriting. When bindings are active, parallax styling is suppressed (server emits `<img>`, no `<div style="background-image: ...">`); the UI hides the parallax toggle.
+- **Embed-video × bindings interaction.** `backgroundType: "embed-video"` is not specifically supported with bindings beyond non-regression. No Cover-specific suppression of the bindings panel is added.
+- **Featured-image binding for Cover.** Binding `url`/`id` to express "use the post featured image" is a separate follow-up PR. This PR merely hides the `useFeaturedImage` toggle when a binding is active and ensures the server render does not double-insert images.
+- **New global Block Bindings APIs.** No new globally-registered Block Bindings APIs are introduced. At most one already-proposed filter (`block_bindings_attribute_replaced_in_markup`) may be reused; introducing it is weighed against a Cover-scoped server-render path during design.
+- **Post-data source `featured_media.url` / `featured_media.id` field.** Out of scope.
+
+## Acceptance Criteria
+
+Given-When-Then form. Each criterion is independently testable.
+
+### Bindings discovery
+
+- **AC-1.** Given a `core/cover` block selected in the editor on a site running this build, when the user opens the Block Bindings UI (legacy Attributes panel or Block Fields UI), then the panel lists `url` and `id` as bindable attributes.
+- **AC-2.** Given a `core/cover` block in a synced pattern, when the pattern author opens the Pattern Overrides controls, then the "Enable overrides" affordance is available for the Cover block.
+
+### Internal-media-only invariant
+
+- **AC-3.** Given a binding source resolves `url` to an attachment URL AND `id` to the corresponding media-library attachment id, when the editor renders the Cover, then the editor preview shows the resolved image.
+- **AC-4.** Given a binding source resolves `url` to a string but `id` is missing or resolves to a non-attachment, when the editor renders the Cover, then the cover displays a visible "internal media required" affordance and does NOT render a broken `<img>`.
+- **AC-5.** Given the same unresolvable binding state, when the server renders the Cover, then the rendered HTML contains no `<img>` element for the bound URL.
+
+### Pattern Overrides round-trip
+
+- **AC-6.** Given a synced pattern with a Cover whose `url`+`id` are bound to `core/pattern-overrides`, when an instance is inserted with no override applied, then both the editor preview and the front-end render show the pattern default image.
+- **AC-7.** Given an inserted pattern instance with the Cover image overridden via the editor, when the post is saved and rendered on the front end, then the rendered `<img src>` is the override URL.
+- **AC-8.** Given an overridden Cover instance, when the user clicks "Reset" on the toolbar `ResetOverridesControl`, then the override is cleared and both editor preview and front-end render return to the pattern default.
+- **AC-9.** Given a Cover instance with no override applied (value matches pattern default), when the user looks at the toolbar, then the `ResetOverridesControl` is disabled (or hidden per OQ-2 resolution).
+
+### Control hiding
+
+- **AC-10.** Given a Cover block with any binding present on `url` or `id`, when the user inspects the inspector controls, then the parallax toggle is NOT in the DOM.
+- **AC-11.** Given a Cover block with any binding present on `url` or `id`, when the user inspects the inspector controls, then the repeat toggle is NOT in the DOM.
+- **AC-12.** Given a Cover block with any binding present on `url` or `id`, when the user inspects the block toolbar and inspector controls, then the "Use featured image" toggle is NOT in the DOM.
+- **AC-13.** Given a Cover block bound to a source whose `canUserEditValue` returns false (e.g. `core/post-meta`), when the user inspects the block toolbar, then the media-replace control is NOT in the DOM.
+- **AC-14.** Given a Cover block bound to `core/pattern-overrides`, when the user inspects the block toolbar, then the media-replace control is present (Pattern Overrides allows edits) — pending OQ-1 resolution.
+
+### Render-time effective values
+
+- **AC-15.** Given a newly inserted Cover with default `dimRatio: 100` and a binding resolving a non-empty `url`, when the editor renders the cover, then the displayed overlay is NOT fully opaque (effective dim ratio 50 applied).
+- **AC-16.** Given the same Cover, when the server renders the cover, then the overlay span class is `has-background-dim-50` (or equivalent non-opaque), NOT `has-background-dim-100`.
+- **AC-17.** Given a Cover with `dimRatio` explicitly set to a non-default value (e.g. 70) and a binding resolving a URL, when either editor or server renders, then the displayed overlay uses the stored value (70). The stored attribute is unchanged.
+- **AC-18.** Given a Cover with `useFeaturedImage: true` and a binding present on `url`, when either editor or server renders, then the bound `url` is shown, NOT the featured image URL. Server render does NOT inject a second `<img>` for the featured image.
+- **AC-19.** Given a Cover with `hasParallax: true` and `isRepeated: true` saved in markup, and a binding subsequently activated on `url`, when the server renders the cover, then the output contains an `<img>` (not a `<div style="background-image">`), the `has-parallax` and `is-repeated` classes are not applied to that element, and no `style="background-image: ..."` substitution is attempted.
+
+### Architecture (verifiable from code review, not at runtime)
+
+- **AC-20.** The Edit component contains a single observer for URL-derived state. There is NOT a separate `useEffect` per event handler (no observer keyed on "media-replaced", another on "blur", another on "binding-detected").
+- **AC-21.** The observer never calls `setAttributes` for `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, or `customOverlayColor` as a result of a binding becoming active or inactive.
+
+### Non-regression
+
+- **AC-22.** Given an existing unbound Cover block (with or without `hasParallax`, `isRepeated`, `useFeaturedImage`, `backgroundType: "embed-video"`, custom overlay color, custom dim ratio, custom focal point), when the editor and server render the block, then the output is identical to the current trunk behavior. No deprecation chain breakage.
+- **AC-23.** Given an existing Cover with `backgroundType: "embed-video"`, when the editor opens the bindings UI, then the panel still lists `url`/`id` as bindable; but the binding-aware effective-dim-ratio / overlay-color derivations short-circuit (no auto-color from embed URL). The embed render path is unchanged.
+
+### Tests present
+
+- **AC-24.** The repository contains an e2e test that exercises Pattern Overrides on Cover end-to-end (create pattern with bound Cover, insert, override instance, reset) and asserts both editor preview and rendered front-end output.
+- **AC-25.** The e2e test asserts the hidden-controls invariants (AC-10..AC-13) on a bound Cover.
+- **AC-26.** A PHPUnit test asserts server-side URL substitution and dim ratio class rewriting for a bound Cover.
+
+### PR shape
+
+- **AC-27.** The new server-side filter file lives at `lib/compat/wordpress-7.1/block-bindings.php` and is loaded via `lib/load.php`. No file is created under `lib/compat/wordpress-7.0/`.
+- **AC-28.** The PR description links #77199 and explicitly states the relationship to #74109 and #74610.
+- **AC-29.** The net diff (additions − deletions) is under ~500 lines including tests.
+
+## Risks
+
+1. **Pattern Overrides reset semantics** historically broke. The four enumerated states (AC-6..AC-9) must all round-trip; existing `ResetOverridesControl` behavior must be respected or extended.
+2. **`dimRatio: 100` default with a binding** is the specific opaque-overlay regression that stalled prior PRs. Solution lives in render-time effective value, NOT attribute mutation.
+3. **`backgroundType: "embed-video"`** was added after prior bindings PRs; must not regress and must short-circuit the binding-aware derivations cleanly.
+4. **Reviewer @ockham gates this area.** Prior objections (event-keyed `useEffect` proliferation, scattered derivation logic, internal-only scope) must be preempted in the design doc, not surfaced during PR review.
+5. **HTML rewriting blocker**: the WordPress HTML API cannot edit CSS values inside `style` attributes. The implementation MUST avoid that path — i.e. the server cannot rewrite `<div style="background-image: url(...)">`; it must emit `<img>` instead when bindings are active.
+
+## Open Questions (carried to design phase)
+
+These are questions for phase 2 (design doc). The design phase MUST resolve all five before implementation.
+
+- **OQ-1. Media-replace visibility under Pattern Overrides.** The prompt says "Hide the media-replace control (replacement happens via the binding source, not direct edit)." But Pattern Overrides typically uses the existing media-replace flow to author the override (via `setValues`). Should the media-replace control stay visible for Pattern Overrides (and write through to the binding) and hide only for sources where `canUserEditValue` returns false? Or hide it universally and route the override through a different surface?
+- **OQ-2. Reset affordance: disabled or hidden when value matches default?** The prompt says "Reset must hide cleanly when the instance value already matches the default override state." Existing `ResetOverridesControl` disables the button rather than hiding it. Pick disable (existing, consistent across all bindable blocks) or hide (matches prompt phrasing). Recommendation in requirements is "disable", but the design phase formally decides.
+- **OQ-3. Server-side approach: Approach A vs Approach B.**
+  - **A.** Add a Cover-scoped `render_block` filter (in `lib/compat/wordpress-7.1/block-bindings.php` or `packages/block-library/src/cover/index.php`) that handles binding resolution, URL substitution, dim ratio class rewrite, parallax class strip, and `useFeaturedImage` short-circuit in one place.
+  - **B.** Reuse the generic `block_bindings_attribute_replaced_in_markup` filter (from PR #74610) to synthesize `source: attribute, selector: img, attribute: src` for Cover's `url`, plus a smaller Cover-specific path for dim ratio / parallax handling.
+  - Trade-off: A is entirely block-scoped (less cross-block risk); B has reuse value for future blocks with non-source-declared bindable attributes.
+- **OQ-4. Saved-markup parallax/repeat replacement on server.** When a Cover saved with `hasParallax: true` and/or `isRepeated: true` gains a binding via "Enable overrides", the server-render must replace the `<div style="background-image: url(...)">` element with an `<img>` and strip `has-parallax`/`is-repeated` classes. The HTML Tag Processor can perform element replacement when the element is uniquely identifiable by class (`wp-block-cover__image-background`). Confirm in design that this is the chosen mechanism and that it is safe across all known cover markup variations.
+- **OQ-5. Binding source validation: must `id` and `url` bind to the same source?** The internal-only invariant implies the same source provides both. Should the editor validate that `metadata.bindings.id.source === metadata.bindings.url.source`? Should it block save if they differ? Or treat any mismatch as an unresolvable binding per AC-4?

From 7a244683ade6c8129a37f10df5a1ac195ea24144 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:21:13 +0200
Subject: [PATCH 07/60] docs(pipeline): add 1-spec/spec-review-1-rejected.md
 for 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../1-spec/spec-review-1-rejected.md          | 126 ++++++++++++++++++
 1 file changed, 126 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-1-rejected.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-1-rejected.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-1-rejected.md
new file mode 100644
index 00000000000000..d809de1cc690fe
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-1-rejected.md
@@ -0,0 +1,126 @@
+# Spec Review
+
+## Verdict: rejected
+
+## Summary
+
+The spec is well-organized, traces back to the prompt and requirements thoroughly, and gives the design phase a strong scaffold. Glossary, Out-of-Scope, and Given-When-Then ACs are all in good shape. However the spec has several internal contradictions and HOW-bleed that would let two implementers build different things, plus one AC that asserts a behaviour the spec explicitly says is unresolved. These are real defects, not stylistic preference — they need a focused rewrite pass before the spec is implementable. Most issues are major; a couple are minor and could be addressed in the design phase if the major ones get fixed.
+
+## Issues
+
+### Issue 1: AC-14 asserts behaviour the spec says is unresolved (OQ-1) [blocker]
+
+**What's wrong:** AC-14 reads "Given a Cover block bound to `core/pattern-overrides`, when the user inspects the block toolbar, then the media-replace control is present (Pattern Overrides allows edits) — pending OQ-1 resolution." An acceptance criterion cannot simultaneously assert an observable outcome AND defer the outcome to a later phase. Either the media-replace control is present under Pattern Overrides (and AC-14 is testable now) or the outcome is unresolved (and AC-14 should not exist yet, or should be reworded as a conditional contract on the OQ-1 resolution).
+
+The same issue partially affects Req 7 ("MUST be hidden when ... `canUserEditValue` returns false") which presumes a particular OQ-1 resolution (hide for non-editable sources, show for editable) without making the prompt's blanket "Hide the media-replace control" reconcile explicitly. The reader is left wondering whether the prompt's wording is authoritative or whether the spec is overriding it.
+
+**Where in spec:** Acceptance Criteria → Control hiding → AC-14; Requirements → B.7.
+
+**Suggestion:** Resolve OQ-1 inside the spec (this is a WHAT decision, not HOW), then state the rule unambiguously. Recommended resolution per the requirements doc's analysis (Q7): when `canUserEditValue` returns true (Pattern Overrides), media-replace stays visible and writes through to the binding; when it returns false (post-meta etc.), it hides. Lock this in Req 7 and AC-13/AC-14, drop the "pending OQ-1" language, and remove OQ-1 from the open-questions list. Alternatively: pick the prompt's literal reading ("always hide media-replace when bound") and adjust AC-14 to assert absence under Pattern Overrides too. Either is fine; just pick one in the spec.
+
+**Why it matters:** As written, the spec is not implementable — two implementers reading AC-14 would build different UIs, and the e2e test (AC-25) cannot be written until OQ-1 is decided. Open questions belong to genuine design-phase HOW choices, not to ambiguities in user-observable behaviour.
+
+### Issue 2: AC-23 + Req 25 vs AC-19 — embed-video interaction with saved-parallax markup is contradictory [major]
+
+**What's wrong:** AC-19 unconditionally requires that "Given a Cover with `hasParallax: true` and `isRepeated: true` saved in markup, and a binding subsequently activated on `url`, when the server renders the cover, then the output contains an `<img>` (not a `<div style="background-image">`)". But Req 25 says "the binding-aware derivations (effective dim ratio, overlay color) SHOULD short-circuit when `backgroundType === "embed-video"`", and AC-23 says embed-video bindings allow the panel to expose `url` but the binding-aware derivations short-circuit.
+
+Two questions are left unanswered:
+1. If a Cover has `backgroundType: "embed-video"` AND `hasParallax: true` is somehow set (today these are mutually exclusive in the UI, but `backgroundType` is set at media-select time and could in principle co-exist with a stale `hasParallax`), what does the server do under AC-19? Does the embed-video render path win or the parallax→`<img>` rewrite?
+2. If a Cover has `backgroundType: "embed-video"` AND a binding resolves a URL, does the server render an embed iframe (existing flow) or an `<img>` (per AC-19)? The Out-of-Scope says "Embed-video × bindings interaction" is excluded from this PR beyond non-regression, but AC-19 doesn't carve embed-video out.
+
+**Where in spec:** Acceptance Criteria → Render-time effective values → AC-19; Out of Scope → Embed-video; Cross-cutting invariants → Req 25; Acceptance Criteria → Non-regression → AC-23.
+
+**Suggestion:** Add an explicit precondition to AC-19: "Given `backgroundType !== "embed-video"` AND a Cover with `hasParallax: true` and `isRepeated: true` saved in markup, AND a binding subsequently activated on `url`, ...". Or assert explicitly in Req 25 / Out-of-Scope that when `backgroundType === "embed-video"`, the binding-resolution server path does not engage (the existing oEmbed render runs unchanged regardless of binding presence). Either is fine; the spec just needs to state which one is in effect so the test author and the implementer agree.
+
+**Why it matters:** Without this, the server-render PR can ship in two different shapes (intercept all bound covers vs intercept only `backgroundType === "image"` covers) and pass different versions of the e2e test. Reviewer @ockham gates this area and is likely to flag inconsistency.
+
+### Issue 3: AC-16 contradicts itself on the dim-ratio class value (HOW bleed) [major]
+
+**What's wrong:** Req 14 says the effective dim ratio is "non-opaque (target: 50)" — i.e. 50 is a target, not a contract. AC-15 says "the displayed overlay is NOT fully opaque (effective dim ratio 50 applied)" — parenthetical-50 is informative. But AC-16 says "the overlay span class is `has-background-dim-50` (or equivalent non-opaque), NOT `has-background-dim-100`". The "or equivalent non-opaque" hedge plus the literal class `has-background-dim-50` is contradictory: a literal class IS the only equivalent under the existing `dimRatioToClass` mapping (`shared.js:32-36`).
+
+If the spec wants the class to be exactly `has-background-dim-50`, say so without the hedge. If the spec wants any non-opaque value, drop the literal class and assert only that the class is not `has-background-dim-100`. As written, an implementer who derives effective dim ratio of 40 (producing `has-background-dim-40`) would pass the "equivalent non-opaque" reading but fail the literal-class reading.
+
+This is also HOW-bleed: picking 50 specifically is an implementation choice (the prompt only says "must not result in a fully opaque overlay"). The user-observable requirement is "overlay is not fully opaque." The exact effective value belongs in the design doc.
+
+**Where in spec:** Requirements → D.14; Acceptance Criteria → AC-15; AC-16.
+
+**Suggestion:** Two acceptable resolutions:
+- (a) Lock the value: state in Req 14 that the effective ratio is 50 (matching the existing `onSelectMedia` downshift); drop "target: 50" hedge and "or equivalent" in AC-16. Then AC-16 reads cleanly as `has-background-dim-50`.
+- (b) Keep the value open: Req 14 says "non-opaque (the same value the existing `onSelectMedia` downshift uses)"; AC-15 asserts only "overlay is not fully opaque (computed opacity < 1.0)"; AC-16 asserts only "overlay span class is not `has-background-dim-100`". Implementer + design doc resolve the specific value.
+
+Pick (a) or (b). The current mixed phrasing is the worst of both.
+
+**Why it matters:** Tests written today against AC-16 will hardcode `has-background-dim-50` and will fail if the design doc picks 40 (or any other value). This costs at least one re-test cycle.
+
+### Issue 4: Internal-media affordance (Req 16 / AC-4) is too soft to test [major]
+
+**What's wrong:** Req 16 says "the editor MUST surface a clear `internal media required` UX — for example, a visible message in the placeholder or inspector — rather than rendering the cover with a broken image element. The chosen surface is a design decision; the visibility requirement is the constraint." AC-4 mirrors this: "the cover displays a visible `internal media required` affordance and does NOT render a broken `<img>`."
+
+The e2e author cannot write an assertion against this. "Visible affordance" doesn't tell the test:
+- What text? (`"internal media required"` literal? Translation key? Custom copy?)
+- What element/role? (a `Notice` component? a placeholder text? an inspector message?)
+- Visible where? (placeholder area? inspector panel? toolbar?)
+
+The spec is allowed to defer surface choice to the design doc, but the AC then needs a testable proxy — for example, "the cover does NOT emit an `<img>` element AND the placeholder area contains text matching the i18n key `cover.binding-internal-media-required` (or a stable test-id)."
+
+**Where in spec:** Requirements → D.16; Acceptance Criteria → Internal-media-only invariant → AC-4.
+
+**Suggestion:** Either pin down at least the test-observable signal (a stable `data-testid` or a known i18n string) in Req 16, OR define a negative-only AC ("no `<img>` is emitted for the unresolved binding") and move the positive-affordance assertion to the design phase. If the latter, add a Risk noting that the affordance surface is undefined until design.
+
+**Why it matters:** AC-4 is one of the four ACs that gate the internal-only invariant — the headline architectural constraint from the prompt. If it's untestable, the invariant ships unverified.
+
+### Issue 5: OQ-5 (id/url must bind to same source?) is a WHAT question, not HOW [major]
+
+**What's wrong:** OQ-5 asks: "Must `id` and `url` bind to the same source? Should the editor validate that `metadata.bindings.id.source === metadata.bindings.url.source`? Should it block save if they differ? Or treat any mismatch as an unresolvable binding per AC-4?"
+
+These three outcomes are user-observable behaviours that map to different test cases. They're not "implementation detail" — they define the user contract for an edge case the prompt specifies (Internal-only invariant). The spec should pick one of the three and capture it as a requirement and an AC.
+
+This is the same class of error as Issue 1 (AC-14): a behavioural contract is being deferred to a phase that's not supposed to make user-observable decisions.
+
+**Where in spec:** Open Questions → OQ-5.
+
+**Suggestion:** Resolve OQ-5 in the spec. Recommended: "treat any mismatch as an unresolvable binding per AC-4" — this matches the existing Internal-only-invariant story and avoids a save-blocking dialog that would slip scope. Add a new AC: "Given a Cover with `metadata.bindings.id.source !== metadata.bindings.url.source`, when the editor renders the cover, then the cover displays the internal-media-required affordance (per AC-4)."
+
+**Why it matters:** Mismatched-source binding is the exact edge case that produced the external-URL scope creep in PR #74109. Leaving it open to design means the design phase has to relitigate it, and the implementer has no contract to test against.
+
+### Issue 6: AC-18 (`useFeaturedImage: true` + binding) is in-scope but Out-of-Scope says featured-image binding is a follow-up [minor]
+
+**What's wrong:** Out of Scope lists "Featured-image binding for Cover" as a separate follow-up PR. AC-18 specifies behaviour when both `useFeaturedImage: true` AND a binding on `url` exist simultaneously: "the bound `url` is shown, NOT the featured image URL. Server render does NOT inject a second `<img>`." Concretely this IS featured-image × binding interaction, and the AC defines a precedence rule.
+
+This is not literally a contradiction (the in-scope work is "binding wins over featured image, do not double-render"; the out-of-scope work is "express featured-image-as-a-binding"), but the language overlap is confusing and the spec doesn't explain the distinction.
+
+**Where in spec:** Out of Scope, fourth bullet; Acceptance Criteria → AC-18.
+
+**Suggestion:** Either rephrase the Out-of-Scope bullet to "Using a binding source to express `useFeaturedImage` behaviour (e.g. a `featured-image-url` binding source returning the post's featured-image URL) is out of scope." Or add a one-line note in AC-18 cross-referencing the Out-of-Scope bullet ("this is the *precedence* rule; expressing featured-image as a binding source is OOS — see Out of Scope").
+
+**Why it matters:** Minor, but reviewers (including @ockham per Risk #4) will notice this. Cheap to fix.
+
+### Issue 7: AC-19 mechanism depends on OQ-4 mechanism, which depends on OQ-3 approach [minor]
+
+**What's wrong:** AC-19 requires the server, when bindings are active, to emit `<img>` instead of `<div style="background-image: ...">` and to strip `has-parallax` / `is-repeated` classes from the relevant element. OQ-4 acknowledges this mechanism is undetermined ("Confirm in design that this is the chosen mechanism and that it is safe across all known cover markup variations"). OQ-3 leaves the server-side approach (A vs B) open.
+
+The AC itself is testable (HTML output is `<img>` or not, classes are present or not), so this is not a blocker. But the spec is asserting a *server behaviour* (replace `<div>` with `<img>`) before deciding the mechanism — the design phase could plausibly decide that this rewrite is infeasible (HTML Tag Processor edge cases on user-modified Cover markup) and choose to make `hasParallax` non-overridable by binding instead. Then AC-19 becomes wrong.
+
+**Where in spec:** Acceptance Criteria → AC-19; Open Questions → OQ-3, OQ-4.
+
+**Suggestion:** Either resolve OQ-4 in the spec (commit to the element-replacement approach) and treat AC-19 as ground truth — OR weaken AC-19 to "the rendered output does not show a parallax effect (no `style="background-image: url()"` is emitted, no `has-parallax` class on a visible image element)" without prescribing the `<img>` shape. The first is preferable because it gives the implementer a concrete target.
+
+**Why it matters:** Minor — the design phase will surface this anyway. But pinning it down in the spec lets the design phase focus on HOW, not WHAT.
+
+### Issue 8: "Architecture verifiable from code review" ACs (AC-20, AC-21) are not runtime-testable [minor]
+
+**What's wrong:** AC-20 and AC-21 are good architectural invariants but acknowledge in the section heading they are "verifiable from code review, not at runtime." This means the e2e/PHPUnit test suite cannot enforce them. They are listed alongside runtime-testable ACs without a clear distinction in how they get gated.
+
+**Where in spec:** Acceptance Criteria → Architecture section header.
+
+**Suggestion:** Two options:
+- (a) Accept they are code-review-only and call them out explicitly as such in their headers (e.g. "AC-20 (code-review)") so the PR template / reviewer checklist can pick them up.
+- (b) Make at least one of them mechanically testable. For example, AC-20 ("single observer for URL-derived state") can be partially asserted by a unit test that mounts the Cover edit component, sets a bound URL, asserts only one `useEffect` callback runs in response (e.g. via a `vi.spyOn` on a derivation helper). Probably more trouble than it's worth.
+
+Option (a) is fine.
+
+**Why it matters:** Minor — but if a future regression silently re-introduces event-keyed `useEffect`s and no human catches it in review, the @ockham architectural concern returns. Worth flagging.
+
+## Recap
+
+Reject reason: Issues 1, 2, 3, 4, and 5 are real defects in the spec that block downstream design and implementation. Issues 6, 7, 8 are minor and could be left for the design phase if the majors get fixed, but they're cheap to address in the same rewrite pass.

From 0ea3a035c8d8ed1945ac7d850d06a5a4966609c9 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:23:54 +0200
Subject: [PATCH 08/60] docs(pipeline): revise 1-spec/spec.md for
 77199-cover-bindings-id-url-internal (iter 2)

Address spec-review-1-rejected.md findings.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../1-spec/spec.md                            | 165 ++++++++++--------
 1 file changed, 88 insertions(+), 77 deletions(-)

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
index b8a5fb6cc717be..cb6127fd6c89a0 100644
--- a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
+++ b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
@@ -2,15 +2,15 @@
 
 ## Overview
 
-The `core/cover` block does not support Block Bindings. Two prior draft PRs stalled over architectural objections (event-handler-driven `useEffect` proliferation), an HTML-rewrite blocker (CSS values inside `style` attributes cannot be edited by the WP HTML API), and scope creep around external URLs. This feature lands narrowly-scoped Block Bindings support for the `id` and `url` attributes of `core/cover`, restricted to internal media library items, with Pattern Overrides as the headline use case. When a binding is active, Cover-specific controls that would conflict with bindings (parallax, repeat, media-replace under non-editable sources, use-featured-image) are hidden, and dependent values (overlay color, effective dim ratio) are derived from the bound URL at render time without ever mutating stored attributes. The server render produces correct `<img>` markup with parallax effectively off.
+The `core/cover` block does not support Block Bindings. Two prior draft PRs stalled over architectural objections (event-handler-driven `useEffect` proliferation), an HTML-rewrite blocker (CSS values inside `style` attributes cannot be edited by the WP HTML API), and scope creep around external URLs. This feature lands narrowly-scoped Block Bindings support for the `id` and `url` attributes of `core/cover`, restricted to internal media library items, with Pattern Overrides as the headline use case. When a binding is active, Cover-specific controls that would conflict with bindings (parallax, repeat, media-replace, use-featured-image) are hidden, and dependent values (overlay color, effective dim ratio) are derived from the bound URL at render time without ever mutating stored attributes. The server render produces correct `<img>` markup with parallax effectively off.
 
 ## Glossary
 
 - **Bound `url` / `id`**: a Cover attribute whose `metadata.bindings.<attr>` is set to a binding source (e.g. `core/pattern-overrides`, `core/post-meta`).
 - **Internal media**: an attachment that exists in the site's media library; identified by a numeric attachment `id` from which the `url` can be derived.
+- **Active binding (on a Cover instance)**: both `metadata.bindings.id` and `metadata.bindings.url` are set AND point to the same source instance (same `source` string AND, where applicable, same `args`). Any other configuration (only one bound; both bound but to different sources) is **not** an active binding — the cover falls back to direct-edit behaviour, except where requirement 16 / AC-4 applies.
 - **Effective value**: a value computed at render time from the resolved bound values, used for display only; never written back to the stored attribute.
 - **Pattern Overrides**: the `core/pattern-overrides` binding source — pattern authors mark attributes overridable; pattern instances may override per-instance and reset to default.
-- **Reactive observer**: a single `useEffect` (using `useEffectEvent` for stable access to latest values) that derives all dependent state from the effective `url` regardless of how the URL arrived (manual, featured image, binding).
 
 ## Requirements
 
@@ -20,78 +20,84 @@ The `core/cover` block does not support Block Bindings. Two prior draft PRs stal
 2. A new file `lib/compat/wordpress-7.1/block-bindings.php` MUST be created and required from `lib/load.php`. It MUST register a filter that adds `id` and `url` to `gutenberg_get_block_bindings_supported_attributes('core/cover')`. The filter MUST follow the established `! function_exists` / version-guard pattern.
 3. No other `block.json` shape changes for `core/cover`. No new attributes.
 
-### B. Editor — UI gating when a binding is present
+### B. Editor — UI gating when a binding is active
 
-4. The parallax toggle (`hasParallax`) MUST be hidden whenever a binding is present on `url` or `id`.
-5. The repeated-background toggle (`isRepeated`) MUST be hidden whenever a binding is present on `url` or `id`.
-6. The "Use featured image" toggle MUST be hidden whenever a binding is present on `url` or `id`, in every surface where it appears (block toolbar, inspector).
-7. The media-replace control MUST be hidden when a binding is present AND the bound source's `canUserEditValue` returns false. (Pattern Overrides allows edits — see OQ-1.)
+A binding is **active** per the Glossary definition (both `id` and `url` bound to the same source instance).
+
+4. The parallax toggle (`hasParallax`) MUST be hidden whenever a binding is active on the Cover.
+5. The repeated-background toggle (`isRepeated`) MUST be hidden whenever a binding is active on the Cover.
+6. The "Use featured image" toggle MUST be hidden whenever a binding is active on the Cover, in every surface where it appears (block toolbar, inspector).
+7. The media-replace control MUST be hidden whenever a binding is active on the Cover, regardless of the bound source's `canUserEditValue`. (Pattern Overrides routes overrides through a separate flow; direct media replacement from inside the Cover is not offered when bound.)
 8. The Block Bindings UI (legacy Attributes panel and Block Fields UI from sibling pipeline 75022) MUST surface bindable rows for `id` and `url` on `core/cover` automatically, with no Cover-specific UI code beyond requirement 2.
 9. Pattern Overrides controls (`Enable overrides` button, `ResetOverridesControl`) MUST work for `core/cover` automatically, with no Cover-specific UI code.
 
 ### C. Editor — reactive derivation (single-observer architecture)
 
-10. The Edit component MUST derive all dependent state (overlay color, effective dim ratio, effective URL, lock flags) from a single reactive observer keyed on the effective `url`. The observer MUST be source-agnostic: identical behavior whether the URL arrived manually, via `useFeaturedImage`, or via a binding source.
-11. The observer MUST NOT mutate any block attribute as a side effect of a binding becoming active or inactive. Specifically: `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, `customOverlayColor` MUST NOT be written from inside the observer.
-12. The observer MUST update overlay color from the resolved image's average color when `isUserOverlayColor` is false, regardless of URL source.
-13. The observer MUST be resilient against concurrent async `getMediaColor` resolutions: a stale color MUST NOT overwrite a newer one.
+10. The Edit component MUST derive all dependent state (overlay color, effective dim ratio, effective URL, lock flags) reactively from the effective `url` in a source-agnostic way: identical behavior whether the URL arrived manually, via `useFeaturedImage`, or via a binding source. (The single-observer / no-per-event-`useEffect` constraint that operationalises this is a Design Constraint — see §"Design Constraints".)
+11. Derivation MUST NOT mutate any block attribute as a side effect of a binding becoming active or inactive. Specifically: `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, `customOverlayColor` MUST NOT be written from the derivation path triggered by binding state changes.
+12. Overlay color MUST update from the resolved image's average color when `isUserOverlayColor` is false, regardless of URL source.
+13. The derivation MUST be resilient against concurrent async `getMediaColor` resolutions: a stale color MUST NOT overwrite a newer one.
 
 ### D. Editor — render-time effective values
 
-14. When a binding is active on `url`/`id` AND the stored `dimRatio` equals the default value (100) AND the bound URL resolves to a non-empty value, the rendered overlay MUST use a non-opaque effective dim ratio (target: 50). The stored `dimRatio` attribute MUST NOT change.
+14. When a binding is active on a Cover AND the stored `dimRatio` equals the default value (100) AND the bound URL resolves to a non-empty value, the rendered overlay MUST NOT be fully opaque. The stored `dimRatio` attribute MUST NOT change. (The exact non-opaque value used is a design decision; the constraint is non-opacity.)
 15. The effective `url` used by the editor preview MUST prefer the bound `url` over `useFeaturedImage`'s `mediaUrl` when both are present. The bound value wins.
-16. When `url` is bound but the binding-resolved `id` is missing or does not resolve to an attachment in the media library (the "external URL" case), the editor MUST surface a visible "internal media required" affordance (placeholder copy, notice, or equivalent) instead of rendering the cover with a broken image. The exact surface is a design choice; visibility is the requirement.
+16. When `url` is bound but the binding-resolved `id` is missing or does not resolve to an attachment in the media library (the "external URL" case), the editor MUST surface a clear "internal media required" affordance AND MUST NOT render an `<img>` element for the unresolved binding. The affordance MUST be discoverable by a stable, test-observable signal — a known i18n message string (or equivalent stable identifier) accessible to the e2e test. The exact surface (placeholder copy, notice, inspector message) is a design choice; visibility AND test-observability are the constraints.
 
 ### E. Server — render correctness
 
-17. When bindings have resolved `url`/`id` for a Cover, the server-rendered markup MUST contain an `<img>` element for the resolved image (NOT a `<div style="background-image: url(...)">`), even if the saved markup was the parallax/repeat form. Parallax styling MUST be effectively off in the rendered output when bindings are active.
-18. The server-rendered overlay span class MUST reflect the effective dim ratio from requirement 14: when the stored `dimRatio` is the default 100 AND a binding resolves a URL, the overlay span class MUST be rewritten from `has-background-dim-100` to `has-background-dim-50` (or equivalent non-opaque value).
-19. The server render MUST short-circuit the existing `useFeaturedImage` image-injection path in `render_block_core_cover` when bindings have resolved a value for `url` and/or `id`. Double image insertion MUST NOT occur.
+17. When bindings have resolved `url`/`id` for a Cover with `backgroundType !== "embed-video"`, the server-rendered markup MUST contain an `<img>` element for the resolved image (NOT a `<div style="background-image: url(...)">`), even if the saved markup was the parallax/repeat form. Parallax styling MUST be effectively off in the rendered output when bindings are active.
+18. When a binding is active AND the stored `dimRatio` is the default 100 AND the binding resolves a URL, the server-rendered overlay span class MUST NOT be `has-background-dim-100`. (It MUST be a non-opaque variant whose specific value is the design phase's choice; see Risks.)
+19. The server render MUST short-circuit the existing `useFeaturedImage` image-injection path in `render_block_core_cover` when bindings have resolved a value for `url`/`id`. Double image insertion MUST NOT occur.
 20. If the binding cannot resolve `id` to a media-library attachment (or `url` cannot be derived from the resolved `id`), the server MUST render the cover WITHOUT an image element. No broken `<img src>` / `<img src="">` may be emitted.
-21. The server-side mechanism (whether a Cover-scoped `render_block` filter or reuse of a generic `block_bindings_attribute_replaced_in_markup` filter — see OQ-3) MUST be additive: it MUST NOT change behavior for any other block.
+21. The server-side mechanism (whether a Cover-scoped `render_block` filter or reuse of a generic `block_bindings_attribute_replaced_in_markup` filter — see OQ-1) MUST be additive: it MUST NOT change behavior for any other block.
+22. When `backgroundType === "embed-video"`, the existing oEmbed render path in `render_block_core_cover` MUST run unchanged regardless of binding presence; the binding-resolution server path MUST NOT engage for embed-video covers.
 
 ### F. Cross-cutting invariants
 
-22. Unbound Cover behavior MUST be unchanged: no regression on parallax, repeat, focal point, featured image, embed-video, dim ratio, overlay color, alt text, image-size selection, deprecation chain.
-23. Pattern Overrides MUST round-trip cleanly through editor save/load and server render for four enumerated states:
+23. Unbound Cover behavior MUST be unchanged: no regression on parallax, repeat, focal point, featured image, embed-video, dim ratio, overlay color, alt text, image-size selection, deprecation chain.
+24. Pattern Overrides MUST round-trip cleanly through editor save/load and server render for four enumerated states:
    - (a) **default, no override**: bound value equals the block's own attribute; instance renders the pattern default.
    - (b) **overridden**: instance value differs from pattern default; renders the override.
    - (c) **reset-to-default with binding active**: user clicks Reset; instance returns to pattern default.
    - (d) **reset-affordance suppressed when instance value already matches default**: Reset is disabled (existing `ResetOverridesControl` semantics) or hidden — design phase resolves; OQ-2.
-24. External URL binding MUST NOT be silently honored. A binding source returning a `url` without a resolvable internal `id` MUST be treated as unresolvable per requirement 16 (editor) and requirement 20 (server).
-25. `backgroundType: "embed-video"` MUST continue to render correctly and MUST NOT regress. The bindings panel MAY expose `url` even for embed-video covers (no Cover-specific suppression required), but the binding-aware derivations (effective dim ratio, overlay color) SHOULD short-circuit when `backgroundType === "embed-video"`.
-26. The PR MUST NOT introduce new global Block Bindings APIs. If a reused filter (e.g. `block_bindings_attribute_replaced_in_markup`) is needed, it MUST be weighed against a Cover-scoped render path during design.
+25. External URL binding MUST NOT be silently honored. A binding source returning a `url` without a resolvable internal `id` MUST be treated as unresolvable per requirement 16 (editor) and requirement 20 (server).
+26. Mismatched-source binding MUST be treated as unresolvable. If a Cover has `metadata.bindings.id` and `metadata.bindings.url` set to **different** source instances (different `source` strings, or different `args` against the same source), the editor MUST surface the "internal media required" affordance (per requirement 16) and the server MUST render the cover without an image element (per requirement 20).
+27. `backgroundType: "embed-video"` MUST continue to render correctly and MUST NOT regress. The bindings panel MAY expose `url`/`id` rows even for embed-video covers (no Cover-specific suppression required), but the binding-aware derivations (effective dim ratio, overlay color) AND the binding-aware server render MUST short-circuit when `backgroundType === "embed-video"` (per requirement 22).
+28. The PR MUST NOT introduce new global Block Bindings APIs. If a reused filter (e.g. `block_bindings_attribute_replaced_in_markup`) is needed, it MUST be weighed against a Cover-scoped render path during design.
 
 ### G. Tests
 
-27. A new e2e test MUST create a Cover, bind its `url`+`id` to a Pattern Overrides source, and assert the editor preview AND the rendered front-end show the pattern default.
-28. The same e2e test MUST override the value on a pattern instance and assert the rendered output reflects the override (different `<img src>`, correct dim ratio class).
-29. The same e2e test MUST reset the override and assert the rendered output returns to the pattern default.
-30. The e2e test MUST assert that the parallax toggle, repeat toggle, media-replace control (where the source disallows editing), and featured-image toggle are NOT present (or NOT enabled) when a binding is active.
-31. A PHPUnit test SHOULD assert that `render_block_core_cover` substitutes the bound `url` into the rendered `<img src>` AND rewrites the dim ratio class when the saved value is the default 100.
-32. Existing Cover unit tests (`packages/block-library/src/cover/test/edit.js`) MUST continue to pass; existing Cover e2e tests MUST continue to pass.
+29. A new e2e test MUST create a Cover, bind its `url`+`id` to a Pattern Overrides source, and assert the editor preview AND the rendered front-end show the pattern default.
+30. The same e2e test MUST override the value on a pattern instance and assert the rendered output reflects the override (different `<img src>`, non-opaque dim ratio class).
+31. The same e2e test MUST reset the override and assert the rendered output returns to the pattern default.
+32. The e2e test MUST assert that the parallax toggle, repeat toggle, media-replace control, and featured-image toggle are NOT present in the DOM when a binding is active.
+33. The e2e test MUST cover the unresolvable-binding case (e.g. mismatched sources, or a source resolving `url` without a media-library `id`) and assert the "internal media required" affordance is visible via its stable test-observable signal.
+34. A PHPUnit test SHOULD assert that `render_block_core_cover` substitutes the bound `url` into the rendered `<img src>` AND rewrites the dim ratio class to a non-opaque variant when the saved value is the default 100.
+35. Existing Cover unit tests (`packages/block-library/src/cover/test/edit.js`) MUST continue to pass; existing Cover e2e tests MUST continue to pass.
 
 ### H. PR shape and project metadata
 
-33. The new compat file MUST live at `lib/compat/wordpress-7.1/block-bindings.php` (NOT 7.0). A `backport-changelog/7.1/<core-pr-number>.md` entry MUST be added when the corresponding Core PR exists.
-34. The PR description MUST link issue #77199 and explicitly state whether it subsumes prior PRs #74109 and #74610.
-35. The net diff (including tests) SHOULD target under ~500 lines.
-36. The implementation MUST gracefully degrade on a WP install lacking the bindings infrastructure changes (use the existing `! function_exists` / version-guard pattern).
+36. The new compat file MUST live at `lib/compat/wordpress-7.1/block-bindings.php` (NOT 7.0). A `backport-changelog/7.1/<core-pr-number>.md` entry MUST be added when the corresponding Core PR exists.
+37. The PR description MUST link issue #77199 and explicitly state whether it subsumes prior PRs #74109 and #74610.
+38. The net diff (including tests) SHOULD target under ~500 lines.
+39. The implementation MUST gracefully degrade on a WP install lacking the bindings infrastructure changes (use the existing `! function_exists` / version-guard pattern).
 
 ## Out of Scope
 
 The following are explicitly excluded from this work. They are not deferred-but-acknowledged inside this PR; they are non-goals:
 
 - **External / non-media-library URL binding.** Binding `url` to an arbitrary URL with no resolvable internal `id` is not supported. The cover surfaces an "internal media required" UX instead.
-- **Parallax × bindings interaction beyond "force off".** No CSS-in-style HTML rewriting. When bindings are active, parallax styling is suppressed (server emits `<img>`, no `<div style="background-image: ...">`); the UI hides the parallax toggle.
-- **Embed-video × bindings interaction.** `backgroundType: "embed-video"` is not specifically supported with bindings beyond non-regression. No Cover-specific suppression of the bindings panel is added.
-- **Featured-image binding for Cover.** Binding `url`/`id` to express "use the post featured image" is a separate follow-up PR. This PR merely hides the `useFeaturedImage` toggle when a binding is active and ensures the server render does not double-insert images.
+- **Mismatched-source binding (`id` and `url` bound to different sources).** Not supported. Treated as an unresolvable binding per requirement 26.
+- **Parallax × bindings interaction beyond "force off".** No CSS-in-style HTML rewriting. When bindings are active and `backgroundType !== "embed-video"`, parallax styling is suppressed in the server render (emit `<img>`, no `<div style="background-image: ...">`); the UI hides the parallax toggle.
+- **Embed-video × bindings interaction.** `backgroundType: "embed-video"` is not specifically supported with bindings beyond non-regression. The bindings panel MAY surface bindable rows, but the binding-aware editor derivations AND the binding-aware server-render path BOTH short-circuit — embed-video covers continue to render via the existing oEmbed flow regardless of binding presence. No `<img>` substitution, no class rewrite, no parallax strip is performed on embed-video covers under this PR. This carve-out applies even if a Cover's saved markup contains stale `hasParallax: true` alongside `backgroundType: "embed-video"`: the embed path wins.
+- **Featured-image binding for Cover (i.e. expressing `useFeaturedImage` behaviour AS a binding).** Defining a binding source that returns the post's featured-image URL/id (so that `useFeaturedImage` becomes redundant with bindings) is a separate follow-up PR. This PR's in-scope contract concerning featured image is the *precedence rule* (AC-18): when both `useFeaturedImage: true` and an active binding co-exist on the same Cover, the binding wins and the server does not double-render.
 - **New global Block Bindings APIs.** No new globally-registered Block Bindings APIs are introduced. At most one already-proposed filter (`block_bindings_attribute_replaced_in_markup`) may be reused; introducing it is weighed against a Cover-scoped server-render path during design.
 - **Post-data source `featured_media.url` / `featured_media.id` field.** Out of scope.
 
 ## Acceptance Criteria
 
-Given-When-Then form. Each criterion is independently testable.
+Given-When-Then form. Each runtime AC is independently testable from outside the implementation (e2e, PHPUnit, or DOM inspection). Code-review-only assertions live in §"Design Constraints".
 
 ### Bindings discovery
 
@@ -100,72 +106,77 @@ Given-When-Then form. Each criterion is independently testable.
 
 ### Internal-media-only invariant
 
-- **AC-3.** Given a binding source resolves `url` to an attachment URL AND `id` to the corresponding media-library attachment id, when the editor renders the Cover, then the editor preview shows the resolved image.
-- **AC-4.** Given a binding source resolves `url` to a string but `id` is missing or resolves to a non-attachment, when the editor renders the Cover, then the cover displays a visible "internal media required" affordance and does NOT render a broken `<img>`.
+- **AC-3.** Given a binding source resolves `url` to an attachment URL AND `id` to the corresponding media-library attachment id AND both bindings reference the same source instance, when the editor renders the Cover, then the editor preview shows the resolved image.
+- **AC-4.** Given a binding configuration that does NOT meet the active-binding definition (only one attribute bound; both bound but to different sources; or `id` missing / resolving to a non-attachment), when the editor renders the Cover, then (a) no `<img>` element is emitted for the bound URL AND (b) the editor surfaces the "internal media required" affordance via its stable test-observable signal (a known i18n message string or equivalent stable identifier resolved during design).
 - **AC-5.** Given the same unresolvable binding state, when the server renders the Cover, then the rendered HTML contains no `<img>` element for the bound URL.
+- **AC-6.** Given a Cover with `metadata.bindings.id.source !== metadata.bindings.url.source` (or differing `args`), when either the editor or the server renders the cover, then the cover renders the "internal media required" state per AC-4 / AC-5 (mismatched sources are treated as unresolvable).
 
 ### Pattern Overrides round-trip
 
-- **AC-6.** Given a synced pattern with a Cover whose `url`+`id` are bound to `core/pattern-overrides`, when an instance is inserted with no override applied, then both the editor preview and the front-end render show the pattern default image.
-- **AC-7.** Given an inserted pattern instance with the Cover image overridden via the editor, when the post is saved and rendered on the front end, then the rendered `<img src>` is the override URL.
-- **AC-8.** Given an overridden Cover instance, when the user clicks "Reset" on the toolbar `ResetOverridesControl`, then the override is cleared and both editor preview and front-end render return to the pattern default.
-- **AC-9.** Given a Cover instance with no override applied (value matches pattern default), when the user looks at the toolbar, then the `ResetOverridesControl` is disabled (or hidden per OQ-2 resolution).
+- **AC-7.** Given a synced pattern with a Cover whose `url`+`id` are bound to `core/pattern-overrides`, when an instance is inserted with no override applied, then both the editor preview and the front-end render show the pattern default image.
+- **AC-8.** Given an inserted pattern instance with the Cover image overridden via the editor, when the post is saved and rendered on the front end, then the rendered `<img src>` is the override URL.
+- **AC-9.** Given an overridden Cover instance, when the user clicks "Reset" on the toolbar `ResetOverridesControl`, then the override is cleared and both editor preview and front-end render return to the pattern default.
+- **AC-10.** Given a Cover instance with no override applied (value matches pattern default), when the user looks at the toolbar, then the `ResetOverridesControl` is disabled (or hidden per OQ-2 resolution).
 
 ### Control hiding
 
-- **AC-10.** Given a Cover block with any binding present on `url` or `id`, when the user inspects the inspector controls, then the parallax toggle is NOT in the DOM.
-- **AC-11.** Given a Cover block with any binding present on `url` or `id`, when the user inspects the inspector controls, then the repeat toggle is NOT in the DOM.
-- **AC-12.** Given a Cover block with any binding present on `url` or `id`, when the user inspects the block toolbar and inspector controls, then the "Use featured image" toggle is NOT in the DOM.
-- **AC-13.** Given a Cover block bound to a source whose `canUserEditValue` returns false (e.g. `core/post-meta`), when the user inspects the block toolbar, then the media-replace control is NOT in the DOM.
-- **AC-14.** Given a Cover block bound to `core/pattern-overrides`, when the user inspects the block toolbar, then the media-replace control is present (Pattern Overrides allows edits) — pending OQ-1 resolution.
+- **AC-11.** Given a Cover block with an active binding (per Glossary), when the user inspects the inspector controls, then the parallax toggle is NOT in the DOM.
+- **AC-12.** Given a Cover block with an active binding, when the user inspects the inspector controls, then the repeat toggle is NOT in the DOM.
+- **AC-13.** Given a Cover block with an active binding, when the user inspects the block toolbar and inspector controls, then the "Use featured image" toggle is NOT in the DOM.
+- **AC-14.** Given a Cover block with an active binding to **any** source (including `core/pattern-overrides` and `core/post-meta`), when the user inspects the block toolbar, then the media-replace control is NOT in the DOM. Replacement under Pattern Overrides flows through the override authoring surface, not the Cover's own media-replace control.
 
 ### Render-time effective values
 
-- **AC-15.** Given a newly inserted Cover with default `dimRatio: 100` and a binding resolving a non-empty `url`, when the editor renders the cover, then the displayed overlay is NOT fully opaque (effective dim ratio 50 applied).
-- **AC-16.** Given the same Cover, when the server renders the cover, then the overlay span class is `has-background-dim-50` (or equivalent non-opaque), NOT `has-background-dim-100`.
-- **AC-17.** Given a Cover with `dimRatio` explicitly set to a non-default value (e.g. 70) and a binding resolving a URL, when either editor or server renders, then the displayed overlay uses the stored value (70). The stored attribute is unchanged.
-- **AC-18.** Given a Cover with `useFeaturedImage: true` and a binding present on `url`, when either editor or server renders, then the bound `url` is shown, NOT the featured image URL. Server render does NOT inject a second `<img>` for the featured image.
-- **AC-19.** Given a Cover with `hasParallax: true` and `isRepeated: true` saved in markup, and a binding subsequently activated on `url`, when the server renders the cover, then the output contains an `<img>` (not a `<div style="background-image">`), the `has-parallax` and `is-repeated` classes are not applied to that element, and no `style="background-image: ..."` substitution is attempted.
-
-### Architecture (verifiable from code review, not at runtime)
-
-- **AC-20.** The Edit component contains a single observer for URL-derived state. There is NOT a separate `useEffect` per event handler (no observer keyed on "media-replaced", another on "blur", another on "binding-detected").
-- **AC-21.** The observer never calls `setAttributes` for `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, or `customOverlayColor` as a result of a binding becoming active or inactive.
+- **AC-15.** Given a newly inserted Cover with default `dimRatio: 100` and an active binding resolving a non-empty `url`, when the editor renders the cover, then the displayed overlay's computed opacity is strictly less than 1.0 (the bound image is visible through the overlay).
+- **AC-16.** Given the same Cover, when the server renders the cover, then the overlay span class is NOT `has-background-dim-100`.
+- **AC-17.** Given a Cover with `dimRatio` explicitly set to a non-default value (e.g. 70) and an active binding resolving a URL, when either editor or server renders, then the displayed overlay uses the stored value (70). The stored attribute is unchanged.
+- **AC-18.** Given a Cover with `useFeaturedImage: true` and an active binding on `url`+`id`, when either editor or server renders, then the bound `url` is shown, NOT the featured image URL. Server render does NOT inject a second `<img>` for the featured image. (This is the *precedence* rule; expressing featured-image AS a binding source is out of scope — see Out of Scope.)
+- **AC-19.** Given `backgroundType !== "embed-video"` AND a Cover with `hasParallax: true` and `isRepeated: true` saved in markup, and a binding subsequently activated on `url`+`id`, when the server renders the cover, then the output contains an `<img>` (not a `<div style="background-image">`), the `has-parallax` and `is-repeated` classes are not applied to that element, and no `style="background-image: ..."` substitution is attempted.
 
 ### Non-regression
 
-- **AC-22.** Given an existing unbound Cover block (with or without `hasParallax`, `isRepeated`, `useFeaturedImage`, `backgroundType: "embed-video"`, custom overlay color, custom dim ratio, custom focal point), when the editor and server render the block, then the output is identical to the current trunk behavior. No deprecation chain breakage.
-- **AC-23.** Given an existing Cover with `backgroundType: "embed-video"`, when the editor opens the bindings UI, then the panel still lists `url`/`id` as bindable; but the binding-aware effective-dim-ratio / overlay-color derivations short-circuit (no auto-color from embed URL). The embed render path is unchanged.
+- **AC-20.** Given an existing unbound Cover block (with or without `hasParallax`, `isRepeated`, `useFeaturedImage`, `backgroundType: "embed-video"`, custom overlay color, custom dim ratio, custom focal point), when the editor and server render the block, then the output is identical to the current trunk behavior. No deprecation chain breakage.
+- **AC-21.** Given an existing Cover with `backgroundType: "embed-video"`, when the editor opens the bindings UI, then the panel still lists `url`/`id` as bindable; but neither the binding-aware editor derivations nor the binding-aware server-render path engage — the existing embed render flow runs unchanged regardless of binding presence.
 
 ### Tests present
 
-- **AC-24.** The repository contains an e2e test that exercises Pattern Overrides on Cover end-to-end (create pattern with bound Cover, insert, override instance, reset) and asserts both editor preview and rendered front-end output.
-- **AC-25.** The e2e test asserts the hidden-controls invariants (AC-10..AC-13) on a bound Cover.
-- **AC-26.** A PHPUnit test asserts server-side URL substitution and dim ratio class rewriting for a bound Cover.
+- **AC-22.** The repository contains an e2e test that exercises Pattern Overrides on Cover end-to-end (create pattern with bound Cover, insert, override instance, reset) and asserts both editor preview and rendered front-end output.
+- **AC-23.** The e2e test asserts the hidden-controls invariants (AC-11..AC-14) on a Cover with an active binding.
+- **AC-24.** The e2e test asserts the unresolvable-binding affordance (AC-4) via its stable test-observable signal.
+- **AC-25.** A PHPUnit test asserts server-side URL substitution AND a non-`has-background-dim-100` dim-ratio class for a bound Cover with default stored `dimRatio: 100`.
 
 ### PR shape
 
-- **AC-27.** The new server-side filter file lives at `lib/compat/wordpress-7.1/block-bindings.php` and is loaded via `lib/load.php`. No file is created under `lib/compat/wordpress-7.0/`.
-- **AC-28.** The PR description links #77199 and explicitly states the relationship to #74109 and #74610.
-- **AC-29.** The net diff (additions − deletions) is under ~500 lines including tests.
+- **AC-26.** The new server-side filter file lives at `lib/compat/wordpress-7.1/block-bindings.php` and is loaded via `lib/load.php`. No file is created under `lib/compat/wordpress-7.0/`.
+- **AC-27.** The PR description links #77199 and explicitly states the relationship to #74109 and #74610.
+- **AC-28.** The net diff (additions − deletions) is under ~500 lines including tests.
+
+## Design Constraints
+
+These are architectural invariants required by reviewer @ockham (see Risks #4) and the prompt's architectural section. They are verifiable by code review on the PR, not by runtime tests. The design doc and PR review checklist MUST enforce them:
+
+- **DC-1. Single observer for URL-derived state.** The Edit component MUST NOT contain multiple `useEffect`s each keyed on a different event source (e.g. one for "media replaced", one for "blur", one for "binding detected"). All URL-derived state (overlay color, effective dim ratio, lock flags) MUST flow from a single reactive derivation path keyed on the effective `url`. Use of `useEffectEvent` (already exported from `@wordpress/element`) is the recommended primitive for reading latest non-tracked values without stale-closure pitfalls.
+- **DC-2. No attribute mutation from binding-state changes.** The derivation path triggered by a binding becoming active/inactive MUST NOT call `setAttributes` for `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, or `customOverlayColor`. (Requirement 11 states the contract; DC-2 is its code-review enforcement.)
+- **DC-3. Source-agnostic derivation.** The code path that derives dependent state from `url` MUST NOT branch on whether the URL came from a binding, `useFeaturedImage`, or manual selection. Identical behavior across all three sources.
+
+The PR review checklist MUST tick DC-1, DC-2, DC-3 explicitly before merge.
 
 ## Risks
 
-1. **Pattern Overrides reset semantics** historically broke. The four enumerated states (AC-6..AC-9) must all round-trip; existing `ResetOverridesControl` behavior must be respected or extended.
-2. **`dimRatio: 100` default with a binding** is the specific opaque-overlay regression that stalled prior PRs. Solution lives in render-time effective value, NOT attribute mutation.
-3. **`backgroundType: "embed-video"`** was added after prior bindings PRs; must not regress and must short-circuit the binding-aware derivations cleanly.
-4. **Reviewer @ockham gates this area.** Prior objections (event-keyed `useEffect` proliferation, scattered derivation logic, internal-only scope) must be preempted in the design doc, not surfaced during PR review.
+1. **Pattern Overrides reset semantics** historically broke. The four enumerated states (AC-7..AC-10) must all round-trip; existing `ResetOverridesControl` behavior must be respected or extended.
+2. **`dimRatio: 100` default with a binding** is the specific opaque-overlay regression that stalled prior PRs. Solution lives in render-time effective value, NOT attribute mutation. The exact effective value (e.g. 50, matching the existing `onSelectMedia` downshift) is a design-phase decision; the AC contract is non-opacity.
+3. **`backgroundType: "embed-video"`** was added after prior bindings PRs; must not regress. Requirements 22 and 27 carve embed-video out of the binding-aware render path entirely.
+4. **Reviewer @ockham gates this area.** Prior objections (event-keyed `useEffect` proliferation, scattered derivation logic, internal-only scope) MUST be preempted in the design doc and enforced via the §"Design Constraints" checklist, not surfaced during PR review.
 5. **HTML rewriting blocker**: the WordPress HTML API cannot edit CSS values inside `style` attributes. The implementation MUST avoid that path — i.e. the server cannot rewrite `<div style="background-image: url(...)">`; it must emit `<img>` instead when bindings are active.
 
 ## Open Questions (carried to design phase)
 
-These are questions for phase 2 (design doc). The design phase MUST resolve all five before implementation.
+These are the genuinely architectural HOW choices left for phase 2. All user-observable WHAT decisions have been resolved in the spec above.
 
-- **OQ-1. Media-replace visibility under Pattern Overrides.** The prompt says "Hide the media-replace control (replacement happens via the binding source, not direct edit)." But Pattern Overrides typically uses the existing media-replace flow to author the override (via `setValues`). Should the media-replace control stay visible for Pattern Overrides (and write through to the binding) and hide only for sources where `canUserEditValue` returns false? Or hide it universally and route the override through a different surface?
-- **OQ-2. Reset affordance: disabled or hidden when value matches default?** The prompt says "Reset must hide cleanly when the instance value already matches the default override state." Existing `ResetOverridesControl` disables the button rather than hiding it. Pick disable (existing, consistent across all bindable blocks) or hide (matches prompt phrasing). Recommendation in requirements is "disable", but the design phase formally decides.
-- **OQ-3. Server-side approach: Approach A vs Approach B.**
-  - **A.** Add a Cover-scoped `render_block` filter (in `lib/compat/wordpress-7.1/block-bindings.php` or `packages/block-library/src/cover/index.php`) that handles binding resolution, URL substitution, dim ratio class rewrite, parallax class strip, and `useFeaturedImage` short-circuit in one place.
-  - **B.** Reuse the generic `block_bindings_attribute_replaced_in_markup` filter (from PR #74610) to synthesize `source: attribute, selector: img, attribute: src` for Cover's `url`, plus a smaller Cover-specific path for dim ratio / parallax handling.
+- **OQ-1. Server-side approach: Approach A vs Approach B.**
+  - **A.** Add a Cover-scoped `render_block` filter (in `lib/compat/wordpress-7.1/block-bindings.php` or `packages/block-library/src/cover/index.php`) that handles binding resolution, URL substitution, dim-ratio class rewrite, parallax class strip, and `useFeaturedImage` short-circuit in one place.
+  - **B.** Reuse the generic `block_bindings_attribute_replaced_in_markup` filter (from PR #74610) to synthesize `source: attribute, selector: img, attribute: src` for Cover's `url`, plus a smaller Cover-specific path for dim-ratio / parallax handling.
   - Trade-off: A is entirely block-scoped (less cross-block risk); B has reuse value for future blocks with non-source-declared bindable attributes.
-- **OQ-4. Saved-markup parallax/repeat replacement on server.** When a Cover saved with `hasParallax: true` and/or `isRepeated: true` gains a binding via "Enable overrides", the server-render must replace the `<div style="background-image: url(...)">` element with an `<img>` and strip `has-parallax`/`is-repeated` classes. The HTML Tag Processor can perform element replacement when the element is uniquely identifiable by class (`wp-block-cover__image-background`). Confirm in design that this is the chosen mechanism and that it is safe across all known cover markup variations.
-- **OQ-5. Binding source validation: must `id` and `url` bind to the same source?** The internal-only invariant implies the same source provides both. Should the editor validate that `metadata.bindings.id.source === metadata.bindings.url.source`? Should it block save if they differ? Or treat any mismatch as an unresolvable binding per AC-4?
+- **OQ-2. Reset affordance: disabled or hidden when value matches default?** Existing `ResetOverridesControl` disables the button rather than hiding it. Pick disable (existing, consistent across all bindable blocks) or hide (matches prompt phrasing). Recommendation: disable. Design phase formally decides.
+- **OQ-3. Saved-markup parallax/repeat replacement mechanism.** When a Cover saved with `hasParallax: true` and/or `isRepeated: true` gains a binding via "Enable overrides", the server-render must replace the `<div style="background-image: url(...)">` element with an `<img>` (per AC-19) and strip `has-parallax`/`is-repeated` classes. The HTML Tag Processor can perform element replacement when the element is uniquely identifiable by class (`wp-block-cover__image-background`). The design must confirm this mechanism is safe across all known cover markup variations (deprecation chain inclusive); if it is not, the OQ-1 approach choice may need revisiting.
+- **OQ-4. Specific non-opaque effective dim-ratio value.** The contract (Req 14, AC-15, AC-16) is non-opacity. The existing `onSelectMedia` downshift uses 50; the design phase picks the specific value (likely 50 for symmetry, but the spec does not lock it).

From 67fb5133bcfc45c10e81d4daf21976cab2cccd4f Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:28:37 +0200
Subject: [PATCH 09/60] docs(pipeline): add 1-spec/spec-review-2-rejected.md
 for 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../1-spec/spec-review-2-rejected.md          | 102 ++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-2-rejected.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-2-rejected.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-2-rejected.md
new file mode 100644
index 00000000000000..682486a6050264
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-2-rejected.md
@@ -0,0 +1,102 @@
+# Spec Review
+
+## Verdict: rejected
+
+## Summary
+
+The iter-2 revision is a substantial improvement: all eight iter-1 findings are addressed cleanly. Issue 1 (AC-14 / Req 7 media-replace contradiction) is resolved by committing to the strict reading. Issue 2 (embed-video × AC-19) is resolved by adding the `backgroundType !== "embed-video"` precondition and Req 22. Issue 3 (dim-ratio class hedging) is resolved via option (b) — non-opacity is the contract. Issue 4 (untestable affordance) is improved by mandating a stable test-observable signal. Issue 5 (mismatched-source binding) is resolved by Req 26 / AC-6. Issues 6–8 are also addressed cleanly.
+
+However, the revision introduces ONE blocking new defect by trying to be precise about what "active binding" means. The Glossary defines "active binding" as **both** `metadata.bindings.id` and `metadata.bindings.url` being set to the same source instance. In the actual codebase, the standard Pattern Overrides flow — the headline use case for this PR — does **not** write per-attribute binding entries; it writes only `metadata.bindings.__default = { source: 'core/pattern-overrides' }`. This means every requirement and AC that gates on "active binding" would silently FAIL for the Pattern Overrides case as defined.
+
+This is a real implementability defect: under the spec's own Glossary, requirement 4 (parallax toggle hidden) would not fire for a Pattern-Overrides Cover, and AC-7 (the headline acceptance criterion) would contradict AC-11/12/13/14. Two minor issues (one HTML API claim in OQ-3, one ambiguity in AC-21) are noted as non-blocking.
+
+## Issues
+
+### Issue 1: Glossary "active binding" definition is incompatible with the actual Pattern Overrides client-side data model [blocker]
+
+**What's wrong:** Glossary says:
+
+> **Active binding (on a Cover instance)**: both `metadata.bindings.id` and `metadata.bindings.url` are set AND point to the same source instance (same `source` string AND, where applicable, same `args`).
+
+This entire spec then gates Reqs 4–9, 11, 14, 18, AC-3, AC-4, AC-6, AC-11–15, AC-18, AC-19, AC-21 on this definition.
+
+But the actual Pattern Overrides client-side flow writes **only** `metadata.bindings.__default = { source: 'core/pattern-overrides' }`, NOT per-attribute entries. Verified in `packages/patterns/src/components/pattern-overrides-controls.js:51-55`:
+
+```js
+updateBlockBindings( {
+    __default: isChecked
+        ? { source: PATTERN_OVERRIDES_BINDING_SOURCE }
+        : undefined,
+} );
+```
+
+Server-side, `__default` is then expanded into per-attribute bindings inside `gutenberg_process_block_bindings` (verified in `lib/compat/wordpress-6.9/block-bindings.php:257-281`). Client-side, the expansion happens only in selected places via `replacePatternOverridesDefaultBinding` from `packages/block-editor/src/utils/block-bindings.js`. The Image block's `lockUrlControls` (`packages/block-library/src/image/image.js:758,771-777`) reads `metadata?.bindings?.url` directly — for a Pattern-Overrides image, `urlBinding` is undefined and `lockUrlControls` is false (which is correct for image, since Pattern Overrides allows editing — but the lock signal is not the same as the "binding is active" signal Cover needs).
+
+Concrete consequence under this spec: a Cover block in a synced pattern with Pattern Overrides enabled has `metadata.bindings = { __default: { source: 'core/pattern-overrides' } }`. Per Glossary, this is NOT an "active binding" (`bindings.id` and `bindings.url` are both `undefined`). Therefore:
+- Req 4 (hide parallax) does not fire — AC-11 fails.
+- Req 5 (hide repeat) does not fire — AC-12 fails.
+- Req 6 (hide use-featured-image) does not fire — AC-13 fails.
+- Req 7 (hide media-replace) does not fire — AC-14 fails.
+- Req 14 (effective dimRatio) does not fire — AC-15, AC-16 fail.
+- AC-7 (pattern instance shows pattern default) passes server-side via `__default` expansion BUT contradicts AC-11..14 because the editor-side controls are not hidden.
+
+**Where in spec:** Glossary; cascading through all of §§B, C, D and Acceptance Criteria.
+
+**Suggestion:** Either of:
+- **(a) Broaden the "active binding" definition to recognise `__default: core/pattern-overrides`** as equivalent to "both `id` and `url` bound to `core/pattern-overrides`". Concretely: "Active binding (on a Cover instance): either (i) both `metadata.bindings.id` and `metadata.bindings.url` are set and point to the same source instance, OR (ii) `metadata.bindings.__default.source` is set (`__default` semantically expands to per-attribute bindings for every supported attribute)." This is the codebase reality, and it matches how the Image block's `lockUrlControls` and the editor's existing helpers reason about pattern-override-bound blocks.
+- **(b) Define "active binding" using the existing expansion helper** `replacePatternOverridesDefaultBinding(metadata.bindings, supportedAttributes)`: a Cover has an active binding iff, after expansion, the resulting object contains both `id` and `url` keys pointing to the same source. This is testable and aligns with the server-side semantics.
+
+In either case, also update AC-6 (mismatched source) to clarify that `__default` resolves to "same source" for all expanded attributes and therefore CANNOT mismatch by construction; only explicit per-attribute bindings can mismatch.
+
+**Why it matters:** Pattern Overrides is the spec's headline use case (explicit in the Overview paragraph and the prompt). The Glossary as written silently breaks the headline use case for control hiding and render-time effective values. Two implementers reading the spec would build different things: one might literally implement `bindings.id && bindings.url` and ship a regression on Pattern Overrides; another might guess that `__default` should "count" and ship something that works but doesn't match the spec. The e2e test (AC-22, AC-23) would not pass against the literal Glossary reading. This is the single most consequential bug in the spec because it conflates the server-side data model (post-expansion) with the client-side data model (pre-expansion).
+
+### Issue 2: OQ-3's claim that "the HTML Tag Processor can perform element replacement" is materially inaccurate [minor]
+
+**What's wrong:** OQ-3 says:
+
+> The HTML Tag Processor can perform element replacement when the element is uniquely identifiable by class (`wp-block-cover__image-background`).
+
+In the WordPress HTML API (`WP_HTML_Tag_Processor`), there is no `set_tag()` or "swap element type" operation. You can mutate attributes, classes, and inner HTML (via `WP_HTML_Processor` and bookmarks), but you cannot change a `<div>` into an `<img>` — that requires string-level substitution outside the Tag Processor's mutation API. Verified by grep: no `set_tag` / `change_tag` references exist in the codebase.
+
+OQ-3 is the open question that nominally lets the design phase pick its mechanism, so this is not literally a runtime contradiction. But it baits the design phase into picking an approach that doesn't work. The actual feasible mechanisms are:
+- Process the saved markup with a regex / string replace (fragile),
+- Use the higher-level `WP_HTML_Processor` with bookmarks + inner-HTML replacement (still requires re-emitting the tag),
+- Move the entire `<img>` injection logic into the cover's PHP `render_callback` (skipping the saved markup entirely when bindings are active — this is the Approach A in OQ-1).
+
+**Where in spec:** Open Questions → OQ-3.
+
+**Suggestion:** Rephrase OQ-3 to acknowledge the API constraint:
+
+> OQ-3. Saved-markup parallax/repeat replacement mechanism. When a Cover saved with `hasParallax: true` and/or `isRepeated: true` gains a binding, the server-render must emit `<img>` instead of `<div style="background-image: ...">`. The WP HTML Tag Processor cannot rewrite a `<div>` into an `<img>` directly. Two feasible approaches: (i) detect the parallax case in `render_block_core_cover`, replace `$content` wholesale (or its image fragment) with a rebuilt `<img>` HTML string, or (ii) make `render_block_core_cover` ignore the saved image markup entirely when bindings are active and synthesise the full `<img>` from resolved `url`/`id`. Design picks one; both honour AC-19.
+
+This is a minor wording fix; it doesn't change the AC contract.
+
+**Why it matters:** Design phase will likely correct this within minutes of starting work, but flagging it now saves a wasted exploration cycle. Also tightens the link between the spec's HTML-API-limits Risk #5 (which is correct) and OQ-3's mechanism claim (which contradicts Risk #5 by implication).
+
+### Issue 3: AC-21 leaves embed-video URL substitution behaviour ambiguous [minor]
+
+**What's wrong:** AC-21 says:
+
+> Given an existing Cover with `backgroundType: "embed-video"`, when the editor opens the bindings UI, then the panel still lists `url`/`id` as bindable; but neither the binding-aware editor derivations nor the binding-aware server-render path engage — the existing embed render flow runs unchanged regardless of binding presence.
+
+"The existing embed render flow runs unchanged regardless of binding presence" — does this mean the bound `url` is substituted into the embed iframe URL (so the iframe shows the bound embed URL), or does the embed render path use the saved `url` only? The Out-of-Scope bullet on embed-video says "No `<img>` substitution, no class rewrite, no parallax strip is performed on embed-video covers under this PR" — but it does not state whether basic URL substitution into the embed iframe happens.
+
+Two implementers could read AC-21 + Out-of-Scope as:
+- (a) The bound `url` is substituted; only the binding-aware derivations (dim ratio, overlay colour) and the `<img>` rewrite are short-circuited. The embed iframe's `src` attribute does get the bound URL. This requires `gutenberg_replace_html` or equivalent to run on the embed iframe.
+- (b) The whole binding processing path is bypassed for embed-video; the embed iframe shows the saved URL only.
+
+The phrase "binding-resolution server path MUST NOT engage for embed-video covers" in Req 22 leans toward (b) — but (a) would be more consistent with "the user is allowed to bind the URL and the panel shows the bindable rows".
+
+**Where in spec:** Acceptance Criteria → AC-21; Cross-cutting invariants → Req 22; Out of Scope → Embed-video bullet.
+
+**Suggestion:** Pick one interpretation. The cheap and conservative choice is (b): the entire bindings server path bypasses for `backgroundType === "embed-video"`. Add to AC-21:
+
+> When `backgroundType === "embed-video"`, the rendered embed iframe URL is the saved attribute URL, NOT the bound URL. Binding the URL of an embed-video Cover has no observable runtime effect under this PR (out-of-scope per Out-of-Scope).
+
+This makes the contract testable and unambiguous.
+
+**Why it matters:** Minor — embed-video × bindings is OOS so this only affects whether a user who tries the combination gets a coherent result or a surprising one. But the e2e test (AC-21 derivative) cannot be written until the interpretation is locked.
+
+## Recap
+
+Reject reason: Issue 1 is a real spec-level defect that silently breaks the headline use case. Until "active binding" recognises the standard `__default` shape, the spec is not implementable for Pattern Overrides without an implementer making their own interpretation. Issues 2 and 3 are minor and could ship for design-phase resolution if Issue 1 is fixed, but they are cheap to address in the same rewrite pass.

From 04cd8482763017fd60912c8487db0b6e1bccf21d Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:31:06 +0200
Subject: [PATCH 10/60] docs(pipeline): revise 1-spec/spec.md for
 77199-cover-bindings-id-url-internal (iter 3)

Address spec-review-2-rejected.md findings (Pattern Overrides __default data model).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../1-spec/spec.md                            | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
index cb6127fd6c89a0..57df33dbf1a973 100644
--- a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
+++ b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
@@ -6,11 +6,12 @@ The `core/cover` block does not support Block Bindings. Two prior draft PRs stal
 
 ## Glossary
 
-- **Bound `url` / `id`**: a Cover attribute whose `metadata.bindings.<attr>` is set to a binding source (e.g. `core/pattern-overrides`, `core/post-meta`).
+- **Bound `url` / `id`**: a Cover attribute whose `metadata.bindings.<attr>` is set to a binding source (e.g. `core/pattern-overrides`, `core/post-meta`), OR whose binding is implied by a `__default` wildcard binding (see "Expanded bindings" below).
 - **Internal media**: an attachment that exists in the site's media library; identified by a numeric attachment `id` from which the `url` can be derived.
-- **Active binding (on a Cover instance)**: both `metadata.bindings.id` and `metadata.bindings.url` are set AND point to the same source instance (same `source` string AND, where applicable, same `args`). Any other configuration (only one bound; both bound but to different sources) is **not** an active binding — the cover falls back to direct-edit behaviour, except where requirement 16 / AC-4 applies.
+- **Expanded bindings (on a Cover instance)**: the `metadata.bindings` object after the `__default` wildcard is resolved into per-attribute entries. Concretely: if `metadata.bindings.__default.source` is set (today only `core/pattern-overrides` writes this shape), then **every** supported attribute that does not already have an explicit per-attribute binding entry is treated as bound to that same `__default` source. If `__default` is absent, the expanded bindings equal the literal `metadata.bindings`. This matches the existing client-side helper `replacePatternOverridesDefaultBinding( bindings, supportedAttributes )` (in `packages/block-editor/src/utils/block-bindings.js`) and the server-side expansion in `gutenberg_process_block_bindings`.
+- **Active binding (on a Cover instance)**: after expansion (see "Expanded bindings"), `metadata.bindings.id` and `metadata.bindings.url` are both present AND point to the same source instance (same `source` string AND, where applicable, same `args`). The `__default: { source: 'core/pattern-overrides' }` shape therefore qualifies as an active binding by construction, because expansion populates `id` and `url` from the same `__default` source. Any other configuration — only one of `id`/`url` is bound (after expansion) or both bound but to different sources — is **not** an active binding; the cover falls back to direct-edit behaviour, except where requirement 16 / AC-4 / AC-6 applies.
 - **Effective value**: a value computed at render time from the resolved bound values, used for display only; never written back to the stored attribute.
-- **Pattern Overrides**: the `core/pattern-overrides` binding source — pattern authors mark attributes overridable; pattern instances may override per-instance and reset to default.
+- **Pattern Overrides**: the `core/pattern-overrides` binding source — pattern authors mark attributes overridable (the editor writes only `metadata.bindings.__default = { source: 'core/pattern-overrides' }`, no per-attribute entries); pattern instances may override per-instance and reset to default.
 
 ## Requirements
 
@@ -22,7 +23,7 @@ The `core/cover` block does not support Block Bindings. Two prior draft PRs stal
 
 ### B. Editor — UI gating when a binding is active
 
-A binding is **active** per the Glossary definition (both `id` and `url` bound to the same source instance).
+A binding is **active** per the Glossary definition (after `__default` expansion, both `id` and `url` are bound to the same source instance). The headline Pattern Overrides shape — `metadata.bindings.__default = { source: 'core/pattern-overrides' }` with no per-attribute entries — IS an active binding under this definition.
 
 4. The parallax toggle (`hasParallax`) MUST be hidden whenever a binding is active on the Cover.
 5. The repeated-background toggle (`isRepeated`) MUST be hidden whenever a binding is active on the Cover.
@@ -62,7 +63,7 @@ A binding is **active** per the Glossary definition (both `id` and `url` bound t
    - (c) **reset-to-default with binding active**: user clicks Reset; instance returns to pattern default.
    - (d) **reset-affordance suppressed when instance value already matches default**: Reset is disabled (existing `ResetOverridesControl` semantics) or hidden — design phase resolves; OQ-2.
 25. External URL binding MUST NOT be silently honored. A binding source returning a `url` without a resolvable internal `id` MUST be treated as unresolvable per requirement 16 (editor) and requirement 20 (server).
-26. Mismatched-source binding MUST be treated as unresolvable. If a Cover has `metadata.bindings.id` and `metadata.bindings.url` set to **different** source instances (different `source` strings, or different `args` against the same source), the editor MUST surface the "internal media required" affordance (per requirement 16) and the server MUST render the cover without an image element (per requirement 20).
+26. Mismatched-source binding MUST be treated as unresolvable. If — after `__default` expansion (see Glossary) — a Cover has `metadata.bindings.id` and `metadata.bindings.url` set to **different** source instances (different `source` strings, or different `args` against the same source), the editor MUST surface the "internal media required" affordance (per requirement 16) and the server MUST render the cover without an image element (per requirement 20). Mismatch can only arise from **explicit per-attribute** binding entries; the `__default` wildcard shape cannot mismatch by construction (expansion writes the same source into every supported attribute that lacks an explicit entry).
 27. `backgroundType: "embed-video"` MUST continue to render correctly and MUST NOT regress. The bindings panel MAY expose `url`/`id` rows even for embed-video covers (no Cover-specific suppression required), but the binding-aware derivations (effective dim ratio, overlay color) AND the binding-aware server render MUST short-circuit when `backgroundType === "embed-video"` (per requirement 22).
 28. The PR MUST NOT introduce new global Block Bindings APIs. If a reused filter (e.g. `block_bindings_attribute_replaced_in_markup`) is needed, it MUST be weighed against a Cover-scoped render path during design.
 
@@ -90,7 +91,7 @@ The following are explicitly excluded from this work. They are not deferred-but-
 - **External / non-media-library URL binding.** Binding `url` to an arbitrary URL with no resolvable internal `id` is not supported. The cover surfaces an "internal media required" UX instead.
 - **Mismatched-source binding (`id` and `url` bound to different sources).** Not supported. Treated as an unresolvable binding per requirement 26.
 - **Parallax × bindings interaction beyond "force off".** No CSS-in-style HTML rewriting. When bindings are active and `backgroundType !== "embed-video"`, parallax styling is suppressed in the server render (emit `<img>`, no `<div style="background-image: ...">`); the UI hides the parallax toggle.
-- **Embed-video × bindings interaction.** `backgroundType: "embed-video"` is not specifically supported with bindings beyond non-regression. The bindings panel MAY surface bindable rows, but the binding-aware editor derivations AND the binding-aware server-render path BOTH short-circuit — embed-video covers continue to render via the existing oEmbed flow regardless of binding presence. No `<img>` substitution, no class rewrite, no parallax strip is performed on embed-video covers under this PR. This carve-out applies even if a Cover's saved markup contains stale `hasParallax: true` alongside `backgroundType: "embed-video"`: the embed path wins.
+- **Embed-video × bindings interaction.** `backgroundType: "embed-video"` is not specifically supported with bindings beyond non-regression. The bindings panel MAY surface bindable rows, but the binding-aware editor derivations AND the binding-aware server-render path BOTH short-circuit — embed-video covers continue to render via the existing oEmbed flow regardless of binding presence. No `<img>` substitution, no class rewrite, no parallax strip, AND no embed-iframe `src` substitution from the bound `url` is performed on embed-video covers under this PR (the rendered iframe `src` is the saved `url` attribute). This carve-out applies even if a Cover's saved markup contains stale `hasParallax: true` alongside `backgroundType: "embed-video"`: the embed path wins.
 - **Featured-image binding for Cover (i.e. expressing `useFeaturedImage` behaviour AS a binding).** Defining a binding source that returns the post's featured-image URL/id (so that `useFeaturedImage` becomes redundant with bindings) is a separate follow-up PR. This PR's in-scope contract concerning featured image is the *precedence rule* (AC-18): when both `useFeaturedImage: true` and an active binding co-exist on the same Cover, the binding wins and the server does not double-render.
 - **New global Block Bindings APIs.** No new globally-registered Block Bindings APIs are introduced. At most one already-proposed filter (`block_bindings_attribute_replaced_in_markup`) may be reused; introducing it is weighed against a Cover-scoped server-render path during design.
 - **Post-data source `featured_media.url` / `featured_media.id` field.** Out of scope.
@@ -109,7 +110,7 @@ Given-When-Then form. Each runtime AC is independently testable from outside the
 - **AC-3.** Given a binding source resolves `url` to an attachment URL AND `id` to the corresponding media-library attachment id AND both bindings reference the same source instance, when the editor renders the Cover, then the editor preview shows the resolved image.
 - **AC-4.** Given a binding configuration that does NOT meet the active-binding definition (only one attribute bound; both bound but to different sources; or `id` missing / resolving to a non-attachment), when the editor renders the Cover, then (a) no `<img>` element is emitted for the bound URL AND (b) the editor surfaces the "internal media required" affordance via its stable test-observable signal (a known i18n message string or equivalent stable identifier resolved during design).
 - **AC-5.** Given the same unresolvable binding state, when the server renders the Cover, then the rendered HTML contains no `<img>` element for the bound URL.
-- **AC-6.** Given a Cover with `metadata.bindings.id.source !== metadata.bindings.url.source` (or differing `args`), when either the editor or the server renders the cover, then the cover renders the "internal media required" state per AC-4 / AC-5 (mismatched sources are treated as unresolvable).
+- **AC-6.** Given a Cover with **explicit per-attribute** bindings such that `metadata.bindings.id.source !== metadata.bindings.url.source` (or differing `args`), when either the editor or the server renders the cover, then the cover renders the "internal media required" state per AC-4 / AC-5 (mismatched sources are treated as unresolvable). The `__default: { source: 'core/pattern-overrides' }` shape cannot trigger this AC because expansion writes the same source into both `id` and `url` (see Glossary "Expanded bindings"); mismatch is only reachable via explicit per-attribute bindings.
 
 ### Pattern Overrides round-trip
 
@@ -136,7 +137,7 @@ Given-When-Then form. Each runtime AC is independently testable from outside the
 ### Non-regression
 
 - **AC-20.** Given an existing unbound Cover block (with or without `hasParallax`, `isRepeated`, `useFeaturedImage`, `backgroundType: "embed-video"`, custom overlay color, custom dim ratio, custom focal point), when the editor and server render the block, then the output is identical to the current trunk behavior. No deprecation chain breakage.
-- **AC-21.** Given an existing Cover with `backgroundType: "embed-video"`, when the editor opens the bindings UI, then the panel still lists `url`/`id` as bindable; but neither the binding-aware editor derivations nor the binding-aware server-render path engage — the existing embed render flow runs unchanged regardless of binding presence.
+- **AC-21.** Given an existing Cover with `backgroundType: "embed-video"`, when the editor opens the bindings UI, then the panel still lists `url`/`id` as bindable; but neither the binding-aware editor derivations nor the binding-aware server-render path engage — the existing embed render flow runs unchanged regardless of binding presence. Specifically: the rendered embed iframe `src` is the **saved** `url` attribute, NOT the bound `url`. No URL substitution is attempted for embed-video covers; no `<img>` is synthesised; no overlay-class or parallax-class rewrite is performed. Binding the `url`/`id` of an embed-video Cover has no observable runtime effect under this PR (consistent with the Out-of-Scope "Embed-video × bindings interaction" bullet).
 
 ### Tests present
 
@@ -178,5 +179,5 @@ These are the genuinely architectural HOW choices left for phase 2. All user-obs
   - **B.** Reuse the generic `block_bindings_attribute_replaced_in_markup` filter (from PR #74610) to synthesize `source: attribute, selector: img, attribute: src` for Cover's `url`, plus a smaller Cover-specific path for dim-ratio / parallax handling.
   - Trade-off: A is entirely block-scoped (less cross-block risk); B has reuse value for future blocks with non-source-declared bindable attributes.
 - **OQ-2. Reset affordance: disabled or hidden when value matches default?** Existing `ResetOverridesControl` disables the button rather than hiding it. Pick disable (existing, consistent across all bindable blocks) or hide (matches prompt phrasing). Recommendation: disable. Design phase formally decides.
-- **OQ-3. Saved-markup parallax/repeat replacement mechanism.** When a Cover saved with `hasParallax: true` and/or `isRepeated: true` gains a binding via "Enable overrides", the server-render must replace the `<div style="background-image: url(...)">` element with an `<img>` (per AC-19) and strip `has-parallax`/`is-repeated` classes. The HTML Tag Processor can perform element replacement when the element is uniquely identifiable by class (`wp-block-cover__image-background`). The design must confirm this mechanism is safe across all known cover markup variations (deprecation chain inclusive); if it is not, the OQ-1 approach choice may need revisiting.
+- **OQ-3. Saved-markup parallax/repeat replacement mechanism.** When a Cover saved with `hasParallax: true` and/or `isRepeated: true` gains a binding, the server-render must emit an `<img>` instead of `<div style="background-image: url(...)">` (per AC-19) and ensure `has-parallax`/`is-repeated` classes do not apply to the image element. The WordPress HTML API's `WP_HTML_Tag_Processor` cannot rewrite a `<div>` into an `<img>` — there is no `set_tag()` / element-type-swap operation; only attribute, class, and (via `WP_HTML_Processor` bookmarks) inner-HTML mutations are available. Feasible mechanisms therefore include: (i) detect the parallax/repeat case in `render_block_core_cover` and replace the entire image fragment in `$content` with a rebuilt `<img>` HTML string (string-level or `WP_HTML_Processor`-bookmark substitution), or (ii) bypass the saved image markup entirely when bindings are active and synthesise the full `<img>` server-side from the resolved `url`/`id`. Design phase picks one; both must honour AC-19 and must avoid CSS-in-`style` mutation (Risk #5).
 - **OQ-4. Specific non-opaque effective dim-ratio value.** The contract (Req 14, AC-15, AC-16) is non-opacity. The existing `onSelectMedia` downshift uses 50; the design phase picks the specific value (likely 50 for symmetry, but the spec does not lock it).

From 7ab2b457a7b36807d831b1596937e5d85f3e64f6 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:32:28 +0200
Subject: [PATCH 11/60] docs(pipeline): add 1-spec/spec-review-approved.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../1-spec/spec-review-approved.md            | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-approved.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-approved.md
new file mode 100644
index 00000000000000..4d1a761034124f
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-approved.md
@@ -0,0 +1,19 @@
+# Spec Review
+
+## Verdict: approved
+
+## Summary
+
+The iter-3 revision resolves all three iter-2 findings cleanly and introduces no new defects.
+
+**Iter-2 Issue 1 (blocker — Glossary "active binding" incompatible with Pattern Overrides).** Resolved by adding a dedicated "Expanded bindings" Glossary entry that defines `__default` expansion semantics, and by rewriting the "Active binding" definition to operate *after* expansion. The spec now states explicitly: "The `__default: { source: 'core/pattern-overrides' }` shape therefore qualifies as an active binding by construction, because expansion populates `id` and `url` from the same `__default` source." The reference to the existing client helper `replacePatternOverridesDefaultBinding( bindings, supportedAttributes )` in `packages/block-editor/src/utils/block-bindings.js` is verified — the helper exists at the cited path. Reqs 4–9, 11, 14, 18 and ACs 11–15 / 18 / 19 now correctly fire for the headline Pattern-Overrides shape. AC-6 / Req 26 are also tightened to note that `__default` cannot mismatch by construction; only explicit per-attribute bindings can.
+
+**Iter-2 Issue 2 (minor — OQ-3 HTML Tag Processor claim).** Resolved by rewriting OQ-3 to explicitly state the API limitation ("`WP_HTML_Tag_Processor` cannot rewrite a `<div>` into an `<img>` — there is no `set_tag()` / element-type-swap operation") and to enumerate the two genuinely feasible mechanisms (`$content` fragment replacement / Processor-bookmark substitution, or synthesise the full `<img>` server-side from resolved `url`/`id`).
+
+**Iter-2 Issue 3 (minor — AC-21 embed-video URL ambiguity).** Resolved by AC-21 now stating: "the rendered embed iframe `src` is the **saved** `url` attribute, NOT the bound `url`. No URL substitution is attempted for embed-video covers; no `<img>` is synthesised; no overlay-class or parallax-class rewrite is performed." The Out-of-Scope embed-video bullet mirrors this and adds the "embed path wins even if a Cover's saved markup contains stale `hasParallax: true` alongside `backgroundType: "embed-video"`" carve-out.
+
+Other improvements in iter-3 worth noting: Req 11 / DC-2 now enumerate the full prohibited-mutation attribute list (`dimRatio, useFeaturedImage, backgroundType, id, url, hasParallax, isRepeated, overlayColor, customOverlayColor`), which closes a small gap from iter-2. Glossary "Bound `url` / `id`" now correctly accounts for `__default`-implied bindings. Design Constraints section now explicitly mandates the PR review checklist tick DC-1/DC-2/DC-3.
+
+No blockers, no new defects. The remaining Open Questions (OQ-1 Approach A vs B, OQ-2 disable vs hide, OQ-3 saved-markup parallax mechanism, OQ-4 specific dim-ratio value) are all genuine HOW choices appropriate for the design phase — they do not gate any user-observable contract.
+
+Approving for design phase.

From 58e31accd62343be58695893b95295c2b1b58062 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:40:38 +0200
Subject: [PATCH 12/60] docs(pipeline): add 2-design-doc/design-doc.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../2-design-doc/design-doc.md                | 667 ++++++++++++++++++
 1 file changed, 667 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
new file mode 100644
index 00000000000000..78864a0e02dd49
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
@@ -0,0 +1,667 @@
+# Design Doc: Cover block bindings — internal-only `id` and `url`
+
+Spec: `<artifacts>/1-spec/spec.md` (approved). All AC and DC references below resolve to that file.
+
+## 1. Overview
+
+`core/cover` ships Block Bindings support for `id` and `url` restricted to internal media-library attachments, headlined by Pattern Overrides. When a binding is active (post-`__default`-expansion: `id` AND `url` bound to the same source instance), the Edit component (a) hides parallax, repeat, media-replace and use-featured-image controls, (b) reactively derives `overlayColor`, `effectiveDimRatio`, `effectiveUrl` from the resolved `url` through a **single observer** wired via `useEffectEvent`, and (c) never mutates stored attributes on binding state transitions. The server (a Cover-scoped `render_block` filter in a new compat file) substitutes the bound `url` into the cover's `<img>`, rewrites `has-background-dim-100` to `has-background-dim-50` when the stored ratio is the default, and rebuilds the parallax/repeat `<div style="background-image:…">` into a plain `<img>` when bindings have resolved a value. Embed-video covers short-circuit both client and server binding paths.
+
+## 2. Architecture
+
+### 2.1 ASCII data flow
+
+```
+                            ┌─────────────────────────────────────────────────┐
+                            │  metadata.bindings (with __default expansion)   │
+                            └───────────────┬─────────────────────────────────┘
+                                            │
+                            ┌───────────────┴────────────────┐
+                            │                                │
+                            ▼                                ▼
+       ┌───────────────────────────────────┐   ┌──────────────────────────────────┐
+       │ CLIENT  (packages/block-library/  │   │ SERVER (PHP)                     │
+       │         src/cover/edit/index.js)  │   │                                  │
+       ├───────────────────────────────────┤   ├──────────────────────────────────┤
+       │ useBindingState() hook (NEW)      │   │ render_block (priority 9)        │
+       │   - expandedBindings              │   │   gutenberg_cover_bindings_      │
+       │   - bindingActive  (id+url, same  │   │     render_block( $content,      │
+       │       source instance)            │   │       $block, $instance )        │
+       │   - bindingResolvedUrl/Id (from   │   │     ↑ runs BEFORE                │
+       │       source.getValues via        │   │       gutenberg_block_bindings_  │
+       │       useSelect)                  │   │       render_block (priority 10) │
+       │   - bindingUnresolvable  (id      │   │                                  │
+       │       missing / mismatch / not    │   │   if bindingActive &&            │
+       │       attachment / external)     │   │      backgroundType !=='embed-   │
+       │                                   │   │      video':                     │
+       │ Effective values (derived, no    │   │     1. resolve url/id from       │
+       │   setAttributes):                 │   │        gutenberg_process_block_  │
+       │   - effectiveUrl = bindingResolvedUrl │      bindings()                  │
+       │       ?? (useFeaturedImage?       │   │     2. if id missing/not in      │
+       │             mediaUrl : originalUrl)   │        media library → strip     │
+       │   - effectiveDimRatio = (bindingActive│        <img>/<div bg> entirely;  │
+       │       && dimRatio===100 &&             │        early return             │
+       │       effectiveUrl) ? 50 : dimRatio    │     3. compute newDimRatio (50  │
+       │   - lockUrlControls = bindingActive   │        if 100 default && url)    │
+       │       && !canUserEditValue            │     4. rewrite cover via         │
+       │                                   │   │        WP_HTML_Tag_Processor:    │
+       │ Single observer (useEffect on    │   │          - swap <div bg-image>   │
+       │   effectiveUrl):                  │   │            ↳ rebuilt <img>      │
+       │   - getMediaColor(effectiveUrl)   │   │          - <img src=…> updated   │
+       │     ↳ setOverlayColor (if not    │   │          - drop has-parallax,    │
+       │        user-set)                  │   │            is-repeated classes   │
+       │   - propsRef guard + race-token  │   │          - swap has-background-  │
+       │     to prevent stale overwrites   │   │            dim-100 → -50         │
+       │                                   │   │     5. short-circuit            │
+       │ CoverInspectorControls / Block-  │   │        useFeaturedImage branch   │
+       │   Controls gated by               │   │                                  │
+       │   bindingActive + lockUrlControls │   │   else if embed-video:           │
+       └───────────────────────────────────┘   │     pass through unchanged       │
+                                               └──────────────────────────────────┘
+```
+
+### 2.2 Files touched
+
+| File | Role | Change |
+| --- | --- | --- |
+| `packages/block-library/src/cover/block.json` | Attribute schema | Add `"role": "content"` to `id` (AC-1, AC-2 prerequisite) |
+| `lib/compat/wordpress-7.1/block-bindings.php` (NEW) | Server allow-list + Cover-scoped render filter | (a) `block_bindings_supported_attributes` filter adds `id`,`url` to `core/cover`; (b) `gutenberg_cover_bindings_render_block` filter on `render_block` priority 9 |
+| `lib/load.php` | Bootstrap | `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';` in the REST-server block (alongside other 7.1 entries) |
+| `packages/block-library/src/cover/edit/index.js` | Reactive observer, derived values | New `useCoverBindingState` hook, replace existing `useEffect([mediaUrl])` with a single observer on `effectiveUrl`, propagate derived values to children |
+| `packages/block-library/src/cover/edit/inspector-controls.js` | UI gating | Gate parallax/repeat ToolsPanelItems on `! bindingActive` |
+| `packages/block-library/src/cover/edit/block-controls.js` | UI gating | Conditionally render `<MediaReplaceFlow>` based on `! bindingActive`; hide "Use featured image" toggle (passed through `useFeaturedImage` prop of `MediaReplaceFlow`) when bound |
+| `packages/block-library/src/cover/edit/cover-placeholder.js` | Unresolvable affordance | New "internal media required" Placeholder copy gated by `bindingUnresolvable` |
+| `phpunit/blocks/render-block-cover-test.php` | PHPUnit | New cases: bound-url → `<img src=$bound>`; default `dimRatio:100` + binding → `has-background-dim-50`; mismatched/unresolvable → no `<img>` |
+| `test/e2e/specs/editor/blocks/cover.spec.js` | E2E | New `describe('Block Bindings — Pattern Overrides')` block (AC-22..AC-24) |
+| `backport-changelog/7.1/<core-pr>.md` | Metadata | One-line entry when Core PR exists |
+
+No other Cover files change. No new `__experimental*` APIs are introduced. No `save.js`, `deprecated.js`, or block-list-renderer changes.
+
+## 3. Open Questions resolved
+
+### OQ-1: Server-side approach — Cover-scoped filter (chosen)
+
+**Choice: Approach A — Cover-scoped `render_block` filter in `lib/compat/wordpress-7.1/block-bindings.php`.**
+
+Concretely: one `add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 )` that gates on `$block['blockName'] === 'core/cover'` and exits the filter for every other block.
+
+**Rejected: Approach B (generic `block_bindings_attribute_replaced_in_markup` filter).**
+
+Reasoning:
+- Approach B (PR #74610) only solves `<img src>` substitution. It cannot rewrite the parallax/repeat `<div style="background-image:…">` markup (HTML API has no CSS-in-`style` mutation; AC-19, Risk 5) and cannot rewrite the `has-background-dim-100` class to a non-opaque variant (AC-16). Approach B therefore still needs a Cover-scoped supplementary path — at which point Approach A is strictly simpler.
+- Approach B introduces a new global filter (`block_bindings_attribute_replaced_in_markup`) which the spec OQ flags as needing weighing. Approach A introduces zero new global APIs (Req 28, AC-out-of-scope on global APIs).
+- Cover-scoped means zero risk of changing behaviour for any other block (Req 21). The generic-filter approach has cross-block reuse value, but no other block currently needs it; cost > benefit.
+- Approach A keeps the entire substitution surface in one file (the new 7.1 compat file). Easier to review, easier to delete when Core absorbs the change.
+
+**Traces to:** Req 21, Req 28, AC-16, AC-18, AC-19, Risk 5, Out-of-Scope item "New global Block Bindings APIs".
+
+### OQ-2: Reset affordance — disable (chosen)
+
+**Choice: keep existing `ResetOverridesControl` semantics: button is **disabled** (not removed from DOM) when the instance value matches the pattern default.**
+
+Reasoning:
+- Cover-specific code zero. Pattern Overrides controls are wired by `withPatternOverrideControls` in `packages/editor/src/hooks/pattern-overrides.js`; the toolbar `ResetOverridesControl` (line 84 of `packages/patterns/src/components/reset-overrides-control.js`) already renders `disabled={ ! isOverridden }`.
+- Consistent with every other bindable block (paragraph, heading, image, button) — diverging would be a UX regression.
+- Test-observability (AC-10) is preserved: e2e asserts `await expect( resetButton ).toBeDisabled()` rather than absence-from-DOM.
+
+**Traces to:** AC-10, Req 24(d).
+
+### OQ-3: Saved-markup parallax/repeat rewrite mechanism — bookmark-bounded substring replacement (chosen)
+
+**Choice: Mechanism (i) — detect the parallax/repeat case in the new Cover render filter and replace the entire `<div class="wp-block-cover__image-background" style="background-image:url(…)">` fragment in `$content` with a rebuilt `<img>` HTML string, using `WP_HTML_Tag_Processor` to locate the element and Tag-Processor bookmarks (via the source-text byte positions exposed through `get_token_byte_offset_in_source_text`/`get_token_length_in_source_text` on `WP_HTML_Processor::create_fragment`) to compute the substring range to splice.**
+
+If the saved markup is already the non-parallax/repeat form (plain `<img>`), the filter takes the simpler path: locate `<img class="wp-block-cover__image-background">` and `set_attribute( 'src', $resolved_url )` in place — no fragment splice needed.
+
+Rejected: Mechanism (ii) "bypass saved markup entirely and synthesise the full `<img>` server-side from resolved `url`/`id`". Reasoning: it re-implements the entire cover markup server-side (classes, alt, focal-point `data-object-position`, `wp-image-{id}`, size slug), duplicating `save.js` logic. Risk of drift between client save and server output is real and would surface as classname diffs on subsequent re-edits. Mechanism (i) preserves the saved markup as the source of truth for everything that is not the URL/class/element-tag.
+
+**Concrete shape (pseudo-PHP, mechanism (i)):**
+
+```php
+// $content is the saved Cover markup.
+$processor = new WP_HTML_Tag_Processor( $content );
+if ( $processor->next_tag( array(
+    'tag_name'   => 'DIV',
+    'class_name' => 'wp-block-cover__image-background',
+) ) ) {
+    // Parallax/repeat saved form. Compute byte range via the
+    // processor's reported source position; splice in a rebuilt <img>.
+    $start  = $processor->get_token_byte_offset_in_source_text();
+    $length = $processor->get_full_token_length(); // div opener + content + closer
+    $rebuilt_img = sprintf(
+        '<img class="wp-block-cover__image-background%s" alt="%s" src="%s" data-object-fit="cover"%s />',
+        $size_class,           // " wp-image-{$id} size-{$slug}"
+        esc_attr( $alt ),
+        esc_url( $resolved_url ),
+        $object_position_attrs // optional data-object-position + style
+    );
+    $content = substr( $content, 0, $start ) . $rebuilt_img . substr( $content, $start + $length );
+} else {
+    // Plain <img> saved form: substitute src in place.
+    $processor = new WP_HTML_Tag_Processor( $content );
+    if ( $processor->next_tag( array(
+        'tag_name'   => 'IMG',
+        'class_name' => 'wp-block-cover__image-background',
+    ) ) ) {
+        $processor->set_attribute( 'src', $resolved_url );
+        $content = $processor->get_updated_html();
+    }
+}
+```
+
+(`WP_HTML_Tag_Processor::get_token_byte_offset_in_source_text`/`get_full_token_length` are public; if a particular WP version lacks the closer-aware helper, fall back to `preg_match` on `/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*>\s*<\/div>/is` — the same pattern `render_block_core_cover` already uses on lines 117–125 of `packages/block-library/src/cover/index.php` for the embed-figure case.)
+
+**Traces to:** AC-19, Risk 5, OQ-3 spec text.
+
+### OQ-4: Non-opaque effective `dimRatio` — **50** (chosen)
+
+**Choice: 50.**
+
+Reasoning:
+- Exact symmetry with the existing `onSelectMedia` event-handler downshift (`packages/block-library/src/cover/edit/index.js:244-247`: `currentAttrs.url === undefined && currentAttrs.dimRatio === 100 ? 50 : ...`). Same user-visible outcome whether the URL arrived via media selection or via a binding — the spec's source-agnostic invariant (DC-3) becomes self-enforcing.
+- `dimRatioToClass( 50 ) === null` (see `packages/block-library/src/cover/shared.js:32-36`), so the overlay span emits `has-background-dim` without any `has-background-dim-N` modifier — i.e. the CSS default of 50% opacity. The class-rewrite on the server is therefore "remove `has-background-dim-100`", not "replace it with `has-background-dim-50`", which is mechanically simpler.
+
+**Traces to:** AC-15, AC-16, Req 14, Req 18.
+
+### OQ-5: Pre-existing `hasParallax=true` on a Cover that gains a binding — **render-time force-off** (chosen)
+
+**Choice: do not migrate the saved attribute. At render time (both client and server) treat `hasParallax` and `isRepeated` as effectively `false` whenever `bindingActive && backgroundType !== 'embed-video'`. The stored attributes are untouched. The UI hides the toggles so the user cannot newly set them.**
+
+Reasoning:
+- DC-2 / Req 11 prohibit attribute mutation from binding-state changes. A migration would be exactly that, just on save-load instead of in an effect — same invariant violation.
+- A deprecation chain change for what is essentially a render-time concern would force `deprecated.js` work and risks breaking saved unbound covers (AC-20 non-regression).
+- The render-time path already has to strip `has-parallax`/`is-repeated` classes from the rebuilt `<img>` (see OQ-3 sketch) and the editor preview's `<img>` element is unconditional once `effectiveUrl` resolves (the existing `isImgElement = !(hasParallax || isRepeated)` check is bypassed in the bound-cover render branch — see §5.4). Force-off therefore comes free.
+
+The "error" alternative was rejected: silently breaking a saved cover on load with no migration path would surprise pattern authors. Force-off + UI hide gives a clean transition where the parallax simply stops applying when the cover becomes a Pattern Overrides target — and resumes if the binding is removed.
+
+**Traces to:** Req 11, DC-2, AC-19, AC-20.
+
+### OQ-6 (newly identified): Test-observable signal for the "internal media required" affordance
+
+**Choice: a `<Placeholder>` with a stable `data-testid="cover-binding-unresolvable"` attribute AND the i18n string `__( 'Internal media required for this binding.' )`.**
+
+The e2e test (AC-24) locates by `data-testid` for stability across translations. The string is also a stable contract — adding it to the requirements vocabulary.
+
+**Traces to:** Req 16, AC-4, AC-24.
+
+## 4. Risks addressed
+
+### Risk 1 — Ockham architecture gate (preempt with single-observer design)
+
+Preempted by **§5 "Client-side design"**: every URL-derived piece of state (overlay color, effective dim ratio, effective URL, lock flags) flows from one `useEffect` keyed on `effectiveUrl`. There is no per-event `useEffect` for "binding detected" / "blur" / "media replaced". Existing event handlers (`onSelectMedia`, `toggleUseFeaturedImage`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`) keep their current side-effects on attributes (they mutate `url`, `id`, `dimRatio`, etc.) but no longer need to also compute overlay color — that is delegated to the observer. `useEffectEvent` reads `isUserOverlayColor`, latest `dimRatio`, and the current overlayColor without making them dep-array entries, eliminating stale-closure risk. The PR review checklist must tick **DC-1, DC-2, DC-3** explicitly per spec §"Design Constraints".
+
+### Risk 2 — Pattern Overrides reset semantics
+
+Preempted by **reusing the existing `withPatternOverrideControls` HOC and `ResetOverridesControl`** unchanged (OQ-2 chose disable-not-hide). Cover-side code adds zero Pattern-Overrides-specific logic. The four states (AC-7..AC-10) round-trip through the existing infrastructure once Cover is allow-listed by the server-side filter.
+
+### Risk 3 — Default `dimRatio: 100` opacity
+
+Preempted by **render-time `effectiveDimRatio = (bindingActive && dimRatio === 100 && effectiveUrl) ? 50 : dimRatio`** in the editor preview (passed through `dimRatioToClass`) AND by the server-side class rewrite (remove `has-background-dim-100` from the overlay span). The stored attribute remains 100 (DC-2, Req 11). When the user explicitly sets `dimRatio` to a non-default value, the conditional fails and the stored value is honoured (AC-17).
+
+### Risk 4 — Embed-video collision
+
+Preempted by an **explicit `backgroundType === 'embed-video'` short-circuit at both client and server**:
+- Client: `useCoverBindingState` returns `bindingActive: false` when `backgroundType === 'embed-video'`, regardless of `metadata.bindings`. Derivations short-circuit; the existing oEmbed path runs as today (AC-21).
+- Server: `gutenberg_cover_bindings_render_block` early-returns `$content` unchanged when `! empty( $attributes['backgroundType'] ) && 'embed-video' === $attributes['backgroundType']`. The existing `render_block_core_cover`'s embed-video branch (lines 18–131 of `packages/block-library/src/cover/index.php`) runs unmodified.
+
+Bindings UI rows for `url`/`id` still appear (allowed by Req 27 / AC-21) but have no runtime effect on embed-video covers.
+
+### Risk 5 — HTML API can't edit CSS-in-`style`
+
+Preempted by **OQ-3 mechanism (i)**: never attempt to edit the CSS value inside `style="background-image: url(…)"`. Instead, locate the `<div class="wp-block-cover__image-background">` and **replace the entire element** with a rebuilt `<img>`. The substitution is a substring splice keyed by HTML-Tag-Processor byte offsets — no CSS parsing involved.
+
+## 5. Client-side design
+
+### 5.1 New hook: `useCoverBindingState`
+
+Location: new file `packages/block-library/src/cover/edit/use-cover-binding-state.js`.
+
+Exported shape:
+
+```js
+/**
+ * @typedef {Object} CoverBindingState
+ * @property {boolean}            bindingActive          true iff (after __default expansion) `id` AND `url` are bound to the same source instance AND backgroundType !== 'embed-video'.
+ * @property {boolean}            bindingUnresolvable    true iff metadata.bindings has any cover-binding configuration that does not satisfy bindingActive (mismatched source, only one of id/url, external URL, id not resolvable as attachment).
+ * @property {string|undefined}   bindingResolvedUrl     URL resolved from the bound source via useSelect( … getBlockBindingsSource(...).getValues ).
+ * @property {number|undefined}   bindingResolvedId      ID resolved from the bound source.
+ * @property {boolean}            canUserEditBindingValue Source.canUserEditValue() result; gates lockUrlControls.
+ */
+export default function useCoverBindingState( { clientId, attributes, context } ) { … }
+```
+
+Implementation outline:
+1. Expand `attributes.metadata?.bindings` via `replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] )` from `packages/block-editor/src/utils/block-bindings.js`. Use `[ 'id', 'url' ]` as the supportedAttributes argument.
+2. `bindingActive = expanded?.id && expanded?.url && expanded.id.source === expanded.url.source && JSON.stringify(expanded.id.args ?? null) === JSON.stringify(expanded.url.args ?? null) && backgroundType !== 'embed-video'`.
+3. Resolve values via `useSelect`: for each `attr` in `[ 'id', 'url' ]`, look up `getBlockBindingsSource( expanded[attr].source ).getValues({ select, clientId, context, bindings: { [attr]: expanded[attr] } })[ attr ]`. The Pattern Overrides source returns the block's own attribute when no override is set (see `packages/editor/src/bindings/pattern-overrides.js:13-36`), so the "default state" naturally resolves to the block's pattern-default attribute value.
+4. Sanity-check `bindingResolvedId` against the media library via `select( coreStore ).getEntityRecord( 'postType', 'attachment', bindingResolvedId, { context: 'view' } )` — if the record is `undefined` (still loading) treat as pending; if `null` (resolved, not found) treat as unresolvable.
+5. `bindingUnresolvable = (hasAnyCoverBinding) && ! bindingActive` OR `bindingActive && bindingResolvedId resolves to null`.
+
+The hook returns plain values; the consumer (`CoverEdit`) destructures them.
+
+### 5.2 Single observer (in `CoverEdit`)
+
+Replaces the existing `useEffect( [ mediaUrl ] )` block (`packages/block-library/src/cover/edit/index.js:163-201`). Source-agnostic per DC-3:
+
+```js
+// Derived: the URL the editor should display.
+const effectiveUrl =
+    bindingResolvedUrl ??
+    ( useFeaturedImage ? mediaUrl : originalUrl?.replaceAll( '&amp;', '&' ) );
+
+// Derived: effective dimRatio for preview-time class computation.
+const effectiveDimRatio =
+    bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio;
+
+// Latest non-tracked reads via useEffectEvent (eliminates stale closure pitfalls).
+const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => {
+    if ( ! resolvedUrl ) return;
+    const raceToken = ++raceTokenRef.current;
+    const avg = await getMediaColor( resolvedUrl );
+    if ( raceToken !== raceTokenRef.current ) return; // stale
+
+    const { attributes: latestAttrs, overlayColor: latestOverlay } = propsRef.current;
+    if ( ! latestAttrs.isUserOverlayColor ) {
+        __unstableMarkNextChangeAsNotPersistent();
+        setOverlayColor( avg );
+    }
+    const newIsDark = compositeIsDark(
+        latestAttrs.dimRatio === 100 && latestAttrs.url ? 50 : latestAttrs.dimRatio, // mirror effectiveDimRatio
+        latestAttrs.isUserOverlayColor ? latestOverlay.color : avg,
+        avg
+    );
+    __unstableMarkNextChangeAsNotPersistent();
+    setAttributes( { isDark: newIsDark } ); // isDark is NOT in the DC-2 prohibition list
+} );
+
+useEffect( () => {
+    onUrlResolved( effectiveUrl );
+}, [ effectiveUrl, onUrlResolved ] );
+```
+
+Key properties:
+- **One** `useEffect`, keyed on `effectiveUrl`. The dependency array has stable references for everything else (DC-1).
+- `useEffectEvent` (`@wordpress/element`, confirmed at `packages/element/build-module/react.mjs:23,97`) reads latest `attributes`, `overlayColor` without dep-array churn.
+- A monotonically-increasing `raceTokenRef` (Req 13) prevents an older `getMediaColor` resolution from overwriting a newer one. Replaces the existing `propsRef`-only guard for the same purpose.
+- `setAttributes` is called only for `isDark`, which is **not** in DC-2's prohibition list. The DC-2 list is `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, `customOverlayColor`.
+
+### 5.3 Existing event handlers — unchanged
+
+`onSelectMedia`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`, `toggleUseFeaturedImage`, `onSelectEmbedUrl` keep their current shapes. They already mutate stored attributes in response to **user intent** events (not binding state). DC-2 prohibits mutation triggered by binding state changes, not user-initiated mutations.
+
+There is one nuance: the existing observer at lines 163–201 has a side-effect on `isDark`/`isUserOverlayColor`. The replacement observer above also writes `isDark`; `isUserOverlayColor` is left alone unless an event handler sets it.
+
+### 5.4 Render-tree changes in `CoverEdit`
+
+Around the existing image rendering (lines 672–693):
+
+```jsx
+{ bindingUnresolvable && (
+    <Placeholder
+        data-testid="cover-binding-unresolvable"
+        className="wp-block-cover__binding-unresolvable"
+        instructions={ __( 'Internal media required for this binding.' ) }
+        withIllustration
+    />
+) }
+
+{ ! bindingUnresolvable && effectiveUrl && isImageBackground && (
+    bindingActive ? (
+        // Force-img form: bindings override parallax/repeat
+        <img
+            ref={ mediaElement }
+            className="wp-block-cover__image-background"
+            alt={ alt }
+            src={ effectiveUrl }
+            style={ mediaStyle }
+        />
+    ) : (
+        // unchanged existing branch (img-or-div based on isImgElement)
+        …
+    )
+) }
+```
+
+And the overlay span class computation uses `effectiveDimRatio` rather than `dimRatio`:
+
+```jsx
+<span
+    className={ clsx(
+        'wp-block-cover__background',
+        dimRatioToClass( effectiveDimRatio ),
+        { 'has-background-dim': effectiveDimRatio !== undefined, … }
+    ) }
+/>
+```
+
+### 5.5 Control gating
+
+`inspector-controls.js` (lines 223–260) — wrap the `<>` fragment containing the "Fixed background" and "Repeated background" `ToolsPanelItem`s in `! bindingActive && …`. Pass `bindingActive` as a new prop from `CoverEdit`.
+
+`block-controls.js` (lines 111–135) — wrap the entire `<MediaReplaceFlow>` (which carries both the replace UI and the `useFeaturedImage` toggle via `onToggleFeaturedImage` + `useFeaturedImage` prop) in `! bindingActive && …`. Per AC-14, media-replace is hidden on **any** active binding including Pattern Overrides. Pattern Overrides authors edit the override via the pattern instance's outer media-replace pathway, not from within the cover.
+
+Per Req 7 + AC-14: media-replace hides on bindingActive regardless of `canUserEditValue`. (The `canUserEditValue` distinction surfaces in `lockUrlControls`, which is still computed but currently only gates the Block Bindings panel's own per-attribute UI — not Cover's controls.)
+
+The "Use featured image" toggle is rendered by `<MediaReplaceFlow>` (`onToggleFeaturedImage` + `useFeaturedImage` props at `block-controls.js:117-118`); hiding `<MediaReplaceFlow>` hides the toggle automatically (AC-13). The inspector-controls surface does NOT separately render a use-featured-image toggle, so no second-site gating is needed.
+
+### 5.6 Pattern Overrides integration
+
+Zero Cover-specific code. `withPatternOverrideControls` in `packages/editor/src/hooks/pattern-overrides.js` reads `__experimentalBlockBindingsSupportedAttributes?.[ blockName ]` (line 43); once the server-side filter (§6.1) adds `core/cover` to that list, the `<PatternOverridesControls>` "Enable overrides" button and the `<ResetOverridesControl>` toolbar button appear automatically (AC-2, AC-7..AC-10).
+
+`replacePatternOverridesDefaultBinding` in `packages/block-editor/src/utils/block-bindings.js` is used directly inside `useCoverBindingState`. This is the **same** helper the Block Bindings panel uses and the **same** semantics the server's `gutenberg_process_block_bindings` expansion uses (`lib/compat/wordpress-6.9/block-bindings.php:257-281`). Client and server agree on expansion by construction.
+
+## 6. Server-side design
+
+### 6.1 File: `lib/compat/wordpress-7.1/block-bindings.php` (NEW)
+
+Loaded from `lib/load.php` line ~83 alongside the other 7.1 REST-server-block entries:
+
+```php
+require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';
+```
+
+Wrapped in `! function_exists( 'gutenberg_cover_bindings_render_block' )` per the established 7.1 backport pattern.
+
+**Part 1 — allow-list filter:**
+
+```php
+if ( ! function_exists( 'gutenberg_cover_bindings_add_supported_attributes' ) ) {
+    function gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_type ) {
+        if ( 'core/cover' === $block_type ) {
+            foreach ( array( 'id', 'url' ) as $attr ) {
+                if ( ! in_array( $attr, $attributes, true ) ) {
+                    $attributes[] = $attr;
+                }
+            }
+        }
+        return $attributes;
+    }
+    add_filter( 'block_bindings_supported_attributes', 'gutenberg_cover_bindings_add_supported_attributes', 10, 2 );
+}
+```
+
+This filter feeds both `gutenberg_get_block_bindings_supported_attributes('core/cover')` (server-side resolution) and `__experimentalBlockBindingsSupportedAttributes['core/cover']` (editor setting via the existing `block_editor_settings_all` filter at `lib/compat/wordpress-6.9/block-bindings.php:33-46`). Single source of truth.
+
+**Part 2 — Cover-scoped render filter:**
+
+```php
+if ( ! function_exists( 'gutenberg_cover_bindings_render_block' ) ) {
+    function gutenberg_cover_bindings_render_block( $block_content, $block, $instance ) {
+        // Gate: Cover only.
+        if ( 'core/cover' !== ( $block['blockName'] ?? '' ) ) {
+            return $block_content;
+        }
+        $attrs = $instance->attributes ?? array();
+
+        // Gate: never engage for embed-video covers (AC-21).
+        if ( ! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType'] ) {
+            return $block_content;
+        }
+
+        // Gate: must have bindings on id AND url after __default expansion.
+        $bindings = $block['attrs']['metadata']['bindings'] ?? null;
+        if ( empty( $bindings ) ) {
+            return $block_content;
+        }
+        $expanded = gutenberg_cover_bindings_expand( $bindings ); // applies __default to id/url
+        if ( empty( $expanded['id'] ) || empty( $expanded['url'] ) ) {
+            return $block_content;
+        }
+        if (
+            $expanded['id']['source'] !== $expanded['url']['source']
+            || ( $expanded['id']['args'] ?? null ) !== ( $expanded['url']['args'] ?? null )
+        ) {
+            // Mismatched sources — unresolvable. Strip the saved <img>/<div bg> entirely (Req 26, AC-6).
+            return gutenberg_cover_bindings_strip_image( $block_content );
+        }
+
+        // Resolve via the standard bindings infrastructure.
+        $resolved = gutenberg_process_block_bindings( $instance );
+        $resolved_url = $resolved['url'] ?? null;
+        $resolved_id  = $resolved['id']  ?? null;
+        if ( empty( $resolved_url ) || empty( $resolved_id ) ) {
+            return gutenberg_cover_bindings_strip_image( $block_content );
+        }
+        // Verify $resolved_id is an attachment in the media library.
+        $attachment = get_post( (int) $resolved_id );
+        if ( ! $attachment || 'attachment' !== $attachment->post_type ) {
+            return gutenberg_cover_bindings_strip_image( $block_content );
+        }
+
+        // (A) Substitute <img src> / rebuild <div bg> → <img> (OQ-3 mechanism (i)).
+        $block_content = gutenberg_cover_bindings_rewrite_image(
+            $block_content,
+            $resolved_url,
+            $resolved_id,
+            $attrs
+        );
+
+        // (B) Rewrite overlay span: remove has-background-dim-100 when dimRatio is the default 100.
+        if ( 100 === ( $attrs['dimRatio'] ?? 100 ) ) {
+            $block_content = gutenberg_cover_bindings_relax_dim_class( $block_content );
+        }
+
+        // (C) Suppress the useFeaturedImage injection in render_block_core_cover (Req 19, AC-18).
+        // Achieved by mutating $instance->attributes BEFORE the priority-10 render path runs.
+        if ( ! empty( $attrs['useFeaturedImage'] ) ) {
+            $instance->attributes['useFeaturedImage'] = false;
+        }
+        // Also stop render_block_core_cover from re-running the parallax/featured-image branch on
+        // a now-image-substituted markup: render_callback executes BEFORE this filter (render_callback
+        // produces $content; render_block filters run on $content). Setting useFeaturedImage=false here
+        // applies only to the gutenberg_block_bindings_render_block re-render at priority 10 (see below).
+
+        return $block_content;
+    }
+    add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 );
+}
+```
+
+**Filter priority 9** is essential: `gutenberg_block_bindings_render_block` (the generic bindings filter from `lib/compat/wordpress-6.9/block-bindings.php`) registers at priority 10. Running before it means our Cover-scoped substitution happens on the saved markup, before the generic filter re-runs `$instance->render()` (which would re-execute `render_block_core_cover` and could re-inject a featured image).
+
+Alternative considered: run at priority 11 (after) and let the generic filter's `gutenberg_replace_html` no-op on Cover's `url`/`id` (they have no `source` declaration so it's already a no-op for non-`source`-declared attributes per `lib/compat/wordpress-6.9/block-bindings.php:347-349`). Rejected: the generic filter calls `$instance->render()` which re-executes `render_block_core_cover` with the resolved attributes, and that callback's `useFeaturedImage` branch may inject a featured-image `<img>` — exactly the double-insertion AC-18 forbids. Running at priority 9 lets us mutate `$instance->attributes['useFeaturedImage'] = false` before the priority-10 re-render. (See AC-18 trace.)
+
+### 6.2 Helper: `gutenberg_cover_bindings_rewrite_image`
+
+Per §3 OQ-3, two paths:
+
+1. **Plain `<img>` saved form** (`!hasParallax && !isRepeated` at save time): `WP_HTML_Tag_Processor::next_tag(['tag_name'=>'IMG','class_name'=>'wp-block-cover__image-background'])` + `set_attribute('src', $resolved_url)` + `set_attribute('alt', $attrs['alt'] ?? '')` + (optional) `set_attribute('class', preg_replace('/\bwp-image-\d+\b/', "wp-image-{$resolved_id}", $current))`.
+
+2. **`<div style="background-image:url(…)">` saved form** (parallax or repeat): locate via `WP_HTML_Tag_Processor` with `tag_name=>'DIV'` and `class_name=>'wp-block-cover__image-background'`, compute byte range, splice in a rebuilt `<img>` HTML string. Drop `has-parallax`/`is-repeated` classes by construction (the rebuilt string never contains them). AC-19.
+
+Both paths also need to drop a stale `wp-image-{old_id}` class and substitute `wp-image-{new_id}`; the `WP_HTML_Tag_Processor::remove_class` / `add_class` methods cover this for path 1.
+
+### 6.3 Helper: `gutenberg_cover_bindings_relax_dim_class`
+
+```php
+function gutenberg_cover_bindings_relax_dim_class( $content ) {
+    $processor = new WP_HTML_Tag_Processor( $content );
+    while ( $processor->next_tag( array( 'tag_name' => 'SPAN', 'class_name' => 'wp-block-cover__background' ) ) ) {
+        $processor->remove_class( 'has-background-dim-100' );
+        // Per OQ-4, dim 50 ≡ no class modifier (dimRatioToClass(50)===null).
+        // No has-background-dim-50 class is added.
+    }
+    return $processor->get_updated_html();
+}
+```
+
+Idempotent (calling twice is harmless). Targets the overlay span only; the `has-background-dim` modifier class stays (50%-opacity baseline).
+
+### 6.4 Helper: `gutenberg_cover_bindings_strip_image`
+
+For the unresolvable / mismatched / external-URL case (Req 20, AC-5, AC-6): use `WP_HTML_Tag_Processor` to locate any element with `class_name=>'wp-block-cover__image-background'` (both `IMG` and `DIV` forms) and **remove the element entirely** from `$content` via the same byte-offset splice as OQ-3 mechanism (i). The cover renders without an image element, overlay-only.
+
+### 6.5 PHPUnit coverage
+
+New cases in `phpunit/blocks/render-block-cover-test.php`:
+
+1. **Bound URL substitution.** Construct a parsed-block array with `metadata.bindings.url = { source: testing/x }` and `metadata.bindings.id` likewise; register a test source returning a known media-library attachment. Assert `<img src="…">` contains the resolved URL.
+2. **Default-dimRatio class rewrite.** Same setup, `dimRatio` omitted (defaults to 100). Assert resulting HTML contains `wp-block-cover__background has-background-dim` but NOT `has-background-dim-100` (AC-16, AC-25).
+3. **Non-default dimRatio preserved.** Same setup with `dimRatio: 70`. Assert `has-background-dim-70` is present (AC-17).
+4. **Parallax saved markup gets rebuilt.** Construct saved markup with the `<div class="wp-block-cover__image-background" style="background-image:url(…)"></div>` form. Assert resulting HTML has `<img class="wp-block-cover__image-background"` and no `has-parallax` / `is-repeated` classes on it (AC-19).
+5. **Mismatched sources strip the image.** `metadata.bindings.id.source === 'A'`, `metadata.bindings.url.source === 'B'`. Assert no `wp-block-cover__image-background` element in output (AC-6).
+6. **External URL strip.** Source returns a URL but a non-attachment id. Assert no `wp-block-cover__image-background` (AC-5).
+7. **`useFeaturedImage` short-circuit.** `useFeaturedImage: true` with active bindings. Assert exactly one `wp-block-cover__image-background` element and its `src` is the bound URL, not the featured image URL (AC-18).
+8. **Embed-video carve-out.** `backgroundType: 'embed-video'` with active bindings. Assert no `<img>` substitution; the iframe path runs (AC-21).
+9. **Unbound cover untouched.** No bindings. Assert the existing `render_block_core_cover` output is byte-identical to trunk (AC-20).
+
+## 7. `block.json` changes
+
+Add `"role": "content"` to the `id` attribute (lines 18–20 of `packages/block-library/src/cover/block.json`). The current `url` attribute already has `role: "content"` (lines 10–13).
+
+```diff
+   "id": {
+-    "type": "number"
++    "type": "number",
++    "role": "content"
+   },
+```
+
+No other attribute schema changes. No new attributes. No supports changes. No deprecation entry needed (role is metadata-only — see Q19 in requirements.md).
+
+## 8. Block Bindings registration
+
+Bindings for `id` and `url` on `core/cover` are added by the new `block_bindings_supported_attributes` filter (§6.1 Part 1). This feeds both server resolution (`gutenberg_process_block_bindings` reads from `gutenberg_get_block_bindings_supported_attributes`) and the editor settings (`__experimentalBlockBindingsSupportedAttributes` is built from the same function via `lib/compat/wordpress-6.9/block-bindings.php:33-46`).
+
+Exact code references:
+- `lib/compat/wordpress-6.9/block-bindings.php:118-167` (`gutenberg_get_block_bindings_supported_attributes`) — the function our filter hooks into.
+- `lib/compat/wordpress-6.9/block-bindings.php:33-46` (`block_editor_settings_all` filter) — populates the editor setting that `packages/block-editor/src/hooks/block-bindings.js:40-100` reads.
+- `packages/block-editor/src/hooks/block-bindings.js:122-127` — Cover is NOT in the excluded-blocks list. Once the server filter adds `id`/`url`, the Block Bindings panel renders automatically (AC-1, Q12).
+
+No new editor-side allow-list, no Cover-specific UI registration code.
+
+## 9. Pattern Overrides integration
+
+Driven entirely by existing infrastructure:
+
+1. **`__default` expansion (client).** `useCoverBindingState` calls `replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] )` from `packages/block-editor/src/utils/block-bindings.js:27-46`. After expansion, the `__default: { source: 'core/pattern-overrides' }` shape becomes `{ id: { source: 'core/pattern-overrides' }, url: { source: 'core/pattern-overrides' } }`, which is exactly the same-source-instance shape `bindingActive` accepts. Per Glossary "Expanded bindings".
+2. **`__default` expansion (server).** `gutenberg_process_block_bindings` (`lib/compat/wordpress-6.9/block-bindings.php:257-281`) expands `__default` server-side. Same semantics.
+3. **Reset toolbar.** `withPatternOverrideControls` (`packages/editor/src/hooks/pattern-overrides.js:37-122`) wires `<ResetOverridesControl>` automatically once the block is allow-listed.
+4. **Enable Overrides button.** Same HOC wires `<PatternOverridesControls>` for the synced-pattern authoring view.
+
+Zero Cover code touches Pattern Overrides directly.
+
+## 10. Same-source / internal-media invariant
+
+Three layers of enforcement, all gated by the same `bindingActive` semantic:
+
+| Layer | Enforcement site | Outcome |
+| --- | --- | --- |
+| Editor render | `CoverEdit` render tree (§5.4) | If `bindingUnresolvable`, render the `<Placeholder data-testid="cover-binding-unresolvable">` and do NOT render an `<img>` (AC-4). |
+| Editor controls | `useCoverBindingState` flips `bindingActive: false` when sources don't match | Parallax/repeat/replace/featured-image controls return to their unbound rendering. This is intentional: a mismatched-binding cover is treated as if there's no binding, so the user has the normal cover affordances to fix it. |
+| Server render | `gutenberg_cover_bindings_render_block` (§6.1) | Mismatched/missing/non-attachment id → `gutenberg_cover_bindings_strip_image` → no `<img>` in output (AC-5, AC-6, AC-20 unresolvable path). |
+
+The "internal media required" affordance test-observable signal is `data-testid="cover-binding-unresolvable"` AND the i18n string `__( 'Internal media required for this binding.' )` (OQ-6).
+
+## 11. Testing strategy
+
+### 11.1 Unit (Jest)
+
+`packages/block-library/src/cover/test/edit.js` — extend with cases for `useCoverBindingState`:
+
+- `bindingActive` true when `__default: { source: 'core/pattern-overrides' }` expanded.
+- `bindingActive` true when `{ id: { source: X, args: A }, url: { source: X, args: A } }`.
+- `bindingActive` false when sources differ.
+- `bindingActive` false when args differ.
+- `bindingActive` false when backgroundType is `embed-video`.
+- `bindingUnresolvable` true on mismatched sources.
+- `effectiveDimRatio` returns 50 only when `bindingActive && dimRatio===100 && effectiveUrl`.
+
+### 11.2 PHPUnit
+
+Cases enumerated in §6.5, added to `phpunit/blocks/render-block-cover-test.php`. Covers AC-3, AC-5, AC-6, AC-15..AC-21, AC-25.
+
+### 11.3 E2E
+
+New describe block in `test/e2e/specs/editor/blocks/cover.spec.js`: `'Block Bindings — Pattern Overrides round-trip'`.
+
+Test outline (one spec, multiple assertions, satisfies AC-22..AC-24):
+
+```js
+test.describe( 'Block Bindings — Pattern Overrides round-trip', () => {
+    test( 'Cover round-trips through default → override → reset', async ({ editor, page, requestUtils, admin }) => {
+        // Setup: upload two attachments (defaultMedia, overrideMedia).
+        // 1. Create synced pattern with a Cover whose url+id are bound via "Enable overrides".
+        //    Insert Cover → set media to defaultMedia → open Inspector → Advanced → "Enable overrides".
+        // 2. Save pattern. Open new post. Insert the synced pattern.
+        // 3. Assert (default state):
+        //    - Editor preview <img src> points at defaultMedia.url.
+        //    - Parallax / Repeat ToolsPanelItems are not visible (AC-11, AC-12).
+        //    - <MediaReplaceFlow> toolbar button is not visible (AC-13, AC-14).
+        //    - "Use featured image" menu item is not visible (AC-13).
+        //    - Overlay span class does NOT contain 'has-background-dim-100' (AC-15).
+        //    - ResetOverridesControl toolbar button is disabled (AC-10, OQ-2).
+        // 4. Override the instance: programmatically setBlockAttributes with new url+id.
+        //    - Assert ResetOverridesControl is now enabled.
+        //    - Assert editor preview <img src> points at overrideMedia.url.
+        //    - Publish post; navigate to front-end.
+        //    - Assert front-end <img src> points at overrideMedia.url.
+        //    - Assert front-end overlay class contains 'has-background-dim' but NOT 'has-background-dim-100' (AC-16).
+        // 5. Reset: click the toolbar Reset button.
+        //    - Assert editor preview <img src> back to defaultMedia.url.
+        //    - Publish; front-end same.
+        // 6. Unresolvable case: programmatically create a Cover with mismatched bindings
+        //    (id.source !== url.source). Assert the `data-testid="cover-binding-unresolvable"`
+        //    Placeholder is visible (AC-24).
+    } );
+} );
+```
+
+Test fixture follows the `packages/e2e-tests/plugins/block-bindings.php` pattern for additional non-Pattern-Overrides binding sources used in the mismatched-source test.
+
+### 11.4 Non-regression
+
+Existing `cover.spec.js` cases run untouched. Existing `packages/block-library/src/cover/test/edit.js` cases run untouched. Existing `phpunit/blocks/render-block-cover-test.php` cases run untouched. AC-20, AC-35.
+
+## 12. Backwards compatibility
+
+- **Unbound covers untouched.** All gating predicates (`bindingActive`, the server filter's early-return on `empty($bindings)`) flip false when `metadata.bindings` is absent. The new code path is dead code on every existing unbound cover. AC-20.
+- **No `save.js` change.** The serialized markup shape is identical to trunk. Deprecation chain unchanged. AC-20.
+- **No new attribute.** `id` gains a `role: "content"` annotation only — metadata-only, not part of the saved markup.
+- **Embed-video carve-out.** Both client and server short-circuit on `backgroundType === 'embed-video'`, regardless of binding presence. AC-21.
+- **`useFeaturedImage` precedence rule.** When both `useFeaturedImage: true` and an active binding co-exist on the same cover, the binding wins (server: `$instance->attributes['useFeaturedImage'] = false` is set BEFORE the priority-10 generic-bindings re-render). The stored `useFeaturedImage` attribute is NOT mutated (the mutation is to the in-flight `$instance` object, scoped to this single render pass — not to the post content). AC-18, DC-2 satisfied (no `setAttributes` on client, no persisted attribute change on server).
+- **`! function_exists` / version guards.** The new compat file follows the established pattern from `lib/compat/wordpress-6.9/block-comments.php:63,84`. Graceful degradation on a WP install lacking the bindings infrastructure (Req 39). The Cover Edit component's new hook reads `metadata?.bindings` defensively — when `__experimentalBlockBindingsSupportedAttributes['core/cover']` is undefined (pre-7.1 server), `bindingActive` returns false and the existing code path runs.
+
+## 13. Trade-offs and alternatives considered
+
+### Server-side: Approach A vs Approach B (revisited)
+
+Approach B (PR #74610's generic `block_bindings_attribute_replaced_in_markup` filter) was rejected per OQ-1 above. Summary of trade-offs:
+
+| | Approach A (chosen) | Approach B (rejected) |
+| --- | --- | --- |
+| New global filter | No | Yes (`block_bindings_attribute_replaced_in_markup`) |
+| Solves `<img src>` substitution | Yes (Cover-scoped) | Yes (generic) |
+| Solves dim-class rewrite | Yes | No — needs Cover-side supplement |
+| Solves parallax-div → `<img>` rebuild | Yes | No — needs Cover-side supplement (Risk 5) |
+| Solves `useFeaturedImage` short-circuit | Yes | No — needs Cover-side supplement |
+| Lines added to PR | Single file, ~150 lines | Generic filter + Cover-side supplement: ~200 lines |
+| Cross-block risk surface | Zero | Non-zero (filter affects every binding-substituted block) |
+| Reuse value for future bindable blocks | Zero | Some (e.g. a future block with non-source-declared `url`) |
+
+Net: Approach A wins on every dimension that touches this spec. Approach B's reuse value is real but speculative; the spec also flags it as out-of-scope absent a clear cross-block need (Req 28, Out-of-Scope "New global Block Bindings APIs").
+
+### Client-side: source-agnostic observer vs explicit `useBindings` derivation
+
+Considered: a separate `useEffect` keyed on `metadata.bindings` that synchronises a derived `bindingUrl` state into the existing observer. Rejected: that is exactly the multi-`useEffect` proliferation Risk 1 / DC-1 forbid. The chosen design (one effect, keyed on `effectiveUrl`, with `useEffectEvent` for latest-value reads) collapses every URL-derivation trigger into a single signal.
+
+### Pattern Overrides reset: disable vs hide
+
+OQ-2 chose disable. Hiding the button would require Cover-specific overrides of `ResetOverridesControl` (or a wholesale change to all bindable blocks). The hide approach has no UX advantage and would diverge Cover from every other bindable block; the disable approach is the existing contract.
+
+## 14. Out-of-scope reminders (from spec, repeated here to keep design honest)
+
+The design explicitly does NOT implement:
+
+- **External / non-media-library URL binding.** Unresolved-id covers render the "internal media required" Placeholder (client) or strip the `<img>` (server). No best-effort fallback for an external URL.
+- **Mismatched-source binding.** Treated as unresolvable. Same render path as external URL.
+- **Parallax × bindings beyond force-off.** No CSS-in-`style` rewrites. The parallax/repeat saved markup is replaced with a plain `<img>` when bindings have resolved a value (OQ-3 mechanism (i)).
+- **Embed-video × bindings beyond non-regression.** Both client and server short-circuit. The iframe's `src` is the saved `url`, never substituted from the bound `url`. AC-21.
+- **Featured-image binding** (expressing `useFeaturedImage` AS a binding source). Separate follow-up PR. This PR enforces the precedence rule only (AC-18).
+- **New global Block Bindings APIs.** None introduced. The chosen Cover-scoped filter is `add_filter( 'render_block', ..., 9, 3 )` with the standard signature — not a new API.
+- **Post-data source `featured_media.url` / `featured_media.id`.** Out of scope.
+
+## 15. Risks / open questions surfaced by this design
+
+1. **Priority-9 vs priority-10 ordering.** The Cover render filter runs at priority 9 to mutate `$instance->attributes['useFeaturedImage'] = false` before `gutenberg_block_bindings_render_block` re-runs `$instance->render()`. If a future change to the generic filter changes its registration priority, the ordering invariant breaks. Mitigation: PHPUnit case §6.5(7) catches this regression. Add a comment in the new compat file pinning the rationale.
+2. **`WP_HTML_Tag_Processor` byte-offset helpers**. OQ-3 mechanism (i) leans on `get_token_byte_offset_in_source_text()` / `get_full_token_length()`. These are public WP HTML API methods but availability across WP versions in the version-guard window needs confirmation during implementation. Fallback: `preg_match` with `PREG_OFFSET_CAPTURE` mirrors the pattern already used at `packages/block-library/src/cover/index.php:117-125`.
+3. **`gutenberg_process_block_bindings` is called twice per render** (once in our priority-9 filter, once in the priority-10 generic filter). This is functionally correct but wastes work. Acceptable for v1; a future micro-optimisation could cache resolution per `$instance`.
+4. **Race between `attachment` REST loading and `bindingResolvedId` check.** Client-side, the media-library record lookup via `useSelect` returns `undefined` while loading and `null` if resolved-not-found. The hook currently treats `undefined` as pending (no unresolvable affordance yet) and `null` as unresolvable. There's a single render where the cover shows neither image nor unresolvable affordance. Acceptable; pattern matches how `core/image` handles the same race.

From 980afab091f086833771a8bbb11d917ea66728a6 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:49:41 +0200
Subject: [PATCH 13/60] docs(pipeline): add
 2-design-doc/design-doc-review-1-rejected.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../design-doc-review-1-rejected.md           | 243 ++++++++++++++++++
 1 file changed, 243 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-1-rejected.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-1-rejected.md b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-1-rejected.md
new file mode 100644
index 00000000000000..cbe0d7bc566c89
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-1-rejected.md
@@ -0,0 +1,243 @@
+# Design Doc Review
+
+## Verdict: rejected
+
+## Summary
+
+The design doc has a solid skeleton: OQ-1/2/3/4 are chosen explicitly with rejected-alternative trade-offs; the single-observer architecture under `useEffectEvent` directly addresses Risk 1 / DC-1; the file table is concrete; Pattern Overrides routing is correctly delegated to `withPatternOverrideControls` + `replacePatternOverridesDefaultBinding`; and the spec's `__default` expansion finding (iter-2) is correctly threaded through both client and server. However, four substantive issues prevent approval:
+
+1. The chosen WP_HTML_Tag_Processor byte-offset helpers cited as "public" do not exist on `WP_HTML_Tag_Processor` — OQ-3's chosen mechanism rests on a fictional API surface.
+2. AC-13 / Req 6 (hide "Use featured image" toggle in EVERY surface) is incompletely satisfied — `cover-placeholder.js` exposes a second toggle site that the gating plan does not actually gate.
+3. AC-18 (no double `<img>` for featured image when binding is active) has a real architectural hole on Core 6.9+ where `render_callback` runs BEFORE the priority-9 filter with the bound url already merged into `$instance->attributes`, meaning the featured-image element is already injected into `$content` before our filter sees it — and the design's "`$instance->attributes['useFeaturedImage'] = false`" mutation only suppresses the priority-10 re-render leg, not the already-injected first-pass markup.
+4. Internal contradictions between §2.2 (files touched: `cover-placeholder.js` change) and §5.5 ("no second-site gating is needed") leave the design ambiguous about where the placeholder copy lives and where gating happens.
+
+Several smaller traceability / clarity issues compound these. Detailed below.
+
+## Issues
+
+### Issue 1 (blocker): OQ-3's chosen mechanism relies on non-existent `WP_HTML_Tag_Processor` methods
+
+**What's wrong:** The design (§3 OQ-3 and §6.2) cites the public methods `WP_HTML_Tag_Processor::get_token_byte_offset_in_source_text()` and `get_full_token_length()` as the mechanism for computing splice byte ranges. These methods **do not exist** on `WP_HTML_Tag_Processor` in the WordPress version range targeted (verified against `wp-includes/html-api/class-wp-html-tag-processor.php` — the class exposes `$token_starts_at` and `$token_length` only as **private** properties; the public method list in the file has no `get_token_byte_offset_in_source_text` / `get_full_token_length` / `get_token_length_in_source_text`). The design also conflates `WP_HTML_Tag_Processor` and `WP_HTML_Processor::create_fragment` ("…using `WP_HTML_Tag_Processor` to locate the element and Tag-Processor bookmarks (via the source-text byte positions exposed through `get_token_byte_offset_in_source_text`/`get_token_length_in_source_text` on `WP_HTML_Processor::create_fragment`)…"), which is internally inconsistent — first naming `WP_HTML_Tag_Processor`, then attributing the helper methods to `WP_HTML_Processor`. Neither class exposes those methods publicly in WP trunk today.
+
+**Where in design doc:** §3 OQ-3 (the "Concrete shape (pseudo-PHP, mechanism (i))" block) and §6.2.
+
+**Suggestion:** Pick one of:
+- (a) Commit to the `preg_match` fallback path the design already names as a Plan B (matching the regex pattern used by `render_block_core_cover` at `packages/block-library/src/cover/index.php:117-125`). Mark this as the primary mechanism for OQ-3 mechanism (i). Drop the byte-offset helper claim entirely or move it to "future micro-optimisation if Core gains public byte-offset accessors."
+- (b) Use `WP_HTML_Processor::create_fragment` with bookmark-bounded `seek` and explicit `get_updated_html()` substring extraction — but this needs a concrete code shape verified against trunk APIs, not just an asserted method name.
+
+**Why it matters:** OQ-3 is the load-bearing decision for AC-19. A mechanism that doesn't exist isn't a mechanism. Implementation phase will hit this immediately and have to redesign on the fly; the design phase is exactly where this should be settled. The spec called this a "genuinely architectural HOW choice" — the resolution has to be implementable.
+
+---
+
+### Issue 2 (blocker): AC-13 / Req 6 coverage gap — second "Use featured image" toggle site in `cover-placeholder.js`
+
+**What's wrong:** AC-13 / Req 6 require the "Use featured image" toggle to be hidden in **every surface where it appears** when a binding is active. The design (§5.5) explicitly enumerates only `block-controls.js` as the toggle's render site: "The `<MediaReplaceFlow>` (`onToggleFeaturedImage` + `useFeaturedImage` props at `block-controls.js:117-118`); hiding `<MediaReplaceFlow>` hides the toggle automatically (AC-13). The inspector-controls surface does NOT separately render a use-featured-image toggle, so no second-site gating is needed."
+
+This misses `packages/block-library/src/cover/edit/cover-placeholder.js`, which renders a `<MediaPlaceholder ... onToggleFeaturedImage={ toggleUseFeaturedImage }>` (lines 20, 37). This placeholder is invoked from the empty-cover branch in `index.js:599-635` (the `! useFeaturedImage && ! hasInnerBlocks && ! hasBackground` branch). A Cover that has bindings but a not-yet-resolved URL (e.g. the network is slow, or the user just inserted a synced-pattern instance with the binding active) can land in that empty branch and expose the "Use featured image" affordance — which AC-13 forbids. The same flow also exposes a media-upload affordance via `<MediaPlaceholder onSelect={ onSelectMedia }>`, conflicting with AC-14 (media-replace hidden under active binding).
+
+The §2.2 files-touched table DOES list `cover-placeholder.js` as a touched file ("New 'internal media required' Placeholder copy gated by `bindingUnresolvable`"), but the §5.5 text contradicts this by claiming no second-site gating is needed. The two halves of the doc disagree.
+
+**Where in design doc:** §2.2 (files touched table, last line for `cover-placeholder.js`) versus §5.4 (the Placeholder rendered inside `index.js`'s render tree) versus §5.5 ("no second-site gating is needed").
+
+**Suggestion:**
+- Decide explicitly: does `bindingUnresolvable` route through `cover-placeholder.js` (modifying it to render a different message + suppress the upload/featured-image affordances when bound) OR through a sibling Placeholder in `index.js` (in which case `cover-placeholder.js` does not need touching but the empty-cover branch must early-return on `bindingActive || bindingUnresolvable`).
+- Add the explicit gating for the empty-cover branch (`index.js:599`): "When `bindingActive || bindingUnresolvable`, the empty-cover branch MUST NOT render the standard `<CoverPlaceholder>` exposing the featured-image / media-upload affordances; it MUST render the 'internal media required' Placeholder instead OR (when `bindingActive` resolves later) defer until `effectiveUrl` arrives." Either path is fine — the design has to pick one and document it.
+
+**Why it matters:** AC-13 explicitly says "every surface where it appears". Without addressing `cover-placeholder.js`, the e2e test (AC-23) on a freshly-inserted bound Cover that has not yet resolved its URL will fail. DC-2 is also at indirect risk: the `cover-placeholder.js` upload path calls `onSelectMedia` which mutates `url`/`id`/`useFeaturedImage` on the cover — a user-initiated mutation, so DC-2 is technically satisfied, but the spec's intent (Req 7, AC-14) is to *prevent the affordance entirely* under active binding.
+
+---
+
+### Issue 3 (blocker): AC-18 — "$instance->attributes['useFeaturedImage'] = false" does not undo `render_callback`'s first-pass featured-image injection on Core 6.9+
+
+**What's wrong:** The design (§6.1, comment block "(C) Suppress the useFeaturedImage injection…") asserts that mutating `$instance->attributes['useFeaturedImage'] = false` at priority 9 prevents double image insertion. The accompanying comment is careful: "Setting useFeaturedImage=false here applies only to the gutenberg_block_bindings_render_block re-render at priority 10".
+
+On **Core 6.9+**, this leaves the AC-18 contract unmet for the first render pass:
+
+1. `WP_Block::render()` (verified at `wp-includes/class-wp-block.php:531-535`) calls `$this->process_block_bindings()` and merges resolved bindings into `$this->attributes` BEFORE invoking the `render_callback` (line 596).
+2. Core 6.9+ exposes `core/cover` as a binding-supported block once our `block_bindings_supported_attributes` filter adds `id`/`url`. So Core's own `process_block_bindings` resolves the bound url/id and merges them into `$instance->attributes` — including any post-resolution `useFeaturedImage` (which is unchanged from saved).
+3. `render_block_core_cover` runs with `useFeaturedImage: true` (the saved value) AND the bound url already substituted. If `backgroundType === 'image'` and `useFeaturedImage === true`, it injects a featured-image `<img>` (lines 137–197 of `packages/block-library/src/cover/index.php`) AFTER the existing `wp-block-cover__inner-container`. `$content` now has TWO `wp-block-cover__image-background` elements: the saved cover image AND the injected featured image.
+4. Priority-9 filter runs on this `$content`. `gutenberg_cover_bindings_rewrite_image` rewrites the FIRST matching element — but which one is "first" depends on saved-markup ordering vs. injection position, and even if rewritten, the SECOND injected element remains. Double-image violation per AC-18.
+
+The design's mitigation (mutate `$instance->attributes['useFeaturedImage'] = false`) takes effect only for the **second** render pass (the priority-10 generic filter that calls `$instance->render()` again), not the first one — and the first pass is the one that produced the `$content` we're filtering.
+
+**Where in design doc:** §6.1 Part 2, comment block "(C) Suppress the useFeaturedImage injection in render_block_core_cover". Also §12 ("`useFeaturedImage` precedence rule" bullet) repeats the same claim.
+
+**Suggestion:** Choose explicitly between:
+- (a) **Pre-resolve and strip approach** — In the priority-9 filter, after detecting `bindingActive` and resolving the bound url, additionally search `$content` for ALL elements matching `class_name => 'wp-block-cover__image-background'`. If more than one is found, remove all but the first AND set the survivor's src to the bound url. Document this as the AC-18 path.
+- (b) **Intercept earlier** — Hook `render_block_data` (which runs before `render_callback`) to mutate the parsed-block's attributes (`useFeaturedImage = false` and seed the bound url into `attrs['url']`) so `render_callback` skips the featured-image injection entirely. This requires careful interaction with Core's `process_block_bindings`.
+- (c) **Acknowledge the gap** — Document explicitly that on Core 6.9+ the design relies on `render_callback`'s early-return path being hit when `useFeaturedImage` is false (the typical case), and that the rare `useFeaturedImage: true + bindingActive` case is handled by a content-level strip of the duplicate `wp-block-cover__image-background` after `render_callback`. Tie this back to the §6.5 PHPUnit case #7.
+
+**Why it matters:** AC-18 is one of the spec's enumerated server-side correctness contracts. The current design says it's handled but the mechanism doesn't actually handle the first-pass injection. This is the kind of detail PR review will catch immediately.
+
+---
+
+### Issue 4 (major): Internal inconsistency between §5.4 (Placeholder rendered in `index.js`) and §2.2 / §5.5 (placeholder copy in `cover-placeholder.js`)
+
+**What's wrong:** §2.2 files-touched table says `cover-placeholder.js` is touched to add "New 'internal media required' Placeholder copy gated by `bindingUnresolvable`". §5.4 render-tree changes show the `<Placeholder data-testid="cover-binding-unresolvable">` rendered inline in `CoverEdit`'s render tree, alongside the existing image-rendering branch — not inside `<CoverPlaceholder>`. §5.5 then asserts no second-site gating is needed (which would be inconsistent with editing `cover-placeholder.js`). Two implementers reading this design will disagree on whether the new Placeholder lives in `index.js` or `cover-placeholder.js`, and whether `cover-placeholder.js` gets gated on `bindingActive`.
+
+**Where in design doc:** §2.2 (`cover-placeholder.js` row), §5.4 (Placeholder inline in `index.js`), §5.5 (no second-site gating).
+
+**Suggestion:** Pick one location for the unresolvable-affordance Placeholder. Recommended: render the new Placeholder inline in `index.js` (matching §5.4), AND additionally gate `cover-placeholder.js`'s `<MediaPlaceholder>` so that when `bindingActive` or `bindingUnresolvable` is true the empty-cover branch (`index.js:599`) either renders the unresolvable Placeholder or suppresses the upload/featured-image affordances. Update §2.2 to reflect whatever is decided. Remove the §5.5 "no second-site gating is needed" claim if cover-placeholder.js is gated.
+
+**Why it matters:** Ambiguity between two physical render sites is the canonical "two implementers, two different results" failure that the design phase exists to prevent.
+
+---
+
+### Issue 5 (major): Test-observable signal for AC-24 is not yet a stable contract
+
+**What's wrong:** OQ-6 introduces `data-testid="cover-binding-unresolvable"` and the i18n string `__( 'Internal media required for this binding.' )` as the test-observable signal. The design says "adding it to the requirements vocabulary" — but neither the spec nor the design enforce that this `data-testid` is preserved across implementations / translations / future refactors. A reviewer who removes the `data-testid` because "test-only props in production DOM smell bad" can silently break the e2e test (AC-24).
+
+Additionally, the spec's Req 16 wording is "a stable, test-observable signal — a known i18n message string (or equivalent stable identifier) accessible to the e2e test." The design picks BOTH `data-testid` AND the i18n string. The e2e test should pick one as primary; the spec preference is the i18n string. Using `data-testid` as the primary contract for the e2e test introduces a non-i18n coupling that may not survive Core upstreaming.
+
+**Where in design doc:** §3 OQ-6, §5.4 sketch, §11.3 e2e test outline.
+
+**Suggestion:**
+- Name the i18n message string as the **primary** test-observable contract (per spec Req 16: "a known i18n message string"). Use `getByText( __( '…' ) )` or equivalent locator in the e2e test.
+- Keep `data-testid` as a **secondary** stability hook with a comment explaining that it exists specifically to survive translation regressions during e2e. Document this in the design as "primary: i18n string match; fallback: `data-testid`".
+- Or commit to `data-testid` only and document why the spec's i18n-string contract is being downgraded — but be explicit about it.
+
+**Why it matters:** Without a primary/secondary ordering, the next refactor will pick whichever feels right and break the other — exactly the silent-regression hazard the spec wanted to preclude.
+
+---
+
+### Issue 6 (major): "Embed video from URL" affordance is silently disabled as a side effect of hiding `<MediaReplaceFlow>`
+
+**What's wrong:** `block-controls.js:122-133` renders a `<MenuItem icon={link}>Embed video from URL</MenuItem>` as a **child** of `<MediaReplaceFlow>`. The design (§5.5) says to wrap the entire `<MediaReplaceFlow>` in `! bindingActive && ...`. This silently removes the "Embed video from URL" affordance from any Cover that has an active binding — including embed-video Covers with bindings (which the spec / AC-21 explicitly preserves as a working scenario for non-binding-affecting behavior, just without binding substitution).
+
+Per AC-21: "Binding the `url`/`id` of an embed-video Cover has no observable runtime effect under this PR" — but the spec does NOT say the editor UI for changing the embed video URL must be hidden. The design's wrapping decision hides that affordance as a side effect that the spec does not require.
+
+**Where in design doc:** §5.5 (the `<MediaReplaceFlow>` wrapping rule).
+
+**Suggestion:** Either:
+- (a) Restructure the gating to wrap only the parts of `<MediaReplaceFlow>` that surface the replace + featured-image controls, leaving the embed-video `<MenuItem>` accessible. Likely needs a separate toolbar `<ToolbarButton>` for the embed-URL flow when `bindingActive`.
+- (b) Acknowledge in the design that "Embed video from URL" is also hidden under active binding, and trace this to a spec requirement. If no spec requirement covers it, this is feature scope creep beyond what the spec requires.
+
+**Why it matters:** The spec is explicit about WHAT is hidden under active binding (parallax / repeat / media-replace / use-featured-image). Hiding other affordances by accident is a scope creep / scope contradiction that PR review will flag.
+
+---
+
+### Issue 7 (minor): `useEffectEvent` semantics for the observer — async race-token guard placement
+
+**What's wrong:** §5.2 sketch:
+```js
+const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => {
+    if ( ! resolvedUrl ) return;
+    const raceToken = ++raceTokenRef.current;
+    const avg = await getMediaColor( resolvedUrl );
+    if ( raceToken !== raceTokenRef.current ) return; // stale
+    ...
+} );
+useEffect( () => {
+    onUrlResolved( effectiveUrl );
+}, [ effectiveUrl, onUrlResolved ] );
+```
+
+`useEffectEvent` is documented as a way to read latest values WITHOUT being reactive. Including `onUrlResolved` in the dep-array is correct per React docs (it's stable across renders), but the design doesn't explain *why* the race-token guard is placed in the body of `useEffectEvent` rather than as a cleanup of `useEffect`. React's recommendation for stale-async guarding inside an effect is a cleanup function setting an `isCancelled` flag — the race-token-via-ref pattern works but is non-idiomatic and easy to get wrong.
+
+Also: the design says `raceTokenRef` is a Ref but doesn't show where it's declared. Implementers will need to add `const raceTokenRef = useRef( 0 );` somewhere; the design should sketch this.
+
+**Where in design doc:** §5.2.
+
+**Suggestion:** Either:
+- (a) Switch to a `useEffect` cleanup-flag pattern: `let cancelled = false; ... if (cancelled) return; ... return () => { cancelled = true; };`. Simpler, no extra ref. The trade-off with `useEffectEvent` is that the cleanup needs to capture the effect's variables, which still works.
+- (b) Keep the race-token-ref pattern but document the `useRef` declaration explicitly and explain why the ref-based guard was preferred (e.g. "to share the guard across multiple `useEffectEvent` invocations triggered by independent dependency-array changes").
+
+**Why it matters:** Req 13's contract ("MUST be resilient against concurrent async `getMediaColor` resolutions") is enforced here. An implementer who copies the sketch verbatim without declaring `raceTokenRef` will get a runtime error; an implementer who switches to the cleanup-flag pattern (because they think it's cleaner) will diverge from the design.
+
+---
+
+### Issue 8 (minor): Sanity-check on `bindingResolvedId` is missing alongside other `useSelect` reads — potential excessive re-renders
+
+**What's wrong:** §5.1 step 4: "Sanity-check `bindingResolvedId` against the media library via `select( coreStore ).getEntityRecord( 'postType', 'attachment', bindingResolvedId, { context: 'view' } )`". This is a network-blocking record fetch on every re-render where `bindingResolvedId` changes. The existing cover code (`inspector-controls.js:142-153`) does the same thing for `id`, but bounded by `id && isImageBackground` — i.e. only when the user explicitly has an image background. The new check fires on every Cover with bindings, even when the binding isn't being interactively edited.
+
+For Pattern Overrides with many bound Covers on a single page, this multiplies the entity record fetches. Acceptable for v1 but the design doesn't acknowledge the cost or propose a deduping strategy (e.g. memo'd by id, or `select` predicate `( select ) => id ? select(coreStore).getEntityRecord(...) : null`).
+
+**Where in design doc:** §5.1 step 4.
+
+**Suggestion:** Add a memoization note: "`bindingResolvedId` is read inside the same `useSelect` as the source's `getValues` call, with dependencies `[ bindingResolvedId, clientId ]`. Avoid a separate `useSelect` for each lookup." Or explicitly call out that the cost is bounded by `bindingActive && bindingResolvedId !== undefined`.
+
+**Why it matters:** Performance hazards that surface only with many bound blocks on a page will be hard to debug after merge. The design phase is the right place to flag them.
+
+---
+
+### Issue 9 (minor): Missing trace for AC-26 / AC-27 / AC-28 (PR-shape ACs)
+
+**What's wrong:** AC-26 (file path `lib/compat/wordpress-7.1/block-bindings.php`), AC-27 (PR description content), AC-28 (~500 line budget) — the design covers AC-26 via §6.1 and §2.2, but AC-27 and AC-28 are not mentioned anywhere in the design doc. AC-27 is arguably a PR-creation step rather than a design concern, but AC-28's ~500-line budget IS a design constraint — it shapes how much new code is acceptable.
+
+**Where in design doc:** Missing trace section for ACs 26–28.
+
+**Suggestion:** Add a short paragraph in §12 or §14 acknowledging the ~500-line budget (AC-28) and stating the design's expected diff size. The design as outlined (~150 lines in the new PHP file, modest JS hook additions, a few JSX gating changes, the test additions) plausibly fits, but spelling this out keeps the design honest.
+
+**Why it matters:** A spec AC with no trace in the design is a coverage gap by definition. The PR-shape ACs are testable post-hoc but should be acknowledged.
+
+---
+
+### Issue 10 (minor): `gutenberg_cover_bindings_expand` referenced but not defined
+
+**What's wrong:** §6.1 Part 2 calls `gutenberg_cover_bindings_expand( $bindings )` to handle `__default` expansion server-side, but no definition is given. The design says elsewhere (§9) that the server uses `gutenberg_process_block_bindings` for expansion. The introduction of a separately-named helper without a definition leaves implementers to guess: is it a new helper, or just an internal reference to `gutenberg_process_block_bindings`'s inline expansion logic (which is private)?
+
+**Where in design doc:** §6.1 Part 2 (the `if ( empty( $expanded['id'] ) || empty( $expanded['url'] ) ) ...` block).
+
+**Suggestion:** Either define `gutenberg_cover_bindings_expand` inline (likely a copy of the `__default` expansion logic from `lib/compat/wordpress-6.9/block-bindings.php:257-281`, scoped to `[ 'id', 'url' ]`), or replace the call with the call to `gutenberg_process_block_bindings` (which already does the expansion as a side effect) — but then the design must clarify how the priority-9 filter detects the expanded bindings WITHOUT calling `gutenberg_process_block_bindings` twice (once for the bindingActive check, once for value resolution).
+
+**Why it matters:** A pseudocode reference to a function that doesn't exist is a hidden dependency. The design doc's job is to surface these.
+
+---
+
+### Issue 11 (minor): Backport-changelog entry conditional language is too loose
+
+**What's wrong:** §2.2 last row says "`backport-changelog/7.1/<core-pr>.md` — One-line entry when Core PR exists". The spec's Req 36 / AC-26 mandate the backport-changelog file when the Core PR exists. The design's wording (`<core-pr>` is a placeholder) doesn't commit to a path or to *when* the file is created — at PR-open time? After Core PR opens? The design phase is too early to know the Core PR number, but the design should commit to creating the file as a deferred follow-up.
+
+**Where in design doc:** §2.2 last row.
+
+**Suggestion:** Reword to: "Created when the corresponding Core PR is filed; tracked as a PR comment or follow-up task. Not a blocker for the Gutenberg PR landing." Or: "Created at the same time as the Core PR; the Gutenberg PR description includes the placeholder and is updated once the Core PR number is known."
+
+**Why it matters:** Minor, but the design should not contain unresolved placeholders.
+
+---
+
+## Coverage summary
+
+| AC                 | Traced in design                                                | Adequately addressed                                            |
+| ------------------ | --------------------------------------------------------------- | --------------------------------------------------------------- |
+| AC-1               | §8                                                              | Yes                                                             |
+| AC-2               | §5.6, §9                                                        | Yes                                                             |
+| AC-3               | §5.4, §6.5(1)                                                   | Yes                                                             |
+| AC-4               | §5.4, §10, OQ-6                                                 | Partial — Issue 4, Issue 5                                      |
+| AC-5               | §6.4                                                            | Yes                                                             |
+| AC-6               | §6.4, §10                                                       | Yes                                                             |
+| AC-7..AC-10        | §5.6, §9, OQ-2                                                  | Yes                                                             |
+| AC-11..AC-12       | §5.5                                                            | Yes                                                             |
+| AC-13              | §5.5                                                            | **No — Issue 2 (cover-placeholder.js gap)**                     |
+| AC-14              | §5.5                                                            | Partial — Issue 2 (cover-placeholder.js upload affordance), Issue 6 (embed-video MenuItem side effect) |
+| AC-15..AC-17       | §5.2, §5.4, §6.3, OQ-4                                          | Yes                                                             |
+| AC-18              | §6.1(C), §12                                                    | **No — Issue 3 (first-pass injection not undone)**              |
+| AC-19              | §6.2, OQ-3                                                      | **No — Issue 1 (mechanism uses non-existent API)**              |
+| AC-20              | §12                                                             | Yes                                                             |
+| AC-21              | §6.1, Risk 4                                                    | Yes (but see Issue 6)                                           |
+| AC-22..AC-24       | §11.3                                                           | Partial — depends on Issues 2 & 5                               |
+| AC-25              | §6.5                                                            | Yes                                                             |
+| AC-26              | §2.2, §6.1                                                      | Yes                                                             |
+| AC-27              | (not traced)                                                    | **No — Issue 9 (missing trace)**                                |
+| AC-28              | (not traced)                                                    | **No — Issue 9 (missing trace)**                                |
+
+## Open Questions resolution check
+
+| OQ    | Choice                          | Rationale + rejected alternatives traced | Verdict                                  |
+| ----- | ------------------------------- | ----------------------------------------- | ---------------------------------------- |
+| OQ-1  | Approach A                      | Yes, with trade-off table in §13          | OK                                       |
+| OQ-2  | Disable                         | Yes                                       | OK                                       |
+| OQ-3  | Mechanism (i)                   | Yes — but mechanism uses non-existent API | **Fail — Issue 1**                       |
+| OQ-4  | 50                              | Yes                                       | OK                                       |
+| OQ-5  | Render-time force-off           | Yes                                       | OK                                       |
+| OQ-6  | data-testid + i18n string       | Partial — primary/secondary not ordered   | **Partial — Issue 5**                    |
+
+## Risks mitigation check
+
+| Risk                                          | Mitigation                                                           | Adequate                                  |
+| --------------------------------------------- | -------------------------------------------------------------------- | ----------------------------------------- |
+| 1. Ockham single-observer                     | §5.2 single useEffect on `effectiveUrl`, useEffectEvent              | Yes (modulo Issue 7 race-token clarity)   |
+| 2. Pattern Overrides reset                    | §5.6 reuse withPatternOverrideControls + ResetOverridesControl       | Yes                                       |
+| 3. dimRatio: 100 default                      | §5.2/§5.4 effectiveDimRatio + §6.3 server class strip                | Yes                                       |
+| 4. Embed-video collision                      | §6.1 short-circuit at both ends                                      | Yes (modulo Issue 6 unintended UI hide)   |
+| 5. HTML API can't edit CSS-in-`style`         | §6.2 element-replace via byte-offset splice                          | **No — Issue 1 (API doesn't exist)**      |

From 0b85aabdbd1e59c89730b1983bf42d9e04fe8102 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 15:57:22 +0200
Subject: [PATCH 14/60] docs(pipeline): revise 2-design-doc/design-doc.md for
 77199-cover-bindings-id-url-internal (iter 2)

Address design-doc-review-1-rejected.md findings.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../2-design-doc/design-doc.md                | 541 ++++++++++++------
 1 file changed, 365 insertions(+), 176 deletions(-)

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
index 78864a0e02dd49..43561fe47d4767 100644
--- a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
+++ b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
@@ -1,10 +1,10 @@
 # Design Doc: Cover block bindings — internal-only `id` and `url`
 
-Spec: `<artifacts>/1-spec/spec.md` (approved). All AC and DC references below resolve to that file.
+Spec: `<artifacts>/1-spec/spec.md` (approved). All AC, DC, Req references resolve to that file.
 
 ## 1. Overview
 
-`core/cover` ships Block Bindings support for `id` and `url` restricted to internal media-library attachments, headlined by Pattern Overrides. When a binding is active (post-`__default`-expansion: `id` AND `url` bound to the same source instance), the Edit component (a) hides parallax, repeat, media-replace and use-featured-image controls, (b) reactively derives `overlayColor`, `effectiveDimRatio`, `effectiveUrl` from the resolved `url` through a **single observer** wired via `useEffectEvent`, and (c) never mutates stored attributes on binding state transitions. The server (a Cover-scoped `render_block` filter in a new compat file) substitutes the bound `url` into the cover's `<img>`, rewrites `has-background-dim-100` to `has-background-dim-50` when the stored ratio is the default, and rebuilds the parallax/repeat `<div style="background-image:…">` into a plain `<img>` when bindings have resolved a value. Embed-video covers short-circuit both client and server binding paths.
+`core/cover` ships Block Bindings support for `id` and `url` restricted to internal media-library attachments, headlined by Pattern Overrides. When a binding is active (post-`__default`-expansion: `id` AND `url` bound to the same source instance), the Edit component (a) hides parallax, repeat, media-replace and use-featured-image controls in *every* render surface (toolbar, inspector, AND the empty-cover placeholder), (b) reactively derives `overlayColor`, `effectiveDimRatio`, `effectiveUrl` from the resolved `url` through a **single observer** wired via `useEffectEvent`, and (c) never mutates stored attributes on binding state transitions. The server (a single Cover-scoped file in `lib/compat/wordpress-7.1/block-bindings.php`) uses an early `render_block_data` filter to neutralise `useFeaturedImage` before `render_callback` runs, then a `render_block` priority-9 filter to substitute the bound URL into the cover's `<img>` (via pure `preg_match` byte-splice for the parallax/repeat case, `WP_HTML_Tag_Processor::set_attribute` for the plain-`<img>` case) and to remove `has-background-dim-100` from the overlay span when the stored ratio is the default. Embed-video covers short-circuit both client and server binding paths.
 
 ## 2. Architecture
 
@@ -22,40 +22,40 @@ Spec: `<artifacts>/1-spec/spec.md` (approved). All AC and DC references below re
        │ CLIENT  (packages/block-library/  │   │ SERVER (PHP)                     │
        │         src/cover/edit/index.js)  │   │                                  │
        ├───────────────────────────────────┤   ├──────────────────────────────────┤
-       │ useBindingState() hook (NEW)      │   │ render_block (priority 9)        │
+       │ useCoverBindingState() hook (NEW) │   │ render_block_data (priority 10)  │
        │   - expandedBindings              │   │   gutenberg_cover_bindings_      │
-       │   - bindingActive  (id+url, same  │   │     render_block( $content,      │
-       │       source instance)            │   │       $block, $instance )        │
-       │   - bindingResolvedUrl/Id (from   │   │     ↑ runs BEFORE                │
-       │       source.getValues via        │   │       gutenberg_block_bindings_  │
-       │       useSelect)                  │   │       render_block (priority 10) │
-       │   - bindingUnresolvable  (id      │   │                                  │
-       │       missing / mismatch / not    │   │   if bindingActive &&            │
-       │       attachment / external)     │   │      backgroundType !=='embed-   │
-       │                                   │   │      video':                     │
-       │ Effective values (derived, no    │   │     1. resolve url/id from       │
-       │   setAttributes):                 │   │        gutenberg_process_block_  │
-       │   - effectiveUrl = bindingResolvedUrl │      bindings()                  │
-       │       ?? (useFeaturedImage?       │   │     2. if id missing/not in      │
-       │             mediaUrl : originalUrl)   │        media library → strip     │
-       │   - effectiveDimRatio = (bindingActive│        <img>/<div bg> entirely;  │
-       │       && dimRatio===100 &&             │        early return             │
-       │       effectiveUrl) ? 50 : dimRatio    │     3. compute newDimRatio (50  │
-       │   - lockUrlControls = bindingActive   │        if 100 default && url)    │
-       │       && !canUserEditValue            │     4. rewrite cover via         │
-       │                                   │   │        WP_HTML_Tag_Processor:    │
-       │ Single observer (useEffect on    │   │          - swap <div bg-image>   │
-       │   effectiveUrl):                  │   │            ↳ rebuilt <img>      │
-       │   - getMediaColor(effectiveUrl)   │   │          - <img src=…> updated   │
-       │     ↳ setOverlayColor (if not    │   │          - drop has-parallax,    │
-       │        user-set)                  │   │            is-repeated classes   │
-       │   - propsRef guard + race-token  │   │          - swap has-background-  │
-       │     to prevent stale overwrites   │   │            dim-100 → -50         │
-       │                                   │   │     5. short-circuit            │
-       │ CoverInspectorControls / Block-  │   │        useFeaturedImage branch   │
-       │   Controls gated by               │   │                                  │
-       │   bindingActive + lockUrlControls │   │   else if embed-video:           │
-       └───────────────────────────────────┘   │     pass through unchanged       │
+       │   - bindingActive  (id+url, same  │   │     prepare_block( $parsed,      │
+       │       source instance)            │   │       $source, $parent )         │
+       │   - bindingResolvedUrl/Id (from   │   │     ↑ runs BEFORE render_call-   │
+       │       source.getValues via        │   │       back, mutates $parsed_     │
+       │       useSelect)                  │   │       block['attrs'] to set      │
+       │   - bindingUnresolvable  (id      │   │       useFeaturedImage=false     │
+       │       missing / mismatch / not    │   │       when bindingActive         │
+       │       attachment / external)      │   │                                  │
+       │                                   │   │ render_block (priority 9)        │
+       │ Effective values (derived, no     │   │   gutenberg_cover_bindings_      │
+       │   setAttributes):                 │   │     render_block( $content,      │
+       │   - effectiveUrl = bindingResolvedUrl │       $block, $instance )         │
+       │       ?? (useFeaturedImage?       │   │     ↑ runs BEFORE                │
+       │             mediaUrl : originalUrl) │       gutenberg_block_bindings_  │
+       │   - effectiveDimRatio = (bindingActive│       render_block (priority 10) │
+       │       && dimRatio===100 &&             │                                  │
+       │       effectiveUrl) ? 50 : dimRatio    │   if bindingActive &&            │
+       │   - lockUrlControls = bindingActive   │      backgroundType !=='embed-   │
+       │       && !canUserEditValue            │      video':                     │
+       │                                   │   │     1. resolve url/id from       │
+       │ Single observer (useEffect on     │   │        gutenberg_process_block_  │
+       │   effectiveUrl):                  │   │        bindings()                │
+       │   - getMediaColor(effectiveUrl)   │   │     2. if id missing/not in      │
+       │     ↳ setOverlayColor (if not     │   │        media library → strip     │
+       │        user-set)                  │   │        <img>/<div bg> entirely;  │
+       │   - propsRef guard + race-token   │   │        early return              │
+       │     to prevent stale overwrites   │   │     3. (A) rewrite img/div via   │
+       │                                   │   │            preg_replace_callback │
+       │ CoverInspectorControls / Block-   │   │            +Tag_Processor        │
+       │   Controls / CoverPlaceholder     │   │     4. (B) strip has-background- │
+       │   gated by bindingActive          │   │            dim-100 from overlay  │
+       └───────────────────────────────────┘   │            span                  │
                                                └──────────────────────────────────┘
 ```
 
@@ -64,31 +64,30 @@ Spec: `<artifacts>/1-spec/spec.md` (approved). All AC and DC references below re
 | File | Role | Change |
 | --- | --- | --- |
 | `packages/block-library/src/cover/block.json` | Attribute schema | Add `"role": "content"` to `id` (AC-1, AC-2 prerequisite) |
-| `lib/compat/wordpress-7.1/block-bindings.php` (NEW) | Server allow-list + Cover-scoped render filter | (a) `block_bindings_supported_attributes` filter adds `id`,`url` to `core/cover`; (b) `gutenberg_cover_bindings_render_block` filter on `render_block` priority 9 |
+| `lib/compat/wordpress-7.1/block-bindings.php` (NEW) | Server allow-list + Cover-scoped render filters | (a) `block_bindings_supported_attributes` filter adds `id`,`url` to `core/cover`; (b) `render_block_data` filter to neutralise `useFeaturedImage` before `render_callback`; (c) `gutenberg_cover_bindings_render_block` filter on `render_block` priority 9 |
 | `lib/load.php` | Bootstrap | `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';` in the REST-server block (alongside other 7.1 entries) |
-| `packages/block-library/src/cover/edit/index.js` | Reactive observer, derived values | New `useCoverBindingState` hook, replace existing `useEffect([mediaUrl])` with a single observer on `effectiveUrl`, propagate derived values to children |
+| `packages/block-library/src/cover/edit/index.js` | Reactive observer, derived values, render-tree gating | New `useCoverBindingState` hook, replace existing `useEffect([mediaUrl])` with a single observer on `effectiveUrl`, gate the empty-cover branch on `bindingActive || bindingUnresolvable`, render the `<Placeholder>` for the unresolvable case inline. |
 | `packages/block-library/src/cover/edit/inspector-controls.js` | UI gating | Gate parallax/repeat ToolsPanelItems on `! bindingActive` |
-| `packages/block-library/src/cover/edit/block-controls.js` | UI gating | Conditionally render `<MediaReplaceFlow>` based on `! bindingActive`; hide "Use featured image" toggle (passed through `useFeaturedImage` prop of `MediaReplaceFlow`) when bound |
-| `packages/block-library/src/cover/edit/cover-placeholder.js` | Unresolvable affordance | New "internal media required" Placeholder copy gated by `bindingUnresolvable` |
-| `phpunit/blocks/render-block-cover-test.php` | PHPUnit | New cases: bound-url → `<img src=$bound>`; default `dimRatio:100` + binding → `has-background-dim-50`; mismatched/unresolvable → no `<img>` |
+| `packages/block-library/src/cover/edit/block-controls.js` | UI gating | Pass `bindingActive` and gate the "Use featured image" toggle (set `onToggleFeaturedImage={ bindingActive ? undefined : toggleUseFeaturedImage }`) AND the media-replace `onSelect` (set `onSelect={ bindingActive ? undefined : onSelectMedia }`). The "Embed video from URL" `<MenuItem>` child of `<MediaReplaceFlow>` MUST remain unconditionally accessible (preserves AC-21 affordance). |
+| `phpunit/blocks/render-block-cover-test.php` | PHPUnit | New cases: bound-url → `<img src=$bound>`; default `dimRatio:100` + binding → `has-background-dim-50`; mismatched/unresolvable → no `<img>`; `useFeaturedImage:true + bindingActive` → exactly one `<img>` with bound URL |
 | `test/e2e/specs/editor/blocks/cover.spec.js` | E2E | New `describe('Block Bindings — Pattern Overrides')` block (AC-22..AC-24) |
-| `backport-changelog/7.1/<core-pr>.md` | Metadata | One-line entry when Core PR exists |
+| `backport-changelog/7.1/<core-pr>.md` | Metadata | Created at the same time the Core PR is filed; Gutenberg PR description includes a `TODO: backport-changelog entry pending Core PR` note and is updated once the Core PR number is known. Not a blocker for the Gutenberg PR landing. |
 
-No other Cover files change. No new `__experimental*` APIs are introduced. No `save.js`, `deprecated.js`, or block-list-renderer changes.
+No other Cover files change. **`cover-placeholder.js` is NOT touched** — the gating happens at the call sites in `index.js` (see §5.4 / §5.5). No new `__experimental*` APIs are introduced. No `save.js`, `deprecated.js`, or block-list-renderer changes.
 
 ## 3. Open Questions resolved
 
 ### OQ-1: Server-side approach — Cover-scoped filter (chosen)
 
-**Choice: Approach A — Cover-scoped `render_block` filter in `lib/compat/wordpress-7.1/block-bindings.php`.**
+**Choice: Approach A — Cover-scoped filters in `lib/compat/wordpress-7.1/block-bindings.php`.**
 
-Concretely: one `add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 )` that gates on `$block['blockName'] === 'core/cover'` and exits the filter for every other block.
+Concretely: one `add_filter( 'render_block_data', ..., 10, 3 )` (Cover-only neutralisation of `useFeaturedImage` before `render_callback`) plus one `add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 )` that gates on `$block['blockName'] === 'core/cover'`.
 
 **Rejected: Approach B (generic `block_bindings_attribute_replaced_in_markup` filter).**
 
 Reasoning:
 - Approach B (PR #74610) only solves `<img src>` substitution. It cannot rewrite the parallax/repeat `<div style="background-image:…">` markup (HTML API has no CSS-in-`style` mutation; AC-19, Risk 5) and cannot rewrite the `has-background-dim-100` class to a non-opaque variant (AC-16). Approach B therefore still needs a Cover-scoped supplementary path — at which point Approach A is strictly simpler.
-- Approach B introduces a new global filter (`block_bindings_attribute_replaced_in_markup`) which the spec OQ flags as needing weighing. Approach A introduces zero new global APIs (Req 28, AC-out-of-scope on global APIs).
+- Approach B introduces a new global filter (`block_bindings_attribute_replaced_in_markup`) which the spec OQ flags as needing weighing. Approach A introduces zero new global APIs (Req 28, Out-of-Scope on global APIs).
 - Cover-scoped means zero risk of changing behaviour for any other block (Req 21). The generic-filter approach has cross-block reuse value, but no other block currently needs it; cost > benefit.
 - Approach A keeps the entire substitution surface in one file (the new 7.1 compat file). Easier to review, easier to delete when Core absorbs the change.
 
@@ -99,55 +98,70 @@ Reasoning:
 **Choice: keep existing `ResetOverridesControl` semantics: button is **disabled** (not removed from DOM) when the instance value matches the pattern default.**
 
 Reasoning:
-- Cover-specific code zero. Pattern Overrides controls are wired by `withPatternOverrideControls` in `packages/editor/src/hooks/pattern-overrides.js`; the toolbar `ResetOverridesControl` (line 84 of `packages/patterns/src/components/reset-overrides-control.js`) already renders `disabled={ ! isOverridden }`.
-- Consistent with every other bindable block (paragraph, heading, image, button) — diverging would be a UX regression.
+- Cover-specific code zero. Pattern Overrides controls are wired by `withPatternOverrideControls` in `packages/editor/src/hooks/pattern-overrides.js`; the toolbar `ResetOverridesControl` (`packages/patterns/src/components/reset-overrides-control.js`) already renders `disabled={ ! isOverridden }`.
+- Consistent with every other bindable block (paragraph, heading, image, button).
 - Test-observability (AC-10) is preserved: e2e asserts `await expect( resetButton ).toBeDisabled()` rather than absence-from-DOM.
 
 **Traces to:** AC-10, Req 24(d).
 
-### OQ-3: Saved-markup parallax/repeat rewrite mechanism — bookmark-bounded substring replacement (chosen)
+### OQ-3: Saved-markup parallax/repeat rewrite mechanism — `preg_match` byte splice + `WP_HTML_Tag_Processor` (chosen)
 
-**Choice: Mechanism (i) — detect the parallax/repeat case in the new Cover render filter and replace the entire `<div class="wp-block-cover__image-background" style="background-image:url(…)">` fragment in `$content` with a rebuilt `<img>` HTML string, using `WP_HTML_Tag_Processor` to locate the element and Tag-Processor bookmarks (via the source-text byte positions exposed through `get_token_byte_offset_in_source_text`/`get_token_length_in_source_text` on `WP_HTML_Processor::create_fragment`) to compute the substring range to splice.**
+**Choice: Mechanism (i) — detect the parallax/repeat case in the new Cover render filter and replace the entire `<div class="wp-block-cover__image-background" style="background-image:url(…)">` fragment in `$content` with a rebuilt `<img>` HTML string, located via `preg_match( … , PREG_OFFSET_CAPTURE )` (the exact same pattern shape that `render_block_core_cover` already uses at `packages/block-library/src/cover/index.php:117-125, 193-197`).**
 
-If the saved markup is already the non-parallax/repeat form (plain `<img>`), the filter takes the simpler path: locate `<img class="wp-block-cover__image-background">` and `set_attribute( 'src', $resolved_url )` in place — no fragment splice needed.
+**Why not the previously-cited byte-offset Tag-Processor helpers.** The prior design draft cited `WP_HTML_Tag_Processor::get_token_byte_offset_in_source_text()` and `get_full_token_length()` as public accessors. Verified at `/Users/carlos/.wp-env/cc4ba7b5738d99b49b19f399987f6e49/WordPress/wp-includes/html-api/class-wp-html-tag-processor.php` — neither method exists. The class's public surface (lines 836–4797) exposes `next_tag`, `set_attribute`, `add_class`, `remove_class`, `set_bookmark`, `seek`, `get_updated_html`, `has_class`, `class_list`, `get_attribute`, `get_token_name`, `get_token_type`, `is_tag_closer`, `has_self_closing_flag`, `get_modifiable_text`, `set_modifiable_text`, `paused_at_incomplete_token`, etc., but `$token_starts_at` (line 609) and `$token_length` (line 628) are declared `private`. Token positions are not exposed by the public API. `set_bookmark` / `seek` allow movement to a previously-visited tag but do not yield substring ranges either. Therefore byte-offset splicing through Tag-Processor private accessors is not a viable mechanism.
 
-Rejected: Mechanism (ii) "bypass saved markup entirely and synthesise the full `<img>` server-side from resolved `url`/`id`". Reasoning: it re-implements the entire cover markup server-side (classes, alt, focal-point `data-object-position`, `wp-image-{id}`, size slug), duplicating `save.js` logic. Risk of drift between client save and server output is real and would surface as classname diffs on subsequent re-edits. Mechanism (i) preserves the saved markup as the source of truth for everything that is not the URL/class/element-tag.
+**Why not pure `WP_HTML_Tag_Processor` mutation.** The Tag Processor cannot rewrite a `<div>` element into an `<img>` element (no `set_tag()` operation in its public API; verified). It also cannot edit a CSS value inside `style="background-image: url(…)"` (Risk 5). For the parallax/repeat saved form, neither of those is feasible.
 
-**Concrete shape (pseudo-PHP, mechanism (i)):**
+**Why not `DOMDocument` for the whole markup.** `DOMDocument::loadHTML` aggressively normalises HTML (wrapping in `<html>/<body>`, expanding void elements, decoding entities), risking observable byte-level diffs versus saved markup for unrelated content (AC-20 non-regression). Round-tripping through `saveHTML` is known-lossy for `class="..."` / `style="..."` attribute ordering and self-closing-slash form. Out of proportion for the small, surgical edit we need.
+
+**Why not "synthesise the full `<img>` from scratch and discard saved markup".** Re-implementing `save.js`'s output (classes including `wp-image-{id} size-{slug}`, `data-object-position`, alt, focal-point style) duplicates client logic. Risk of drift between client save and server output is real and would surface as classname diffs on subsequent re-edits (round-trip / AC-20 hazard).
+
+**Concrete shape — parallax/repeat saved form (mechanism (i)):**
 
 ```php
-// $content is the saved Cover markup.
-$processor = new WP_HTML_Tag_Processor( $content );
-if ( $processor->next_tag( array(
-    'tag_name'   => 'DIV',
-    'class_name' => 'wp-block-cover__image-background',
-) ) ) {
-    // Parallax/repeat saved form. Compute byte range via the
-    // processor's reported source position; splice in a rebuilt <img>.
-    $start  = $processor->get_token_byte_offset_in_source_text();
-    $length = $processor->get_full_token_length(); // div opener + content + closer
+// Pattern mirrors the one already used at packages/block-library/src/cover/index.php:117-125
+// for the figure.wp-block-embed case.
+$div_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
+if ( 1 === preg_match( $div_pattern, $content, $matches, PREG_OFFSET_CAPTURE ) ) {
+    $div_start  = $matches[0][1];
+    $div_length = strlen( $matches[0][0] );
+    // Build the replacement <img>. wp-image-{id}, size-{slug}, alt, optional object-position
+    // come from the bound attachment metadata + the cover's saved $attrs.
     $rebuilt_img = sprintf(
-        '<img class="wp-block-cover__image-background%s" alt="%s" src="%s" data-object-fit="cover"%s />',
-        $size_class,           // " wp-image-{$id} size-{$slug}"
+        '<img class="wp-block-cover__image-background wp-image-%d%s" alt="%s" src="%s" data-object-fit="cover"%s />',
+        (int) $resolved_id,
+        $size_class_suffix,     // e.g. ' size-large' or ''
         esc_attr( $alt ),
         esc_url( $resolved_url ),
-        $object_position_attrs // optional data-object-position + style
+        $object_position_attrs  // ' data-object-position="50% 50%" style="object-position:50% 50%;"' or ''
     );
-    $content = substr( $content, 0, $start ) . $rebuilt_img . substr( $content, $start + $length );
-} else {
-    // Plain <img> saved form: substitute src in place.
-    $processor = new WP_HTML_Tag_Processor( $content );
-    if ( $processor->next_tag( array(
-        'tag_name'   => 'IMG',
-        'class_name' => 'wp-block-cover__image-background',
-    ) ) ) {
-        $processor->set_attribute( 'src', $resolved_url );
-        $content = $processor->get_updated_html();
+    $content = substr( $content, 0, $div_start ) . $rebuilt_img . substr( $content, $div_start + $div_length );
+}
+```
+
+**Concrete shape — plain `<img>` saved form (no parallax/repeat at save time):**
+
+```php
+$processor = new WP_HTML_Tag_Processor( $content );
+if ( $processor->next_tag( array(
+    'tag_name'   => 'IMG',
+    'class_name' => 'wp-block-cover__image-background',
+) ) ) {
+    $processor->set_attribute( 'src', $resolved_url );
+    $processor->set_attribute( 'alt', $alt );
+    // Substitute wp-image-{old} → wp-image-{new}: scan classes and rewrite.
+    // class_list() iterates current classes; remove_class + add_class are public.
+    foreach ( $processor->class_list() as $cls ) {
+        if ( 0 === strpos( $cls, 'wp-image-' ) ) {
+            $processor->remove_class( $cls );
+        }
     }
+    $processor->add_class( 'wp-image-' . (int) $resolved_id );
+    $content = $processor->get_updated_html();
 }
 ```
 
-(`WP_HTML_Tag_Processor::get_token_byte_offset_in_source_text`/`get_full_token_length` are public; if a particular WP version lacks the closer-aware helper, fall back to `preg_match` on `/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*>\s*<\/div>/is` — the same pattern `render_block_core_cover` already uses on lines 117–125 of `packages/block-library/src/cover/index.php` for the embed-figure case.)
+Both methods used (`set_attribute`, `class_list`, `remove_class`, `add_class`, `next_tag`, `get_updated_html`) are confirmed public methods in `WP_HTML_Tag_Processor` (lines 1181, 4310, 4539, 4581, 887, 4637 respectively of `wp-includes/html-api/class-wp-html-tag-processor.php`).
 
 **Traces to:** AC-19, Risk 5, OQ-3 spec text.
 
@@ -156,8 +170,8 @@ if ( $processor->next_tag( array(
 **Choice: 50.**
 
 Reasoning:
-- Exact symmetry with the existing `onSelectMedia` event-handler downshift (`packages/block-library/src/cover/edit/index.js:244-247`: `currentAttrs.url === undefined && currentAttrs.dimRatio === 100 ? 50 : ...`). Same user-visible outcome whether the URL arrived via media selection or via a binding — the spec's source-agnostic invariant (DC-3) becomes self-enforcing.
-- `dimRatioToClass( 50 ) === null` (see `packages/block-library/src/cover/shared.js:32-36`), so the overlay span emits `has-background-dim` without any `has-background-dim-N` modifier — i.e. the CSS default of 50% opacity. The class-rewrite on the server is therefore "remove `has-background-dim-100`", not "replace it with `has-background-dim-50`", which is mechanically simpler.
+- Exact symmetry with the existing `onSelectMedia` event-handler downshift (`packages/block-library/src/cover/edit/index.js`: `currentAttrs.url === undefined && currentAttrs.dimRatio === 100 ? 50 : ...`). Same user-visible outcome whether the URL arrived via media selection or via a binding — the spec's source-agnostic invariant (DC-3) becomes self-enforcing.
+- `dimRatioToClass( 50 ) === null` (see `packages/block-library/src/cover/shared.js`), so the overlay span emits `has-background-dim` without any `has-background-dim-N` modifier — i.e. the CSS default of 50% opacity. The class-rewrite on the server is therefore "remove `has-background-dim-100`", not "replace it with `has-background-dim-50`", which is mechanically simpler.
 
 **Traces to:** AC-15, AC-16, Req 14, Req 18.
 
@@ -168,17 +182,23 @@ Reasoning:
 Reasoning:
 - DC-2 / Req 11 prohibit attribute mutation from binding-state changes. A migration would be exactly that, just on save-load instead of in an effect — same invariant violation.
 - A deprecation chain change for what is essentially a render-time concern would force `deprecated.js` work and risks breaking saved unbound covers (AC-20 non-regression).
-- The render-time path already has to strip `has-parallax`/`is-repeated` classes from the rebuilt `<img>` (see OQ-3 sketch) and the editor preview's `<img>` element is unconditional once `effectiveUrl` resolves (the existing `isImgElement = !(hasParallax || isRepeated)` check is bypassed in the bound-cover render branch — see §5.4). Force-off therefore comes free.
-
-The "error" alternative was rejected: silently breaking a saved cover on load with no migration path would surprise pattern authors. Force-off + UI hide gives a clean transition where the parallax simply stops applying when the cover becomes a Pattern Overrides target — and resumes if the binding is removed.
+- The render-time path already has to strip `has-parallax`/`is-repeated` classes by construction from the rebuilt `<img>` (see OQ-3); the editor preview's `<img>` element is rendered unconditionally once `effectiveUrl` resolves AND `bindingActive` (the existing `isImgElement = !(hasParallax || isRepeated)` check is bypassed in the bound-cover render branch — see §5.4). Force-off therefore comes free.
 
 **Traces to:** Req 11, DC-2, AC-19, AC-20.
 
-### OQ-6 (newly identified): Test-observable signal for the "internal media required" affordance
+### OQ-6: Test-observable signal for the "internal media required" affordance
+
+**Choice: primary contract is the i18n message string `__( 'Internal media required for this binding.' )`. Secondary stability hook is `data-testid="cover-binding-unresolvable"`.**
 
-**Choice: a `<Placeholder>` with a stable `data-testid="cover-binding-unresolvable"` attribute AND the i18n string `__( 'Internal media required for this binding.' )`.**
+**E2E assertion uses the i18n string** (per spec Req 16: "a known i18n message string … accessible to the e2e test"):
 
-The e2e test (AC-24) locates by `data-testid` for stability across translations. The string is also a stable contract — adding it to the requirements vocabulary.
+```js
+await expect(
+    page.getByText( 'Internal media required for this binding.' )
+).toBeVisible();
+```
+
+The `data-testid` attribute is added to the `<Placeholder>` element as a translation-resistant fallback hook. It is **secondary**: the e2e test does not assert on it. Code review may legitimately challenge `data-testid` on production DOM; if removed, AC-24 remains satisfied by the i18n-string locator. The design's intent (versus a hard "must remove `data-testid` if reviewer objects" position) is: keep `data-testid` for cross-locale stability but accept its removal during review if challenged — the i18n-string contract is the load-bearing one.
 
 **Traces to:** Req 16, AC-4, AC-24.
 
@@ -200,13 +220,13 @@ Preempted by **render-time `effectiveDimRatio = (bindingActive && dimRatio === 1
 
 Preempted by an **explicit `backgroundType === 'embed-video'` short-circuit at both client and server**:
 - Client: `useCoverBindingState` returns `bindingActive: false` when `backgroundType === 'embed-video'`, regardless of `metadata.bindings`. Derivations short-circuit; the existing oEmbed path runs as today (AC-21).
-- Server: `gutenberg_cover_bindings_render_block` early-returns `$content` unchanged when `! empty( $attributes['backgroundType'] ) && 'embed-video' === $attributes['backgroundType']`. The existing `render_block_core_cover`'s embed-video branch (lines 18–131 of `packages/block-library/src/cover/index.php`) runs unmodified.
+- Server: both the `render_block_data` filter and `gutenberg_cover_bindings_render_block` early-return when `! empty( $attributes['backgroundType'] ) && 'embed-video' === $attributes['backgroundType']`. The existing `render_block_core_cover`'s embed-video branch (lines 18–131 of `packages/block-library/src/cover/index.php`) runs unmodified.
 
 Bindings UI rows for `url`/`id` still appear (allowed by Req 27 / AC-21) but have no runtime effect on embed-video covers.
 
 ### Risk 5 — HTML API can't edit CSS-in-`style`
 
-Preempted by **OQ-3 mechanism (i)**: never attempt to edit the CSS value inside `style="background-image: url(…)"`. Instead, locate the `<div class="wp-block-cover__image-background">` and **replace the entire element** with a rebuilt `<img>`. The substitution is a substring splice keyed by HTML-Tag-Processor byte offsets — no CSS parsing involved.
+Preempted by **OQ-3 mechanism (i)**: never attempt to edit the CSS value inside `style="background-image: url(…)"`. Instead, locate the `<div class="wp-block-cover__image-background">` and **replace the entire element** with a rebuilt `<img>` via `preg_match` + `substr` splice — no CSS parsing involved, no Tag-Processor private accessors required.
 
 ## 5. Client-side design
 
@@ -221,7 +241,7 @@ Exported shape:
  * @typedef {Object} CoverBindingState
  * @property {boolean}            bindingActive          true iff (after __default expansion) `id` AND `url` are bound to the same source instance AND backgroundType !== 'embed-video'.
  * @property {boolean}            bindingUnresolvable    true iff metadata.bindings has any cover-binding configuration that does not satisfy bindingActive (mismatched source, only one of id/url, external URL, id not resolvable as attachment).
- * @property {string|undefined}   bindingResolvedUrl     URL resolved from the bound source via useSelect( … getBlockBindingsSource(...).getValues ).
+ * @property {string|undefined}   bindingResolvedUrl     URL resolved from the bound source via useSelect.
  * @property {number|undefined}   bindingResolvedId      ID resolved from the bound source.
  * @property {boolean}            canUserEditBindingValue Source.canUserEditValue() result; gates lockUrlControls.
  */
@@ -229,19 +249,52 @@ export default function useCoverBindingState( { clientId, attributes, context }
 ```
 
 Implementation outline:
-1. Expand `attributes.metadata?.bindings` via `replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] )` from `packages/block-editor/src/utils/block-bindings.js`. Use `[ 'id', 'url' ]` as the supportedAttributes argument.
+1. Expand `attributes.metadata?.bindings` via `replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] )` from `packages/block-editor/src/utils/block-bindings.js`.
 2. `bindingActive = expanded?.id && expanded?.url && expanded.id.source === expanded.url.source && JSON.stringify(expanded.id.args ?? null) === JSON.stringify(expanded.url.args ?? null) && backgroundType !== 'embed-video'`.
-3. Resolve values via `useSelect`: for each `attr` in `[ 'id', 'url' ]`, look up `getBlockBindingsSource( expanded[attr].source ).getValues({ select, clientId, context, bindings: { [attr]: expanded[attr] } })[ attr ]`. The Pattern Overrides source returns the block's own attribute when no override is set (see `packages/editor/src/bindings/pattern-overrides.js:13-36`), so the "default state" naturally resolves to the block's pattern-default attribute value.
-4. Sanity-check `bindingResolvedId` against the media library via `select( coreStore ).getEntityRecord( 'postType', 'attachment', bindingResolvedId, { context: 'view' } )` — if the record is `undefined` (still loading) treat as pending; if `null` (resolved, not found) treat as unresolvable.
-5. `bindingUnresolvable = (hasAnyCoverBinding) && ! bindingActive` OR `bindingActive && bindingResolvedId resolves to null`.
+3. Resolve values via **a single `useSelect`** that reads both the bound URL and ID and the attachment record in one closure, deduplicating subscription work:
+
+   ```js
+   const { bindingResolvedUrl, bindingResolvedId, bindingResolvedAttachment } =
+       useSelect( ( select ) => {
+           if ( ! bindingActive ) {
+               return { bindingResolvedUrl: undefined, bindingResolvedId: undefined, bindingResolvedAttachment: undefined };
+           }
+           const source = unlock( select( blockEditorStore ) ).getBlockBindingsSource( expanded.url.source );
+           if ( ! source ) {
+               return { bindingResolvedUrl: undefined, bindingResolvedId: undefined, bindingResolvedAttachment: undefined };
+           }
+           const values = source.getValues( {
+               select,
+               clientId,
+               context,
+               bindings: { id: expanded.id, url: expanded.url },
+           } );
+           const url = values?.url;
+           const id = values?.id;
+           const attachment = id
+               ? select( coreStore ).getEntityRecord( 'postType', 'attachment', id, { context: 'view' } )
+               : undefined;
+           return { bindingResolvedUrl: url, bindingResolvedId: id, bindingResolvedAttachment: attachment };
+       }, [ bindingActive, expanded?.id?.source, expanded?.url?.source, clientId ] );
+   ```
+
+   Notes on performance and correctness:
+   - **Single `useSelect`**: dedupes the subscription. Reading the attachment record in the same closure means the subscription re-fires only when *any* of the closure's reads change, not on every render.
+   - **`undefined` vs `null`**: `getEntityRecord` returns `undefined` while loading (resolution not yet started/resolved), `null` once resolved and not found. The hook treats `undefined` as pending (no unresolvable affordance yet) and `null` as definitively unresolvable. This matches `core/image`'s pattern.
+   - **Pattern Overrides scale**: for N bound Covers on the same post, each instance fires its own `useSelect`, but the `getEntityRecord` selector is memoised by `core-data` (same `( 'postType', 'attachment', id )` key dedupes across consumers). Acceptable for v1; if profiling later reveals churn, the hook can be promoted to a parent-context provider.
+
+4. `bindingUnresolvable = (hasAnyCoverBinding) && ! bindingActive` OR `bindingActive && bindingResolvedAttachment === null` (resolved-not-found) OR `bindingActive && bindingResolvedAttachment && bindingResolvedAttachment.type !== 'attachment'`.
 
 The hook returns plain values; the consumer (`CoverEdit`) destructures them.
 
 ### 5.2 Single observer (in `CoverEdit`)
 
-Replaces the existing `useEffect( [ mediaUrl ] )` block (`packages/block-library/src/cover/edit/index.js:163-201`). Source-agnostic per DC-3:
+Replaces the existing `useEffect( [ mediaUrl ] )` block in `packages/block-library/src/cover/edit/index.js`. Source-agnostic per DC-3:
 
 ```js
+// Declared once at the top of the component body, before any useEffect.
+const raceTokenRef = useRef( 0 );
+
 // Derived: the URL the editor should display.
 const effectiveUrl =
     bindingResolvedUrl ??
@@ -251,12 +304,12 @@ const effectiveUrl =
 const effectiveDimRatio =
     bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio;
 
-// Latest non-tracked reads via useEffectEvent (eliminates stale closure pitfalls).
+// useEffectEvent reads latest non-tracked values without dep-array churn.
 const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => {
     if ( ! resolvedUrl ) return;
-    const raceToken = ++raceTokenRef.current;
+    const myToken = ++raceTokenRef.current;
     const avg = await getMediaColor( resolvedUrl );
-    if ( raceToken !== raceTokenRef.current ) return; // stale
+    if ( myToken !== raceTokenRef.current ) return; // stale resolution; bail
 
     const { attributes: latestAttrs, overlayColor: latestOverlay } = propsRef.current;
     if ( ! latestAttrs.isUserOverlayColor ) {
@@ -277,32 +330,70 @@ useEffect( () => {
 }, [ effectiveUrl, onUrlResolved ] );
 ```
 
-Key properties:
+Key properties and design rationale:
 - **One** `useEffect`, keyed on `effectiveUrl`. The dependency array has stable references for everything else (DC-1).
-- `useEffectEvent` (`@wordpress/element`, confirmed at `packages/element/build-module/react.mjs:23,97`) reads latest `attributes`, `overlayColor` without dep-array churn.
-- A monotonically-increasing `raceTokenRef` (Req 13) prevents an older `getMediaColor` resolution from overwriting a newer one. Replaces the existing `propsRef`-only guard for the same purpose.
+- `useEffectEvent` (`@wordpress/element`, confirmed at `packages/element/build-module/react.mjs`) reads latest `attributes`, `overlayColor` without dep-array churn.
+- **Race token via ref, NOT cleanup flag.** The `useEffectEvent` callback is invoked freshly on every dependency change, but `useEffectEvent`'s identity is stable across renders. A `useEffect` cleanup-flag pattern (`let cancelled = false; … return () => { cancelled = true; };`) would require co-locating the cleanup inside the `useEffect` body — but the async work lives inside `useEffectEvent` (so latest props/state are read). Hoisting the flag out of `useEffectEvent` defeats the latest-value guarantee. The ref-based race token is the simplest pattern that survives both async resolution ordering AND `useEffectEvent`'s "latest reads" contract. **The `raceTokenRef = useRef( 0 )` declaration is explicit (declared at component top, before observer);** implementers reading the sketch verbatim will not encounter an undeclared identifier.
 - `setAttributes` is called only for `isDark`, which is **not** in DC-2's prohibition list. The DC-2 list is `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, `customOverlayColor`.
 
 ### 5.3 Existing event handlers — unchanged
 
 `onSelectMedia`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`, `toggleUseFeaturedImage`, `onSelectEmbedUrl` keep their current shapes. They already mutate stored attributes in response to **user intent** events (not binding state). DC-2 prohibits mutation triggered by binding state changes, not user-initiated mutations.
 
-There is one nuance: the existing observer at lines 163–201 has a side-effect on `isDark`/`isUserOverlayColor`. The replacement observer above also writes `isDark`; `isUserOverlayColor` is left alone unless an event handler sets it.
+There is one nuance: the existing observer has a side-effect on `isDark`/`isUserOverlayColor`. The replacement observer above also writes `isDark`; `isUserOverlayColor` is left alone unless an event handler sets it.
 
 ### 5.4 Render-tree changes in `CoverEdit`
 
-Around the existing image rendering (lines 672–693):
+Two structural changes to `packages/block-library/src/cover/edit/index.js`:
+
+**(1) Empty-cover branch (currently `if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground )` at index.js line 599):** add `bindingActive || bindingUnresolvable` to the predicate so the standard `<CoverPlaceholder>` (which exposes upload + featured-image toggle affordances) NEVER renders on a bound cover. Replace with a binding-aware placeholder branch:
 
 ```jsx
-{ bindingUnresolvable && (
-    <Placeholder
-        data-testid="cover-binding-unresolvable"
-        className="wp-block-cover__binding-unresolvable"
-        instructions={ __( 'Internal media required for this binding.' ) }
-        withIllustration
-    />
-) }
+if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground ) {
+    if ( bindingActive || bindingUnresolvable ) {
+        return (
+            <>
+                { blockControls }
+                { inspectorControls }
+                { hasNonContentControls && isSelected && (
+                    <ResizableCoverPopover { ...resizableCoverProps } />
+                ) }
+                <TagName
+                    { ...blockProps }
+                    className={ clsx( 'is-placeholder', blockProps.className ) }
+                    style={ { ...blockProps.style, minHeight: minHeightWithUnit || undefined } }
+                >
+                    { resizeListener }
+                    { bindingUnresolvable ? (
+                        <Placeholder
+                            data-testid="cover-binding-unresolvable"
+                            className="wp-block-cover__binding-unresolvable"
+                            withIllustration
+                            instructions={ __( 'Internal media required for this binding.' ) }
+                        />
+                    ) : (
+                        /* bindingActive but pending resolution; render an empty placeholder
+                           with no affordances. The single observer will populate the cover
+                           once effectiveUrl arrives. */
+                        <Placeholder
+                            className="wp-block-cover__binding-pending"
+                            withIllustration
+                        />
+                    ) }
+                </TagName>
+            </>
+        );
+    }
+    /* Existing CoverPlaceholder branch (unbound case) — unchanged. */
+    return ( /* … existing return with <CoverPlaceholder> … */ );
+}
+```
 
+The standard `<CoverPlaceholder>` continues to render in the unbound empty-cover branch and (lower in the component, line 750) inside the `<TagName>` with `disableMediaButtons`. **That second `<CoverPlaceholder>` (line 750) is also reached on bound covers** (when `hasBackground` is true), but it is rendered with `disableMediaButtons` — `<MediaPlaceholder>`'s `disableMediaButtons` prop hides the upload-via-DropZone and featured-image affordances. (Verified in `@wordpress/block-editor`'s `MediaPlaceholder`: `disableMediaButtons` short-circuits the upload-zone and gallery-toggle rendering.) Therefore no additional gating is required at that site.
+
+**(2) Non-empty render branch (around `url && isImageBackground` at index.js line 672):**
+
+```jsx
 { ! bindingUnresolvable && effectiveUrl && isImageBackground && (
     bindingActive ? (
         // Force-img form: bindings override parallax/repeat
@@ -334,17 +425,47 @@ And the overlay span class computation uses `effectiveDimRatio` rather than `dim
 
 ### 5.5 Control gating
 
-`inspector-controls.js` (lines 223–260) — wrap the `<>` fragment containing the "Fixed background" and "Repeated background" `ToolsPanelItem`s in `! bindingActive && …`. Pass `bindingActive` as a new prop from `CoverEdit`.
+**`inspector-controls.js`** — wrap the `<>` fragment containing the "Fixed background" and "Repeated background" `ToolsPanelItem`s in `! bindingActive && …`. Pass `bindingActive` as a new prop from `CoverEdit`.
+
+**`block-controls.js`** — the `<MediaReplaceFlow>` element MUST remain rendered in both bound and unbound states, because the "Embed video from URL" `<MenuItem>` is its child and AC-21 requires that affordance to remain accessible on embed-video covers regardless of binding presence. Gating is done at the **prop level**, not by removing the `<MediaReplaceFlow>` wrapper:
+
+```jsx
+<MediaReplaceFlow
+    mediaId={ id }
+    mediaURL={ url }
+    allowedTypes={ ALLOWED_MEDIA_TYPES }
+    onSelect={ bindingActive ? undefined : onSelectMedia }
+    onToggleFeaturedImage={ bindingActive ? undefined : toggleUseFeaturedImage }
+    useFeaturedImage={ bindingActive ? undefined : useFeaturedImage }
+    name={ ! url ? __( 'Add media' ) : __( 'Replace' ) }
+    onReset={ bindingActive ? undefined : onClearMedia }
+    variant="toolbar"
+>
+    { ( { onClose } ) => (
+        <MenuItem
+            icon={ link }
+            onClick={ () => {
+                setIsEmbedUrlInputOpen( true );
+                onClose();
+            } }
+        >
+            { __( 'Embed video from URL' ) }
+        </MenuItem>
+    ) }
+</MediaReplaceFlow>
+```
+
+`MediaReplaceFlow` (verified at `packages/block-editor/src/components/media-replace-flow/`) renders the "Use featured image" toggle ONLY when `onToggleFeaturedImage` is a function; setting it to `undefined` removes that menu item from the dropdown. Same for `onSelect` (the upload + media-library buttons short-circuit when `onSelect` is falsy). `onReset` undefined removes the "Reset" menu item. The "Embed video from URL" `<MenuItem>` child is unaffected — it is rendered through `MediaReplaceFlow`'s `children` prop and surfaces unconditionally inside the dropdown. AC-13, AC-14 satisfied without hiding the embed affordance (AC-21 preserved).
 
-`block-controls.js` (lines 111–135) — wrap the entire `<MediaReplaceFlow>` (which carries both the replace UI and the `useFeaturedImage` toggle via `onToggleFeaturedImage` + `useFeaturedImage` prop) in `! bindingActive && …`. Per AC-14, media-replace is hidden on **any** active binding including Pattern Overrides. Pattern Overrides authors edit the override via the pattern instance's outer media-replace pathway, not from within the cover.
+**Verification of AC-14 surface coverage.** AC-14 requires the media-replace control to be NOT in the DOM. The `<MediaReplaceFlow>` toolbar button remains in the DOM under the gating above (because it still hosts the embed `<MenuItem>`); the dropdown's media-replace and use-featured-image menu items are gone. **This is a minor stretch of the AC-14 literal wording.** AC-14's intent (Req 7) is that direct media replacement from inside the Cover is not offered when bound. Setting `onSelect` / `onToggleFeaturedImage` / `onReset` to `undefined` removes the media-replace and featured-image menu items from the dropdown. The remaining `<MediaReplaceFlow>` toolbar button surfaces only the "Embed video from URL" affordance, which is explicitly preserved by AC-21. The e2e test (§11.3) asserts on the absence of the media-replace and featured-image **menu items**, not on the absence of the `<MediaReplaceFlow>` toolbar button. **If reviewers insist on absolute absence of `<MediaReplaceFlow>` from the DOM**, the spec must be re-opened to reconcile AC-14 vs AC-21; the design's current reading prioritises AC-21's explicit "no observable runtime effect under this PR" against AC-14's literal DOM-absence wording, because AC-21 is the more specific contract for the embed-video case.
 
-Per Req 7 + AC-14: media-replace hides on bindingActive regardless of `canUserEditValue`. (The `canUserEditValue` distinction surfaces in `lockUrlControls`, which is still computed but currently only gates the Block Bindings panel's own per-attribute UI — not Cover's controls.)
+**`cover-placeholder.js` itself is not modified.** Its sole call sites are in `index.js` (lines 616 and 750). The line-616 site is now unreachable under `bindingActive || bindingUnresolvable` (replaced by the binding-aware placeholder branch in §5.4 (1)). The line-750 site is reached on bound covers but uses `disableMediaButtons`, which removes both the upload and the featured-image affordance from `<MediaPlaceholder>`. AC-13, AC-14, Req 7 satisfied without editing `cover-placeholder.js`.
 
-The "Use featured image" toggle is rendered by `<MediaReplaceFlow>` (`onToggleFeaturedImage` + `useFeaturedImage` props at `block-controls.js:117-118`); hiding `<MediaReplaceFlow>` hides the toggle automatically (AC-13). The inspector-controls surface does NOT separately render a use-featured-image toggle, so no second-site gating is needed.
+**`<MediaReplaceFlow>` "Use featured image" toggle** is gated by setting `onToggleFeaturedImage` to `undefined` (above). AC-13 satisfied. **Inspector-controls.js does NOT separately render a use-featured-image toggle**, verified by inspection — there is no second inspector site.
 
 ### 5.6 Pattern Overrides integration
 
-Zero Cover-specific code. `withPatternOverrideControls` in `packages/editor/src/hooks/pattern-overrides.js` reads `__experimentalBlockBindingsSupportedAttributes?.[ blockName ]` (line 43); once the server-side filter (§6.1) adds `core/cover` to that list, the `<PatternOverridesControls>` "Enable overrides" button and the `<ResetOverridesControl>` toolbar button appear automatically (AC-2, AC-7..AC-10).
+Zero Cover-specific code. `withPatternOverrideControls` in `packages/editor/src/hooks/pattern-overrides.js` reads `__experimentalBlockBindingsSupportedAttributes?.[ blockName ]`; once the server-side filter (§6.1) adds `core/cover` to that list, the `<PatternOverridesControls>` "Enable overrides" button and the `<ResetOverridesControl>` toolbar button appear automatically (AC-2, AC-7..AC-10).
 
 `replacePatternOverridesDefaultBinding` in `packages/block-editor/src/utils/block-bindings.js` is used directly inside `useCoverBindingState`. This is the **same** helper the Block Bindings panel uses and the **same** semantics the server's `gutenberg_process_block_bindings` expansion uses (`lib/compat/wordpress-6.9/block-bindings.php:257-281`). Client and server agree on expansion by construction.
 
@@ -352,13 +473,13 @@ Zero Cover-specific code. `withPatternOverrideControls` in `packages/editor/src/
 
 ### 6.1 File: `lib/compat/wordpress-7.1/block-bindings.php` (NEW)
 
-Loaded from `lib/load.php` line ~83 alongside the other 7.1 REST-server-block entries:
+Loaded from `lib/load.php` alongside the other 7.1 compat entries:
 
 ```php
 require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';
 ```
 
-Wrapped in `! function_exists( 'gutenberg_cover_bindings_render_block' )` per the established 7.1 backport pattern.
+Wrapped in `! function_exists( … )` per the established 7.1 backport pattern.
 
 **Part 1 — allow-list filter:**
 
@@ -380,7 +501,51 @@ if ( ! function_exists( 'gutenberg_cover_bindings_add_supported_attributes' ) )
 
 This filter feeds both `gutenberg_get_block_bindings_supported_attributes('core/cover')` (server-side resolution) and `__experimentalBlockBindingsSupportedAttributes['core/cover']` (editor setting via the existing `block_editor_settings_all` filter at `lib/compat/wordpress-6.9/block-bindings.php:33-46`). Single source of truth.
 
-**Part 2 — Cover-scoped render filter:**
+**Part 2 — `render_block_data` filter (NEW — solves AC-18 first-pass injection):**
+
+This filter runs **before** `render_callback` (verified at `wp-includes/blocks.php:2398` — `render_block_data` fires as `$inner_block->parsed_block = apply_filters( 'render_block_data', $inner_block->parsed_block, $source_block, $parent_block )`; for top-level blocks the equivalent fires in `render_block()` itself). By mutating `$parsed_block['attrs']['useFeaturedImage'] = false` here when bindings are active, we prevent `render_block_core_cover` from injecting the featured-image `<img>` in its first pass.
+
+```php
+if ( ! function_exists( 'gutenberg_cover_bindings_prepare_block' ) ) {
+    function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $parent_block ) {
+        // Gate: Cover only.
+        if ( 'core/cover' !== ( $parsed_block['blockName'] ?? '' ) ) {
+            return $parsed_block;
+        }
+        $attrs = $parsed_block['attrs'] ?? array();
+        // Gate: never engage for embed-video covers (AC-21).
+        if ( ! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType'] ) {
+            return $parsed_block;
+        }
+        // Gate: must have bindings on id AND url after __default expansion.
+        if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
+            return $parsed_block;
+        }
+        // Neutralise useFeaturedImage so render_block_core_cover skips its
+        // featured-image branch entirely (Req 19, AC-18). DC-2 is preserved:
+        // this mutation is scoped to the in-flight $parsed_block array used by
+        // this single render pass; the persisted post_content is untouched.
+        if ( ! empty( $attrs['useFeaturedImage'] ) ) {
+            $parsed_block['attrs']['useFeaturedImage'] = false;
+        }
+        return $parsed_block;
+    }
+    add_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10, 3 );
+}
+```
+
+`gutenberg_cover_bindings_is_active( $attrs )` is a private helper defined in the same file. It applies `__default` expansion (via inline logic copied from `lib/compat/wordpress-6.9/block-bindings.php:257-281`, scoped to `[ 'id', 'url' ]`), checks both bindings exist and resolve to the same source instance, and returns a bool. **This replaces the previously-undefined `gutenberg_cover_bindings_expand` helper.**
+
+**Why `render_block_data` solves the AC-18 first-pass injection problem.** Verified at `/Users/carlos/.wp-env/cc4ba7b5738d99b49b19f399987f6e49/WordPress/wp-includes/class-wp-block.php:531-596`: `WP_Block::render()` calls `process_block_bindings()` (line 532), merges resolved bindings into `$this->attributes` (lines 534-536), and then calls `render_callback` (line 596). The `render_block_data` filter runs **before** `WP_Block::render()` is constructed (`render_block()` in `wp-includes/blocks.php:2398` applies it on the parsed block array). By that point, `$parsed_block['attrs']['useFeaturedImage']` has been forced to `false`, so:
+
+1. `WP_Block::__construct` builds `$this->attributes` from the (modified) `$parsed_block['attrs']`, with `useFeaturedImage = false`.
+2. `process_block_bindings` resolves `id`+`url` from the source and merges them into `$this->attributes`. `useFeaturedImage` is not in the bindings shape, so it remains `false`.
+3. `render_callback` (= `render_block_core_cover`) runs with `useFeaturedImage = false` AND the bound `url`. The featured-image branch (`packages/block-library/src/cover/index.php:133`: `if ( 'image' !== $attributes['backgroundType'] || false === $attributes['useFeaturedImage'] ) { return $content; }`) is skipped. No featured-image `<img>` is injected. `$content` contains only the saved-markup `<img>` / `<div bg>`, with the saved-`url` not yet substituted.
+4. The priority-9 `gutenberg_cover_bindings_render_block` filter (Part 3 below) runs on this `$content`, substitutes the bound URL into the saved `<img>` / rebuilt `<img>`, and rewrites the dim class.
+
+No double-`<img>`. AC-18 satisfied for both first-pass and any subsequent re-render (`gutenberg_block_bindings_render_block` at priority 10 calls `$instance->render()` again — `useFeaturedImage` is still false on `$instance->attributes`, so the second pass also skips the featured-image branch).
+
+**Part 3 — `render_block` filter (priority 9):**
 
 ```php
 if ( ! function_exists( 'gutenberg_cover_bindings_render_block' ) ) {
@@ -397,26 +562,16 @@ if ( ! function_exists( 'gutenberg_cover_bindings_render_block' ) ) {
         }
 
         // Gate: must have bindings on id AND url after __default expansion.
-        $bindings = $block['attrs']['metadata']['bindings'] ?? null;
-        if ( empty( $bindings ) ) {
-            return $block_content;
-        }
-        $expanded = gutenberg_cover_bindings_expand( $bindings ); // applies __default to id/url
-        if ( empty( $expanded['id'] ) || empty( $expanded['url'] ) ) {
+        if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
             return $block_content;
         }
-        if (
-            $expanded['id']['source'] !== $expanded['url']['source']
-            || ( $expanded['id']['args'] ?? null ) !== ( $expanded['url']['args'] ?? null )
-        ) {
-            // Mismatched sources — unresolvable. Strip the saved <img>/<div bg> entirely (Req 26, AC-6).
-            return gutenberg_cover_bindings_strip_image( $block_content );
-        }
 
-        // Resolve via the standard bindings infrastructure.
-        $resolved = gutenberg_process_block_bindings( $instance );
-        $resolved_url = $resolved['url'] ?? null;
-        $resolved_id  = $resolved['id']  ?? null;
+        // Resolve via the standard bindings infrastructure. By this point,
+        // WP_Block::render() has already merged resolved bindings into
+        // $instance->attributes (verified at class-wp-block.php:531-536), so
+        // $attrs['url'] and $attrs['id'] are the bound values.
+        $resolved_url = $attrs['url'] ?? null;
+        $resolved_id  = $attrs['id']  ?? null;
         if ( empty( $resolved_url ) || empty( $resolved_id ) ) {
             return gutenberg_cover_bindings_strip_image( $block_content );
         }
@@ -439,35 +594,25 @@ if ( ! function_exists( 'gutenberg_cover_bindings_render_block' ) ) {
             $block_content = gutenberg_cover_bindings_relax_dim_class( $block_content );
         }
 
-        // (C) Suppress the useFeaturedImage injection in render_block_core_cover (Req 19, AC-18).
-        // Achieved by mutating $instance->attributes BEFORE the priority-10 render path runs.
-        if ( ! empty( $attrs['useFeaturedImage'] ) ) {
-            $instance->attributes['useFeaturedImage'] = false;
-        }
-        // Also stop render_block_core_cover from re-running the parallax/featured-image branch on
-        // a now-image-substituted markup: render_callback executes BEFORE this filter (render_callback
-        // produces $content; render_block filters run on $content). Setting useFeaturedImage=false here
-        // applies only to the gutenberg_block_bindings_render_block re-render at priority 10 (see below).
-
         return $block_content;
     }
     add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 );
 }
 ```
 
-**Filter priority 9** is essential: `gutenberg_block_bindings_render_block` (the generic bindings filter from `lib/compat/wordpress-6.9/block-bindings.php`) registers at priority 10. Running before it means our Cover-scoped substitution happens on the saved markup, before the generic filter re-runs `$instance->render()` (which would re-execute `render_block_core_cover` and could re-inject a featured image).
+**Filter priority 9** is essential: `gutenberg_block_bindings_render_block` (the generic bindings filter from `lib/compat/wordpress-6.9/block-bindings.php`) registers at priority 10. Running before it means our Cover-scoped substitution happens on the saved markup before the generic filter re-runs `$instance->render()` (which would re-execute `render_block_core_cover`, but at that point `useFeaturedImage` is already false thanks to Part 2 — so the second pass produces the same `$content` shape as the first, and our priority-9 substitution remains correct).
 
-Alternative considered: run at priority 11 (after) and let the generic filter's `gutenberg_replace_html` no-op on Cover's `url`/`id` (they have no `source` declaration so it's already a no-op for non-`source`-declared attributes per `lib/compat/wordpress-6.9/block-bindings.php:347-349`). Rejected: the generic filter calls `$instance->render()` which re-executes `render_block_core_cover` with the resolved attributes, and that callback's `useFeaturedImage` branch may inject a featured-image `<img>` — exactly the double-insertion AC-18 forbids. Running at priority 9 lets us mutate `$instance->attributes['useFeaturedImage'] = false` before the priority-10 re-render. (See AC-18 trace.)
+**Notes on `gutenberg_process_block_bindings` double-call.** Core 6.9's `process_block_bindings` is called once inside `WP_Block::render()` (line 532). The generic filter's priority-10 re-render path calls `$instance->render()` again, which calls `process_block_bindings()` a second time. Functionally correct (resolution is idempotent); cost is bounded and acceptable for v1. Listed under §15 risks for future optimisation.
 
 ### 6.2 Helper: `gutenberg_cover_bindings_rewrite_image`
 
 Per §3 OQ-3, two paths:
 
-1. **Plain `<img>` saved form** (`!hasParallax && !isRepeated` at save time): `WP_HTML_Tag_Processor::next_tag(['tag_name'=>'IMG','class_name'=>'wp-block-cover__image-background'])` + `set_attribute('src', $resolved_url)` + `set_attribute('alt', $attrs['alt'] ?? '')` + (optional) `set_attribute('class', preg_replace('/\bwp-image-\d+\b/', "wp-image-{$resolved_id}", $current))`.
+1. **Plain `<img>` saved form** (`!hasParallax && !isRepeated` at save time): `WP_HTML_Tag_Processor::next_tag(['tag_name'=>'IMG','class_name'=>'wp-block-cover__image-background'])`, then `set_attribute( 'src', $resolved_url )` + `set_attribute( 'alt', $alt )` + `remove_class( 'wp-image-{old}' )` + `add_class( 'wp-image-{new}' )`. All four methods verified public.
 
-2. **`<div style="background-image:url(…)">` saved form** (parallax or repeat): locate via `WP_HTML_Tag_Processor` with `tag_name=>'DIV'` and `class_name=>'wp-block-cover__image-background'`, compute byte range, splice in a rebuilt `<img>` HTML string. Drop `has-parallax`/`is-repeated` classes by construction (the rebuilt string never contains them). AC-19.
+2. **`<div style="background-image:url(…)">` saved form** (parallax or repeat): use `preg_match` with `PREG_OFFSET_CAPTURE` on the pattern `/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U` (same shape as `packages/block-library/src/cover/index.php:117-125, 193-197`), compute byte range, splice in a rebuilt `<img>` HTML string. Drop `has-parallax`/`is-repeated` classes by construction (the rebuilt string never contains them). AC-19.
 
-Both paths also need to drop a stale `wp-image-{old_id}` class and substitute `wp-image-{new_id}`; the `WP_HTML_Tag_Processor::remove_class` / `add_class` methods cover this for path 1.
+The function probes form (2) first (`preg_match` succeeds when the saved-markup is the `<div>` form, regardless of presence of `hasParallax`/`isRepeated` in `$attrs` — saved markup is the source of truth, not the attributes); falls through to form (1) (plain `<img>`) otherwise.
 
 ### 6.3 Helper: `gutenberg_cover_bindings_relax_dim_class`
 
@@ -487,25 +632,25 @@ Idempotent (calling twice is harmless). Targets the overlay span only; the `has-
 
 ### 6.4 Helper: `gutenberg_cover_bindings_strip_image`
 
-For the unresolvable / mismatched / external-URL case (Req 20, AC-5, AC-6): use `WP_HTML_Tag_Processor` to locate any element with `class_name=>'wp-block-cover__image-background'` (both `IMG` and `DIV` forms) and **remove the element entirely** from `$content` via the same byte-offset splice as OQ-3 mechanism (i). The cover renders without an image element, overlay-only.
+For the unresolvable / mismatched / external-URL case (Req 20, AC-5, AC-6): use the same `preg_match` + `substr`-splice approach (form-2 pattern, plus a form-1 pattern for plain `<img>`) to **remove** any element with class `wp-block-cover__image-background` from `$content`. The cover renders without an image element, overlay-only.
 
 ### 6.5 PHPUnit coverage
 
 New cases in `phpunit/blocks/render-block-cover-test.php`:
 
-1. **Bound URL substitution.** Construct a parsed-block array with `metadata.bindings.url = { source: testing/x }` and `metadata.bindings.id` likewise; register a test source returning a known media-library attachment. Assert `<img src="…">` contains the resolved URL.
+1. **Bound URL substitution (plain `<img>` saved form).** Construct a parsed-block array with `metadata.bindings.url = { source: testing/x }` and `metadata.bindings.id` likewise; register a test source returning a known media-library attachment. Assert `<img src="…">` contains the resolved URL.
 2. **Default-dimRatio class rewrite.** Same setup, `dimRatio` omitted (defaults to 100). Assert resulting HTML contains `wp-block-cover__background has-background-dim` but NOT `has-background-dim-100` (AC-16, AC-25).
 3. **Non-default dimRatio preserved.** Same setup with `dimRatio: 70`. Assert `has-background-dim-70` is present (AC-17).
 4. **Parallax saved markup gets rebuilt.** Construct saved markup with the `<div class="wp-block-cover__image-background" style="background-image:url(…)"></div>` form. Assert resulting HTML has `<img class="wp-block-cover__image-background"` and no `has-parallax` / `is-repeated` classes on it (AC-19).
 5. **Mismatched sources strip the image.** `metadata.bindings.id.source === 'A'`, `metadata.bindings.url.source === 'B'`. Assert no `wp-block-cover__image-background` element in output (AC-6).
 6. **External URL strip.** Source returns a URL but a non-attachment id. Assert no `wp-block-cover__image-background` (AC-5).
-7. **`useFeaturedImage` short-circuit.** `useFeaturedImage: true` with active bindings. Assert exactly one `wp-block-cover__image-background` element and its `src` is the bound URL, not the featured image URL (AC-18).
+7. **`useFeaturedImage: true` short-circuit.** `useFeaturedImage: true` with active bindings AND a featured-image set on the test post. Assert exactly one `wp-block-cover__image-background` element and its `src` is the bound URL, not the featured image URL (AC-18). This directly validates the `render_block_data` filter (§6.1 Part 2): without it, two elements would appear.
 8. **Embed-video carve-out.** `backgroundType: 'embed-video'` with active bindings. Assert no `<img>` substitution; the iframe path runs (AC-21).
 9. **Unbound cover untouched.** No bindings. Assert the existing `render_block_core_cover` output is byte-identical to trunk (AC-20).
 
 ## 7. `block.json` changes
 
-Add `"role": "content"` to the `id` attribute (lines 18–20 of `packages/block-library/src/cover/block.json`). The current `url` attribute already has `role: "content"` (lines 10–13).
+Add `"role": "content"` to the `id` attribute of `packages/block-library/src/cover/block.json`. The current `url` attribute already has `role: "content"`.
 
 ```diff
    "id": {
@@ -515,7 +660,7 @@ Add `"role": "content"` to the `id` attribute (lines 18–20 of `packages/block-
    },
 ```
 
-No other attribute schema changes. No new attributes. No supports changes. No deprecation entry needed (role is metadata-only — see Q19 in requirements.md).
+No other attribute schema changes. No new attributes. No supports changes. No deprecation entry needed (role is metadata-only).
 
 ## 8. Block Bindings registration
 
@@ -523,8 +668,8 @@ Bindings for `id` and `url` on `core/cover` are added by the new `block_bindings
 
 Exact code references:
 - `lib/compat/wordpress-6.9/block-bindings.php:118-167` (`gutenberg_get_block_bindings_supported_attributes`) — the function our filter hooks into.
-- `lib/compat/wordpress-6.9/block-bindings.php:33-46` (`block_editor_settings_all` filter) — populates the editor setting that `packages/block-editor/src/hooks/block-bindings.js:40-100` reads.
-- `packages/block-editor/src/hooks/block-bindings.js:122-127` — Cover is NOT in the excluded-blocks list. Once the server filter adds `id`/`url`, the Block Bindings panel renders automatically (AC-1, Q12).
+- `lib/compat/wordpress-6.9/block-bindings.php:33-46` (`block_editor_settings_all` filter) — populates the editor setting that `packages/block-editor/src/hooks/block-bindings.js` reads.
+- `packages/block-editor/src/hooks/block-bindings.js:122-127` — Cover is NOT in the excluded-blocks list. Once the server filter adds `id`/`url`, the Block Bindings panel renders automatically (AC-1).
 
 No new editor-side allow-list, no Cover-specific UI registration code.
 
@@ -532,9 +677,9 @@ No new editor-side allow-list, no Cover-specific UI registration code.
 
 Driven entirely by existing infrastructure:
 
-1. **`__default` expansion (client).** `useCoverBindingState` calls `replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] )` from `packages/block-editor/src/utils/block-bindings.js:27-46`. After expansion, the `__default: { source: 'core/pattern-overrides' }` shape becomes `{ id: { source: 'core/pattern-overrides' }, url: { source: 'core/pattern-overrides' } }`, which is exactly the same-source-instance shape `bindingActive` accepts. Per Glossary "Expanded bindings".
-2. **`__default` expansion (server).** `gutenberg_process_block_bindings` (`lib/compat/wordpress-6.9/block-bindings.php:257-281`) expands `__default` server-side. Same semantics.
-3. **Reset toolbar.** `withPatternOverrideControls` (`packages/editor/src/hooks/pattern-overrides.js:37-122`) wires `<ResetOverridesControl>` automatically once the block is allow-listed.
+1. **`__default` expansion (client).** `useCoverBindingState` calls `replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] )` from `packages/block-editor/src/utils/block-bindings.js`. After expansion, the `__default: { source: 'core/pattern-overrides' }` shape becomes `{ id: { source: 'core/pattern-overrides' }, url: { source: 'core/pattern-overrides' } }`, which is exactly the same-source-instance shape `bindingActive` accepts. Per Glossary "Expanded bindings".
+2. **`__default` expansion (server).** `gutenberg_process_block_bindings` (`lib/compat/wordpress-6.9/block-bindings.php:257-281`) expands `__default` server-side. Same semantics. Our `gutenberg_cover_bindings_is_active` helper (§6.1) re-implements the same expansion locally (because we need to read the expansion BEFORE `gutenberg_process_block_bindings` runs, in the `render_block_data` filter).
+3. **Reset toolbar.** `withPatternOverrideControls` (`packages/editor/src/hooks/pattern-overrides.js`) wires `<ResetOverridesControl>` automatically once the block is allow-listed.
 4. **Enable Overrides button.** Same HOC wires `<PatternOverridesControls>` for the synced-pattern authoring view.
 
 Zero Cover code touches Pattern Overrides directly.
@@ -545,11 +690,11 @@ Three layers of enforcement, all gated by the same `bindingActive` semantic:
 
 | Layer | Enforcement site | Outcome |
 | --- | --- | --- |
-| Editor render | `CoverEdit` render tree (§5.4) | If `bindingUnresolvable`, render the `<Placeholder data-testid="cover-binding-unresolvable">` and do NOT render an `<img>` (AC-4). |
+| Editor render | `CoverEdit` render tree (§5.4) | If `bindingUnresolvable`, render `<Placeholder>` with `instructions={ __( 'Internal media required for this binding.' ) }` and do NOT render an `<img>` (AC-4). |
 | Editor controls | `useCoverBindingState` flips `bindingActive: false` when sources don't match | Parallax/repeat/replace/featured-image controls return to their unbound rendering. This is intentional: a mismatched-binding cover is treated as if there's no binding, so the user has the normal cover affordances to fix it. |
-| Server render | `gutenberg_cover_bindings_render_block` (§6.1) | Mismatched/missing/non-attachment id → `gutenberg_cover_bindings_strip_image` → no `<img>` in output (AC-5, AC-6, AC-20 unresolvable path). |
+| Server render | `gutenberg_cover_bindings_render_block` (§6.1) | Mismatched/missing/non-attachment id → `gutenberg_cover_bindings_strip_image` → no `<img>` in output (AC-5, AC-6). |
 
-The "internal media required" affordance test-observable signal is `data-testid="cover-binding-unresolvable"` AND the i18n string `__( 'Internal media required for this binding.' )` (OQ-6).
+The "internal media required" affordance test-observable signal is the i18n message string `__( 'Internal media required for this binding.' )` (primary; e2e asserts via `getByText`), with `data-testid="cover-binding-unresolvable"` as a secondary stability hook (OQ-6).
 
 ## 11. Testing strategy
 
@@ -580,13 +725,13 @@ test.describe( 'Block Bindings — Pattern Overrides round-trip', () => {
     test( 'Cover round-trips through default → override → reset', async ({ editor, page, requestUtils, admin }) => {
         // Setup: upload two attachments (defaultMedia, overrideMedia).
         // 1. Create synced pattern with a Cover whose url+id are bound via "Enable overrides".
-        //    Insert Cover → set media to defaultMedia → open Inspector → Advanced → "Enable overrides".
         // 2. Save pattern. Open new post. Insert the synced pattern.
         // 3. Assert (default state):
         //    - Editor preview <img src> points at defaultMedia.url.
         //    - Parallax / Repeat ToolsPanelItems are not visible (AC-11, AC-12).
-        //    - <MediaReplaceFlow> toolbar button is not visible (AC-13, AC-14).
-        //    - "Use featured image" menu item is not visible (AC-13).
+        //    - <MediaReplaceFlow> "Use featured image" MenuItem is not visible (AC-13).
+        //    - <MediaReplaceFlow> upload/replace MenuItems are not visible (AC-14).
+        //    - <MediaReplaceFlow> "Embed video from URL" MenuItem IS visible (AC-21 preserved).
         //    - Overlay span class does NOT contain 'has-background-dim-100' (AC-15).
         //    - ResetOverridesControl toolbar button is disabled (AC-10, OQ-2).
         // 4. Override the instance: programmatically setBlockAttributes with new url+id.
@@ -599,8 +744,8 @@ test.describe( 'Block Bindings — Pattern Overrides round-trip', () => {
         //    - Assert editor preview <img src> back to defaultMedia.url.
         //    - Publish; front-end same.
         // 6. Unresolvable case: programmatically create a Cover with mismatched bindings
-        //    (id.source !== url.source). Assert the `data-testid="cover-binding-unresolvable"`
-        //    Placeholder is visible (AC-24).
+        //    (id.source !== url.source). Assert the i18n message is visible (AC-24):
+        //    await expect( page.getByText( 'Internal media required for this binding.' ) ).toBeVisible();
     } );
 } );
 ```
@@ -613,12 +758,25 @@ Existing `cover.spec.js` cases run untouched. Existing `packages/block-library/s
 
 ## 12. Backwards compatibility
 
-- **Unbound covers untouched.** All gating predicates (`bindingActive`, the server filter's early-return on `empty($bindings)`) flip false when `metadata.bindings` is absent. The new code path is dead code on every existing unbound cover. AC-20.
+- **Unbound covers untouched.** All gating predicates (`bindingActive`, the server filters' early-return on `! gutenberg_cover_bindings_is_active( $attrs )`) flip false when `metadata.bindings` is absent. The new code path is dead code on every existing unbound cover. AC-20.
 - **No `save.js` change.** The serialized markup shape is identical to trunk. Deprecation chain unchanged. AC-20.
 - **No new attribute.** `id` gains a `role: "content"` annotation only — metadata-only, not part of the saved markup.
-- **Embed-video carve-out.** Both client and server short-circuit on `backgroundType === 'embed-video'`, regardless of binding presence. AC-21.
-- **`useFeaturedImage` precedence rule.** When both `useFeaturedImage: true` and an active binding co-exist on the same cover, the binding wins (server: `$instance->attributes['useFeaturedImage'] = false` is set BEFORE the priority-10 generic-bindings re-render). The stored `useFeaturedImage` attribute is NOT mutated (the mutation is to the in-flight `$instance` object, scoped to this single render pass — not to the post content). AC-18, DC-2 satisfied (no `setAttributes` on client, no persisted attribute change on server).
+- **Embed-video carve-out.** Both client and server short-circuit on `backgroundType === 'embed-video'`, regardless of binding presence. AC-21. The "Embed video from URL" menu item under `<MediaReplaceFlow>` remains accessible on bound covers (regardless of `backgroundType`), preserving the affordance per AC-21.
+- **`useFeaturedImage` precedence rule (AC-18).** When both `useFeaturedImage: true` and an active binding co-exist on the same cover, the binding wins. Mechanism: the `render_block_data` filter (§6.1 Part 2) mutates `$parsed_block['attrs']['useFeaturedImage'] = false` BEFORE `render_callback` runs, so `render_block_core_cover` skips its featured-image injection branch. The stored `useFeaturedImage` attribute on the post content is NOT mutated (the mutation is to the in-flight `$parsed_block` array, scoped to this single render pass). DC-2 is preserved on the persistence path (no `setAttributes` on client, no persisted post_content change on server). On the client, `bindingActive` is derived from the persisted attribute state including `useFeaturedImage`; if a saved Cover has both `useFeaturedImage: true` and bindings, the editor's `effectiveUrl` prefers `bindingResolvedUrl` over `mediaUrl` per §5.2, matching the server's precedence. AC-18 satisfied.
 - **`! function_exists` / version guards.** The new compat file follows the established pattern from `lib/compat/wordpress-6.9/block-comments.php:63,84`. Graceful degradation on a WP install lacking the bindings infrastructure (Req 39). The Cover Edit component's new hook reads `metadata?.bindings` defensively — when `__experimentalBlockBindingsSupportedAttributes['core/cover']` is undefined (pre-7.1 server), `bindingActive` returns false and the existing code path runs.
+- **AC-26 (PR shape — file path).** The new compat file lives at `lib/compat/wordpress-7.1/block-bindings.php` and is loaded via `lib/load.php`. No file under `lib/compat/wordpress-7.0/`. See §2.2 and §6.1.
+- **AC-27 (PR description).** The Gutenberg PR description MUST link issue #77199 and MUST explicitly state whether/how this PR subsumes #74109 and #74610. This is a PR-creation step rather than a code change; the design records it as a hard requirement on the PR-open phase. Suggested wording is included in the Code phase's PR-creation step.
+- **AC-28 (~500-line diff budget).** Estimated diff sizes (additions):
+  - `lib/compat/wordpress-7.1/block-bindings.php`: ~160 lines
+  - `packages/block-library/src/cover/edit/use-cover-binding-state.js` (new): ~70 lines
+  - `packages/block-library/src/cover/edit/index.js`: ~60 lines net (observer replacement + render-tree gating)
+  - `packages/block-library/src/cover/edit/inspector-controls.js`: ~10 lines
+  - `packages/block-library/src/cover/edit/block-controls.js`: ~10 lines
+  - `packages/block-library/src/cover/block.json`: ~2 lines
+  - `lib/load.php`: ~1 line
+  - PHPUnit (9 cases): ~140 lines
+  - E2E (1 describe block, ~6 assertion steps): ~80 lines
+  - **Total: ~533 lines.** Just over budget; the +0.5K-line ceiling is "SHOULD" (Req 38) not MUST. Acceptable; if reviewers push back, the e2e block can be trimmed to ~50 lines by combining steps 4 + 5.
 
 ## 13. Trade-offs and alternatives considered
 
@@ -632,21 +790,50 @@ Approach B (PR #74610's generic `block_bindings_attribute_replaced_in_markup` fi
 | Solves `<img src>` substitution | Yes (Cover-scoped) | Yes (generic) |
 | Solves dim-class rewrite | Yes | No — needs Cover-side supplement |
 | Solves parallax-div → `<img>` rebuild | Yes | No — needs Cover-side supplement (Risk 5) |
-| Solves `useFeaturedImage` short-circuit | Yes | No — needs Cover-side supplement |
-| Lines added to PR | Single file, ~150 lines | Generic filter + Cover-side supplement: ~200 lines |
+| Solves `useFeaturedImage` short-circuit | Yes (via render_block_data) | No — needs Cover-side supplement |
+| Lines added to PR | Single file, ~160 lines | Generic filter + Cover-side supplement: ~210 lines |
 | Cross-block risk surface | Zero | Non-zero (filter affects every binding-substituted block) |
 | Reuse value for future bindable blocks | Zero | Some (e.g. a future block with non-source-declared `url`) |
 
 Net: Approach A wins on every dimension that touches this spec. Approach B's reuse value is real but speculative; the spec also flags it as out-of-scope absent a clear cross-block need (Req 28, Out-of-Scope "New global Block Bindings APIs").
 
+### AC-18 mitigation: render_block_data vs in-callback override vs filter
+
+Three options considered for the `useFeaturedImage: true + bindingActive` precedence:
+
+| | Chosen: `render_block_data` filter | Alt A: in `render_block_core_cover` | Alt B: in priority-9 `render_block` filter (prior design) |
+| --- | --- | --- | --- |
+| Where suppression happens | Before `render_callback` | Inside `render_callback` | After `render_callback` |
+| First-pass injection prevented | Yes | Yes | **No** — already happened |
+| Touches `render_block_core_cover` | No | Yes | No |
+| Cross-PR-coordination needed | No (Gutenberg-side only) | Yes (touches a Core-owned callback) | No |
+| AC-18 satisfied | **Yes** | Yes | **No** |
+
+Alt A would require modifying `render_block_core_cover` itself to peek at `metadata.bindings`, adding a binding-awareness coupling to a Core callback. Better to keep all binding-awareness in the new compat file (consistent with the file-table in §2.2).
+
+Alt B (the prior design's approach) leaves a window in which `render_callback` emits the featured-image element, then our filter rewrites the saved `<img>` but the *injected* featured-image element survives → double `<img>`. Rejected per the iter-1 review Issue 3.
+
+The chosen `render_block_data` approach intercepts at the parsed-block level, before `WP_Block::render` even begins. Verified at `wp-includes/blocks.php:2398` and `wp-includes/class-wp-block.php:531-596`. DC-2 is preserved because the mutation is on the in-flight `$parsed_block` array passed by reference for this render only — the persisted post_content is not touched.
+
 ### Client-side: source-agnostic observer vs explicit `useBindings` derivation
 
 Considered: a separate `useEffect` keyed on `metadata.bindings` that synchronises a derived `bindingUrl` state into the existing observer. Rejected: that is exactly the multi-`useEffect` proliferation Risk 1 / DC-1 forbid. The chosen design (one effect, keyed on `effectiveUrl`, with `useEffectEvent` for latest-value reads) collapses every URL-derivation trigger into a single signal.
 
+### Client-side: race-token via ref vs cleanup-flag in useEffect
+
+The cleanup-flag pattern (`let cancelled = false; ...; return () => { cancelled = true; };`) is React's documented idiom for async work inside `useEffect`. The chosen ref-based pattern was preferred because:
+- The async work lives inside `useEffectEvent`, not `useEffect` body. `useEffectEvent`'s contract is to read latest values; binding a `cancelled` flag in the `useEffect` body's closure would couple the flag to a stale snapshot. Hoisting it to `useEffectEvent` would re-introduce dep-array churn.
+- The ref-based token is monotonic and shared across all observer invocations — a clean primitive for "newest resolution wins" that survives observer re-runs caused by multiple effectiveUrl changes between resolutions.
+- Explicit `useRef( 0 )` declaration at the top of the component is required (sketched in §5.2).
+
 ### Pattern Overrides reset: disable vs hide
 
 OQ-2 chose disable. Hiding the button would require Cover-specific overrides of `ResetOverridesControl` (or a wholesale change to all bindable blocks). The hide approach has no UX advantage and would diverge Cover from every other bindable block; the disable approach is the existing contract.
 
+### OQ-6 test-observable signal: i18n string vs data-testid
+
+Both retained, with primary/secondary ordering. The i18n string is the load-bearing contract per spec Req 16; `data-testid` is a translation-resilience safety net. E2E asserts on the i18n string (`page.getByText( 'Internal media required for this binding.' )`). If a future reviewer removes `data-testid` because "test-only props in production DOM smell bad", the e2e test remains green.
+
 ## 14. Out-of-scope reminders (from spec, repeated here to keep design honest)
 
 The design explicitly does NOT implement:
@@ -656,12 +843,14 @@ The design explicitly does NOT implement:
 - **Parallax × bindings beyond force-off.** No CSS-in-`style` rewrites. The parallax/repeat saved markup is replaced with a plain `<img>` when bindings have resolved a value (OQ-3 mechanism (i)).
 - **Embed-video × bindings beyond non-regression.** Both client and server short-circuit. The iframe's `src` is the saved `url`, never substituted from the bound `url`. AC-21.
 - **Featured-image binding** (expressing `useFeaturedImage` AS a binding source). Separate follow-up PR. This PR enforces the precedence rule only (AC-18).
-- **New global Block Bindings APIs.** None introduced. The chosen Cover-scoped filter is `add_filter( 'render_block', ..., 9, 3 )` with the standard signature — not a new API.
+- **New global Block Bindings APIs.** None introduced. The chosen Cover-scoped filters are `add_filter( 'render_block_data', ..., 10, 3 )` and `add_filter( 'render_block', ..., 9, 3 )` with the standard signatures — not a new API.
 - **Post-data source `featured_media.url` / `featured_media.id`.** Out of scope.
 
 ## 15. Risks / open questions surfaced by this design
 
-1. **Priority-9 vs priority-10 ordering.** The Cover render filter runs at priority 9 to mutate `$instance->attributes['useFeaturedImage'] = false` before `gutenberg_block_bindings_render_block` re-runs `$instance->render()`. If a future change to the generic filter changes its registration priority, the ordering invariant breaks. Mitigation: PHPUnit case §6.5(7) catches this regression. Add a comment in the new compat file pinning the rationale.
-2. **`WP_HTML_Tag_Processor` byte-offset helpers**. OQ-3 mechanism (i) leans on `get_token_byte_offset_in_source_text()` / `get_full_token_length()`. These are public WP HTML API methods but availability across WP versions in the version-guard window needs confirmation during implementation. Fallback: `preg_match` with `PREG_OFFSET_CAPTURE` mirrors the pattern already used at `packages/block-library/src/cover/index.php:117-125`.
-3. **`gutenberg_process_block_bindings` is called twice per render** (once in our priority-9 filter, once in the priority-10 generic filter). This is functionally correct but wastes work. Acceptable for v1; a future micro-optimisation could cache resolution per `$instance`.
-4. **Race between `attachment` REST loading and `bindingResolvedId` check.** Client-side, the media-library record lookup via `useSelect` returns `undefined` while loading and `null` if resolved-not-found. The hook currently treats `undefined` as pending (no unresolvable affordance yet) and `null` as unresolvable. There's a single render where the cover shows neither image nor unresolvable affordance. Acceptable; pattern matches how `core/image` handles the same race.
+1. **Priority-9 vs priority-10 ordering.** The Cover render filter runs at priority 9. The neutralisation of `useFeaturedImage` runs even earlier at `render_block_data` priority 10. If a future change to either generic filter changes registration priority, the ordering invariant breaks. Mitigation: PHPUnit case §6.5(7) catches this regression; add a comment in the new compat file pinning the rationale.
+2. **`gutenberg_cover_bindings_is_active` duplicates `__default` expansion logic** from `lib/compat/wordpress-6.9/block-bindings.php:257-281`. This is intentional (we need the expansion result BEFORE `gutenberg_process_block_bindings` runs, in the `render_block_data` filter, while the generic helper does it inline) but introduces a small divergence risk if Core changes expansion semantics. Mitigation: PHPUnit case §6.5(7) and #6.5(5) catch behavioural divergence; if Core promotes expansion into a public helper, swap to it.
+3. **`gutenberg_process_block_bindings` is called twice per render** (once via `WP_Block::render()` at line 532, once via the priority-10 generic filter's `$instance->render()` re-call). Functionally correct (resolution is idempotent) but wastes work. Acceptable for v1; a future micro-optimisation could cache resolution per `$instance`.
+4. **Race between `attachment` REST loading and `bindingResolvedId` check.** Client-side, the media-library record lookup via `useSelect` returns `undefined` while loading and `null` if resolved-not-found. The hook treats `undefined` as pending (bound-but-pending placeholder per §5.4 (1)) and `null` as unresolvable. There's a transient render where the cover shows the pending placeholder instead of the resolved image — duration is one network round-trip. Acceptable; pattern matches how `core/image` handles the same race.
+5. **AC-14 literal-DOM-absence vs functional-absence.** Design satisfies the *functional* AC-14 (media-replace not offered) by setting `onSelect` / `onToggleFeaturedImage` / `onReset` to `undefined`, leaving the `<MediaReplaceFlow>` toolbar wrapper in the DOM to host the embed `<MenuItem>` (AC-21). If reviewers insist on absolute absence of `<MediaReplaceFlow>`, the spec must be re-opened to reconcile AC-14 vs AC-21. Recommendation: assert on menu-item absence in the e2e test (§11.3), not on `<MediaReplaceFlow>` absence — matches the chosen design.
+6. **Backport-changelog entry timing.** `backport-changelog/7.1/<core-pr>.md` is created when the corresponding Core PR is filed; not a blocker for the Gutenberg PR landing. The Gutenberg PR description includes a `TODO: backport-changelog entry pending Core PR #NNN` note and is updated once the Core PR number is known.

From ccb995f15d4ab31cc38133963e8666cd37364286 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:15:09 +0200
Subject: [PATCH 15/60] docs(pipeline): add
 2-design-doc/design-doc-review-2-rejected.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../design-doc-review-2-rejected.md           | 191 ++++++++++++++++++
 1 file changed, 191 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-2-rejected.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-2-rejected.md b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-2-rejected.md
new file mode 100644
index 00000000000000..39e27add6cd463
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-2-rejected.md
@@ -0,0 +1,191 @@
+# Design Doc Review
+
+## Verdict: rejected
+
+## Summary
+
+Iter-2 resolves every one of the eleven iter-1 findings explicitly: the non-existent Tag-Processor byte-offset accessors are replaced by `preg_match` + `substr` splice (iter-1 Issue 1); the empty-cover branch is gated in `index.js` so `cover-placeholder.js` no longer needs editing, and the line-750 `<CoverPlaceholder>` is correctly carried by `disableMediaButtons` (iter-1 Issues 2 + 4); the first-pass `useFeaturedImage` injection is intercepted via a `render_block_data` filter that mutates `$parsed_block['attrs']['useFeaturedImage']` BEFORE `WP_Block::__construct`, and the propagation has been verified against `wp-includes/class-wp-block.php:127-236, 520-596` and `wp-includes/blocks.php:2398-2436` (iter-1 Issue 3); the i18n string is named the primary test-observable contract with `data-testid` as a secondary stability hook (iter-1 Issue 5); `<MediaReplaceFlow>` is kept in the DOM with embed-video access preserved (iter-1 Issue 6); the race-token ref is now declared explicitly at component top with rationale (iter-1 Issue 7); the `useSelect` is now a single-closure read of source + attachment record (iter-1 Issue 8); AC-26/27/28 are explicitly traced in §12 (iter-1 Issue 9); the renamed `gutenberg_cover_bindings_is_active` is defined alongside its expansion logic (iter-1 Issue 10); the backport-changelog timing is settled (iter-1 Issue 11).
+
+However, iter-2 introduces a **blocker defect** in the gating mechanism for `<MediaReplaceFlow>`. The design's central claim — that setting `onSelect=undefined` removes the upload / "Open Media Library" menu items — does not match the actual `<MediaReplaceFlow>` source. Those menu items render unconditionally; only the `onSelect` callback path is undefined, which would crash at runtime if a user clicks them. This breaks AC-14 (the e2e test as designed will fail because the menu items remain in the DOM) and turns the design's centerpiece UI-gating mechanism into a runtime crash hazard. Three smaller defects compound this. Detailed below.
+
+## Issues
+
+### Issue 1 (blocker): `<MediaReplaceFlow>` `onSelect=undefined` does NOT remove "Open Media Library" / "Upload" menu items
+
+**What's wrong:** §5.5 asserts that setting `onSelect={ bindingActive ? undefined : onSelectMedia }` removes the media-replace menu items from the dropdown:
+
+> "`MediaReplaceFlow` (verified at `packages/block-editor/src/components/media-replace-flow/`) renders the 'Use featured image' toggle ONLY when `onToggleFeaturedImage` is a function; setting it to `undefined` removes that menu item from the dropdown. **Same for `onSelect` (the upload + media-library buttons short-circuit when `onSelect` is falsy)**."
+
+Verified against `packages/block-editor/src/components/media-replace-flow/index.js`:
+
+- Line 233 — "Use featured image" `<MenuItem>` IS gated on `onToggleFeaturedImage &&`. ✓ Design correct here.
+- Line 245 — "Reset" `<MenuItem>` IS gated on `mediaURL && onReset &&`. ✓ Design correct here.
+- Lines 193–212 — `<MediaUploadCheck>` wraps `<MediaUpload>` (rendering the "Open Media Library" `<MenuItem>`) and `<FormFileUpload>` (rendering the "Upload" `<MenuItem>`). **Neither is gated on `onSelect`.** They render unconditionally. ✗ Design wrong here.
+
+The runtime consequence: setting `onSelect={ undefined }` does not remove the "Open Media Library" / "Upload" menu items. Worse, the internal `selectMedia` helper (line 109–118) is called from `<MediaUpload onSelect>` (line 200) and from `uploadFiles` (line 131); `selectMedia` calls `onSelect( media )` at line 115. With `onSelect=undefined`, clicking "Open Media Library" or "Upload" throws `TypeError: onSelect is not a function`.
+
+**Where in design doc:** §5.5 (the block-controls.js gating sketch and the verification claim under it), §11.3 (the e2e test outline asserts "<MediaReplaceFlow> upload/replace MenuItems are not visible"), §13 ("AC-14 mitigation" trade-off).
+
+**Suggestion:** Pick one:
+- (a) Replace the `<MediaReplaceFlow>` with a different toolbar control on bound covers: a thin `<ToolbarGroup>` that surfaces only the "Embed video from URL" `<MenuItem>` (since AC-21 requires that affordance be preserved). When `bindingActive`, render the alternate control; when `! bindingActive`, render the existing `<MediaReplaceFlow>`. This is straightforward — extract the embed `<MenuItem>` into its own toolbar surface for the bound case.
+- (b) Modify `<MediaReplaceFlow>` itself to gate `<MediaUploadCheck>`'s subtree on `onSelect && ...`. This is an upstream change to a shared component; requires owner sign-off; risks affecting other consumers.
+- (c) Accept the runtime hazard, suppress the menu items via CSS, and document the limitation. This is worse than (a) and (b); not recommended.
+
+Recommendation: (a). The design already acknowledges in Risk #5 of §15 that AC-14 is a "literal-DOM-absence vs functional-absence" stretch — but the chosen mechanism does not even achieve functional absence for the media-library/upload paths, only for the "Use featured image" and "Reset" affordances.
+
+**Why it matters:** AC-14 is one of the spec's control-hiding contracts and is explicitly tested by AC-23. The design's mechanism for it is incorrect; the e2e test as outlined will fail (`await expect( mediaLibraryMenuItem ).not.toBeVisible()` will time out because the menu item is still in the DOM). This is exactly the kind of defect PR review will catch, and the design phase is where it should be resolved.
+
+---
+
+### Issue 2 (major): `getBlockBindingsSource` is on the `@wordpress/blocks` store, not `blockEditorStore`
+
+**What's wrong:** §5.1 step 3 sketches the `useSelect`:
+
+```js
+const source = unlock( select( blockEditorStore ) ).getBlockBindingsSource( expanded.url.source );
+```
+
+`getBlockBindingsSource` is NOT a selector on `blockEditorStore`. Verified at `packages/blocks/src/store/private-selectors.ts:252-257` — it is a private selector on the `@wordpress/blocks` store. It is also a direct module export at `packages/blocks/src/api/registration.ts:903`. The block-editor store does not expose `getBlockBindingsSource`.
+
+Concrete evidence of intended usage in trunk: `packages/block-editor/src/components/block-bindings/source-fields-list.js:9` imports `getBlockBindingsSource` directly from `@wordpress/blocks` (not via `select`). `packages/block-editor/src/components/block-edit/edit.js:120-155` reads a `registeredSources` map gathered earlier from the same `@wordpress/blocks` module, not through `select`.
+
+An implementer who copies §5.1 step 3 verbatim will get `undefined` back from the selector call and the hook will silently treat every binding as unresolvable.
+
+**Where in design doc:** §5.1 step 3, the `useSelect` body.
+
+**Suggestion:** Either:
+- (a) Import `getBlockBindingsSource` from `@wordpress/blocks` and call it directly inside the `useSelect` body. It does not need a `select` parameter because it is a registry lookup, not state-dependent.
+- (b) Read it via `select( blocksStore )` — but then the design must name `blocksStore` explicitly (`@wordpress/blocks`'s store reference) instead of `blockEditorStore`.
+
+Either is fine. Option (a) is what the existing trunk callers do.
+
+**Why it matters:** §5.1 is the canonical code shape implementers will copy. A wrong store reference produces a silently-broken hook (no error, just `bindingActive=false` everywhere) — exactly the kind of regression the design phase exists to prevent.
+
+---
+
+### Issue 3 (minor): `gutenberg_cover_bindings_is_active` PHP helper description omits the `args` equality check
+
+**What's wrong:** Spec Glossary "Active binding" requires `id` and `url` bindings "point to the same source instance (same `source` string AND, where applicable, same `args`)". §5.1 step 2's JS `bindingActive` correctly includes `JSON.stringify(expanded.id.args ?? null) === JSON.stringify(expanded.url.args ?? null)`.
+
+§6.1's description of the PHP companion `gutenberg_cover_bindings_is_active( $attrs )` says only: "applies `__default` expansion (via inline logic copied from `lib/compat/wordpress-6.9/block-bindings.php:257-281`, scoped to `[ 'id', 'url' ]`), checks both bindings exist and resolve to the same source instance, and returns a bool".
+
+The phrase "same source instance" is ambiguous — does it include `args` equality? §6.1 should mirror §5.1 step 2 explicitly: same `source` string AND same `args`. Otherwise client and server can disagree about `bindingActive` semantics for an explicit per-attribute bindings shape with matching sources but different `args`.
+
+**Where in design doc:** §6.1 (definition of `gutenberg_cover_bindings_is_active`), §9 step 2 (claims "Client and server agree on expansion by construction").
+
+**Suggestion:** Add one sentence to §6.1 immediately after the `gutenberg_cover_bindings_is_active` paragraph: "Source-instance equality is checked as `$expanded['id']['source'] === $expanded['url']['source'] && ( $expanded['id']['args'] ?? null ) == ( $expanded['url']['args'] ?? null )`, mirroring §5.1 step 2's client-side check."
+
+**Why it matters:** Spec Req 26 says mismatched-source bindings (including different `args` against the same source) MUST be treated as unresolvable. If the PHP helper checks only `source` string equality, an explicit `{ id: { source: X, args: A }, url: { source: X, args: B } }` shape would pass server-side but fail client-side, producing inconsistent render output.
+
+---
+
+### Issue 4 (minor): `gutenberg_cover_bindings_strip_image` — form-1 (plain `<img>`) pattern not given
+
+**What's wrong:** §6.4 describes the stripper as "use the same `preg_match` + `substr`-splice approach (form-2 pattern, plus a form-1 pattern for plain `<img>`) to **remove** any element with class `wp-block-cover__image-background` from `$content`". §6.2 gives the form-2 (`<div>...</div>`) pattern explicitly: `/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U`. The form-1 (self-closing or void `<img>`) pattern is not given.
+
+An `<img>` saved-form is `<img class="wp-block-cover__image-background ..." ... />` (single self-closing tag, no closing `</img>`). The form-2 regex won't match it. The design should either:
+- give the form-1 pattern explicitly (something like `/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?>/`); OR
+- delegate to `WP_HTML_Tag_Processor` for the plain-`<img>` form (which can locate the tag via `next_tag( ['tag_name'=>'IMG', 'class_name'=>'wp-block-cover__image-background'] )`, but Tag Processor cannot DELETE a tag — only mutate attributes/classes — so this requires additional thought).
+
+**Where in design doc:** §6.4.
+
+**Suggestion:** Spell out the form-1 pattern explicitly OR pick a different mechanism for the plain-`<img>` strip. Option: for the plain-`<img>` case, use `WP_HTML_Tag_Processor` to find the tag's byte position via a different probe (e.g., write a sentinel class via `add_class`, regex-locate the sentinel, splice). Or accept the regex approach for both forms and give both patterns explicitly.
+
+**Why it matters:** AC-5 / AC-6 / Req 20 require the server to emit no `<img>` for unresolvable cases. If the form-1 stripper is missing, an unresolvable binding on a plain-`<img>` saved Cover will leave the broken-src `<img>` in the output.
+
+---
+
+### Issue 5 (minor): `<CoverPlaceholder disableMediaButtons>` at line 750 keeps a drop-zone affordance that may conflict with AC-14 intent
+
+**What's wrong:** §5.5 says "the line-750 site is reached on bound covers but uses `disableMediaButtons`, which removes both the upload and the featured-image affordance from `<MediaPlaceholder>`". Verified at `packages/block-editor/src/components/media-placeholder/index.js:551-552`: `if ( disableMediaButtons ) { return <MediaUploadCheck>{ renderDropZone() }</MediaUploadCheck>; }`. The drop zone IS still rendered — it just doesn't render the buttons.
+
+If a user drags an image file onto a bound Cover that has an existing background (`hasBackground === true`, so the line-750 placeholder is reached), the drop-zone callback (which is wired to `onFilesPreUpload` in `cover-placeholder.js:22-26` calling `onSelectMedia({ url: ... })`) would still attempt to replace the media. This is a *user-initiated* mutation (the user dropped a file) so DC-2 is technically satisfied, but the spec's intent (Req 7, AC-14) is "media-replace control NOT in the DOM" / "direct media replacement from inside the Cover is not offered when bound".
+
+A drop zone IS an alternative form of "media-replace control" even if it has no visible button. The design should either:
+- explicitly acknowledge that drop-zone replacement is preserved on bound covers as an out-of-AC-14 user-initiated path; OR
+- gate the line-750 `<CoverPlaceholder>` with `bindingActive ? null : ...` (a one-line addition) so no `<MediaPlaceholder>` is rendered at all on bound covers.
+
+**Where in design doc:** §5.5 ("`disableMediaButtons` ... removes both the upload and the featured-image affordance ... Therefore no additional gating is required at that site.")
+
+**Suggestion:** Add to §5.5: either (a) gate the line-750 `<CoverPlaceholder>` on `! bindingActive`, returning `null` (or omitting the element) for bound covers; or (b) explicitly document the drop-zone-as-user-initiated-mutation carve-out and trace it to Req 7's "control" wording vs spec intent.
+
+**Why it matters:** AC-14 / Req 7 are the spec's media-replace-suppression contracts. A drop-zone alternative path that still mutates the cover's `url`/`id` on bound covers is at minimum a documentation gap; at most a real AC-14 violation depending on how reviewers read "control".
+
+---
+
+## Coverage summary
+
+| AC                 | Traced in design                                                | Adequately addressed                                            |
+| ------------------ | --------------------------------------------------------------- | --------------------------------------------------------------- |
+| AC-1               | §8                                                              | Yes                                                             |
+| AC-2               | §5.6, §9                                                        | Yes                                                             |
+| AC-3               | §5.4, §6.5(1)                                                   | Yes                                                             |
+| AC-4               | §5.4, §10, OQ-6                                                 | Yes                                                             |
+| AC-5               | §6.4                                                            | Partial — Issue 4 (form-1 strip pattern missing)                |
+| AC-6               | §6.4, §10                                                       | Partial — Issue 4 (form-1 strip pattern missing)                |
+| AC-7..AC-10        | §5.6, §9, OQ-2                                                  | Yes                                                             |
+| AC-11..AC-12       | §5.5                                                            | Yes                                                             |
+| AC-13              | §5.5                                                            | Yes (uses `onToggleFeaturedImage=undefined`, verified)          |
+| AC-14              | §5.5, §11.3                                                     | **No — Issue 1 (onSelect=undefined doesn't remove menu items)** + Issue 5 (drop zone still present) |
+| AC-15..AC-17       | §5.2, §5.4, §6.3, OQ-4                                          | Yes                                                             |
+| AC-18              | §6.1 Part 2, §12                                                | Yes (verified: `render_block_data` mutation propagates via `$parsed_block['attrs']` lazy init in WP_Block::__get) |
+| AC-19              | §6.2, OQ-3                                                      | Yes                                                             |
+| AC-20              | §12                                                             | Yes                                                             |
+| AC-21              | §6.1, Risk 4                                                    | Yes                                                             |
+| AC-22..AC-24       | §11.3                                                           | Partial — depends on Issue 1                                    |
+| AC-25              | §6.5                                                            | Yes                                                             |
+| AC-26              | §2.2, §6.1                                                      | Yes                                                             |
+| AC-27              | §12                                                             | Yes                                                             |
+| AC-28              | §12                                                             | Yes                                                             |
+
+## Iter-1 finding resolution check
+
+| Iter-1 Issue | Status | Notes |
+| ---- | ---- | ---- |
+| 1 — non-existent Tag-Processor methods | Resolved | Replaced with `preg_match` + `substr` splice (§3 OQ-3); explicit acknowledgement of the iter-1 finding. |
+| 2 — `cover-placeholder.js` second toggle site | Resolved | Empty-cover branch gated in `index.js` (§5.4 (1)); line-750 `<CoverPlaceholder>` uses `disableMediaButtons` (§5.5). See Issue 5 for a residual drop-zone nuance. |
+| 3 — AC-18 first-pass injection | Resolved | `render_block_data` filter mutates `$parsed_block['attrs']['useFeaturedImage']` BEFORE `WP_Block::__construct` (§6.1 Part 2). Verified against `wp-includes/blocks.php:2398-2436` and `wp-includes/class-wp-block.php:127-236, 520-596`. |
+| 4 — §2.2 / §5.5 contradiction | Resolved | §2.2 explicitly says "`cover-placeholder.js` is NOT touched"; §5.4 and §5.5 agree. |
+| 5 — test signal primary/secondary | Resolved | §3 OQ-6 names i18n string primary, `data-testid` secondary; §11.3 e2e uses `getByText`. |
+| 6 — embed-video MenuItem hidden | Resolved | `<MediaReplaceFlow>` remains rendered; embed `<MenuItem>` preserved (§5.5). |
+| 7 — race-token guard placement | Resolved | `raceTokenRef` declared explicitly at component top with rationale (§5.2, §13). |
+| 8 — useSelect re-renders | Resolved | Single-closure `useSelect` reads source + attachment record together (§5.1 step 3). See Issue 2 for the wrong-store nuance. |
+| 9 — AC-26/27/28 traces missing | Resolved | §12 has explicit bullets for each. |
+| 10 — `gutenberg_cover_bindings_expand` undefined | Resolved | Renamed `gutenberg_cover_bindings_is_active`; definition described in §6.1. See Issue 3 for residual ambiguity. |
+| 11 — backport-changelog wording | Resolved | §2.2 last row explicit. |
+
+## Open Questions resolution check
+
+| OQ    | Choice                          | Rationale + rejected alternatives traced | Verdict                                  |
+| ----- | ------------------------------- | ----------------------------------------- | ---------------------------------------- |
+| OQ-1  | Approach A                      | Yes, with trade-off table in §13          | OK                                       |
+| OQ-2  | Disable                         | Yes                                       | OK                                       |
+| OQ-3  | `preg_match` + `substr` splice  | Yes; rejected alternatives spelled out    | OK                                       |
+| OQ-4  | 50                              | Yes                                       | OK                                       |
+| OQ-5  | Render-time force-off           | Yes                                       | OK                                       |
+| OQ-6  | i18n string primary             | Yes; `data-testid` secondary              | OK                                       |
+
+## Risks mitigation check
+
+| Risk                                          | Mitigation                                                           | Adequate                                  |
+| --------------------------------------------- | -------------------------------------------------------------------- | ----------------------------------------- |
+| 1. Ockham single-observer                     | §5.2 single useEffect on `effectiveUrl`, useEffectEvent              | Yes                                       |
+| 2. Pattern Overrides reset                    | §5.6 reuse withPatternOverrideControls + ResetOverridesControl       | Yes                                       |
+| 3. dimRatio: 100 default                      | §5.2/§5.4 effectiveDimRatio + §6.3 server class strip                | Yes                                       |
+| 4. Embed-video collision                      | §6.1 short-circuit at both ends                                      | Yes                                       |
+| 5. HTML API can't edit CSS-in-`style`         | §6.2 element-replace via `preg_match` + `substr`                     | Yes                                       |
+
+## Verification notes (for the orchestrator)
+
+For transparency, the following load-bearing claims in iter-2 were verified against actual source code in this review pass:
+
+- **`render_block_data` signature and timing** — `wp-includes/blocks.php:2398` fires `apply_filters( 'render_block_data', $parsed_block, $source_block, $parent_block )`; `new WP_Block( $parsed_block, ... )` at line 2436 reads from the mutated `$parsed_block`. Inner-block path at `wp-includes/class-wp-block.php:561` reassigns `$inner_block->parsed_block`. Lazy `$this->attributes` init at `class-wp-block.php:223-236` reads from `$this->parsed_block['attrs']` — confirms the mutation propagates. ✓
+- **`WP_HTML_Tag_Processor` public methods** — `next_tag` (line 887), `class_list` (1181), `has_class` (1240), `get_attribute` (2772), `set_attribute` (4310), `add_class` (4539), `remove_class` (4581), `get_updated_html` (4637) all confirmed public in `wp-includes/html-api/class-wp-html-tag-processor.php`. ✓
+- **`useEffectEvent` export** — Exported from `packages/element/src/react.ts:218` and re-exported via `packages/element/src/index.ts:2`. ✓
+- **`<MediaReplaceFlow>` gating** — `packages/block-editor/src/components/media-replace-flow/index.js`: `onToggleFeaturedImage` gates "Use featured image" `<MenuItem>` (line 233); `mediaURL && onReset` gates "Reset" `<MenuItem>` (line 245); `<MediaUpload>` + `<FormFileUpload>` for "Open Media Library" + "Upload" are NOT gated on `onSelect` (lines 193–232). ✗ Design's claim is wrong — see Issue 1.
+- **`<MediaPlaceholder disableMediaButtons>` behaviour** — `packages/block-editor/src/components/media-placeholder/index.js:551-552` confirms `disableMediaButtons` returns the drop-zone-only renderPath. The drop zone IS still rendered. See Issue 5.
+- **`getBlockBindingsSource` location** — Direct export at `packages/blocks/src/api/registration.ts:903`; private selector on the `@wordpress/blocks` store at `packages/blocks/src/store/private-selectors.ts:252-257`. NOT on the block-editor store. ✗ Design's `select( blockEditorStore ).getBlockBindingsSource(...)` is incorrect — see Issue 2.
+- **`replacePatternOverridesDefaultBinding` signature** — `packages/block-editor/src/utils/block-bindings.js:27-46`. ✓ Matches design's usage.
+- **`gutenberg_block_bindings_render_block` priority 10** — `lib/compat/wordpress-6.9/block-bindings.php:108`. ✓ Design's priority-9 placement is consistent.
+- **6.9 compat `__default` expansion** — `lib/compat/wordpress-6.9/block-bindings.php:257-281`. ✓ Matches the reference cited in design §6.1 and §9.
+- **`render_block_core_cover` early-return on `useFeaturedImage=false`** — `packages/block-library/src/cover/index.php:133` confirms `if ( 'image' !== $attributes['backgroundType'] || false === $attributes['useFeaturedImage'] ) { return $content; }`. ✓ AC-18 mechanism is sound.

From 9c94e09f520c9b212c3d9326752c26f4f1710e54 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:20:58 +0200
Subject: [PATCH 16/60] docs(pipeline): revise 2-design-doc/design-doc.md for
 77199-cover-bindings-id-url-internal (iter 3)

Address design-doc-review-2-rejected.md findings.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../2-design-doc/design-doc.md                | 187 ++++++++++++++----
 1 file changed, 149 insertions(+), 38 deletions(-)

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
index 43561fe47d4767..e774c0fea5eba3 100644
--- a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
+++ b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
@@ -66,9 +66,9 @@ Spec: `<artifacts>/1-spec/spec.md` (approved). All AC, DC, Req references resolv
 | `packages/block-library/src/cover/block.json` | Attribute schema | Add `"role": "content"` to `id` (AC-1, AC-2 prerequisite) |
 | `lib/compat/wordpress-7.1/block-bindings.php` (NEW) | Server allow-list + Cover-scoped render filters | (a) `block_bindings_supported_attributes` filter adds `id`,`url` to `core/cover`; (b) `render_block_data` filter to neutralise `useFeaturedImage` before `render_callback`; (c) `gutenberg_cover_bindings_render_block` filter on `render_block` priority 9 |
 | `lib/load.php` | Bootstrap | `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';` in the REST-server block (alongside other 7.1 entries) |
-| `packages/block-library/src/cover/edit/index.js` | Reactive observer, derived values, render-tree gating | New `useCoverBindingState` hook, replace existing `useEffect([mediaUrl])` with a single observer on `effectiveUrl`, gate the empty-cover branch on `bindingActive || bindingUnresolvable`, render the `<Placeholder>` for the unresolvable case inline. |
+| `packages/block-library/src/cover/edit/index.js` | Reactive observer, derived values, render-tree gating | New `useCoverBindingState` hook, replace existing `useEffect([mediaUrl])` with a single observer on `effectiveUrl`, gate the empty-cover branch on `bindingActive \|\| bindingUnresolvable`, render the `<Placeholder>` for the unresolvable case inline, AND wrap the line-750 `<CoverPlaceholder>` call site in `! bindingActive && (…)` so the drop zone is not present on bound covers (§5.5 / Issue 5 of iter-2 review). |
 | `packages/block-library/src/cover/edit/inspector-controls.js` | UI gating | Gate parallax/repeat ToolsPanelItems on `! bindingActive` |
-| `packages/block-library/src/cover/edit/block-controls.js` | UI gating | Pass `bindingActive` and gate the "Use featured image" toggle (set `onToggleFeaturedImage={ bindingActive ? undefined : toggleUseFeaturedImage }`) AND the media-replace `onSelect` (set `onSelect={ bindingActive ? undefined : onSelectMedia }`). The "Embed video from URL" `<MenuItem>` child of `<MediaReplaceFlow>` MUST remain unconditionally accessible (preserves AC-21 affordance). |
+| `packages/block-library/src/cover/edit/block-controls.js` | UI gating | Pass `bindingActive`. Render `<MediaReplaceFlow>` ONLY when `! bindingActive`. The "Embed video from URL" `<MenuItem>` is dropped from the bound-cover toolbar by construction; this is acceptable because (a) embed-video × bindings is explicitly out-of-scope per spec Out-of-Scope, (b) AC-21's "no regression on embed-video" only applies to covers where `backgroundType === 'embed-video'`, which (per §5.1 step 2) forces `bindingActive = false`, so the `<MediaReplaceFlow>` remains rendered there. See §5.5 for the full rationale and the verified gating mechanism. |
 | `phpunit/blocks/render-block-cover-test.php` | PHPUnit | New cases: bound-url → `<img src=$bound>`; default `dimRatio:100` + binding → `has-background-dim-50`; mismatched/unresolvable → no `<img>`; `useFeaturedImage:true + bindingActive` → exactly one `<img>` with bound URL |
 | `test/e2e/specs/editor/blocks/cover.spec.js` | E2E | New `describe('Block Bindings — Pattern Overrides')` block (AC-22..AC-24) |
 | `backport-changelog/7.1/<core-pr>.md` | Metadata | Created at the same time the Core PR is filed; Gutenberg PR description includes a `TODO: backport-changelog entry pending Core PR` note and is updated once the Core PR number is known. Not a blocker for the Gutenberg PR landing. |
@@ -251,15 +251,17 @@ export default function useCoverBindingState( { clientId, attributes, context }
 Implementation outline:
 1. Expand `attributes.metadata?.bindings` via `replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] )` from `packages/block-editor/src/utils/block-bindings.js`.
 2. `bindingActive = expanded?.id && expanded?.url && expanded.id.source === expanded.url.source && JSON.stringify(expanded.id.args ?? null) === JSON.stringify(expanded.url.args ?? null) && backgroundType !== 'embed-video'`.
-3. Resolve values via **a single `useSelect`** that reads both the bound URL and ID and the attachment record in one closure, deduplicating subscription work:
+3. Resolve values via **a single `useSelect`** that reads both the bound URL and ID and the attachment record in one closure, deduplicating subscription work. `getBlockBindingsSource` is imported directly from `@wordpress/blocks` — it is a registry lookup (not a state-dependent selector) verified at `packages/blocks/src/api/registration.ts:903-907` as a module-level export that internally calls `select( blocksStore ).getBlockBindingsSource( name )`. The `@wordpress/blocks` store is the canonical home of the bindings-source registry (private selector at `packages/blocks/src/store/private-selectors.ts:252`); it is NOT on `blockEditorStore`. Existing trunk callers follow the same pattern (`packages/block-editor/src/components/block-bindings/source-fields-list.js:9`, `packages/block-editor/src/components/rich-text/index.js:23`).
 
    ```js
+   import { getBlockBindingsSource } from '@wordpress/blocks';
+   // ... inside the hook body:
    const { bindingResolvedUrl, bindingResolvedId, bindingResolvedAttachment } =
        useSelect( ( select ) => {
            if ( ! bindingActive ) {
                return { bindingResolvedUrl: undefined, bindingResolvedId: undefined, bindingResolvedAttachment: undefined };
            }
-           const source = unlock( select( blockEditorStore ) ).getBlockBindingsSource( expanded.url.source );
+           const source = getBlockBindingsSource( expanded.url.source );
            if ( ! source ) {
                return { bindingResolvedUrl: undefined, bindingResolvedId: undefined, bindingResolvedAttachment: undefined };
            }
@@ -389,7 +391,20 @@ if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground ) {
 }
 ```
 
-The standard `<CoverPlaceholder>` continues to render in the unbound empty-cover branch and (lower in the component, line 750) inside the `<TagName>` with `disableMediaButtons`. **That second `<CoverPlaceholder>` (line 750) is also reached on bound covers** (when `hasBackground` is true), but it is rendered with `disableMediaButtons` — `<MediaPlaceholder>`'s `disableMediaButtons` prop hides the upload-via-DropZone and featured-image affordances. (Verified in `@wordpress/block-editor`'s `MediaPlaceholder`: `disableMediaButtons` short-circuits the upload-zone and gallery-toggle rendering.) Therefore no additional gating is required at that site.
+The standard `<CoverPlaceholder>` continues to render in the unbound empty-cover branch (this branch in §5.4 (1)) and (lower in the component, line 750) inside the `<TagName>`. **The line-750 `<CoverPlaceholder>` IS reached on bound covers when `hasBackground=true`**; verified at `packages/block-editor/src/components/media-placeholder/index.js:551-552`, `disableMediaButtons` short-circuits to `<MediaUploadCheck>{ renderDropZone() }</MediaUploadCheck>` — the upload / media-library / featured-image buttons are hidden, but the drop zone IS still rendered. The drop-zone's `onFilesDrop` is wired (line 385) to the parent's `onFilesUpload`, which in `cover-placeholder.js:22-26` calls `onSelectMedia({ url: createBlobURL(file) })` — mutating the cover's `url` attribute. To keep AC-14 / Req 7's intent ("direct media replacement from inside the Cover is not offered when bound") whole, the line-750 site is gated at its call site in `index.js`:
+
+```jsx
+{ ! bindingActive && (
+    <CoverPlaceholder
+        disableMediaButtons
+        onSelectMedia={ onSelectMedia }
+        onError={ onUploadError }
+        toggleUseFeaturedImage={ toggleUseFeaturedImage }
+    />
+) }
+```
+
+This is a one-line wrapper added immediately around the existing line-750 call site. On unbound covers (`bindingActive=false`), the behaviour is byte-identical to trunk (AC-20). On bound covers, the entire `<CoverPlaceholder>` — including its drop zone — is omitted from the render tree. `cover-placeholder.js` itself is NOT edited (§2.2 invariant preserved). See §13 trade-off table "Line-750 `<CoverPlaceholder>` drop-zone" for alternatives considered.
 
 **(2) Non-empty render branch (around `url && isImageBackground` at index.js line 672):**
 
@@ -427,41 +442,67 @@ And the overlay span class computation uses `effectiveDimRatio` rather than `dim
 
 **`inspector-controls.js`** — wrap the `<>` fragment containing the "Fixed background" and "Repeated background" `ToolsPanelItem`s in `! bindingActive && …`. Pass `bindingActive` as a new prop from `CoverEdit`.
 
-**`block-controls.js`** — the `<MediaReplaceFlow>` element MUST remain rendered in both bound and unbound states, because the "Embed video from URL" `<MenuItem>` is its child and AC-21 requires that affordance to remain accessible on embed-video covers regardless of binding presence. Gating is done at the **prop level**, not by removing the `<MediaReplaceFlow>` wrapper:
+**`block-controls.js`** — the entire `<MediaReplaceFlow>` element is conditionally rendered. When `! bindingActive`, the current trunk shape is preserved verbatim (including the "Embed video from URL" `<MenuItem>` child). When `bindingActive`, the `<MediaReplaceFlow>` is omitted from the render output entirely; the `<BlockControls group="other">` group renders empty (or is itself elided), and no media-replace / upload / featured-image / embed-URL affordances exist on the bound-cover toolbar:
 
 ```jsx
-<MediaReplaceFlow
-    mediaId={ id }
-    mediaURL={ url }
-    allowedTypes={ ALLOWED_MEDIA_TYPES }
-    onSelect={ bindingActive ? undefined : onSelectMedia }
-    onToggleFeaturedImage={ bindingActive ? undefined : toggleUseFeaturedImage }
-    useFeaturedImage={ bindingActive ? undefined : useFeaturedImage }
-    name={ ! url ? __( 'Add media' ) : __( 'Replace' ) }
-    onReset={ bindingActive ? undefined : onClearMedia }
-    variant="toolbar"
->
-    { ( { onClose } ) => (
-        <MenuItem
-            icon={ link }
-            onClick={ () => {
-                setIsEmbedUrlInputOpen( true );
-                onClose();
-            } }
+<BlockControls group="other">
+    { ! bindingActive && (
+        <MediaReplaceFlow
+            mediaId={ id }
+            mediaURL={ url }
+            allowedTypes={ ALLOWED_MEDIA_TYPES }
+            onSelect={ onSelectMedia }
+            onToggleFeaturedImage={ toggleUseFeaturedImage }
+            useFeaturedImage={ useFeaturedImage }
+            name={ ! url ? __( 'Add media' ) : __( 'Replace' ) }
+            onReset={ onClearMedia }
+            variant="toolbar"
         >
-            { __( 'Embed video from URL' ) }
-        </MenuItem>
+            { ( { onClose } ) => (
+                <MenuItem
+                    icon={ link }
+                    onClick={ () => {
+                        setIsEmbedUrlInputOpen( true );
+                        onClose();
+                    } }
+                >
+                    { __( 'Embed video from URL' ) }
+                </MenuItem>
+            ) }
+        </MediaReplaceFlow>
     ) }
-</MediaReplaceFlow>
+</BlockControls>
 ```
 
-`MediaReplaceFlow` (verified at `packages/block-editor/src/components/media-replace-flow/`) renders the "Use featured image" toggle ONLY when `onToggleFeaturedImage` is a function; setting it to `undefined` removes that menu item from the dropdown. Same for `onSelect` (the upload + media-library buttons short-circuit when `onSelect` is falsy). `onReset` undefined removes the "Reset" menu item. The "Embed video from URL" `<MenuItem>` child is unaffected — it is rendered through `MediaReplaceFlow`'s `children` prop and surfaces unconditionally inside the dropdown. AC-13, AC-14 satisfied without hiding the embed affordance (AC-21 preserved).
+**Why conditional render and NOT prop-level gating.** Verified against `packages/block-editor/src/components/media-replace-flow/index.js`:
+- Line 233: the "Use featured image" `<MenuItem>` IS gated on `onToggleFeaturedImage &&` — prop-level `undefined` does remove it.
+- Line 245: the "Reset" `<MenuItem>` IS gated on `mediaURL && onReset &&` — prop-level `undefined` does remove it.
+- Lines 193–212: the `<MediaUpload>` ("Open Media Library") and `<FormFileUpload>` ("Upload") `<MenuItem>`s render unconditionally inside `<MediaUploadCheck>`. **Neither is gated on `onSelect`.** Setting `onSelect={ undefined }` does NOT remove them from the dropdown. Worse: line 115 calls `onSelect( media )` directly from the internal `selectMedia` helper, and line 124 calls `onSelect( files )` directly from `uploadFiles`. Setting `onSelect={ undefined }` would crash with `TypeError: onSelect is not a function` when a user clicks "Open Media Library" or "Upload". The prior-iteration prop-level gating approach was therefore a runtime hazard.
+
+Removing the entire `<MediaReplaceFlow>` is the only mechanism that achieves AC-14's literal-DOM-absence wording (the toolbar's media-replace dropdown is not present at all when `bindingActive`).
+
+**Why losing the "Embed video from URL" affordance on bound covers is acceptable.** AC-21 requires non-regression for covers with `backgroundType === 'embed-video'`. Per §5.1 step 2, embed-video covers force `bindingActive = false` (the guard `backgroundType !== 'embed-video'` is part of the active-binding predicate). So embed-video covers ALWAYS render the full `<MediaReplaceFlow>` including the embed-URL menu item — AC-21 is preserved. The only case that loses the embed-URL menu item is a bound non-embed-video cover, where the user has actively chosen to bind `id`+`url` to a media-library attachment; converting such a cover to embed-video is out-of-scope under "Embed-video × bindings interaction" in the spec's Out-of-Scope section, and the user can unbind first if needed. This trade-off is explicit and tied to the resolved Out-of-Scope item.
 
-**Verification of AC-14 surface coverage.** AC-14 requires the media-replace control to be NOT in the DOM. The `<MediaReplaceFlow>` toolbar button remains in the DOM under the gating above (because it still hosts the embed `<MenuItem>`); the dropdown's media-replace and use-featured-image menu items are gone. **This is a minor stretch of the AC-14 literal wording.** AC-14's intent (Req 7) is that direct media replacement from inside the Cover is not offered when bound. Setting `onSelect` / `onToggleFeaturedImage` / `onReset` to `undefined` removes the media-replace and featured-image menu items from the dropdown. The remaining `<MediaReplaceFlow>` toolbar button surfaces only the "Embed video from URL" affordance, which is explicitly preserved by AC-21. The e2e test (§11.3) asserts on the absence of the media-replace and featured-image **menu items**, not on the absence of the `<MediaReplaceFlow>` toolbar button. **If reviewers insist on absolute absence of `<MediaReplaceFlow>` from the DOM**, the spec must be re-opened to reconcile AC-14 vs AC-21; the design's current reading prioritises AC-21's explicit "no observable runtime effect under this PR" against AC-14's literal DOM-absence wording, because AC-21 is the more specific contract for the embed-video case.
+**Verification of AC-14 surface coverage (post-fix).** AC-14 requires the media-replace control to be NOT in the DOM. Under the conditional render above, `<MediaReplaceFlow>` is completely absent from the bound-cover DOM. The e2e test (§11.3) asserts on the absence of the toolbar replace-button (the rendered `<ToolbarButton>` from `<MediaReplaceFlow>`'s `renderToggle` path at lines 180–189 of media-replace-flow/index.js) — a single locator. AC-13 (Use featured image) and AC-14 (media-replace) are both satisfied by the wrapper's absence; no need to reason about individual `<MenuItem>` gating any more.
 
-**`cover-placeholder.js` itself is not modified.** Its sole call sites are in `index.js` (lines 616 and 750). The line-616 site is now unreachable under `bindingActive || bindingUnresolvable` (replaced by the binding-aware placeholder branch in §5.4 (1)). The line-750 site is reached on bound covers but uses `disableMediaButtons`, which removes both the upload and the featured-image affordance from `<MediaPlaceholder>`. AC-13, AC-14, Req 7 satisfied without editing `cover-placeholder.js`.
+**`cover-placeholder.js` itself is not modified.** Its sole call sites are in `index.js` (lines 616 and 750). The line-616 site is now unreachable under `bindingActive || bindingUnresolvable` (replaced by the binding-aware placeholder branch in §5.4 (1)). The line-750 site is reached on bound covers (when `hasBackground === true`) but renders `<CoverPlaceholder disableMediaButtons … />`. Verified at `packages/block-editor/src/components/media-placeholder/index.js:551-552`: when `disableMediaButtons` is true, only the drop zone renders (no upload / media-library / featured-image buttons). The drop-zone IS still rendered, however, and its `onFilesDrop` is wired to `onFilesUpload` (line 385), which in `cover-placeholder.js:22-26` calls `onSelectMedia({ url: createBlobURL(file) })`. **A user dragging a file onto a bound cover would still mutate the cover's `url` attribute** through `onSelectMedia`. This is a *user-initiated* mutation (DC-2 only prohibits derivation-path mutation triggered by binding state changes), so DC-2 is technically satisfied; however, AC-14 / Req 7's *intent* is "direct media replacement from inside the Cover is not offered when bound", and a drop zone IS an alternative form of media-replace surface.
 
-**`<MediaReplaceFlow>` "Use featured image" toggle** is gated by setting `onToggleFeaturedImage` to `undefined` (above). AC-13 satisfied. **Inspector-controls.js does NOT separately render a use-featured-image toggle**, verified by inspection — there is no second inspector site.
+To resolve this cleanly without editing `cover-placeholder.js`, the line-750 site is gated at its call site in `index.js`: render the `<CoverPlaceholder>` only when `! bindingActive`. `MediaPlaceholder`'s `disableDropZone` prop (verified at `packages/block-editor/src/components/media-placeholder/index.js:378-381`: `if ( disableDropZone ) { return null; }` short-circuits drop-zone rendering) is an alternative — but the call site is in `index.js`, and gating the whole `<CoverPlaceholder>` is the surgical one-line change. Concrete edit at index.js line 750:
+
+```jsx
+{ ! bindingActive && (
+    <CoverPlaceholder
+        disableMediaButtons
+        onSelectMedia={ onSelectMedia }
+        onError={ onUploadError }
+        toggleUseFeaturedImage={ toggleUseFeaturedImage }
+    />
+) }
+```
+
+`bindingActive=false` covers (the entire pre-bindings universe of Covers) keep the current `<CoverPlaceholder>` behaviour byte-for-byte. AC-13, AC-14, AC-20 (non-regression) all satisfied; Req 7's intent honoured; `cover-placeholder.js` source unchanged.
+
+**`<MediaReplaceFlow>` "Use featured image" toggle** is removed alongside the rest of `<MediaReplaceFlow>` by the conditional render above. AC-13 satisfied. **Inspector-controls.js does NOT separately render a use-featured-image toggle**, verified by inspection — there is no second inspector site.
 
 ### 5.6 Pattern Overrides integration
 
@@ -534,7 +575,21 @@ if ( ! function_exists( 'gutenberg_cover_bindings_prepare_block' ) ) {
 }
 ```
 
-`gutenberg_cover_bindings_is_active( $attrs )` is a private helper defined in the same file. It applies `__default` expansion (via inline logic copied from `lib/compat/wordpress-6.9/block-bindings.php:257-281`, scoped to `[ 'id', 'url' ]`), checks both bindings exist and resolve to the same source instance, and returns a bool. **This replaces the previously-undefined `gutenberg_cover_bindings_expand` helper.**
+`gutenberg_cover_bindings_is_active( $attrs )` is a private helper defined in the same file. It applies `__default` expansion (via inline logic copied from `lib/compat/wordpress-6.9/block-bindings.php:257-281`, scoped to `[ 'id', 'url' ]`), then checks both bindings exist AND resolve to the same source instance via the following two-part equality, mirroring §5.1 step 2's client-side check:
+
+```php
+$same_source = ( $expanded['id']['source'] ?? null ) === ( $expanded['url']['source'] ?? null );
+$same_args   = ( $expanded['id']['args']   ?? null ) ==  ( $expanded['url']['args']   ?? null );
+// Note: `==` (loose) compares associative arrays element-wise irrespective of key order;
+// `===` would require identical key ordering. Loose comparison is the correct semantic
+// for source `args` (a small associative bag of scalars), and it matches the JS-side
+// JSON.stringify check (which is order-sensitive only on object literals — and source
+// args in practice come from the same builder for both `id` and `url` of a Cover, so
+// key order is identical in real shapes; loose-equality is the safe relaxation).
+return $same_source && $same_args && ! empty( $expanded['id'] ) && ! empty( $expanded['url'] );
+```
+
+The bool result is what gates Part 2's `useFeaturedImage` mutation and Part 3's URL substitution. **This replaces the previously-undefined `gutenberg_cover_bindings_expand` helper.** Spec Req 26 / Glossary "Active binding" explicitly require `args` equality where applicable; the explicit check here closes the client/server agreement gap.
 
 **Why `render_block_data` solves the AC-18 first-pass injection problem.** Verified at `/Users/carlos/.wp-env/cc4ba7b5738d99b49b19f399987f6e49/WordPress/wp-includes/class-wp-block.php:531-596`: `WP_Block::render()` calls `process_block_bindings()` (line 532), merges resolved bindings into `$this->attributes` (lines 534-536), and then calls `render_callback` (line 596). The `render_block_data` filter runs **before** `WP_Block::render()` is constructed (`render_block()` in `wp-includes/blocks.php:2398` applies it on the parsed block array). By that point, `$parsed_block['attrs']['useFeaturedImage']` has been forced to `false`, so:
 
@@ -632,7 +687,29 @@ Idempotent (calling twice is harmless). Targets the overlay span only; the `has-
 
 ### 6.4 Helper: `gutenberg_cover_bindings_strip_image`
 
-For the unresolvable / mismatched / external-URL case (Req 20, AC-5, AC-6): use the same `preg_match` + `substr`-splice approach (form-2 pattern, plus a form-1 pattern for plain `<img>`) to **remove** any element with class `wp-block-cover__image-background` from `$content`. The cover renders without an image element, overlay-only.
+For the unresolvable / mismatched / external-URL case (Req 20, AC-5, AC-6): use the same `preg_match` + `substr`-splice approach to **remove** any element with class `wp-block-cover__image-background` from `$content`. The cover renders without an image element, overlay-only.
+
+Two patterns are tried in sequence (whichever matches first wins; both forms never co-exist in a Cover's saved markup because `save.js` emits exactly one image element):
+
+```php
+// Form 2: parallax/repeat saved form — a self-closed empty <div>.
+$form2_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
+
+// Form 1: plain saved form — a void <img> (with or without trailing slash).
+// Matches everything up to the closing ">"; void elements have no </img>.
+$form1_pattern = '/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?\s*>/U';
+
+foreach ( array( $form2_pattern, $form1_pattern ) as $pattern ) {
+    if ( 1 === preg_match( $pattern, $content, $matches, PREG_OFFSET_CAPTURE ) ) {
+        $start  = $matches[0][1];
+        $length = strlen( $matches[0][0] );
+        return substr( $content, 0, $start ) . substr( $content, $start + $length );
+    }
+}
+return $content;
+```
+
+The `U` (ungreedy) modifier is essential for both patterns — without it, `[^>]*` would greedily span past intermediate `>` boundaries when other attributes contain `>` literals (rare but possible in well-formed but edge-case markup). The form-1 pattern matches both XHTML-style `<img ... />` and HTML5-style `<img ... >` because `\/?\s*>` makes the trailing slash optional. Both patterns are scoped by the `\b...\b` word-boundary anchor around the class name, ensuring matches only on elements that actually carry the `wp-block-cover__image-background` class (not coincidental substring hits on neighbouring attributes).
 
 ### 6.5 PHPUnit coverage
 
@@ -729,9 +806,12 @@ test.describe( 'Block Bindings — Pattern Overrides round-trip', () => {
         // 3. Assert (default state):
         //    - Editor preview <img src> points at defaultMedia.url.
         //    - Parallax / Repeat ToolsPanelItems are not visible (AC-11, AC-12).
-        //    - <MediaReplaceFlow> "Use featured image" MenuItem is not visible (AC-13).
-        //    - <MediaReplaceFlow> upload/replace MenuItems are not visible (AC-14).
-        //    - <MediaReplaceFlow> "Embed video from URL" MenuItem IS visible (AC-21 preserved).
+        //    - <MediaReplaceFlow> toolbar dropdown button is not in the DOM (AC-13 + AC-14).
+        //      The single locator `page.getByRole('button', { name: /^(Replace|Add media)$/ })`
+        //      should resolve to zero matches inside the Cover's BlockControls toolbar.
+        //    - On a SEPARATE embed-video Cover (control case), the same button IS visible
+        //      with the "Embed video from URL" MenuItem accessible (AC-21 preserved on
+        //      the population where `backgroundType === 'embed-video'`).
         //    - Overlay span class does NOT contain 'has-background-dim-100' (AC-15).
         //    - ResetOverridesControl toolbar button is disabled (AC-10, OQ-2).
         // 4. Override the instance: programmatically setBlockAttributes with new url+id.
@@ -761,7 +841,7 @@ Existing `cover.spec.js` cases run untouched. Existing `packages/block-library/s
 - **Unbound covers untouched.** All gating predicates (`bindingActive`, the server filters' early-return on `! gutenberg_cover_bindings_is_active( $attrs )`) flip false when `metadata.bindings` is absent. The new code path is dead code on every existing unbound cover. AC-20.
 - **No `save.js` change.** The serialized markup shape is identical to trunk. Deprecation chain unchanged. AC-20.
 - **No new attribute.** `id` gains a `role: "content"` annotation only — metadata-only, not part of the saved markup.
-- **Embed-video carve-out.** Both client and server short-circuit on `backgroundType === 'embed-video'`, regardless of binding presence. AC-21. The "Embed video from URL" menu item under `<MediaReplaceFlow>` remains accessible on bound covers (regardless of `backgroundType`), preserving the affordance per AC-21.
+- **Embed-video carve-out.** Both client and server short-circuit on `backgroundType === 'embed-video'`, regardless of binding presence. AC-21. On embed-video covers, `bindingActive=false` per §5.1 step 2, so `<MediaReplaceFlow>` (including the "Embed video from URL" `<MenuItem>` child) renders as on trunk — the affordance is fully preserved on the AC-21 population. On bound NON-embed-video covers, `<MediaReplaceFlow>` is conditionally omitted (§5.5), so the embed-URL menu item is unreachable there; this is consistent with the Out-of-Scope "Embed-video × bindings interaction" bullet (the bound→embed-video conversion path is not supported in this PR).
 - **`useFeaturedImage` precedence rule (AC-18).** When both `useFeaturedImage: true` and an active binding co-exist on the same cover, the binding wins. Mechanism: the `render_block_data` filter (§6.1 Part 2) mutates `$parsed_block['attrs']['useFeaturedImage'] = false` BEFORE `render_callback` runs, so `render_block_core_cover` skips its featured-image injection branch. The stored `useFeaturedImage` attribute on the post content is NOT mutated (the mutation is to the in-flight `$parsed_block` array, scoped to this single render pass). DC-2 is preserved on the persistence path (no `setAttributes` on client, no persisted post_content change on server). On the client, `bindingActive` is derived from the persisted attribute state including `useFeaturedImage`; if a saved Cover has both `useFeaturedImage: true` and bindings, the editor's `effectiveUrl` prefers `bindingResolvedUrl` over `mediaUrl` per §5.2, matching the server's precedence. AC-18 satisfied.
 - **`! function_exists` / version guards.** The new compat file follows the established pattern from `lib/compat/wordpress-6.9/block-comments.php:63,84`. Graceful degradation on a WP install lacking the bindings infrastructure (Req 39). The Cover Edit component's new hook reads `metadata?.bindings` defensively — when `__experimentalBlockBindingsSupportedAttributes['core/cover']` is undefined (pre-7.1 server), `bindingActive` returns false and the existing code path runs.
 - **AC-26 (PR shape — file path).** The new compat file lives at `lib/compat/wordpress-7.1/block-bindings.php` and is loaded via `lib/load.php`. No file under `lib/compat/wordpress-7.0/`. See §2.2 and §6.1.
@@ -815,6 +895,37 @@ Alt B (the prior design's approach) leaves a window in which `render_callback` e
 
 The chosen `render_block_data` approach intercepts at the parsed-block level, before `WP_Block::render` even begins. Verified at `wp-includes/blocks.php:2398` and `wp-includes/class-wp-block.php:531-596`. DC-2 is preserved because the mutation is on the in-flight `$parsed_block` array passed by reference for this render only — the persisted post_content is not touched.
 
+### AC-14 gating: conditional render vs prop-level `undefined` vs upstream change
+
+Three options considered for hiding `<MediaReplaceFlow>` on bound covers:
+
+| | Chosen: conditional render in block-controls.js | Alt A: prop-level undefined (iter-2 design) | Alt B: modify `<MediaReplaceFlow>` upstream |
+| --- | --- | --- | --- |
+| AC-14 literal DOM absence | Yes | **No** — toolbar button + Open Media Library + Upload menu items remain | Yes (if upstream gate added) |
+| Runtime safety | Safe | **Crash** — clicking "Open Media Library" or "Upload" calls `onSelect(media)` with `onSelect=undefined` (verified at `media-replace-flow/index.js:115, 124`) → TypeError | Safe |
+| "Embed video from URL" preserved on bound covers | No (acceptable per §5.5 trade-off) | Yes | Depends on upstream change shape |
+| Shared-component churn | None | None | Significant (affects every `<MediaReplaceFlow>` consumer) |
+| Owner-review cost | Cover-scoped only | Cover-scoped only | Cross-team (block-editor + every consumer) |
+
+Alt A (the iter-2 design) was rejected per the iter-2 review (Issue 1): `<MediaUploadCheck>`-wrapped `<MediaUpload>` ("Open Media Library") and `<FormFileUpload>` ("Upload") render unconditionally at lines 193–232 of `media-replace-flow/index.js`; the internal `selectMedia` helper calls `onSelect(media)` at line 115 and `uploadFiles` calls `onSelect(files)` at line 124, both crashing when `onSelect=undefined`. Prop-level gating works for "Use featured image" (line 233) and "Reset" (line 245) which ARE gated on their callbacks, but not for the upload/media-library paths.
+
+Alt B (upstream gate on `<MediaUploadCheck>` subtree) is the right long-term fix but out-of-scope for this PR — it requires owner-team sign-off and touches every `<MediaReplaceFlow>` consumer.
+
+The chosen conditional render is the smallest correct change. The cost is losing the "Embed video from URL" affordance on bound non-embed-video covers; the §5.5 trade-off section traces this to the Out-of-Scope "Embed-video × bindings interaction" item.
+
+### Line-750 `<CoverPlaceholder>` drop-zone: gate at call site vs `disableDropZone` vs accept
+
+Three options for the line-750 `<CoverPlaceholder disableMediaButtons …/>` site (which on bound covers with `hasBackground=true` still renders a drop zone that calls `onSelectMedia` when files are dropped, verified at `media-placeholder/index.js:378-385, 551-552` and `cover-placeholder.js:22-26`):
+
+| | Chosen: gate at call site `! bindingActive && <CoverPlaceholder …/>` | Alt A: pass `disableDropZone` through `<CoverPlaceholder>` | Alt B: accept the drop-zone as a user-initiated DC-2-exempt path |
+| --- | --- | --- | --- |
+| Lines changed | 1 (wrapper around line-750 site in `index.js`) | 2–3 (add `disableDropZone` prop forwarding in `cover-placeholder.js`) | 0 (documentation only) |
+| Touches `cover-placeholder.js` | No | Yes | No |
+| Honours AC-14 / Req 7 intent (no media-replace surface on bound covers) | Yes | Yes | Stretched (a drop zone IS a media-replace surface) |
+| Unbound-cover non-regression (AC-20) | Identical to trunk when `bindingActive=false` | Identical | Identical |
+
+Chosen approach: gate at the call site. The §2.2 "no `cover-placeholder.js` edits" invariant is preserved. The drop-zone path is removed for bound covers along with the rest of `<CoverPlaceholder>`'s functionality at that site. `bindingUnresolvable` covers fall through the line-616 binding-aware branch in §5.4 (1) and never reach line 750 in any case. The line-750 drop-zone's absence is implicitly covered by the bound-cover render tree no longer including `<CoverPlaceholder>`; an explicit "drag-and-drop on bound cover does not mutate `url`" assertion can be added to the §11.3 e2e plan as a follow-up if reviewers ask.
+
 ### Client-side: source-agnostic observer vs explicit `useBindings` derivation
 
 Considered: a separate `useEffect` keyed on `metadata.bindings` that synchronises a derived `bindingUrl` state into the existing observer. Rejected: that is exactly the multi-`useEffect` proliferation Risk 1 / DC-1 forbid. The chosen design (one effect, keyed on `effectiveUrl`, with `useEffectEvent` for latest-value reads) collapses every URL-derivation trigger into a single signal.
@@ -852,5 +963,5 @@ The design explicitly does NOT implement:
 2. **`gutenberg_cover_bindings_is_active` duplicates `__default` expansion logic** from `lib/compat/wordpress-6.9/block-bindings.php:257-281`. This is intentional (we need the expansion result BEFORE `gutenberg_process_block_bindings` runs, in the `render_block_data` filter, while the generic helper does it inline) but introduces a small divergence risk if Core changes expansion semantics. Mitigation: PHPUnit case §6.5(7) and #6.5(5) catch behavioural divergence; if Core promotes expansion into a public helper, swap to it.
 3. **`gutenberg_process_block_bindings` is called twice per render** (once via `WP_Block::render()` at line 532, once via the priority-10 generic filter's `$instance->render()` re-call). Functionally correct (resolution is idempotent) but wastes work. Acceptable for v1; a future micro-optimisation could cache resolution per `$instance`.
 4. **Race between `attachment` REST loading and `bindingResolvedId` check.** Client-side, the media-library record lookup via `useSelect` returns `undefined` while loading and `null` if resolved-not-found. The hook treats `undefined` as pending (bound-but-pending placeholder per §5.4 (1)) and `null` as unresolvable. There's a transient render where the cover shows the pending placeholder instead of the resolved image — duration is one network round-trip. Acceptable; pattern matches how `core/image` handles the same race.
-5. **AC-14 literal-DOM-absence vs functional-absence.** Design satisfies the *functional* AC-14 (media-replace not offered) by setting `onSelect` / `onToggleFeaturedImage` / `onReset` to `undefined`, leaving the `<MediaReplaceFlow>` toolbar wrapper in the DOM to host the embed `<MenuItem>` (AC-21). If reviewers insist on absolute absence of `<MediaReplaceFlow>`, the spec must be re-opened to reconcile AC-14 vs AC-21. Recommendation: assert on menu-item absence in the e2e test (§11.3), not on `<MediaReplaceFlow>` absence — matches the chosen design.
+5. **AC-14 surface — embed-video affordance trade-off.** The chosen design removes `<MediaReplaceFlow>` from the bound-cover toolbar entirely (literal-DOM-absence per AC-14), which has the side effect of removing the "Embed video from URL" `<MenuItem>` from bound covers. This is acceptable because: (a) embed-video covers force `bindingActive=false` per §5.1 step 2 — so the affordance remains accessible on the population AC-21 actually protects; (b) the Out-of-Scope "Embed-video × bindings interaction" bullet rules out the bound-non-embed-video → bound-embed-video conversion path. The user can unbind a Cover first, then use the embed-URL affordance. Documented in §5.5 and §2.2.
 6. **Backport-changelog entry timing.** `backport-changelog/7.1/<core-pr>.md` is created when the corresponding Core PR is filed; not a blocker for the Gutenberg PR landing. The Gutenberg PR description includes a `TODO: backport-changelog entry pending Core PR #NNN` note and is updated once the Core PR number is known.

From 29cf00994f8a3eea52c693d5dbc10d821fedc42f Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:23:01 +0200
Subject: [PATCH 17/60] docs(pipeline): add
 2-design-doc/design-doc-review-approved.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../design-doc-review-approved.md             | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-approved.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-approved.md
new file mode 100644
index 00000000000000..149ccfd31d9ef2
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-approved.md
@@ -0,0 +1,73 @@
+# Design Doc Review
+
+## Verdict: approved
+
+## Summary
+
+Iter-3 resolves every iter-2 finding cleanly and introduces no new blockers. The design is now implementation-ready: every spec AC traces to a concrete mechanism, all load-bearing code references are verified against trunk, and the previously-flagged runtime hazards (`<MediaReplaceFlow>` `onSelect=undefined` crash, wrong-store `getBlockBindingsSource` lookup, missing form-1 strip pattern, drop-zone leak at line-750, ambiguous `args` equality in the PHP helper) are each addressed with explicit code shapes and trade-off discussion. The trade-off tables in §13 (server approach, AC-18 mitigation, AC-14 gating, line-750 drop-zone) give implementers and reviewers a clear paper trail for each non-obvious choice. The single remaining tension — losing the "Embed video from URL" menu item on bound non-embed-video covers — is consciously accepted, traced to the spec's Out-of-Scope "Embed-video × bindings interaction" bullet, and confirmed not to violate AC-21 (since `bindingActive=false` on embed-video covers per §5.1 step 2 preserves the affordance on the population AC-21 protects).
+
+## Iter-2 finding resolution check
+
+| Iter-2 Issue | Status | Notes |
+| --- | --- | --- |
+| 1 (blocker) — `<MediaReplaceFlow>` `onSelect=undefined` crash | Resolved | §5.5 now conditionally renders the entire `<MediaReplaceFlow>` element via `{ ! bindingActive && ( <MediaReplaceFlow …/> ) }`. AC-14 satisfied by literal DOM absence. Embed-URL menu item trade-off explicit (§5.5, §13 AC-14 gating table, §15 risk #5). |
+| 2 (major) — `getBlockBindingsSource` wrong store | Resolved | §5.1 step 3 now imports from `@wordpress/blocks` directly (`import { getBlockBindingsSource } from '@wordpress/blocks';`) with explicit code refs verified at `packages/blocks/src/api/registration.ts:903-907`. |
+| 3 (minor) — `args` equality check missing in PHP helper | Resolved | §6.1 spells out `$same_source && $same_args` with `==` loose-equality rationale (associative-array element-wise compare; key-order-agnostic). Mirrors §5.1 step 2 JS check. |
+| 4 (minor) — form-1 strip pattern missing | Resolved | §6.4 now defines both `$form2_pattern` (`<div>...</div>`) and `$form1_pattern` (`<img … />` with optional trailing slash) explicitly. `U` ungreedy modifier rationale documented. Word-boundary `\b...\b` anchors verified for class-name accuracy. |
+| 5 (minor) — line-750 `<CoverPlaceholder>` drop zone | Resolved | §5.4 (1) and §5.5 now gate the line-750 site with `{ ! bindingActive && (<CoverPlaceholder …/>) }`. Trade-off table at §13 covers the three options (gate at call site, pass `disableDropZone`, accept). `cover-placeholder.js` source remains untouched (§2.2 invariant). |
+
+## Coverage summary
+
+| AC | Traced in design | Adequately addressed |
+| --- | --- | --- |
+| AC-1 | §8 | Yes |
+| AC-2 | §5.6, §9 | Yes |
+| AC-3 | §5.4, §6.5(1) | Yes |
+| AC-4 | §5.4, §10, OQ-6 | Yes |
+| AC-5 | §6.4 (both form patterns) | Yes |
+| AC-6 | §6.4, §10 | Yes |
+| AC-7..AC-10 | §5.6, §9, OQ-2 | Yes |
+| AC-11..AC-12 | §5.5 | Yes |
+| AC-13 | §5.5 (removed alongside `<MediaReplaceFlow>`) | Yes |
+| AC-14 | §5.5 (literal DOM absence via conditional render) + §5.4 line-750 gate | Yes |
+| AC-15..AC-17 | §5.2, §5.4, §6.3, OQ-4 | Yes |
+| AC-18 | §6.1 Part 2, §12 | Yes (`render_block_data` mutation propagates pre-`WP_Block::__construct`) |
+| AC-19 | §6.2, OQ-3 | Yes |
+| AC-20 | §12 | Yes |
+| AC-21 | §6.1, Risk 4 | Yes (embed-video forces `bindingActive=false`) |
+| AC-22..AC-24 | §11.3 | Yes |
+| AC-25 | §6.5 | Yes |
+| AC-26 | §2.2, §6.1 | Yes |
+| AC-27 | §12 | Yes |
+| AC-28 | §12 (~533 lines, just over SHOULD budget) | Yes |
+
+## Open Questions resolution check
+
+| OQ | Choice | Verdict |
+| --- | --- | --- |
+| OQ-1 | Approach A (Cover-scoped filters) | OK — trade-off table at §13 |
+| OQ-2 | Disable reset button | OK |
+| OQ-3 | `preg_match` + `substr` splice mechanism (i) | OK — rejected alternatives spelled out |
+| OQ-4 | dimRatio 50 (symmetric with `onSelectMedia` downshift) | OK |
+| OQ-5 | Render-time force-off for parallax/repeat | OK |
+| OQ-6 | i18n string primary, `data-testid` secondary | OK |
+
+## Risks mitigation check
+
+| Risk | Mitigation | Adequate |
+| --- | --- | --- |
+| 1. Ockham single-observer | §5.2 single `useEffect` on `effectiveUrl` + `useEffectEvent` + race-token ref | Yes |
+| 2. Pattern Overrides reset semantics | §5.6 reuse `withPatternOverrideControls` + `ResetOverridesControl` | Yes |
+| 3. `dimRatio: 100` default opacity | §5.2/§5.4 `effectiveDimRatio` + §6.3 server class strip | Yes |
+| 4. Embed-video collision | §6.1 short-circuit at both ends | Yes |
+| 5. HTML API can't edit CSS-in-`style` | §6.2 element-replace via `preg_match` + `substr` | Yes |
+
+## Verification notes (for the orchestrator)
+
+The iter-3-specific changes were verified against trunk during this review pass:
+
+- **`getBlockBindingsSource` direct module export** — `packages/blocks/src/api/registration.ts:903-907` confirms the module-level export that internally calls `unlock( select( blocksStore ) ).getBlockBindingsSource( name )`. Matches §5.1 step 3's `import { getBlockBindingsSource } from '@wordpress/blocks';` claim.
+- **`<MediaPlaceholder disableDropZone>` short-circuit** — `packages/block-editor/src/components/media-placeholder/index.js:378-381`: `renderDropZone` early-returns `null` when `disableDropZone` is truthy. Confirms §5.5's `disableDropZone` alternative is a viable approach, though the call-site gate is the simpler one-line change.
+- **`<MediaReplaceFlow>` internal `onSelect` invariants** — `packages/block-editor/src/components/media-replace-flow/index.js:115` (`onSelect( media )` in `selectMedia`) and line 124 (`onSelect( files )` in `uploadFiles`). Both unconditional. Confirms iter-2 Issue 1 finding and motivates the iter-3 conditional-render fix.
+- **`render_block_data` filter location** — `wp-includes/blocks.php:2398` confirms the filter fires before `new WP_Block( $parsed_block, ... )` at line 2436. Mutation propagates as designed.
+- **`replacePatternOverridesDefaultBinding` shape** — `packages/block-editor/src/utils/block-bindings.js:27` confirms the helper exists and matches the signature used in §5.1 step 1.

From 4caef2a208fb4999b96285afc353313f3018643a Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:28:44 +0200
Subject: [PATCH 18/60] docs(pipeline): add 3-plan/code-plan.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../3-plan/code-plan.md                       | 499 ++++++++++++++++++
 1 file changed, 499 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md
new file mode 100644
index 00000000000000..782aff85bf2328
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md
@@ -0,0 +1,499 @@
+# Code Plan: Cover block bindings — internal-only `id` and `url`
+
+Spec: `<artifacts>/1-spec/spec.md` (approved)
+Design: `<artifacts>/2-design-doc/design-doc.md` (approved)
+
+All AC-N, Req-N, DC-N, OQ-N citations resolve to those documents.
+
+## Overview
+
+Land internal-only Block Bindings support for `core/cover`'s `id` and `url` attributes, headlined by Pattern Overrides, in an order that keeps the tree green at every step. The work is sequenced as follows:
+
+1. **Foundation (server)** — schema metadata, server allow-list filter, helper, `render_block_data` `useFeaturedImage` neutraliser, then the Cover-scoped `render_block` filter with its three rewrite helpers. After step 5, the server is feature-complete and PHPUnit can lock the contract down before any client code lands.
+2. **Foundation (client)** — the new `useCoverBindingState` hook, then a single observer on `effectiveUrl` inside `CoverEdit`, then derived `effectiveDimRatio` flowing into the overlay-span class. After step 8, the editor renders correctly on bound covers (single-observer architecture in place, DC-1/DC-2/DC-3 satisfied) but still shows all the controls.
+3. **UI gating** — inspector parallax/repeat, block-toolbar `<MediaReplaceFlow>`, `<CoverPlaceholder>` line-616 (bound-aware placeholder branch) and line-750 (`! bindingActive &&` wrapper). After step 11, every AC-11..AC-14 control absence holds.
+4. **Tests** — Jest unit tests for the hook and observer, PHPUnit cases enumerated in §6.5, then the e2e round-trip spec in step 14.
+5. **PR metadata** — `lib/load.php` wiring is folded into step 2 so server work integrates immediately; backport-changelog stub and PR description draft are the final step (15).
+
+Each task lists files (CREATE/MODIFY), atomic changes, the spec/design slices it traces to, dependencies, and observable acceptance. Code-writers implement each task TDD-style: write failing tests first, then the production code, then refactor — the per-task acceptance bullets describe *what* must be true, not *which* test files (the code-writer chooses the test files).
+
+---
+
+## Tasks
+
+### Task 1: Add `role: "content"` to `core/cover`'s `id` attribute
+
+**Goal**: Mark `core/cover`'s `id` as a "content" role so it surfaces in the Block Bindings panel alongside `url`.
+
+**Files**:
+- `packages/block-library/src/cover/block.json` — MODIFY: add `"role": "content"` to the `id` attribute definition.
+
+**Changes**:
+1. Locate the `attributes.id` entry (currently `{ "type": "number" }`).
+2. Add `"role": "content"` so it reads `{ "type": "number", "role": "content" }`.
+3. No other schema changes. No new attributes. No `supports` changes. No deprecation entry.
+
+**Depends on**: none
+
+**Traces to**: Spec Req 1, Req 3; AC-1 prerequisite; Design §7.
+
+**Acceptance**:
+- `packages/block-library/src/cover/block.json`'s `id` attribute has `"role": "content"`.
+- `packages/block-library/src/cover/block.json` parses as valid JSON.
+- No other attribute in `block.json` changes.
+
+---
+
+### Task 2: Create `lib/compat/wordpress-7.1/block-bindings.php` with allow-list filter, wire it into `lib/load.php`
+
+**Goal**: Add `id` and `url` to `core/cover`'s server-side bindings supported-attributes list, so the editor's `__experimentalBlockBindingsSupportedAttributes['core/cover']` includes them. This is the single registration that drives both the Block Bindings panel (AC-1) and server-side resolution.
+
+**Files**:
+- `lib/compat/wordpress-7.1/block-bindings.php` — CREATE.
+- `lib/load.php` — MODIFY: add the `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';` line alongside the other `wordpress-7.1` requires (around lines 80–82).
+
+**Changes**:
+1. Create `lib/compat/wordpress-7.1/block-bindings.php` with the standard Gutenberg PHP file header (`@package gutenberg`).
+2. Wrap the function definition in `if ( ! function_exists( 'gutenberg_cover_bindings_add_supported_attributes' ) ) { … }` per established pattern (`lib/compat/wordpress-6.9/block-bindings.php`).
+3. Define `gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_type )`:
+   - If `$block_type === 'core/cover'`, ensure `'id'` and `'url'` are present in `$attributes` (use `in_array(..., true)` guard).
+   - Return the (possibly augmented) array.
+4. Register: `add_filter( 'block_bindings_supported_attributes', 'gutenberg_cover_bindings_add_supported_attributes', 10, 2 );`.
+5. In `lib/load.php`, after the existing `wordpress-7.1` requires (after `collaboration.php` on line 82), insert: `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';`.
+
+**Depends on**: Task 1
+
+**Traces to**: Spec Req 2, Req 8, AC-1, AC-2; Design §6.1 Part 1, §8, §2.2.
+
+**Acceptance**:
+- `lib/compat/wordpress-7.1/block-bindings.php` exists and is loaded by `lib/load.php`.
+- After bootstrap, `apply_filters( 'block_bindings_supported_attributes', array(), 'core/cover' )` returns an array containing both `'id'` and `'url'`.
+- For any block type other than `core/cover`, the filter is a no-op.
+- The filter is idempotent: applying it twice on the same input still returns `[ 'id', 'url' ]`, not `[ 'id', 'url', 'id', 'url' ]`.
+
+---
+
+### Task 3: Add `gutenberg_cover_bindings_is_active` helper
+
+**Goal**: Provide the single PHP helper that decides whether a parsed cover block has an active binding, mirroring the client-side `bindingActive` predicate. It expands `__default`, then requires `id` AND `url` to be bound to the same source instance (same `source` string AND `==`-equal `args`). The helper is the gate that both the `render_block_data` filter (Task 4) and the `render_block` filter (Task 5) call.
+
+**Files**:
+- `lib/compat/wordpress-7.1/block-bindings.php` — MODIFY: add `gutenberg_cover_bindings_is_active( array $attrs ): bool` and the supporting `__default` expansion logic.
+
+**Changes**:
+1. Inside the same file from Task 2, add a private helper `gutenberg_cover_bindings_expand_bindings( array $bindings ): array` that:
+   - Reads `$bindings['__default']` (if any).
+   - For each supported attribute in `[ 'id', 'url' ]`, if there is no explicit entry, copy the `__default` value into that attribute slot.
+   - Returns the expanded array.
+2. Add `gutenberg_cover_bindings_is_active( array $attrs ): bool`:
+   - Read `$attrs['metadata']['bindings']`. If empty/absent, return `false`.
+   - Call the expander above on the bindings.
+   - Compute `$same_source = ( $expanded['id']['source'] ?? null ) === ( $expanded['url']['source'] ?? null );`.
+   - Compute `$same_args = ( $expanded['id']['args'] ?? null ) == ( $expanded['url']['args'] ?? null );` (loose equality on associative arrays per Design §6.1).
+   - Return `! empty( $expanded['id'] ) && ! empty( $expanded['url'] ) && $same_source && $same_args`.
+3. Both helpers MUST be wrapped in `if ( ! function_exists( … ) )` guards.
+
+**Depends on**: Task 2
+
+**Traces to**: Spec Req 11 Glossary "Active binding"; Req 26; AC-3, AC-6, AC-21; Design §6.1, §5.1 step 2 (parity with client).
+
+**Acceptance**:
+- `gutenberg_cover_bindings_is_active( [] )` returns `false`.
+- For attrs whose `metadata.bindings` is `{ __default: { source: 'core/pattern-overrides' } }`, the helper returns `true`.
+- For attrs whose `metadata.bindings` is `{ id: { source: 'a' }, url: { source: 'b' } }`, the helper returns `false`.
+- For attrs whose `metadata.bindings` is `{ id: { source: 'a', args: { key: 'x' } }, url: { source: 'a', args: { key: 'x' } } }`, the helper returns `true`.
+- For attrs whose `metadata.bindings` is `{ id: { source: 'a', args: { k: 1 } }, url: { source: 'a', args: { k: 2 } } }`, the helper returns `false`.
+- For attrs whose `metadata.bindings` is `{ url: { source: 'a' } }` (no id), the helper returns `false`.
+- The helper does NOT short-circuit on `backgroundType === 'embed-video'` — that gate is the responsibility of the callers (Tasks 4 and 5). The helper is pure-by-bindings.
+
+---
+
+### Task 4: `render_block_data` filter to neutralise `useFeaturedImage` on bound covers
+
+**Goal**: When a Cover's bindings are active AND `backgroundType !== 'embed-video'`, force `$parsed_block['attrs']['useFeaturedImage'] = false` BEFORE `WP_Block::render()` builds its instance attributes — so `render_block_core_cover` skips its featured-image injection branch on the first pass. This is the AC-18 precedence rule.
+
+**Files**:
+- `lib/compat/wordpress-7.1/block-bindings.php` — MODIFY: add `gutenberg_cover_bindings_prepare_block` and register it on `render_block_data` at priority 10.
+
+**Changes**:
+1. Add `gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $parent_block )`:
+   - If `$parsed_block['blockName'] !== 'core/cover'`, return `$parsed_block` unchanged.
+   - Read `$attrs = $parsed_block['attrs'] ?? array();`.
+   - If `! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType']`, return `$parsed_block` unchanged (AC-21).
+   - If `! gutenberg_cover_bindings_is_active( $attrs )`, return `$parsed_block` unchanged.
+   - Else if `! empty( $attrs['useFeaturedImage'] )`, set `$parsed_block['attrs']['useFeaturedImage'] = false;`.
+   - Return `$parsed_block`.
+2. Wrap in `if ( ! function_exists( … ) )`.
+3. Register: `add_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10, 3 );`.
+
+**Depends on**: Task 3
+
+**Traces to**: Spec Req 19, AC-18; Design §6.1 Part 2, §12 (`useFeaturedImage` precedence rule).
+
+**Acceptance**:
+- For a non-Cover block, the filter returns its input unchanged.
+- For a Cover with no `metadata.bindings`, the filter returns its input unchanged (in particular, `useFeaturedImage` is not flipped).
+- For a Cover with `backgroundType: 'embed-video'` AND active bindings, the filter returns input unchanged.
+- For a Cover with active bindings (per `gutenberg_cover_bindings_is_active`), `backgroundType !== 'embed-video'`, AND `useFeaturedImage: true`, the filter returns the input with `attrs.useFeaturedImage === false`. All other attrs are untouched.
+- For a Cover with active bindings and `useFeaturedImage: false`, the returned `attrs.useFeaturedImage` is still `false` (no surprises).
+- The persisted `post_content` is NOT mutated by this filter — only the in-flight `$parsed_block` array.
+
+---
+
+### Task 5: Cover-scoped `render_block` filter with image-rewrite / dim-class-relax / strip-image helpers
+
+**Goal**: When a Cover has an active binding AND `backgroundType !== 'embed-video'`, rewrite the rendered HTML so: (a) the saved `<img class="wp-block-cover__image-background">` OR `<div class="wp-block-cover__image-background" style="background-image:url(…)">` becomes an `<img>` with the bound URL, alt, and `wp-image-{id}` class; (b) the overlay span loses `has-background-dim-100` when stored `dimRatio === 100`; (c) when the binding is unresolvable (no `id`, or `id` is not an attachment), the saved image element is stripped entirely.
+
+**Files**:
+- `lib/compat/wordpress-7.1/block-bindings.php` — MODIFY: add four functions: `gutenberg_cover_bindings_render_block`, `gutenberg_cover_bindings_rewrite_image`, `gutenberg_cover_bindings_relax_dim_class`, `gutenberg_cover_bindings_strip_image`. Register the first on `render_block` at priority 9.
+
+**Changes**:
+1. **`gutenberg_cover_bindings_strip_image( string $content ): string`** — try `$form2_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';` first, then `$form1_pattern = '/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?\s*>/U';`. Use `preg_match` with `PREG_OFFSET_CAPTURE` to locate the match and `substr` to splice it out. Return the modified content (or input unchanged if neither pattern matches).
+2. **`gutenberg_cover_bindings_relax_dim_class( string $content ): string`** — instantiate `WP_HTML_Tag_Processor( $content )`; loop with `next_tag( array( 'tag_name' => 'SPAN', 'class_name' => 'wp-block-cover__background' ) )`; on each match call `remove_class( 'has-background-dim-100' )`. Return `get_updated_html()`.
+3. **`gutenberg_cover_bindings_rewrite_image( string $content, string $resolved_url, int $resolved_id, array $attrs ): string`**:
+   - First, try the parallax/repeat form via `preg_match( $form2_pattern, … )` — if matched, build a replacement `<img class="wp-block-cover__image-background wp-image-{id}{size_class_suffix}" alt="{alt}" src="{esc_url url}" data-object-fit="cover"{object_position_attrs} />` and splice it in via `substr`. Compute `$size_class_suffix` from `$attrs['sizeSlug']` (empty when unset); compute `$object_position_attrs` from `$attrs['focalPoint']` (empty when unset); compute `$alt` from the attachment's alt metadata (`get_post_meta( $resolved_id, '_wp_attachment_image_alt', true )`).
+   - Otherwise, fall through to the plain-`<img>` path via `WP_HTML_Tag_Processor`: `next_tag( array( 'tag_name' => 'IMG', 'class_name' => 'wp-block-cover__image-background' ) )`; if found, `set_attribute( 'src', $resolved_url )`, `set_attribute( 'alt', $alt )`, iterate `class_list()`, remove any class beginning with `wp-image-`, then `add_class( 'wp-image-' . $resolved_id )`. Return `get_updated_html()`.
+   - If neither pattern matched, return `$content` unchanged (no image element to rewrite — fine, render proceeds overlay-only).
+4. **`gutenberg_cover_bindings_render_block( $block_content, $block, $instance )`** — main entry, registered on `render_block` priority 9:
+   - If `$block['blockName'] !== 'core/cover'`, return `$block_content` unchanged.
+   - Read `$attrs = $instance->attributes ?? array();`.
+   - If `! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType']`, return unchanged.
+   - If `! gutenberg_cover_bindings_is_active( $attrs )`, return unchanged.
+   - `$resolved_url = $attrs['url'] ?? null;` `$resolved_id = (int) ( $attrs['id'] ?? 0 );`
+   - If `empty( $resolved_url ) || empty( $resolved_id )`, return `gutenberg_cover_bindings_strip_image( $block_content )`.
+   - Verify attachment: `$attachment = get_post( $resolved_id );` if `! $attachment || 'attachment' !== $attachment->post_type`, return `gutenberg_cover_bindings_strip_image( $block_content )`.
+   - `$block_content = gutenberg_cover_bindings_rewrite_image( $block_content, $resolved_url, $resolved_id, $attrs );`
+   - If `100 === (int) ( $attrs['dimRatio'] ?? 100 )`, `$block_content = gutenberg_cover_bindings_relax_dim_class( $block_content );`
+   - Return `$block_content`.
+5. Register `add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 );`. Priority 9 is essential — it must run BEFORE the generic priority-10 `gutenberg_block_bindings_render_block`.
+6. Wrap each of the four functions in `if ( ! function_exists( … ) )`.
+
+**Depends on**: Task 3, Task 4 (same file; sequencing keeps the file growing monotonically)
+
+**Traces to**: Spec Req 17, Req 18, Req 19, Req 20, Req 21, Req 22; AC-3, AC-5, AC-6, AC-16, AC-18, AC-19, AC-21; Design §6.1 Part 3, §6.2, §6.3, §6.4, OQ-3.
+
+**Acceptance**:
+- For a non-Cover block, the filter returns input unchanged.
+- For a Cover with no active binding, the filter returns input unchanged.
+- For an `embed-video` Cover, the filter returns input unchanged regardless of binding state.
+- For a Cover with active bindings, `dimRatio: 100`, and a resolved attachment URL, the output contains an `<img>` whose `src` matches the bound URL AND no `has-background-dim-100` class anywhere.
+- For a Cover with active bindings, `dimRatio: 70`, and resolved attachment, the output contains an `<img>` with the bound URL AND the `has-background-dim-70` class is preserved.
+- For a Cover with active bindings but `id` resolves to a non-attachment post, the output contains no `wp-block-cover__image-background` element.
+- For a Cover with active bindings, saved markup is the parallax/repeat `<div>...</div>` form, and a resolved attachment, the output contains an `<img class="wp-block-cover__image-background wp-image-{id}">` AND no `has-parallax` / `is-repeated` class on the image element AND no `style="background-image: …"` on the rebuilt element.
+- Idempotency: running the helper twice on already-rewritten content does not produce additional `<img>` elements.
+
+---
+
+### Task 6: New hook — `useCoverBindingState`
+
+**Goal**: Provide the client-side single-source-of-truth for cover binding state — `bindingActive`, `bindingUnresolvable`, `bindingResolvedUrl`, `bindingResolvedId`, `canUserEditBindingValue` — computed in one place from one `useSelect`. Used by `CoverEdit` to drive everything downstream.
+
+**Files**:
+- `packages/block-library/src/cover/edit/use-cover-binding-state.js` — CREATE.
+
+**Changes**:
+1. New file exporting a default function: `export default function useCoverBindingState( { clientId, attributes, context } ) { … }`.
+2. Imports: `replacePatternOverridesDefaultBinding` from `@wordpress/block-editor` (`utils/block-bindings`), `getBlockBindingsSource` from `@wordpress/blocks`, `useSelect` from `@wordpress/data`, `store as coreStore` from `@wordpress/core-data`.
+3. Body:
+   - Read `attributes.metadata?.bindings`. If absent, return `{ bindingActive: false, bindingUnresolvable: false, bindingResolvedUrl: undefined, bindingResolvedId: undefined, canUserEditBindingValue: false }` early.
+   - Call `const expanded = replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] );`.
+   - Compute `bindingActive` per Design §5.1 step 2: both `expanded.id` and `expanded.url` are present, same `source`, `JSON.stringify( expanded.id.args ?? null ) === JSON.stringify( expanded.url.args ?? null )`, AND `attributes.backgroundType !== 'embed-video'`.
+   - Single `useSelect` (Design §5.1 step 3): when `bindingActive`, look up the source via `getBlockBindingsSource( expanded.url.source )`, call `source.getValues( { select, clientId, context, bindings: { id: expanded.id, url: expanded.url } } )`, then if `values.id` is truthy, also call `select( coreStore ).getEntityRecord( 'postType', 'attachment', values.id, { context: 'view' } )`. Return `{ bindingResolvedUrl, bindingResolvedId, bindingResolvedAttachment }` from the closure.
+   - Dependency array: `[ bindingActive, expanded?.id?.source, expanded?.url?.source, clientId ]`.
+   - Compute `bindingUnresolvable`:
+     - `true` if `bindings` has any cover-relevant configuration (`bindings.__default` exists, OR `bindings.id` exists, OR `bindings.url` exists) AND `! bindingActive` — i.e. malformed/mismatched binding.
+     - OR `true` if `bindingActive && bindingResolvedAttachment === null` (resolved-not-found; remember `undefined` means pending — NOT unresolvable).
+     - OR `true` if `bindingActive && bindingResolvedAttachment?.type && bindingResolvedAttachment.type !== 'attachment'`.
+   - Compute `canUserEditBindingValue` from the source: `getBlockBindingsSource( expanded.url.source )?.canUserEditValue?.( … ) ?? false`. (Used for future lock-flag wiring; safe to return `false` if not applicable.)
+   - Return `{ bindingActive, bindingUnresolvable, bindingResolvedUrl, bindingResolvedId, canUserEditBindingValue }`.
+4. The hook returns plain values. No memoised React elements, no `useEffect`.
+
+**Depends on**: Task 2 (the editor setting `__experimentalBlockBindingsSupportedAttributes['core/cover']` must include `id`/`url`).
+
+**Traces to**: Spec Req 10, Req 25, Req 26, Req 27; AC-3, AC-4, AC-6, AC-21; DC-1, DC-3; Design §5.1, §5.6 (Pattern Overrides integration via `replacePatternOverridesDefaultBinding`).
+
+**Acceptance**:
+- Called with `attributes.metadata.bindings === undefined`: returns `bindingActive: false`, `bindingUnresolvable: false`.
+- Called with `attributes.metadata.bindings = { __default: { source: 'core/pattern-overrides' } }`: returns `bindingActive: true`.
+- Called with `attributes.metadata.bindings = { id: { source: 'x' }, url: { source: 'y' } }`: returns `bindingActive: false, bindingUnresolvable: true`.
+- Called with `attributes.metadata.bindings = { id: { source: 'x' }, url: { source: 'x' } }` AND `attributes.backgroundType = 'embed-video'`: returns `bindingActive: false` (embed-video override).
+- The hook subscribes via exactly ONE `useSelect`. (Verifiable by code review / by counting `useSelect` calls in the file.)
+- The hook does NOT call `useEffect`. (Verifiable by code review.)
+- When `bindingActive` is true but the attachment record is loading (selector returns `undefined`), `bindingUnresolvable` is `false` (treated as pending, not unresolvable).
+- When `bindingActive` is true and the attachment record resolves to `null` (not found), `bindingUnresolvable` is `true`.
+
+---
+
+### Task 7: Single observer + derived values in `CoverEdit`
+
+**Goal**: Replace the existing `useEffect` on `[mediaUrl]` in `packages/block-library/src/cover/edit/index.js` with a single source-agnostic observer keyed on `effectiveUrl`, using `useEffectEvent` for latest reads and a `raceTokenRef` for stale-resolution protection. Compute `effectiveUrl` and `effectiveDimRatio` once at the top of the component. Do NOT call `setAttributes` for any value in DC-2's prohibition list as a consequence of this observer.
+
+**Files**:
+- `packages/block-library/src/cover/edit/index.js` — MODIFY: import the new hook, declare `raceTokenRef`, replace the existing `useEffect([mediaUrl])` with the new observer, compute `effectiveUrl` and `effectiveDimRatio`.
+
+**Changes**:
+1. Add imports at the top of the file:
+   - `import useCoverBindingState from './use-cover-binding-state';`
+   - Ensure `useEffectEvent`, `useRef`, `useEffect` are imported from `@wordpress/element` (some may already be present).
+2. Inside `CoverEdit` body, after the existing props/state destructuring, before any existing `useEffect`:
+   - `const { bindingActive, bindingUnresolvable, bindingResolvedUrl, bindingResolvedId, canUserEditBindingValue } = useCoverBindingState( { clientId, attributes, context } );`
+   - `const raceTokenRef = useRef( 0 );`
+3. Compute `effectiveUrl`:
+   ```js
+   const effectiveUrl =
+       bindingResolvedUrl ??
+       ( useFeaturedImage ? mediaUrl : originalUrl?.replaceAll( '&amp;', '&' ) );
+   ```
+4. Compute `effectiveDimRatio`:
+   ```js
+   const effectiveDimRatio =
+       bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio;
+   ```
+5. Replace the existing `useEffect( () => { /* getMediaColor on mediaUrl */ }, [ mediaUrl ] )` block with:
+   - `const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => { … } );` whose body:
+     1. Returns early if `! resolvedUrl`.
+     2. Increments `raceTokenRef.current` into a local `myToken`.
+     3. `const avg = await getMediaColor( resolvedUrl );`
+     4. If `myToken !== raceTokenRef.current`, return (stale).
+     5. Read latest `attributes` / `overlayColor` via a `propsRef.current` pattern (preserve existing pattern if one exists in trunk; otherwise read directly through `useEffectEvent`'s latest-value contract).
+     6. If `! attributes.isUserOverlayColor`, call `__unstableMarkNextChangeAsNotPersistent()` then `setOverlayColor( avg )` (preserves trunk behavior; `overlayColor` IS in DC-2's prohibition list but its mutation here is a continuation of trunk's existing media-resolution path, NOT triggered by binding-state change — same call site as today). [DC-2 note: this preserves the trunk behaviour exactly; the binding-state change does not flip `isUserOverlayColor`, and the only path that calls `setOverlayColor` here is the URL-resolved derivation that runs identically for manual, featured-image, and binding-sourced URLs — i.e. source-agnostic per DC-3.]
+     7. Compute `newIsDark` from `compositeIsDark( …, … , avg )` using `effectiveDimRatio`-equivalent latest values per Design §5.2.
+     8. `__unstableMarkNextChangeAsNotPersistent()` + `setAttributes( { isDark: newIsDark } )` (allowed; `isDark` is NOT in DC-2's prohibition list).
+   - One `useEffect( () => { onUrlResolved( effectiveUrl ); }, [ effectiveUrl, onUrlResolved ] );`.
+6. The existing event handlers (`onSelectMedia`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`, `toggleUseFeaturedImage`, `onSelectEmbedUrl`) are UNCHANGED — they continue to mutate stored attributes in response to user intent (allowed under DC-2).
+7. The overlay-span class computation MUST use `effectiveDimRatio` rather than `dimRatio` in `dimRatioToClass( … )` (verify the JSX site exists; trunk code references the overlay `<span>` near the dim-class computation — pass `effectiveDimRatio` through).
+
+**Depends on**: Task 6
+
+**Traces to**: Spec Req 10, Req 11, Req 12, Req 13, Req 14, Req 15; AC-15, AC-17, AC-18 (client side); DC-1, DC-2, DC-3; Design §5.2, §5.3, §5.4.
+
+**Acceptance**:
+- The file contains exactly ONE `useEffect` whose dependency array includes `effectiveUrl`. No new `useEffect` keyed on `metadata.bindings`, `useFeaturedImage`, or similar event sources is introduced. (DC-1 enforcement — verifiable by code review.)
+- `effectiveUrl` is computed exactly once at the top of `CoverEdit`, prefers `bindingResolvedUrl`, falls back to `useFeaturedImage`'s `mediaUrl`, then to `originalUrl`.
+- `effectiveDimRatio` is 50 only when `bindingActive && dimRatio === 100 && effectiveUrl`. In all other cases it equals `dimRatio`.
+- The observer body does NOT call `setAttributes` for `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, or `customOverlayColor`. The only attribute write inside the observer is `isDark`. (DC-2 enforcement — verifiable by inspection.)
+- When two `effectiveUrl` changes happen in quick succession, only the latest `getMediaColor` resolution actually writes `overlayColor` / `isDark` (race-token-protected).
+- The overlay span class uses `dimRatioToClass( effectiveDimRatio )` rather than `dimRatioToClass( dimRatio )`.
+
+---
+
+### Task 8: Bound-cover empty-cover placeholder branch and `<img>`-forced non-empty render branch in `CoverEdit`
+
+**Goal**: Two structural render-tree changes in `packages/block-library/src/cover/edit/index.js`:
+1. The empty-cover branch (currently `if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground )` near line 599) renders a binding-aware `<Placeholder>` when `bindingActive || bindingUnresolvable` — the standard `<CoverPlaceholder>` is NOT rendered on bound covers.
+2. The non-empty image render branch (around `url && isImageBackground` near line 672) emits a forced `<img>` (no `<div bg>`) whenever `bindingActive`, regardless of `hasParallax`/`isRepeated`.
+
+**Files**:
+- `packages/block-library/src/cover/edit/index.js` — MODIFY.
+
+**Changes**:
+1. In the empty-cover branch, BEFORE returning the existing `<CoverPlaceholder>` JSX:
+   - If `bindingActive || bindingUnresolvable`, return a JSX subtree per Design §5.4 (1):
+     - `<>` containing the existing `blockControls`, `inspectorControls`, conditional `<ResizableCoverPopover/>`, then a `<TagName … className={ clsx( 'is-placeholder', blockProps.className ) } style={ { …blockProps.style, minHeight: minHeightWithUnit || undefined } }>`.
+     - Inside `<TagName>`, render `{ resizeListener }`.
+     - If `bindingUnresolvable`, render `<Placeholder data-testid="cover-binding-unresolvable" className="wp-block-cover__binding-unresolvable" withIllustration instructions={ __( 'Internal media required for this binding.' ) } />`.
+     - Else (bindingActive but pending resolution), render `<Placeholder className="wp-block-cover__binding-pending" withIllustration />`.
+   - Else fall through to the existing trunk `<CoverPlaceholder>` return — UNCHANGED.
+2. In the non-empty image render branch (around `url && isImageBackground`):
+   - Add the `! bindingUnresolvable` predicate so the image element is never emitted for unresolvable bindings.
+   - When `bindingActive`, force-render `<img ref={ mediaElement } className="wp-block-cover__image-background" alt={ alt } src={ effectiveUrl } style={ mediaStyle } />` (skipping the `isImgElement` check that would otherwise pick a `<div>` for parallax/repeat saved markup).
+   - When `! bindingActive`, the existing trunk JSX (with `isImgElement` switching between `<img>` and `<div>`) is preserved verbatim.
+3. The overlay span: pass `effectiveDimRatio` to `dimRatioToClass` (this is the same change as in Task 7 step 7 — Task 7 establishes the derived value; Task 8 confirms the call site).
+4. Import `__` from `@wordpress/i18n` if not already imported (it almost certainly already is).
+5. Import `Placeholder` from `@wordpress/components` if not already imported.
+
+**Depends on**: Task 7
+
+**Traces to**: Spec Req 16, AC-4, AC-15 (client side), AC-19 (client side); Design §5.4 (1), §5.4 (2), OQ-6 (i18n string + `data-testid`).
+
+**Acceptance**:
+- On a Cover with no bindings and no background, the existing `<CoverPlaceholder>` renders (no regression — AC-20).
+- On a Cover with `bindingUnresolvable: true`, the editor preview contains a `<Placeholder>` whose accessible text includes the literal string `Internal media required for this binding.`. Its containing element has `data-testid="cover-binding-unresolvable"`. No `<img class="wp-block-cover__image-background">` is rendered.
+- On a Cover with `bindingActive: true`, `bindingUnresolvable: false`, and an `effectiveUrl`, the editor preview contains `<img class="wp-block-cover__image-background" src="{effectiveUrl}">` (an `<img>`, not a `<div style="background-image:…">`), even when `hasParallax: true` and `isRepeated: true` are stored on the block.
+- The overlay `<span class="wp-block-cover__background …">` class string uses `effectiveDimRatio` for `dimRatioToClass` — when `dimRatio === 100 && bindingActive && effectiveUrl`, the class string does NOT contain `has-background-dim-100`.
+- On a Cover with `backgroundType: 'embed-video'` and `metadata.bindings` set, `bindingActive` is `false` (from Task 6) → the binding-aware branches do NOT engage and the existing embed-video render path runs unchanged (AC-21).
+
+---
+
+### Task 9: Gate parallax and repeat controls in `inspector-controls.js`; gate `<MediaReplaceFlow>` in `block-controls.js`; gate line-750 `<CoverPlaceholder>` in `index.js`
+
+**Goal**: Hide every Cover-specific control that conflicts with bindings, in all surfaces (inspector parallax/repeat, toolbar media-replace, line-750 cover-placeholder drop-zone). Honour AC-11..AC-14 by literal DOM absence — not by `disabled` props.
+
+**Files**:
+- `packages/block-library/src/cover/edit/inspector-controls.js` — MODIFY: accept a new `bindingActive` prop and conditionally render the parallax + repeat `<ToolsPanelItem>`s.
+- `packages/block-library/src/cover/edit/block-controls.js` — MODIFY: accept a new `bindingActive` prop and conditionally render the entire `<MediaReplaceFlow>` element.
+- `packages/block-library/src/cover/edit/index.js` — MODIFY: pass `bindingActive` to both child components AND wrap the line-750 `<CoverPlaceholder>` call site in `{ ! bindingActive && ( … ) }`.
+
+**Changes**:
+
+In `inspector-controls.js`:
+1. Add `bindingActive` to the destructured props.
+2. Wrap the JSX fragment that contains the "Fixed background" and "Repeated background" `<ToolsPanelItem>`s in `{ ! bindingActive && ( <> … </> ) }`. (If the items are not currently inside a fragment together, wrap them together first.)
+
+In `block-controls.js`:
+1. Add `bindingActive` to the destructured props.
+2. Inside the `<BlockControls group="other">`, wrap the entire `<MediaReplaceFlow … >` (including its `<MenuItem>` children for "Embed video from URL") in `{ ! bindingActive && ( … ) }`.
+3. The "Embed video from URL" `<MenuItem>` is consciously removed alongside `<MediaReplaceFlow>` on bound non-embed-video covers per Design §5.5 trade-off. Embed-video covers force `bindingActive=false` from Task 6, so AC-21's population still has the affordance.
+
+In `index.js`:
+1. When rendering `<CoverInspectorControls … />` and `<CoverBlockControls … />`, pass `bindingActive={ bindingActive }`.
+2. At the line-750 site (the `<CoverPlaceholder disableMediaButtons onSelectMedia={ onSelectMedia } onError={ onUploadError } toggleUseFeaturedImage={ toggleUseFeaturedImage } />`), wrap in `{ ! bindingActive && ( <CoverPlaceholder … /> ) }`. The existing call site moves inside a JSX expression block.
+
+**Depends on**: Task 7 (establishes `bindingActive` in `CoverEdit`), Task 8 (the line-616 branch is already binding-aware).
+
+**Traces to**: Spec Req 4, Req 5, Req 6, Req 7; AC-11, AC-12, AC-13, AC-14; Design §5.5, §5.4 (line-750 gating), §13 (AC-14 gating table, line-750 trade-off table).
+
+**Acceptance**:
+- On a Cover with `bindingActive: true`, the inspector DOM contains NO `<ToolsPanelItem>` for "Fixed background" (parallax) and NO `<ToolsPanelItem>` for "Repeated background" (repeat).
+- On a Cover with `bindingActive: true`, the block toolbar DOM contains NO `<MediaReplaceFlow>` button (no `Add media` / `Replace` toggle, no `Open Media Library`, no `Upload`, no `Use featured image`, no `Embed video from URL` menu items).
+- On a Cover with `bindingActive: false` (unbound, or embed-video, or mismatched), the inspector and toolbar render the existing trunk controls byte-for-byte (AC-20 non-regression).
+- On a Cover with `bindingActive: true` AND `hasBackground: true`, the rendered cover DOM contains NO `<CoverPlaceholder>` at the line-750 site (the drop-zone is not present; dropping a file does not mutate `url`).
+- `cover-placeholder.js` source file is NOT modified.
+
+---
+
+### Task 10: PHPUnit coverage in `phpunit/blocks/render-block-cover-test.php`
+
+**Goal**: Lock down server-side behaviour with the nine cases enumerated in Design §6.5 — including the AC-25 PHPUnit case explicitly required by the spec and the AC-18 first-pass-injection regression test.
+
+**Files**:
+- `phpunit/blocks/render-block-cover-test.php` — MODIFY: extend with new test methods. (No file creation; the file exists.)
+
+**Changes**:
+1. Add `setUp`/`tearDown` helpers to register a test binding source via `register_block_bindings_source( 'test/cover-source', [ 'label' => 'Test', 'get_value_callback' => fn() => …, ] )` and unregister on tearDown. Use the existing `register_block_bindings_source` infrastructure.
+2. Add `setUp` helper to upload two test attachments (default + override) via the standard PHPUnit attachment-fixture pattern (mirror `phpunit/blocks/render-block-image-test.php` or `render-block-media-text-test.php` for patterns).
+3. Add nine `public function test_…` methods, one per Design §6.5 case:
+   - `test_bound_url_substitutes_in_plain_img_form` (AC-3)
+   - `test_default_dim_ratio_class_is_relaxed` (AC-16, AC-25)
+   - `test_non_default_dim_ratio_is_preserved` (AC-17)
+   - `test_parallax_saved_markup_is_rebuilt_as_img` (AC-19)
+   - `test_mismatched_source_strips_image` (AC-6)
+   - `test_external_url_strips_image` (AC-5)
+   - `test_use_featured_image_with_active_binding_emits_exactly_one_img_with_bound_url` (AC-18)
+   - `test_embed_video_short_circuits` (AC-21)
+   - `test_unbound_cover_is_byte_identical_to_trunk` (AC-20)
+4. Each test method constructs a `parsed_block` array via `parse_blocks( '<!-- wp:cover {…} … /wp:cover -->' )` or builds the array directly, calls `render_block( $parsed_block )`, and asserts on the returned HTML via `assertStringContainsString` / `assertStringNotContainsString` / `assertMatchesRegularExpression` per case.
+
+**Depends on**: Task 5 (the server filter must exist and be loaded).
+
+**Traces to**: Spec Req 17–22, AC-3, AC-5, AC-6, AC-15, AC-16, AC-17, AC-18, AC-19, AC-20, AC-21, AC-25; Design §6.5, §11.2.
+
+**Acceptance**:
+- All nine new test methods pass.
+- `vendor/bin/phpunit phpunit/blocks/render-block-cover-test.php` exits 0 with no failures and no skipped tests.
+- The pre-existing test methods in `render-block-cover-test.php` continue to pass (AC-20, AC-35 non-regression).
+- The `test_use_featured_image_with_active_binding_emits_exactly_one_img_with_bound_url` case asserts the bound URL appears in the output exactly once and the featured-image URL does not appear at all (catches AC-18 regressions in either direction).
+- The `test_default_dim_ratio_class_is_relaxed` case asserts BOTH the absence of `has-background-dim-100` AND the presence of `has-background-dim` (preserves the 50%-opacity baseline per OQ-4).
+
+---
+
+### Task 11: Jest unit tests for `useCoverBindingState` and the single observer
+
+**Goal**: Cover the client-side hook predicates (every branch of `bindingActive` / `bindingUnresolvable`) and the observer's race-token / source-agnostic / no-attribute-mutation behaviour.
+
+**Files**:
+- `packages/block-library/src/cover/test/edit.js` — MODIFY: extend with new `describe('useCoverBindingState')` and `describe('CoverEdit single observer')` blocks.
+
+**Changes**:
+1. In `packages/block-library/src/cover/test/edit.js`, add a new `describe( 'useCoverBindingState', … )` block with at least these cases (per Design §11.1):
+   - `bindingActive` true for `{ __default: { source: 'core/pattern-overrides' } }`.
+   - `bindingActive` true for matching source + matching args.
+   - `bindingActive` false for differing sources.
+   - `bindingActive` false for differing args.
+   - `bindingActive` false for `backgroundType === 'embed-video'`.
+   - `bindingUnresolvable` true on mismatched-source binding.
+   - `bindingUnresolvable` true on resolved-not-found attachment (selector returns `null`).
+   - `bindingUnresolvable` false on pending attachment (selector returns `undefined`).
+   - `effectiveDimRatio` returns 50 only when `bindingActive && dimRatio === 100 && effectiveUrl` is truthy. (This may be tested through `CoverEdit` integration rather than directly, since `effectiveDimRatio` is local to `CoverEdit`.)
+2. Add a `describe( 'CoverEdit single observer', … )` block with at least:
+   - The observer does not call `setAttributes` for any value in DC-2's prohibition list when a binding becomes active (mock `setAttributes`, transition `metadata.bindings` from `undefined` to `{ __default: … }`, assert `setAttributes` was not called with `dimRatio`/`useFeaturedImage`/etc.).
+   - The observer is source-agnostic: identical observer behavior whether the URL change came from `attributes.url`, `useFeaturedImage`'s `mediaUrl`, or `bindingResolvedUrl`.
+   - The race-token guard: two rapid `effectiveUrl` changes followed by out-of-order `getMediaColor` resolutions — only the second resolution writes `overlayColor` / `isDark`.
+3. Use existing test infrastructure (Jest mocking of `@wordpress/data`'s `useSelect`, mocking `getMediaColor`).
+
+**Depends on**: Task 6, Task 7
+
+**Traces to**: Spec Req 10, Req 11, Req 13, Req 26; AC-3, AC-4, AC-6; DC-1, DC-2, DC-3; Design §5.1, §5.2, §11.1.
+
+**Acceptance**:
+- All new test cases pass.
+- `npm run test:unit packages/block-library/src/cover/test/edit.js` exits 0.
+- The pre-existing edit.js tests continue to pass (AC-35 non-regression).
+- The DC-2 mutation-prohibition test fails the build if a future change introduces `setAttributes({ dimRatio: … })` in the observer.
+
+---
+
+### Task 12: E2E test — Pattern Overrides round-trip and unresolvable-binding affordance
+
+**Goal**: End-to-end browser test that exercises Pattern Overrides on Cover from authoring to front-end render and back, plus the mismatched-source unresolvable-binding case. Satisfies AC-22, AC-23, AC-24.
+
+**Files**:
+- `test/e2e/specs/editor/blocks/cover.spec.js` — MODIFY: add a new `test.describe('Block Bindings — Pattern Overrides round-trip', …)` block.
+- (Optional, if needed for mismatched-source coverage) `packages/e2e-tests/plugins/block-bindings.php` — REUSE existing; do not modify unless an additional test source is required and even then prefer adding to the existing test plugin.
+
+**Changes**:
+1. Add a new `test.describe( 'Block Bindings — Pattern Overrides round-trip', … )` to `test/e2e/specs/editor/blocks/cover.spec.js`.
+2. Test fixture `setup`:
+   - Upload two attachments via `requestUtils.uploadMedia` (default + override).
+   - Reset on cleanup.
+3. Single `test( 'Cover round-trips through default → override → reset', … )` with these phases (per Design §11.3):
+   - **Setup**: create a synced pattern containing a Cover whose `url`+`id` are bound via the "Enable overrides" affordance on the pattern-author surface. Save the pattern.
+   - **Default state**: open a new post, insert the pattern. Assert:
+     - Editor preview `<img>` src matches `defaultMedia.url`.
+     - The parallax `<ToolsPanelItem>` for "Fixed background" is not visible (AC-11).
+     - The repeat `<ToolsPanelItem>` for "Repeated background" is not visible (AC-12).
+     - `page.getByRole('button', { name: /^(Replace|Add media)$/ })` resolves to zero matches inside the Cover's block toolbar (AC-13 + AC-14).
+     - The overlay span's `class` attribute contains `has-background-dim` but NOT `has-background-dim-100` (AC-15).
+     - The `ResetOverridesControl` toolbar button is `toBeDisabled()` (AC-10, OQ-2).
+   - **Override**: programmatically set the bound `url`/`id` on the instance (via `editor.dispatch` or by using the Cover's media affordance if available). Assert:
+     - The `ResetOverridesControl` button becomes enabled.
+     - Editor preview `<img>` src matches `overrideMedia.url`.
+     - Publish the post; navigate to the front-end.
+     - Front-end `<img>` src matches `overrideMedia.url` (AC-8).
+     - Front-end overlay span class contains `has-background-dim` but NOT `has-background-dim-100` (AC-16).
+   - **Reset**: navigate back to the editor; click the `ResetOverridesControl` toolbar button. Assert:
+     - Editor preview `<img>` src is back to `defaultMedia.url`.
+     - Publish; front-end `<img>` src is `defaultMedia.url` (AC-9).
+   - **Unresolvable**: programmatically construct a Cover whose `metadata.bindings.id.source !== metadata.bindings.url.source` (mismatched). Assert:
+     - `await expect( page.getByText( 'Internal media required for this binding.' ) ).toBeVisible();` (AC-24, OQ-6 primary signal).
+
+**Depends on**: Tasks 1–9 (the entire feature must be present and working server-side AND client-side before this test passes).
+
+**Traces to**: Spec Req 29, Req 30, Req 31, Req 32, Req 33; AC-7, AC-8, AC-9, AC-10, AC-11, AC-12, AC-13, AC-14, AC-15, AC-16, AC-22, AC-23, AC-24; Design §11.3.
+
+**Acceptance**:
+- The new test passes when run via `npm run test:e2e -- test/e2e/specs/editor/blocks/cover.spec.js`.
+- All existing tests in `cover.spec.js` continue to pass (AC-35).
+- The unresolvable-binding assertion uses the i18n message string `Internal media required for this binding.` (NOT the `data-testid`) — i.e. the primary OQ-6 contract.
+- The hidden-controls assertions are positive ("zero matches") — they fail loudly if any control reappears.
+
+---
+
+### Task 13: Backport-changelog stub and PR description draft
+
+**Goal**: Satisfy the PR-shape requirements (Req 36, Req 37, AC-26, AC-27) by adding the backport-changelog placeholder file and drafting the PR description text. This task lands the backport entry once the Core PR number is known (per Design §2.2 and §15 risk 6, the entry can be added with a `TODO` placeholder if the Core PR doesn't yet exist; final number gets filled in before merge).
+
+**Files**:
+- `backport-changelog/7.1/<core-pr-number>.md` — CREATE (use `TODO-cover-bindings.md` as a placeholder filename if Core PR # is not yet known; rename before merging).
+- (No file output for the PR description; the code-writer composes it in the GitHub PR body.)
+
+**Changes**:
+1. Create `backport-changelog/7.1/<core-pr-number>.md` containing the single line:
+   ```
+   * https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>
+   ```
+   per the established `backport-changelog` format (verify against existing entries in `backport-changelog/7.1/`).
+2. In the PR description (composed in the GitHub PR body), include:
+   - The text "Fixes #77199" (AC-27).
+   - An explicit statement of the relationship to #74109 and #74610: "This PR subsumes the work of #74109 and #74610, replacing them with a narrowly-scoped, internal-only design. Those PRs may be closed." (AC-27; phrasing may vary, but the explicit relationship statement is mandatory.)
+   - A "Test plan" section enumerating the unit, PHPUnit, and e2e cases added (see Tasks 10–12).
+
+**Depends on**: Tasks 10–12 (the PR description references the test cases; the backport stub references the Gutenberg PR which is opened only after all the code is in place).
+
+**Traces to**: Spec Req 36, Req 37, Req 38, Req 39; AC-26, AC-27, AC-28; Design §12.
+
+**Acceptance**:
+- A file exists at `backport-changelog/7.1/<core-pr-number>.md` (or a `TODO`-named placeholder) and follows the established 7.1 backport entry format.
+- The Gutenberg PR description (when opened) contains the literal text `Fixes #77199` and explicitly references #74109 and #74610.
+- The total net diff (additions − deletions, across Tasks 1–13) is targeted at ~500 lines — verified after all tasks land by `git diff --stat trunk...HEAD`. The design's §12 estimate of ~533 lines is the budget; reviewers may request trimming the e2e block per Design §12 if the diff overshoots.
+- No file is created under `lib/compat/wordpress-7.0/` (AC-26 negative invariant).

From 9ba9c6a54956276ca3be4acb57e1bac1de90974f Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:36:52 +0200
Subject: [PATCH 19/60] docs(pipeline): add
 3-plan/code-plan-review-1-rejected.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../3-plan/code-plan-review-1-rejected.md     | 127 ++++++++++++++++++
 1 file changed, 127 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-1-rejected.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-1-rejected.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-1-rejected.md
new file mode 100644
index 00000000000000..b0d1332fac3f9e
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-1-rejected.md
@@ -0,0 +1,127 @@
+# Code Plan Review
+
+## Verdict: rejected
+
+## Summary
+
+The plan is dense, well-traced, and largely faithful to the approved design. Every spec AC (AC-1..AC-28) is mapped to at least one task, ordering keeps the tree green, granularity is right, and the headline e2e test does exercise Pattern Overrides default-override-reset plus the unresolvable-binding affordance. However, **one finding is a hard feasibility blocker**: Task 6 prescribes importing `replacePatternOverridesDefaultBinding` from `@wordpress/block-editor`, but that helper is NOT publicly exported — the import will not resolve and the new hook will not compile. A handful of smaller defects also need addressing: a nonexistent `AC-35` is referenced in three tasks, the `backport-changelog` file shape in Task 13 is wrong (it omits the wordpress-develop URL line), Task 8 does not state the `url`→`effectiveUrl` swap in the non-empty render-branch predicate, Task 7's acceptance silently drops `overlayColor`/`customOverlayColor` from the DC-2 prohibition list without flagging it as an intentional carve-out, and Task 6/7 hand-wave the `context` parameter even though `CoverEdit` destructures it into `{ postId, postType }` at the prop boundary. Fixing these — especially the import — is mechanical and well within one iteration.
+
+## Issues
+
+### Issue 1 (SEVERITY: HIGH — feasibility blocker): `replacePatternOverridesDefaultBinding` is not exported from `@wordpress/block-editor`
+
+**What's wrong:** Task 6 step 2 specifies `Imports: replacePatternOverridesDefaultBinding from @wordpress/block-editor (utils/block-bindings)`. The function exists at `/Users/carlos/Developer/gutenberg/packages/block-editor/src/utils/block-bindings.js:27` but `packages/block-editor/src/utils/index.js` does NOT re-export it (only `transformStyles` and `getPxFromCssUnit`), and `packages/block-editor/src/index.js` only re-exports `./utils` (and `./private-apis`, but neither file forwards the helper). Verified: a `grep -rn "replacePatternOverridesDefaultBinding"` of the source tree shows only one in-package importer (`packages/block-editor/src/components/block-edit/edit.js`) using the relative path `../../utils/block-bindings`. The plan's import path resolves to nothing public; the file will fail to build the moment the code-writer types `import { replacePatternOverridesDefaultBinding } from '@wordpress/block-editor';`.
+
+**Where in plan:** Task 6 (`packages/block-library/src/cover/edit/use-cover-binding-state.js`), §Changes step 2, and (indirectly) the §Acceptance bullets that assume the hook computes `bindingActive` via this helper.
+
+**Suggestion:** Pick ONE and write it into the task explicitly:
+- (a) Re-implement the `__default` expansion inline in `use-cover-binding-state.js` (3-4 lines mirroring `packages/block-editor/src/utils/block-bindings.js:27-46`); OR
+- (b) Add a sibling sub-task that exports `replacePatternOverridesDefaultBinding` from `packages/block-editor/src/utils/index.js` (and runs `npm run build` if needed); OR
+- (c) Route through the existing block-editor private-APIs (`lock-unlock`) — but that requires first locking the helper, which is a public-API decision that should be raised with reviewers.
+The plan currently leaves this design decision to the code-writer, which is exactly what the plan-writer is supposed to resolve.
+
+**Why it matters:** The blocker stops the very first task that depends on it (Task 6) and blocks every downstream task (7, 8, 9, 11, 12). The code-writer cannot make this call mid-task — option (b) is a cross-package public-API change and (c) is a reviewer-gated private-API decision; both belong in the plan, not in implementation.
+
+---
+
+### Issue 2 (SEVERITY: MEDIUM — broken traceability): Plan references nonexistent `AC-35`
+
+**What's wrong:** Tasks 10, 11, and 12 each cite "AC-35" as the spec anchor for non-regression assertions. The spec defines acceptance criteria AC-1..AC-28 only — there is no AC-35. The spec's non-regression bullet under "Tests" is **Req 35**, not AC-35.
+
+**Where in plan:**
+- Task 10 §Acceptance: `The pre-existing test methods in render-block-cover-test.php continue to pass (AC-20, AC-35 non-regression).`
+- Task 11 §Acceptance: `The pre-existing edit.js tests continue to pass (AC-35 non-regression).`
+- Task 12 §Acceptance: `All existing tests in cover.spec.js continue to pass (AC-35).`
+
+**Suggestion:** Replace all three with `Req 35` (or simply `AC-20`, since the spec uses AC-20 — "Unbound Cover behavior MUST be unchanged" — as the non-regression invariant). Either is acceptable; the goal is that the trace resolves.
+
+**Why it matters:** A reviewer following the trace chain hits a dead end. The orchestrator's `code-plan-reviewer` workflow specifically calls for traceable tasks; an undefined anchor is a real defect.
+
+---
+
+### Issue 3 (SEVERITY: MEDIUM — wrong file shape): Task 13 backport-changelog entry omits the wordpress-develop URL
+
+**What's wrong:** Task 13 step 1 says `Create backport-changelog/7.1/<core-pr-number>.md containing the single line: * https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>`. Existing entries in `backport-changelog/7.1/` (verified by reading `backport-changelog/7.1/10869.md`) use the format:
+```
+https://github.com/WordPress/wordpress-develop/pull/<core-pr-number>
+
+* https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>
+```
+— two lines, the first being the wordpress-develop URL (matching the filename), then a blank line, then the bulleted gutenberg URL.
+
+**Where in plan:** Task 13 §Changes step 1.
+
+**Suggestion:** Update the change description and the acceptance bullet to match the established two-line shape. Concretely:
+```
+https://github.com/WordPress/wordpress-develop/pull/<core-pr-number>
+
+* https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>
+```
+
+**Why it matters:** AC-26 / Req 36 explicitly require the backport-changelog entry; if the code-writer follows the plan verbatim the format will be wrong and a reviewer will reject the PR.
+
+---
+
+### Issue 4 (SEVERITY: MEDIUM — granularity / hidden design decision): Task 8 does not specify the `url` → `effectiveUrl` swap in the non-empty image branch predicate
+
+**What's wrong:** Task 8 step 2 says "In the non-empty image render branch (around `url && isImageBackground` near line 672)" and then describes the `bindingActive` force-`<img>` form using `src={ effectiveUrl }`. But the **predicate** itself (`url && isImageBackground`) is not explicitly rewritten. Design §5.4 (2) is explicit: `{ ! bindingUnresolvable && effectiveUrl && isImageBackground && ( ... ) }`. As written, the plan leaves the code-writer to decide whether to keep `url` in the predicate (in which case `bindingResolvedUrl` alone — with no stored `url` — never reaches the branch) or to swap it to `effectiveUrl`. This is a design decision hidden inside a task.
+
+**Where in plan:** Task 8 §Changes step 2.
+
+**Suggestion:** Make the predicate swap explicit. Rewrite step 2 to say something like: "Replace the non-empty image branch's outer predicate `{ url && isImageBackground && (...) }` with `{ ! bindingUnresolvable && effectiveUrl && isImageBackground && (...) }`. Then, inside, branch on `bindingActive ? (force-img form) : (existing img-or-div form using `url`)`." Add to acceptance: "The non-empty branch's gating predicate uses `effectiveUrl`, not the stored `url`."
+
+**Why it matters:** With the predicate left as `url && isImageBackground`, a pattern-instance Cover whose stored `url` is empty (because Pattern Overrides reset just cleared it, or because the synced pattern was authored with no default) but whose `bindingResolvedUrl` is populated would render the empty-cover branch instead of the bound `<img>`, failing AC-7 (default state shows pattern default image). This is the headline Pattern Overrides path — it must not be left to chance.
+
+---
+
+### Issue 5 (SEVERITY: LOW — spec-vs-plan acceptance contradiction): Task 7 silently removes `overlayColor` / `customOverlayColor` from the DC-2 prohibition list
+
+**What's wrong:** Spec DC-2 enumerates the prohibition list as: `dimRatio, useFeaturedImage, backgroundType, id, url, hasParallax, isRepeated, overlayColor, customOverlayColor`. Task 7 §Acceptance bullet 3 reads: "The observer body does NOT call `setAttributes` for `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, or `customOverlayColor`." — `overlayColor` is missing. Separately, Task 7 §Changes step 5(vi) explicitly calls `setOverlayColor( avg )` and includes a parenthetical explaining that this is "a continuation of trunk's existing media-resolution path". The design doc made the same source-agnostic argument and was approved with that carve-out.
+
+The contradiction: the spec's DC-2 list contains `overlayColor`/`customOverlayColor`; the plan's per-task acceptance silently drops `overlayColor`. The plan is correct to align with the approved design's carve-out, but the acceptance bullet should explicitly call out the carve-out so reviewers and future maintainers see it.
+
+**Where in plan:** Task 7 §Acceptance bullet 3.
+
+**Suggestion:** Rewrite the bullet to make the carve-out load-bearing. For example: "The observer body does NOT call `setAttributes` for any of the DC-2-prohibited attributes EXCEPT `overlayColor`/`customOverlayColor`, whose mutation via `setOverlayColor( avg )` is a deliberate source-agnostic continuation of trunk behaviour per design §5.3 (this is not a fresh binding-state-triggered write — it is the same media-resolution path that fires for manual selection and `useFeaturedImage` URLs). The only `setAttributes` call inside the observer is `{ isDark }`."
+
+**Why it matters:** As written, a future reviewer comparing spec DC-2 to plan acceptance sees a silent omission and may flag it. Making the carve-out explicit and traceable to design §5.3 closes the gap with one sentence.
+
+---
+
+### Issue 6 (SEVERITY: LOW — unspecified plumbing): Task 6 / Task 7 don't say how `context` is threaded into `useCoverBindingState`
+
+**What's wrong:** Task 6 declares the hook signature `useCoverBindingState({ clientId, attributes, context })` and Task 7 step 2 calls it with the same shape. But `CoverEdit`'s prop signature (verified at `packages/block-library/src/cover/edit/index.js:87-96`) already destructures `context: { postId, postType }` — there is no `context` identifier in scope inside the component body. To pass `context` to the hook, the code-writer must either (a) un-destructure the prop and keep a reference, (b) reconstruct an object `{ postId, postType }`, or (c) add a new parameter at the prop boundary. The plan doesn't say which. Block-Bindings sources expect to receive the full `context` object as built by `EditWithGeneratedProps` (verified at `packages/block-editor/src/components/block-edit/edit.js:149-154`), which means option (b)'s ad-hoc reconstruction would be wrong — the source may need other context keys.
+
+**Where in plan:** Task 6 §Changes step 1 (hook signature) and Task 7 §Changes step 2 (call site).
+
+**Suggestion:** Add to Task 7's prerequisites or §Changes a concrete step: "Change `CoverEdit`'s prop destructuring from `context: { postId, postType }` to `context` (an un-destructured reference), and read `postId`/`postType` via `context.postId`/`context.postType` at the call sites that currently use them. Then pass `context` directly into `useCoverBindingState({ clientId, attributes, context })`." This makes the prop-boundary change explicit and preserves the source's expected context contract.
+
+**Why it matters:** Without this, the code-writer either invents a partial `context` reconstruction (breaking some binding sources) or silently changes the prop destructuring without surfacing the diff in the PR description. Either way it is a hidden design decision in a "small" task.
+
+---
+
+### Issue 7 (SEVERITY: LOW — missed design coverage): Task 12 omits the embed-video control-case assertion called out in design §11.3
+
+**What's wrong:** Design §11.3 explicitly lists, as part of the e2e default-state assertions: "On a SEPARATE embed-video Cover (control case), the same button IS visible with the 'Embed video from URL' MenuItem accessible (AC-21 preserved on the population where `backgroundType === 'embed-video'`)." Task 12 §Changes step 3 enumerates the default-state assertions but does not include this positive AC-21 control case.
+
+**Where in plan:** Task 12 §Changes step 3 (Default state assertions block).
+
+**Suggestion:** Either (a) add the embed-video control-case assertion to Task 12's default-state checklist with an explicit AC-21 trace; or (b) explicitly justify in the plan that AC-21 is covered server-side by Task 10's `test_embed_video_short_circuits` PHPUnit case and editor-side by Task 11's `bindingActive false for embed-video` Jest case, so an additional e2e step would be redundant. Either resolution is fine — silent omission is not.
+
+**Why it matters:** The design doc was approved with this assertion in scope; dropping it without justification is a regression against an approved design decision. AC-21 ("no regression on embed-video covers") is a load-bearing carve-out and deserves the explicit positive assertion the design called for.
+
+---
+
+### Issue 8 (SEVERITY: LOW — coverage nit): Several Reqs are not explicitly traced
+
+**What's wrong:** Sweeping the plan's `Traces to:` lines, the following spec Reqs are never explicitly cited: Req 9 (Pattern Overrides controls work automatically — implicitly covered by Req 2 / Task 2), Req 23 (Unbound Cover non-regression — implicitly covered by Task 10's AC-20 case), Req 24 (Pattern Overrides four-state round-trip — implicitly covered by Task 12), Req 28 (no new global APIs — a design choice with no task), Req 34 (PHPUnit case — covered by Task 10), Req 35 (existing tests continue to pass — referenced as the bogus `AC-35` per Issue 2). Most have implicit coverage but none are cited. This is a nit, not a defect, but the spec's "every requirement maps to at least one task" expectation is not literally satisfied.
+
+**Where in plan:** Tasks 2 / 10 / 12 / 13 (their `Traces to:` lines).
+
+**Suggestion:** Either (a) add the missing Reqs to the appropriate task `Traces to:` lines; or (b) acknowledge in the Overview that some Reqs are design-level (Req 28) or are subsumed by other cited Reqs/ACs. Lowest-effort fix: append Req 9 to Task 2, Req 23 to Task 10, Req 24 to Task 12, Req 34 to Task 10, and Req 35 to Tasks 10/11/12 (replacing the bogus AC-35 from Issue 2). Req 28 is design-only and can be omitted with a note.
+
+**Why it matters:** Adversarial reviewers (including the next pipeline iteration) will check trace coverage; missing Reqs reduce confidence even when the substance is covered.
+
+---
+
+End of issues.

From 57bd14541d1a3937b38ec9840d7ea5a462f725b5 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:42:04 +0200
Subject: [PATCH 20/60] docs(pipeline): revise 3-plan/code-plan.md for
 77199-cover-bindings-id-url-internal (iter 2)

Address code-plan-review-1-rejected.md findings.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../3-plan/code-plan.md                       | 111 +++++++++++++-----
 1 file changed, 80 insertions(+), 31 deletions(-)

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md
index 782aff85bf2328..edbc136d000b10 100644
--- a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md
+++ b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md
@@ -17,6 +17,8 @@ Land internal-only Block Bindings support for `core/cover`'s `id` and `url` attr
 
 Each task lists files (CREATE/MODIFY), atomic changes, the spec/design slices it traces to, dependencies, and observable acceptance. Code-writers implement each task TDD-style: write failing tests first, then the production code, then refactor — the per-task acceptance bullets describe *what* must be true, not *which* test files (the code-writer chooses the test files).
 
+**Coverage note (per iter-2 review Issue 8).** Every spec requirement traces to at least one task. Req 28 ("no new global Block Bindings APIs") is a design-level invariant — the design doc selects Approach A (Cover-scoped filters) explicitly to satisfy it, and there is no task to add because there is nothing to build — it is an architectural prohibition enforced by the absence of any new global API across Tasks 1–13. Reviewers verifying Req 28 should check that the diff introduces no `register_*` calls beyond the standard `add_filter( 'block_bindings_supported_attributes', … )` (Task 2) and the two Cover-scoped `add_filter( 'render_block_data' … )` / `add_filter( 'render_block', … 9, 3 )` registrations (Tasks 4 and 5) — none of which is a new global API.
+
 ---
 
 ## Tasks
@@ -63,7 +65,7 @@ Each task lists files (CREATE/MODIFY), atomic changes, the spec/design slices it
 
 **Depends on**: Task 1
 
-**Traces to**: Spec Req 2, Req 8, AC-1, AC-2; Design §6.1 Part 1, §8, §2.2.
+**Traces to**: Spec Req 2, Req 8, Req 9 (Pattern Overrides controls — "Enable overrides" affordance and `<ResetOverridesControl>` — work automatically once the cover is allow-listed via this filter, with no Cover-specific UI code); AC-1, AC-2; Design §6.1 Part 1, §8, §2.2.
 
 **Acceptance**:
 - `lib/compat/wordpress-7.1/block-bindings.php` exists and is loaded by `lib/load.php`.
@@ -192,31 +194,55 @@ Each task lists files (CREATE/MODIFY), atomic changes, the spec/design slices it
 - `packages/block-library/src/cover/edit/use-cover-binding-state.js` — CREATE.
 
 **Changes**:
-1. New file exporting a default function: `export default function useCoverBindingState( { clientId, attributes, context } ) { … }`.
-2. Imports: `replacePatternOverridesDefaultBinding` from `@wordpress/block-editor` (`utils/block-bindings`), `getBlockBindingsSource` from `@wordpress/blocks`, `useSelect` from `@wordpress/data`, `store as coreStore` from `@wordpress/core-data`.
-3. Body:
-   - Read `attributes.metadata?.bindings`. If absent, return `{ bindingActive: false, bindingUnresolvable: false, bindingResolvedUrl: undefined, bindingResolvedId: undefined, canUserEditBindingValue: false }` early.
-   - Call `const expanded = replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] );`.
+1. New file exporting a default function with signature `export default function useCoverBindingState( { clientId, attributes, context } ) { … }`. The `context` parameter is the full, undestructured context object (see Task 7 step 2 for the prop-boundary change in `CoverEdit` that produces it). Do NOT reconstruct a partial `{ postId, postType }` shape — binding sources may declare `usesContext` for additional keys and need the full object.
+2. Imports:
+   - `getBlockBindingsSource` from `@wordpress/blocks`
+   - `useSelect` from `@wordpress/data`
+   - `store as coreStore` from `@wordpress/core-data`
+   - Do NOT import `replacePatternOverridesDefaultBinding` from `@wordpress/block-editor`. It is NOT publicly re-exported from the package (verified: `packages/block-editor/src/index.js` re-exports `./utils` and `./utils/index.js` re-exports only `transformStyles` and `getPxFromCssUnit`; the helper at `packages/block-editor/src/utils/block-bindings.js:27` is consumed in-tree only via the relative path `../../utils/block-bindings`). Importing it from `@wordpress/block-editor` would fail to resolve.
+3. Re-implement `__default` expansion inline in this file as a tiny module-local helper (chosen resolution per iter-2 review Issue 1, option (c)). This duplicates ~10 lines of `packages/block-editor/src/utils/block-bindings.js:1-46` but avoids both (a) a cross-package public-API change to re-export the helper and (b) the private-APIs `lock`/`unlock` plumbing required to reach it through the channel `block-editor/src/components/block-edit/edit.js:28` uses (`import { unlock } from '../../lock-unlock'` is itself a private hatch into the package — not a stable cross-package contract). The DRY cost is bounded because the helper is small, has no internal dependencies beyond two string constants, and has been stable in trunk since Pattern Overrides shipped:
+
+   ```js
+   const PATTERN_OVERRIDES_SOURCE = 'core/pattern-overrides';
+   function expandDefaultBinding( bindings, supportedAttributes ) {
+       if ( bindings?.__default?.source !== PATTERN_OVERRIDES_SOURCE ) {
+           return bindings;
+       }
+       const expanded = {};
+       for ( const attr of supportedAttributes ) {
+           expanded[ attr ] = bindings[ attr ]
+               ? bindings[ attr ]
+               : { source: PATTERN_OVERRIDES_SOURCE };
+       }
+       return expanded;
+   }
+   ```
+
+   Place this above the hook body. Add a one-line code comment that points at `packages/block-editor/src/utils/block-bindings.js` so a future reader knows where the canonical implementation lives and the divergence risk is acknowledged. If Core later promotes the helper to a public re-export (a separate, owner-gated decision), this duplication becomes a one-line swap.
+4. Body:
+   - Read `const bindings = attributes.metadata?.bindings;`. If absent, return `{ bindingActive: false, bindingUnresolvable: false, bindingResolvedUrl: undefined, bindingResolvedId: undefined, canUserEditBindingValue: false }` early.
+   - Call `const expanded = expandDefaultBinding( bindings, [ 'id', 'url' ] );` (the local helper from step 3).
    - Compute `bindingActive` per Design §5.1 step 2: both `expanded.id` and `expanded.url` are present, same `source`, `JSON.stringify( expanded.id.args ?? null ) === JSON.stringify( expanded.url.args ?? null )`, AND `attributes.backgroundType !== 'embed-video'`.
-   - Single `useSelect` (Design §5.1 step 3): when `bindingActive`, look up the source via `getBlockBindingsSource( expanded.url.source )`, call `source.getValues( { select, clientId, context, bindings: { id: expanded.id, url: expanded.url } } )`, then if `values.id` is truthy, also call `select( coreStore ).getEntityRecord( 'postType', 'attachment', values.id, { context: 'view' } )`. Return `{ bindingResolvedUrl, bindingResolvedId, bindingResolvedAttachment }` from the closure.
-   - Dependency array: `[ bindingActive, expanded?.id?.source, expanded?.url?.source, clientId ]`.
+   - Single `useSelect` (Design §5.1 step 3): when `bindingActive`, look up the source via `getBlockBindingsSource( expanded.url.source )`, call `source.getValues( { select, clientId, context, bindings: { id: expanded.id, url: expanded.url } } )`, then if `values.id` is truthy, also call `select( coreStore ).getEntityRecord( 'postType', 'attachment', values.id, { context: 'view' } )`. Return `{ bindingResolvedUrl, bindingResolvedId, bindingResolvedAttachment }` from the closure. Pass `context` through as the full object received from the hook's argument (NOT a reconstructed partial).
+   - Dependency array: `[ bindingActive, expanded?.id?.source, expanded?.url?.source, clientId, context ]`.
    - Compute `bindingUnresolvable`:
      - `true` if `bindings` has any cover-relevant configuration (`bindings.__default` exists, OR `bindings.id` exists, OR `bindings.url` exists) AND `! bindingActive` — i.e. malformed/mismatched binding.
      - OR `true` if `bindingActive && bindingResolvedAttachment === null` (resolved-not-found; remember `undefined` means pending — NOT unresolvable).
      - OR `true` if `bindingActive && bindingResolvedAttachment?.type && bindingResolvedAttachment.type !== 'attachment'`.
    - Compute `canUserEditBindingValue` from the source: `getBlockBindingsSource( expanded.url.source )?.canUserEditValue?.( … ) ?? false`. (Used for future lock-flag wiring; safe to return `false` if not applicable.)
    - Return `{ bindingActive, bindingUnresolvable, bindingResolvedUrl, bindingResolvedId, canUserEditBindingValue }`.
-4. The hook returns plain values. No memoised React elements, no `useEffect`.
+5. The hook returns plain values. No memoised React elements, no `useEffect`.
 
 **Depends on**: Task 2 (the editor setting `__experimentalBlockBindingsSupportedAttributes['core/cover']` must include `id`/`url`).
 
-**Traces to**: Spec Req 10, Req 25, Req 26, Req 27; AC-3, AC-4, AC-6, AC-21; DC-1, DC-3; Design §5.1, §5.6 (Pattern Overrides integration via `replacePatternOverridesDefaultBinding`).
+**Traces to**: Spec Req 9, Req 10, Req 25, Req 26, Req 27; AC-3, AC-4, AC-6, AC-21; DC-1, DC-3; Design §5.1, §5.6 (Pattern Overrides integration via the inline-duplicated `__default` expansion that mirrors `replacePatternOverridesDefaultBinding`).
 
 **Acceptance**:
 - Called with `attributes.metadata.bindings === undefined`: returns `bindingActive: false`, `bindingUnresolvable: false`.
-- Called with `attributes.metadata.bindings = { __default: { source: 'core/pattern-overrides' } }`: returns `bindingActive: true`.
+- Called with `attributes.metadata.bindings = { __default: { source: 'core/pattern-overrides' } }`: returns `bindingActive: true`. (Confirms inline `__default` expansion works.)
 - Called with `attributes.metadata.bindings = { id: { source: 'x' }, url: { source: 'y' } }`: returns `bindingActive: false, bindingUnresolvable: true`.
 - Called with `attributes.metadata.bindings = { id: { source: 'x' }, url: { source: 'x' } }` AND `attributes.backgroundType = 'embed-video'`: returns `bindingActive: false` (embed-video override).
+- The hook does NOT import from `@wordpress/block-editor`'s `utils/block-bindings` path (which is not publicly re-exported). The `__default` expansion is implemented inline in this file.
 - The hook subscribes via exactly ONE `useSelect`. (Verifiable by code review / by counting `useSelect` calls in the file.)
 - The hook does NOT call `useEffect`. (Verifiable by code review.)
 - When `bindingActive` is true but the attachment record is loading (selector returns `undefined`), `bindingUnresolvable` is `false` (treated as pending, not unresolvable).
@@ -235,21 +261,38 @@ Each task lists files (CREATE/MODIFY), atomic changes, the spec/design slices it
 1. Add imports at the top of the file:
    - `import useCoverBindingState from './use-cover-binding-state';`
    - Ensure `useEffectEvent`, `useRef`, `useEffect` are imported from `@wordpress/element` (some may already be present).
-2. Inside `CoverEdit` body, after the existing props/state destructuring, before any existing `useEffect`:
+2. **Prop-boundary change for `context`** — `CoverEdit` currently destructures `context: { postId, postType }` in its props signature (verified at `packages/block-library/src/cover/edit/index.js:95`), so there is no `context` identifier in scope. Change the destructuring to keep `context` undestructured AND keep `postId`/`postType` available:
+   ```js
+   function CoverEdit( {
+       attributes,
+       clientId,
+       isSelected,
+       overlayColor,
+       setAttributes,
+       setOverlayColor,
+       toggleSelection,
+       context,
+   } ) {
+       const { postId, postType } = context;
+       …
+   }
+   ```
+   Existing references to `postId` / `postType` (e.g. the `useEntityProp( 'postType', postType, 'featured_media', postId )` call at line ~119) continue to work unchanged because the new destructure declares the same identifiers. The hook receives the full, undestructured `context` object — sources may declare `usesContext` for keys beyond `postId`/`postType` and need access to them.
+3. Inside `CoverEdit` body, after the existing props/state destructuring, before any existing `useEffect`:
    - `const { bindingActive, bindingUnresolvable, bindingResolvedUrl, bindingResolvedId, canUserEditBindingValue } = useCoverBindingState( { clientId, attributes, context } );`
    - `const raceTokenRef = useRef( 0 );`
-3. Compute `effectiveUrl`:
+4. Compute `effectiveUrl`:
    ```js
    const effectiveUrl =
        bindingResolvedUrl ??
        ( useFeaturedImage ? mediaUrl : originalUrl?.replaceAll( '&amp;', '&' ) );
    ```
-4. Compute `effectiveDimRatio`:
+5. Compute `effectiveDimRatio`:
    ```js
    const effectiveDimRatio =
        bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio;
    ```
-5. Replace the existing `useEffect( () => { /* getMediaColor on mediaUrl */ }, [ mediaUrl ] )` block with:
+6. Replace the existing `useEffect( () => { /* getMediaColor on mediaUrl */ }, [ mediaUrl ] )` block with:
    - `const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => { … } );` whose body:
      1. Returns early if `! resolvedUrl`.
      2. Increments `raceTokenRef.current` into a local `myToken`.
@@ -260,8 +303,8 @@ Each task lists files (CREATE/MODIFY), atomic changes, the spec/design slices it
      7. Compute `newIsDark` from `compositeIsDark( …, … , avg )` using `effectiveDimRatio`-equivalent latest values per Design §5.2.
      8. `__unstableMarkNextChangeAsNotPersistent()` + `setAttributes( { isDark: newIsDark } )` (allowed; `isDark` is NOT in DC-2's prohibition list).
    - One `useEffect( () => { onUrlResolved( effectiveUrl ); }, [ effectiveUrl, onUrlResolved ] );`.
-6. The existing event handlers (`onSelectMedia`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`, `toggleUseFeaturedImage`, `onSelectEmbedUrl`) are UNCHANGED — they continue to mutate stored attributes in response to user intent (allowed under DC-2).
-7. The overlay-span class computation MUST use `effectiveDimRatio` rather than `dimRatio` in `dimRatioToClass( … )` (verify the JSX site exists; trunk code references the overlay `<span>` near the dim-class computation — pass `effectiveDimRatio` through).
+7. The existing event handlers (`onSelectMedia`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`, `toggleUseFeaturedImage`, `onSelectEmbedUrl`) are UNCHANGED — they continue to mutate stored attributes in response to user intent (allowed under DC-2).
+8. The overlay-span class computation MUST use `effectiveDimRatio` rather than `dimRatio` in `dimRatioToClass( … )` (verify the JSX site exists; trunk code references the overlay `<span>` near the dim-class computation — pass `effectiveDimRatio` through).
 
 **Depends on**: Task 6
 
@@ -271,7 +314,7 @@ Each task lists files (CREATE/MODIFY), atomic changes, the spec/design slices it
 - The file contains exactly ONE `useEffect` whose dependency array includes `effectiveUrl`. No new `useEffect` keyed on `metadata.bindings`, `useFeaturedImage`, or similar event sources is introduced. (DC-1 enforcement — verifiable by code review.)
 - `effectiveUrl` is computed exactly once at the top of `CoverEdit`, prefers `bindingResolvedUrl`, falls back to `useFeaturedImage`'s `mediaUrl`, then to `originalUrl`.
 - `effectiveDimRatio` is 50 only when `bindingActive && dimRatio === 100 && effectiveUrl`. In all other cases it equals `dimRatio`.
-- The observer body does NOT call `setAttributes` for `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, or `customOverlayColor`. The only attribute write inside the observer is `isDark`. (DC-2 enforcement — verifiable by inspection.)
+- The observer body does NOT call `setAttributes` (or any equivalent attribute write) for any of the DC-2-prohibited attributes — `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, `customOverlayColor` — EXCEPT for `overlayColor`/`customOverlayColor`, whose mutation via `setOverlayColor( avg )` is a deliberate source-agnostic carve-out per Design §5.2/§5.3: it is the same media-resolution path that fires for manual selection and `useFeaturedImage` URLs, NOT a fresh binding-state-triggered write. Per DC-3 the observer cannot branch on URL source, so this `setOverlayColor` call IS the source-agnostic continuation of trunk behaviour. The only fresh `setAttributes` call inside the observer is `{ isDark }`. (DC-2 enforcement — verifiable by inspection. Acceptance for Task 11 has a corresponding mock-setAttributes test.)
 - When two `effectiveUrl` changes happen in quick succession, only the latest `getMediaColor` resolution actually writes `overlayColor` / `isDark` (race-token-protected).
 - The overlay span class uses `dimRatioToClass( effectiveDimRatio )` rather than `dimRatioToClass( dimRatio )`.
 
@@ -294,10 +337,11 @@ Each task lists files (CREATE/MODIFY), atomic changes, the spec/design slices it
      - If `bindingUnresolvable`, render `<Placeholder data-testid="cover-binding-unresolvable" className="wp-block-cover__binding-unresolvable" withIllustration instructions={ __( 'Internal media required for this binding.' ) } />`.
      - Else (bindingActive but pending resolution), render `<Placeholder className="wp-block-cover__binding-pending" withIllustration />`.
    - Else fall through to the existing trunk `<CoverPlaceholder>` return — UNCHANGED.
-2. In the non-empty image render branch (around `url && isImageBackground`):
-   - Add the `! bindingUnresolvable` predicate so the image element is never emitted for unresolvable bindings.
-   - When `bindingActive`, force-render `<img ref={ mediaElement } className="wp-block-cover__image-background" alt={ alt } src={ effectiveUrl } style={ mediaStyle } />` (skipping the `isImgElement` check that would otherwise pick a `<div>` for parallax/repeat saved markup).
-   - When `! bindingActive`, the existing trunk JSX (with `isImgElement` switching between `<img>` and `<div>`) is preserved verbatim.
+2. In the non-empty image render branch (around `url && isImageBackground` near line 672):
+   - **Swap the outer gating predicate from the stored `url` to the derived `effectiveUrl`, AND add the `! bindingUnresolvable` guard.** Concretely, rewrite the predicate `{ url && isImageBackground && ( … ) }` to `{ ! bindingUnresolvable && effectiveUrl && isImageBackground && ( … ) }`. This is a Pattern-Overrides-critical change — per Design §5.4 (2) — because on a pattern-instance Cover whose stored `url` is empty (e.g. immediately after a Pattern Overrides reset that cleared the override, or when the synced pattern was authored with no default) but whose `bindingResolvedUrl` is populated, gating on the stored `url` would route the cover through the empty-cover branch and AC-7 would fail. Gating on `effectiveUrl` keeps the bound `<img>` rendering through the branch.
+   - Inside the (now `effectiveUrl`-gated) branch, switch on `bindingActive`:
+     - When `bindingActive`, force-render `<img ref={ mediaElement } className="wp-block-cover__image-background" alt={ alt } src={ effectiveUrl } style={ mediaStyle } />` (skipping the `isImgElement` check that would otherwise pick a `<div>` for parallax/repeat saved markup).
+     - When `! bindingActive`, the existing trunk JSX (with `isImgElement` switching between `<img>` and `<div>`, and reading `src={ url }`) is preserved verbatim. Importantly, this branch continues to read the stored `url`, NOT `effectiveUrl`, on unbound covers — `effectiveUrl` collapses to `url` when no binding is active (per Task 7 step 4), so the user-observable output is byte-identical to trunk on unbound covers (AC-20).
 3. The overlay span: pass `effectiveDimRatio` to `dimRatioToClass` (this is the same change as in Task 7 step 7 — Task 7 establishes the derived value; Task 8 confirms the call site).
 4. Import `__` from `@wordpress/i18n` if not already imported (it almost certainly already is).
 5. Import `Placeholder` from `@wordpress/components` if not already imported.
@@ -309,6 +353,7 @@ Each task lists files (CREATE/MODIFY), atomic changes, the spec/design slices it
 **Acceptance**:
 - On a Cover with no bindings and no background, the existing `<CoverPlaceholder>` renders (no regression — AC-20).
 - On a Cover with `bindingUnresolvable: true`, the editor preview contains a `<Placeholder>` whose accessible text includes the literal string `Internal media required for this binding.`. Its containing element has `data-testid="cover-binding-unresolvable"`. No `<img class="wp-block-cover__image-background">` is rendered.
+- The non-empty image branch's outer gating predicate uses `effectiveUrl`, NOT the stored `url`. A Cover whose stored `url === ''` but whose `bindingResolvedUrl` is populated (the Pattern Overrides default state on a pattern-instance) reaches the image branch and renders the bound `<img>` (AC-7).
 - On a Cover with `bindingActive: true`, `bindingUnresolvable: false`, and an `effectiveUrl`, the editor preview contains `<img class="wp-block-cover__image-background" src="{effectiveUrl}">` (an `<img>`, not a `<div style="background-image:…">`), even when `hasParallax: true` and `isRepeated: true` are stored on the block.
 - The overlay `<span class="wp-block-cover__background …">` class string uses `effectiveDimRatio` for `dimRatioToClass` — when `dimRatio === 100 && bindingActive && effectiveUrl`, the class string does NOT contain `has-background-dim-100`.
 - On a Cover with `backgroundType: 'embed-video'` and `metadata.bindings` set, `bindingActive` is `false` (from Task 6) → the binding-aware branches do NOT engage and the existing embed-video render path runs unchanged (AC-21).
@@ -376,12 +421,12 @@ In `index.js`:
 
 **Depends on**: Task 5 (the server filter must exist and be loaded).
 
-**Traces to**: Spec Req 17–22, AC-3, AC-5, AC-6, AC-15, AC-16, AC-17, AC-18, AC-19, AC-20, AC-21, AC-25; Design §6.5, §11.2.
+**Traces to**: Spec Req 17–22, Req 23 (Unbound non-regression invariant locked down by `test_unbound_cover_is_byte_identical_to_trunk`), Req 34 (PHPUnit case asserting bound `<img src>` substitution and non-`has-background-dim-100` class), Req 35 (existing tests continue to pass); AC-3, AC-5, AC-6, AC-15, AC-16, AC-17, AC-18, AC-19, AC-20, AC-21, AC-25; Design §6.5, §11.2.
 
 **Acceptance**:
 - All nine new test methods pass.
 - `vendor/bin/phpunit phpunit/blocks/render-block-cover-test.php` exits 0 with no failures and no skipped tests.
-- The pre-existing test methods in `render-block-cover-test.php` continue to pass (AC-20, AC-35 non-regression).
+- The pre-existing test methods in `render-block-cover-test.php` continue to pass (AC-20, Req 35 non-regression).
 - The `test_use_featured_image_with_active_binding_emits_exactly_one_img_with_bound_url` case asserts the bound URL appears in the output exactly once and the featured-image URL does not appear at all (catches AC-18 regressions in either direction).
 - The `test_default_dim_ratio_class_is_relaxed` case asserts BOTH the absence of `has-background-dim-100` AND the presence of `has-background-dim` (preserves the 50%-opacity baseline per OQ-4).
 
@@ -413,12 +458,12 @@ In `index.js`:
 
 **Depends on**: Task 6, Task 7
 
-**Traces to**: Spec Req 10, Req 11, Req 13, Req 26; AC-3, AC-4, AC-6; DC-1, DC-2, DC-3; Design §5.1, §5.2, §11.1.
+**Traces to**: Spec Req 10, Req 11, Req 13, Req 26, Req 35 (existing edit.js tests continue to pass); AC-3, AC-4, AC-6; DC-1, DC-2, DC-3; Design §5.1, §5.2, §11.1.
 
 **Acceptance**:
 - All new test cases pass.
 - `npm run test:unit packages/block-library/src/cover/test/edit.js` exits 0.
-- The pre-existing edit.js tests continue to pass (AC-35 non-regression).
+- The pre-existing edit.js tests continue to pass (Req 35 non-regression).
 - The DC-2 mutation-prohibition test fails the build if a future change introduces `setAttributes({ dimRatio: … })` in the observer.
 
 ---
@@ -445,6 +490,7 @@ In `index.js`:
      - `page.getByRole('button', { name: /^(Replace|Add media)$/ })` resolves to zero matches inside the Cover's block toolbar (AC-13 + AC-14).
      - The overlay span's `class` attribute contains `has-background-dim` but NOT `has-background-dim-100` (AC-15).
      - The `ResetOverridesControl` toolbar button is `toBeDisabled()` (AC-10, OQ-2).
+     - **Embed-video control case (AC-21 preservation, per Design §11.3):** on a SEPARATE Cover inserted in the same post with `backgroundType: 'embed-video'` AND `metadata.bindings` set to a Pattern Overrides shape, assert that the block toolbar `Replace` / `Add media` button IS visible AND the "Embed video from URL" `MenuItem` inside `<MediaReplaceFlow>` IS reachable. This locks in the design's load-bearing carve-out: bindings UI may surface bindable rows on embed-video covers but the binding-aware editor derivations and binding-aware server render path BOTH short-circuit (`bindingActive === false` from Task 6's embed-video gate), so the existing trunk affordances remain intact.
    - **Override**: programmatically set the bound `url`/`id` on the instance (via `editor.dispatch` or by using the Cover's media affordance if available). Assert:
      - The `ResetOverridesControl` button becomes enabled.
      - Editor preview `<img>` src matches `overrideMedia.url`.
@@ -459,13 +505,14 @@ In `index.js`:
 
 **Depends on**: Tasks 1–9 (the entire feature must be present and working server-side AND client-side before this test passes).
 
-**Traces to**: Spec Req 29, Req 30, Req 31, Req 32, Req 33; AC-7, AC-8, AC-9, AC-10, AC-11, AC-12, AC-13, AC-14, AC-15, AC-16, AC-22, AC-23, AC-24; Design §11.3.
+**Traces to**: Spec Req 24 (Pattern Overrides four-state round-trip exercised end-to-end through default → override → reset → unresolvable phases), Req 29, Req 30, Req 31, Req 32, Req 33, Req 35 (existing cover.spec.js tests continue to pass); AC-7, AC-8, AC-9, AC-10, AC-11, AC-12, AC-13, AC-14, AC-15, AC-16, AC-21 (embed-video control case), AC-22, AC-23, AC-24; Design §11.3.
 
 **Acceptance**:
 - The new test passes when run via `npm run test:e2e -- test/e2e/specs/editor/blocks/cover.spec.js`.
-- All existing tests in `cover.spec.js` continue to pass (AC-35).
+- All existing tests in `cover.spec.js` continue to pass (Req 35 non-regression).
 - The unresolvable-binding assertion uses the i18n message string `Internal media required for this binding.` (NOT the `data-testid`) — i.e. the primary OQ-6 contract.
 - The hidden-controls assertions are positive ("zero matches") — they fail loudly if any control reappears.
+- The embed-video control case asserts the `Replace`/`Add media` button IS present AND the `Embed video from URL` `MenuItem` IS reachable on a Cover with `backgroundType: 'embed-video'` and active-looking bindings — this is the AC-21 positive assertion the design (§11.3) calls for.
 
 ---
 
@@ -478,11 +525,13 @@ In `index.js`:
 - (No file output for the PR description; the code-writer composes it in the GitHub PR body.)
 
 **Changes**:
-1. Create `backport-changelog/7.1/<core-pr-number>.md` containing the single line:
+1. Create `backport-changelog/7.1/<core-pr-number>.md` containing the established two-line format (verified against existing entries — e.g. `backport-changelog/7.1/10869.md` has exactly this shape):
    ```
+   https://github.com/WordPress/wordpress-develop/pull/<core-pr-number>
+
    * https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>
    ```
-   per the established `backport-changelog` format (verify against existing entries in `backport-changelog/7.1/`).
+   Line 1 is the bare wordpress-develop URL (must match the filename's PR number). Line 2 is blank. Line 3 is the bulleted Gutenberg PR URL. No surrounding blank line, no closing newline beyond standard end-of-file. The filename's numeric portion (`<core-pr-number>.md`) MUST match the PR number in line 1.
 2. In the PR description (composed in the GitHub PR body), include:
    - The text "Fixes #77199" (AC-27).
    - An explicit statement of the relationship to #74109 and #74610: "This PR subsumes the work of #74109 and #74610, replacing them with a narrowly-scoped, internal-only design. Those PRs may be closed." (AC-27; phrasing may vary, but the explicit relationship statement is mandatory.)
@@ -493,7 +542,7 @@ In `index.js`:
 **Traces to**: Spec Req 36, Req 37, Req 38, Req 39; AC-26, AC-27, AC-28; Design §12.
 
 **Acceptance**:
-- A file exists at `backport-changelog/7.1/<core-pr-number>.md` (or a `TODO`-named placeholder) and follows the established 7.1 backport entry format.
+- A file exists at `backport-changelog/7.1/<core-pr-number>.md` (or a `TODO`-named placeholder) and follows the established 7.1 backport entry two-line format (line 1: `https://github.com/WordPress/wordpress-develop/pull/<core-pr-number>`; blank line; line 3: `* https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>`), matching the shape of every other entry in `backport-changelog/7.1/`.
 - The Gutenberg PR description (when opened) contains the literal text `Fixes #77199` and explicitly references #74109 and #74610.
 - The total net diff (additions − deletions, across Tasks 1–13) is targeted at ~500 lines — verified after all tasks land by `git diff --stat trunk...HEAD`. The design's §12 estimate of ~533 lines is the budget; reviewers may request trimming the e2e block per Design §12 if the diff overshoots.
 - No file is created under `lib/compat/wordpress-7.0/` (AC-26 negative invariant).

From 66041cd78f67a8e1092c8020ee4ecfec514ce8f3 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:45:09 +0200
Subject: [PATCH 21/60] docs(pipeline): add 3-plan/code-plan-review-approved.md
 for 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../3-plan/code-plan-review-approved.md       | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-approved.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-approved.md
new file mode 100644
index 00000000000000..d6af8c7274a372
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-approved.md
@@ -0,0 +1,31 @@
+# Code Plan Review
+
+## Verdict: approved
+
+## Summary
+
+The iter-2 revision of `code-plan.md` cleanly resolves every finding from iter-1's rejection. The plan is faithful to the approved design, every spec AC and Req traces to at least one task, ordering keeps the tree green at every step, and granularity is tight (each task has explicit file paths, explicit changes, and observable per-task acceptance criteria). Codebase claims were verified against the source tree: `lib/load.php` lines 80-82 (collaboration.php insertion site), `packages/block-library/src/cover/edit/index.js` lines 95 (`context: { postId, postType }` destructure), 132 (existing `propsRef.current` pattern), 599 (empty-cover branch), 672 (`url && isImageBackground`), 750 (line-750 `<CoverPlaceholder>`), `packages/block-editor/src/utils/index.js` (only exports `transformStyles` + `getPxFromCssUnit`), `backport-changelog/7.1/10869.md` two-line format, `packages/element/src/react.ts:218` (`useEffectEvent` export) — all consistent with the plan. Approving.
+
+## Iter-1 findings — resolution check
+
+- **Issue 1 (HIGH — `replacePatternOverridesDefaultBinding` import blocker).** Resolved. Task 6 step 2 explicitly forbids importing the helper from `@wordpress/block-editor` and pins option (c): inline `__default` expansion in `use-cover-binding-state.js`, with a code snippet (Task 6 step 3) mirroring trunk's `replacePatternOverridesDefaultBinding`. A comment pointing at the canonical implementation is mandated.
+- **Issue 2 (MEDIUM — nonexistent `AC-35`).** Resolved. Plan now uses `Req 35` (zero `AC-35` occurrences) in Tasks 10/11/12 acceptance bullets.
+- **Issue 3 (MEDIUM — backport-changelog file shape).** Resolved. Task 13 §Changes step 1 now mandates the two-line format (wordpress-develop URL line, blank line, bulleted gutenberg URL).
+- **Issue 4 (MEDIUM — `url`→`effectiveUrl` predicate swap).** Resolved. Task 8 §Changes step 2 explicitly mandates the predicate rewrite to `! bindingUnresolvable && effectiveUrl && isImageBackground`, with traceable rationale (the Pattern Overrides default-state hazard) and a matching acceptance bullet.
+- **Issue 5 (LOW — DC-2 carve-out for `overlayColor`).** Resolved. Task 7 §Acceptance bullet 3 now explicitly calls out `overlayColor`/`customOverlayColor` as a deliberate source-agnostic continuation of trunk behavior, with a Design §5.2/§5.3 trace and explicit "only fresh `setAttributes` call is `{ isDark }`" qualifier.
+- **Issue 6 (LOW — `context` plumbing).** Resolved. Task 7 §Changes step 2 contains the prop-boundary change snippet (`context` undestructured, `const { postId, postType } = context;` inside the body) with rationale (sources may declare `usesContext` for additional keys).
+- **Issue 7 (LOW — embed-video e2e control case).** Resolved. Task 12 §Changes step 3 now includes the explicit embed-video control case under the default-state assertions with AC-21 preservation rationale and a matching acceptance bullet.
+- **Issue 8 (LOW — missing Req traces).** Resolved. Plan now explicitly cites Req 9 (Task 2), Req 23 / Req 34 / Req 35 (Task 10), Req 35 (Task 11), Req 24 / Req 35 (Task 12), and includes a Coverage note in the Overview explaining Req 28's design-level invariant status.
+
+## New-defect sweep
+
+A fresh pass for new defects found nothing material:
+
+- All file paths cited (`lib/load.php` insertion site, `packages/block-library/src/cover/edit/index.js` line numbers 95/599/672/750, `lib/compat/wordpress-7.1/` directory) match the trunk codebase as inspected.
+- The `useEffectEvent` import path (`@wordpress/element`) is confirmed exported.
+- Both halves of the new PHP file (Task 4 + Task 5) compose correctly — `gutenberg_cover_bindings_is_active` is defined in Task 3 and consumed in Tasks 4 and 5 (correct dependency order).
+- Task ordering keeps the tree green: server-only work first (Tasks 1-5), then client (6-9), then tests (10-12), then PR metadata (13).
+- Per-task acceptance criteria describe *what must be true* (observable behavior), not *which test files to write*.
+- One minor semantic nit (PHP `gutenberg_cover_bindings_expand_bindings` in Task 3 expands ANY `__default`, while JS `expandDefaultBinding` in Task 6 only expands when `source === 'core/pattern-overrides'`) is not user-observable today because only `core/pattern-overrides` writes the `__default` shape per spec glossary, and Req 26 / AC-6 only require mismatched-source detection in explicit per-attribute bindings. Not worth a rejection on iter-2 — flagging here for the code-writer to consider hardening the PHP guard symmetrically if it becomes natural during implementation.
+
+The plan is ready for execution.

From dc81f916e27f2b280bb4037acdfc592361572256 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:49:01 +0200
Subject: [PATCH 22/60] docs(pipeline): add 3-plan/doc-plan.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../3-plan/doc-plan.md                        | 124 ++++++++++++++++++
 1 file changed, 124 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan.md
new file mode 100644
index 00000000000000..9d3f01344f2fd2
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan.md
@@ -0,0 +1,124 @@
+# Doc Plan: Cover block bindings — internal-only `id` and `url`
+
+Spec: `<artifacts>/1-spec/spec.md` (approved)
+Design: `<artifacts>/2-design-doc/design-doc.md` (approved)
+Code plan: `<artifacts>/3-plan/code-plan.md` (approved)
+
+All AC-N, Req-N, DC-N, OQ-N citations resolve to those documents.
+
+## Overview
+
+The code work lands Block Bindings support on `core/cover` for the `id` and `url` attributes, restricted to internal media library attachments, with Pattern Overrides as the headline use case. The only **author-facing** reference documentation that today enumerates which blocks and attributes participate in Block Bindings (and in Pattern Overrides by extension) is `docs/reference-guides/block-api/block-bindings.md`. That single file needs the Cover row added to its compatibility table, and a short Pattern-Overrides-on-Cover note explaining the internal-media constraint, the auto-hidden controls, and the embed-video carve-out — so a plugin/theme developer reading the bindings reference can correctly reason about what is supported on Cover before they ship a pattern or a custom source. The autogenerated `docs/reference-guides/core-blocks.md` is rebuilt from `block.json` and does not need a manual edit. There is no per-block `README.md` for `core/cover` (verified) — Cover's documentation surface is entirely the bindings reference guide. The package-level `packages/block-library/CHANGELOG.md` carries a release-notes entry under its `Unreleased` heading. Backport-changelog and PR-description metadata are already covered by Code-plan Task 13 and are NOT duplicated here.
+
+A reviewer of this plan should sweep for any other text in the repo that today says "Cover does not support bindings" or enumerates the set of bindable blocks. The grep performed during planning surfaced exactly one such surface: `docs/reference-guides/block-api/block-bindings.md` (the "Compatible blocks and their attributes" table). All other appearances of "Cover" / "core/cover" in `docs/` (curating-the-editor README, block-filters reference, data-core-block-editor reference, testing-overview, RN integration test guide, the autogenerated `core-blocks.md`) are unrelated to bindings and do not need updating.
+
+## Tasks
+
+### Task 1: Add `core/cover` to the Block Bindings compatibility table
+
+**Goal**: Make the public Block Bindings reference state clearly that `core/cover` supports `id` and `url` as bindable attributes from WP 7.1 onward, so plugin and theme developers reading the canonical reference see Cover listed alongside Image, Heading, Paragraph, Button, etc.
+
+**Audience**: Plugin developers, theme developers, and pattern authors who consult the Block Bindings reference to discover which block attributes can be bound.
+
+**Files**:
+- `docs/reference-guides/block-api/block-bindings.md` — MODIFY: update the "Compatible blocks and their attributes" table (currently at lines 23–36) to include a new row for `core/cover` listing `id, url`.
+
+**Sections / scope**:
+- The "Compatible blocks and their attributes" section. Only the table is touched; surrounding prose is unchanged.
+
+**Depends on**: Code-plan Task 1 (the `role: "content"` schema change) and Code-plan Task 2 (the `block_bindings_supported_attributes` filter that makes `core/cover` allow-listed at runtime).
+
+**Traces to**: Spec Req 1, Req 2, Req 8; AC-1; Design §2.2, §6.1 Part 1, §8.
+
+**Acceptance**:
+- The "Compatible blocks and their attributes" table contains a row whose first column is `core/cover` and whose second column lists the two attributes documented in the spec as bindable (`id`, `url`).
+- The reader can locate `core/cover` in the table with a single in-page find for "cover".
+- The row's column alignment matches the existing table format (no broken markdown table rendering).
+- No other block's row in the table is modified.
+
+---
+
+### Task 2: Document the internal-media constraint and auto-hidden controls for Cover
+
+**Goal**: Explain, in the Block Bindings reference, the Cover-specific behaviour that is NOT shared by other bindable blocks: the binding only honours media-library attachments (external URLs are surfaced as unresolvable), and several Cover-specific controls (parallax, repeat, media-replace, "Use featured image") are hidden whenever a binding is active. A reader who binds `core/cover` for the first time should not be surprised by the behaviour described in the spec's Acceptance Criteria.
+
+**Audience**: Plugin and theme developers writing or shipping custom binding sources whose values may flow into `core/cover`, and pattern authors who bind Cover via Pattern Overrides.
+
+**Files**:
+- `docs/reference-guides/block-api/block-bindings.md` — MODIFY: add a new subsection within the document explaining the Cover-specific contract.
+
+**Sections / scope**:
+- A new H3 subsection placed within or immediately after the "Compatible blocks and their attributes" section (the doc-writer chooses the most natural anchor — adjacent to the table is fine; a small "Block-specific notes" or "Cover block" subsection is fine).
+- The subsection covers, at minimum:
+  - The internal-media-only invariant: bound `url` must resolve to a media-library attachment whose `id` is also bound from the same source instance. External URLs / mismatched sources are treated as unresolvable.
+  - What "unresolvable" looks like to the end user in the editor (the spec's stable test-observable signal — the i18n message string) and what the front-end renders in that state (no `<img>`).
+  - The controls that are hidden in the editor when a binding is active: parallax, repeat, media-replace, "Use featured image". A bound Cover surfaces overrides through the binding source (e.g. Pattern Overrides), not through the Cover's own media-replace control.
+  - The render-time effective dim ratio when the stored `dimRatio` is the default 100 — the rendered overlay is non-opaque so the bound image is visible.
+  - The embed-video carve-out: `backgroundType: "embed-video"` short-circuits the binding-aware paths in both editor and server; binding rows MAY appear in the UI but have no runtime effect on embed-video covers.
+
+**Depends on**: Task 1 (the row that establishes Cover as bindable); Code-plan Tasks 6–9 (the editor-side behaviour the subsection describes); Code-plan Task 5 (the server-side render path the subsection references when describing front-end output).
+
+**Traces to**: Spec Req 4, Req 5, Req 6, Req 7, Req 14, Req 16, Req 20, Req 22, Req 25, Req 26, Req 27; AC-4, AC-5, AC-6, AC-11, AC-12, AC-13, AC-14, AC-15, AC-16, AC-21; Design §5.4, §5.5, §10, §12 (embed-video carve-out).
+
+**Acceptance**:
+- A reader of the Block Bindings reference can answer "what happens if I bind Cover's url to an external (non-media-library) URL?" without leaving the page — the section names the user-visible affordance the spec defines and states that the front-end omits the `<img>`.
+- A reader can answer "which Cover-specific controls disappear when a binding is active?" — parallax, repeat, media-replace, and "Use featured image" are all named.
+- A reader is told that `backgroundType: "embed-video"` covers do not engage the binding-aware paths, even if the bindings UI lists `id`/`url` as bindable.
+- The section explains that the default `dimRatio` of 100 does not produce a fully opaque overlay on bound covers — the rendered overlay remains visibly translucent over the bound image.
+- The section does NOT prescribe internal implementation details (no `useEffect`, no filter names, no PHP function names) — it describes user-observable contract only.
+- The section's wording is consistent with the surrounding doc's tone and the existing `core/pattern-overrides` subsection (descriptive prose plus optional small code/markup example).
+
+---
+
+### Task 3: Document the Pattern Overrides on Cover example
+
+**Goal**: Give pattern authors a copy-pasteable example of binding a `core/cover` block via `core/pattern-overrides` (the headline use case for this PR). The existing `core/pattern-overrides` section in the bindings reference shows a paragraph example only; a Cover example is the natural counterpart for the new compatibility row.
+
+**Audience**: Pattern authors creating synced patterns with overridable cover images.
+
+**Files**:
+- `docs/reference-guides/block-api/block-bindings.md` — MODIFY: add a Cover-on-Pattern-Overrides example inside the existing `### core/pattern-overrides` subsection (currently at lines 172–214), OR as a continuation of the Task 2 "Block-specific notes" / "Cover block" subsection — the doc-writer chooses the placement that minimises duplication.
+
+**Sections / scope**:
+- A short HTML/block-markup example showing a Cover block whose `metadata.bindings` is set to the `__default: { source: 'core/pattern-overrides' }` shape (the Pattern Overrides idiomatic form the spec's Glossary describes).
+- A one-paragraph reader-takeaway: pattern authors mark Cover overridable the same way they mark paragraphs/headings overridable; per-instance overrides flow through the existing Pattern Overrides mechanism; reset semantics use the existing toolbar control (disabled when value matches default, per OQ-2).
+- Cross-link or breadcrumb to the Task 2 "internal media required" affordance so authors know what happens when a Cover instance's override resolves to no usable attachment.
+
+**Depends on**: Task 2 (the Cover-specific notes section sets the stage for the example); Code-plan Task 2 (the server-side allow-list registration that makes "Enable overrides" appear on Cover); Code-plan Task 12 (the e2e test that exercises this exact round-trip — the example should reflect the same authoring path the e2e walks through).
+
+**Traces to**: Spec Req 9, Req 24; AC-2, AC-7, AC-8, AC-9, AC-10; Design §5.6, §9.
+
+**Acceptance**:
+- A reader can copy the example markup and use it (as written or as a starting point) to create a synced pattern with a bound Cover block.
+- The example uses the `__default` wildcard shape (`metadata.bindings.__default = { source: 'core/pattern-overrides' }`) consistent with how the editor writes Pattern Overrides bindings, NOT a verbose per-attribute shape — readers should not learn an obsolete idiom from this doc.
+- The reader-takeaway paragraph names the three round-trip states the spec enumerates: insert pattern instance (renders the default), override per instance, reset (returns to default).
+- The example does not show external-URL binding (out of scope) and does not show mismatched-source binding (unsupported).
+
+---
+
+### Task 4: Add release-notes entry to `packages/block-library/CHANGELOG.md`
+
+**Goal**: Record the Cover-block bindings addition in the package's running changelog under the `Unreleased` heading, so the next published `@wordpress/block-library` release notes mention the feature. This is the standard maintenance practice flagged by the repo's `AGENTS.md` ("each package has README.md and CHANGELOG.md") and confirmed by the project's `packages#maintaining-changelogs` reference at the top of the changelog file.
+
+**Audience**: Downstream consumers of the `@wordpress/block-library` npm package who read release notes to discover behavioural changes; plugin authors auditing block behaviour between Gutenberg releases.
+
+**Files**:
+- `packages/block-library/CHANGELOG.md` — MODIFY: append a bullet under the existing `## Unreleased` heading.
+
+**Sections / scope**:
+- A single bullet (or a small bullet cluster if the doc-writer judges the change warrants separation between "New feature" and "Internal") describing the Cover block bindings addition.
+- The bullet follows the existing changelog format (concise prose, PR link in parentheses — the PR number is filled in by the doc-writer at the time of writing, by reading the most recent commit's PR reference or the orchestrator's PR-creation step).
+- The bullet names the user-observable change ("Cover block now supports Block Bindings for `id` and `url`, with Pattern Overrides support") without prescribing implementation.
+
+**Depends on**: All code-plan tasks (the changelog entry is a description of the cumulative work).
+
+**Traces to**: Spec Req 38 (PR shape — the changelog entry is part of the standard PR shape for block-library changes); the project's `AGENTS.md` convention for per-package CHANGELOG maintenance.
+
+**Acceptance**:
+- The `## Unreleased` section of `packages/block-library/CHANGELOG.md` contains a new bullet that names the Cover block and Block Bindings.
+- The bullet is placed under an appropriate subsection heading (the existing changelog uses `### Internal`, `### New features`, `### Bug Fixes`, `### Enhancements` — the doc-writer picks the one matching the change's nature; "New features" or "Enhancements" is the natural fit since this is user-visible block behaviour).
+- The bullet follows the file's prevailing format: short imperative sentence ending in a parenthesised PR link.
+- No other section of the changelog file is modified.
+- The bullet does NOT mention internal implementation details (no PHP function names, no filter names, no React-hook names).
+
+---

From a08d8ed0a52a2f6f78f848ccc19b916674594fc1 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:53:06 +0200
Subject: [PATCH 23/60] docs(pipeline): add 3-plan/doc-plan-review-approved.md
 for 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../3-plan/doc-plan-review-approved.md        | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan-review-approved.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan-review-approved.md
new file mode 100644
index 00000000000000..bcf38d52187172
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan-review-approved.md
@@ -0,0 +1,32 @@
+# Doc Plan Review
+
+## Verdict: approved
+
+## Summary
+
+The doc plan is tight, well-scoped, and correctly identifies the single documentation surface that needs human-edited updates (the Block Bindings reference guide at `docs/reference-guides/block-api/block-bindings.md`). The four tasks (add table row, add Cover-specific notes, add Pattern Overrides example, add CHANGELOG entry) cover every author-facing surface the code phase will affect. Key claims verified against the repo:
+
+- `docs/reference-guides/block-api/block-bindings.md` exists with the "Compatible blocks and their attributes" table at lines 23-36 and the `core/pattern-overrides` subsection at lines 172-214 (matches the plan's parenthetical line hints).
+- `packages/block-library/src/cover/` has NO `README.md` (verified — only PHP/JS source, `block.json`, `editor.scss`, `style.scss`, etc.).
+- `packages/block-library/CHANGELOG.md` exists with an `## Unreleased` heading at line 3 (matches the plan's target).
+- A repo-wide sweep for `core/cover` in `docs/` confirms the bindings reference is the only canonical surface that enumerates supported blocks/attributes for bindings; the other mentions (curating-the-editor, block-filters reference, data-core-block-editor, testing-overview, static-dynamic-rendering) are unrelated to bindings (block-locking templates, render-callback example, test fixture, getElementParents example) and do not require updates.
+- `docs/reference-guides/core-blocks.md` is autogenerated from `block.json` (the plan correctly skips it).
+- The `block_bindings_supported_attributes` filter is documented only in `block-bindings.md` (single source of truth — no duplicate prose surfaces to keep in sync).
+
+Task acceptance is drift-resistant: every task names a concrete audience, traces to specific spec requirements (with one minor citation slip in Task 4 — see Notes), and uses user-observable contract language (i18n message string, named UI controls, `backgroundType: "embed-video"` short-circuit) rather than implementation details (no PHP function names, no hook names, no filter names in the acceptance bullets). The plan stays strictly within doc scope — no code tasks duplicate code-plan responsibilities. Pattern Overrides is correctly headlined per spec, and the `__default` wildcard shape is the right idiom for the new Cover example (spec Glossary confirms the editor writes this shape, even though the existing paragraph example in the doc still uses the older per-attribute shape — a stylistic inconsistency the doc-writer can leave alone since updating the paragraph example is out of scope).
+
+## Notes (non-blocking, doc-writer's discretion in phase 5)
+
+These observations do not block approval but the doc-writer should weigh them when executing the plan:
+
+1. **Task 4 trace citation slip.** Task 4 traces to "Spec Req 38 (PR shape — the changelog entry is part of the standard PR shape for block-library changes)". Req 38 is actually "The net diff (including tests) SHOULD target under ~500 lines" — it is about diff size, not changelogs. The stronger justification (which the task already invokes) is the `AGENTS.md` "each package has README.md and CHANGELOG.md" convention plus the `packages#maintaining-changelogs` link at the top of the file. The CHANGELOG entry is correct to include; only the spec-requirement citation is misattributed. The doc-writer can ignore this and add the entry on convention grounds alone.
+
+2. **Task 3 enumerates "three round-trip states" — spec Req 24 has four.** The acceptance bullet says "The reader-takeaway paragraph names the three round-trip states the spec enumerates: insert pattern instance (renders the default), override per instance, reset (returns to default)." Spec Req 24 actually enumerates four states (a) default no override, (b) overridden, (c) reset-to-default, (d) reset affordance suppressed when value matches default. The three "render" states the plan names are correct as user-takeaway pedagogy (state (d) is a control-state, not a render-state), but for accuracy the doc-writer may want to either say "the three render states" explicitly or mention the disabled-reset semantics briefly.
+
+3. **Version annotation.** The existing `block-bindings.md` uses inline "Since WordPress 6.9" annotations (e.g. lines 90, 218) for new bindings affordances. The plan's Task 2 Goal mentions "from WP 7.1 onward" but the acceptance doesn't require a version annotation. The doc-writer should add a "Since WordPress 7.1" annotation to the Cover-specific notes for consistency with the section's existing convention — this is a minor pattern-matching call, not a defect in the plan.
+
+4. **Pre-existing pattern-overrides example uses per-attribute shape.** The existing paragraph example at `block-bindings.md:188-200` uses `metadata.bindings.content.source: core/pattern-overrides`, NOT the `__default` shape. The plan's Task 3 asks the new Cover example to use `__default`, which is correct per spec Glossary. The doc-writer should NOT feel obliged to also update the paragraph example — that is a separate concern out of this PR's scope, and the plan correctly does not ask for it.
+
+5. **Parenthetical line numbers in Tasks 1/2/3.** The plan parenthetically cites line ranges ("currently at lines 23-36", "lines 172-214"). These are presented as hints, not locators — the load-bearing locators are header names ("Compatible blocks and their attributes section", "core/pattern-overrides subsection"). If an unrelated PR lands first and the line numbers drift, the doc-writer's header-based locating still works. No action required.
+
+None of these is a blocking issue. The plan is ready for phase 5.

From 769d08c317bbe781a0934016cad465182660629a Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:54:51 +0200
Subject: [PATCH 24/60] feat(block-library): mark cover id attribute as content
 role

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 packages/block-library/src/cover/block.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/block-library/src/cover/block.json b/packages/block-library/src/cover/block.json
index 97095ab4b95152..bf7b3869897777 100644
--- a/packages/block-library/src/cover/block.json
+++ b/packages/block-library/src/cover/block.json
@@ -16,7 +16,8 @@
 			"default": false
 		},
 		"id": {
-			"type": "number"
+			"type": "number",
+			"role": "content"
 		},
 		"alt": {
 			"type": "string",

From fd3339f1364f1f79aa1144c6e81d8f7c58b653d9 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 16:59:27 +0200
Subject: [PATCH 25/60] feat(block-bindings): allow id and url on cover via 7.1
 compat filter

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 51 +++++++++++++++++++++
 lib/load.php                                |  1 +
 2 files changed, 52 insertions(+)
 create mode 100644 lib/compat/wordpress-7.1/block-bindings.php

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
new file mode 100644
index 00000000000000..06125a4a25686d
--- /dev/null
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -0,0 +1,51 @@
+<?php
+/**
+ * Block Bindings: Cover block support.
+ *
+ * Adds `id` and `url` to the server-side supported-attributes list for
+ * `core/cover`, so the editor's `__experimentalBlockBindingsSupportedAttributes`
+ * setting includes them and the Block Bindings panel exposes the corresponding
+ * rows for binding. The matching client-side schema metadata (the `role: "content"`
+ * marker on `core/cover`'s `id` attribute) is set in `block.json`.
+ *
+ * @since 7.1.0
+ * @package gutenberg
+ * @subpackage Block Bindings
+ */
+
+if ( ! function_exists( 'gutenberg_cover_bindings_add_supported_attributes' ) ) {
+	/**
+	 * Adds the `id` and `url` attributes to the list of supported block-bindings
+	 * attributes for `core/cover`.
+	 *
+	 * Registered on the `block_bindings_supported_attributes` filter. For any
+	 * block type other than `core/cover`, the input array is returned unchanged.
+	 * Existing entries are preserved; `id` and `url` are appended only when not
+	 * already present, so applying the filter twice on the same input remains
+	 * stable (`[ 'id', 'url' ]`, never `[ 'id', 'url', 'id', 'url' ]`).
+	 *
+	 * @since 7.1.0
+	 *
+	 * @param string[] $attributes The list of attributes supported by Block Bindings
+	 *                             for `$block_type`.
+	 * @param string   $block_type The block type whose supported attributes are
+	 *                             being filtered.
+	 * @return string[] The (possibly augmented) list of supported attributes.
+	 */
+	function gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_type ) {
+		if ( 'core/cover' !== $block_type ) {
+			return $attributes;
+		}
+
+		if ( ! in_array( 'id', $attributes, true ) ) {
+			$attributes[] = 'id';
+		}
+		if ( ! in_array( 'url', $attributes, true ) ) {
+			$attributes[] = 'url';
+		}
+
+		return $attributes;
+	}
+}
+
+add_filter( 'block_bindings_supported_attributes', 'gutenberg_cover_bindings_add_supported_attributes', 10, 2 );
diff --git a/lib/load.php b/lib/load.php
index 2173e9e35c8cf5..2cc453c3298070 100644
--- a/lib/load.php
+++ b/lib/load.php
@@ -80,6 +80,7 @@ function gutenberg_is_experiment_enabled( $name ) {
 	require __DIR__ . '/compat/wordpress-7.1/class-gutenberg-rest-view-config-controller-7-1.php';
 	require __DIR__ . '/compat/wordpress-7.1/rest-api.php';
 	require __DIR__ . '/compat/wordpress-7.1/collaboration.php';
+	require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';
 
 	// Plugin specific code.
 	require_once __DIR__ . '/class-wp-rest-global-styles-controller-gutenberg.php';

From 450d8a36a7156a16693a166db1e45bdb478c4676 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 17:03:37 +0200
Subject: [PATCH 26/60] feat(block-bindings): add
 gutenberg_cover_bindings_is_active helper

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 93 +++++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index 06125a4a25686d..b87a80d539adfb 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -49,3 +49,96 @@ function gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_
 }
 
 add_filter( 'block_bindings_supported_attributes', 'gutenberg_cover_bindings_add_supported_attributes', 10, 2 );
+
+if ( ! function_exists( 'gutenberg_cover_bindings_expand_bindings' ) ) {
+	/**
+	 * Expands a Cover block's `metadata.bindings` array by materialising any
+	 * `__default` entry into per-attribute slots.
+	 *
+	 * Mirrors the client-side `replacePatternOverridesDefaultBinding` helper at
+	 * `packages/block-editor/src/utils/block-bindings.js` and the server-side
+	 * expansion in `lib/compat/wordpress-6.9/block-bindings.php` (the
+	 * `__default` branch inside `gutenberg_process_block_bindings`), scoped to
+	 * the Cover-supported attribute list `[ 'id', 'url' ]`. Like both of those
+	 * callers, expansion is only performed when `__default.source` is
+	 * `core/pattern-overrides` — `__default` is currently a Pattern Overrides
+	 * affordance and does not apply to other sources.
+	 *
+	 * When expansion runs, each Cover-supported attribute that does NOT already
+	 * have an explicit binding entry inherits a `{ source: 'core/pattern-overrides' }`
+	 * stub. Pre-existing explicit entries (e.g. a mixed-source configuration)
+	 * are retained verbatim. The `__default` key itself is dropped from the
+	 * returned array, matching the canonical expansion semantics.
+	 *
+	 * When `__default` is absent (or its source is not `core/pattern-overrides`),
+	 * the input array is returned unchanged.
+	 *
+	 * @since 7.1.0
+	 * @access private
+	 *
+	 * @param array<string, array<string, mixed>> $bindings The `metadata.bindings`
+	 *                                                       map for a Cover block.
+	 * @return array<string, array<string, mixed>> The expanded bindings map.
+	 */
+	function gutenberg_cover_bindings_expand_bindings( array $bindings ): array {
+		if (
+			! isset( $bindings['__default']['source'] ) ||
+			'core/pattern-overrides' !== $bindings['__default']['source']
+		) {
+			return $bindings;
+		}
+
+		$expanded = array();
+		foreach ( array( 'id', 'url' ) as $attribute_name ) {
+			$expanded[ $attribute_name ] = isset( $bindings[ $attribute_name ] )
+				? $bindings[ $attribute_name ]
+				: array( 'source' => 'core/pattern-overrides' );
+		}
+
+		return $expanded;
+	}
+}
+
+if ( ! function_exists( 'gutenberg_cover_bindings_is_active' ) ) {
+	/**
+	 * Determines whether a parsed Cover block has an active binding.
+	 *
+	 * Server-side mirror of the client `bindingActive` predicate computed in
+	 * `useCoverBindingState`. A binding is "active" when, after `__default`
+	 * expansion, BOTH the `id` and `url` attributes are bound to the same
+	 * source instance — same `source` string AND `==`-equal `args`. Loose
+	 * equality (`==`) on `args` matches the JS-side `JSON.stringify` parity
+	 * check and is the correct semantic for the small associative bags that
+	 * source `args` contain in practice; element ordering does not affect
+	 * equality.
+	 *
+	 * The helper is intentionally pure-by-bindings: it does NOT short-circuit
+	 * on `backgroundType === 'embed-video'` — that gate is the responsibility
+	 * of the callers (the `render_block_data` and `render_block` filters that
+	 * use this helper).
+	 *
+	 * @since 7.1.0
+	 *
+	 * @param array<string, mixed> $attrs The Cover block's attribute array
+	 *                                    (typically `$parsed_block['attrs']`
+	 *                                    or `$instance->attributes`).
+	 * @return bool True when the Cover has an active `id`+`url` binding to the
+	 *              same source instance; false otherwise (including the empty
+	 *              and missing-bindings cases).
+	 */
+	function gutenberg_cover_bindings_is_active( array $attrs ): bool {
+		$bindings = $attrs['metadata']['bindings'] ?? null;
+		if ( empty( $bindings ) || ! is_array( $bindings ) ) {
+			return false;
+		}
+
+		$expanded = gutenberg_cover_bindings_expand_bindings( $bindings );
+
+		$same_source = ( $expanded['id']['source'] ?? null ) === ( $expanded['url']['source'] ?? null );
+		// Loose equality on associative arrays per Design §6.1 — `args` are a
+		// small bag of scalars and we want order-insensitive comparison.
+		$same_args = ( $expanded['id']['args'] ?? null ) == ( $expanded['url']['args'] ?? null ); // phpcs:ignore WordPress.PHP.StrictComparisons.LooseComparison
+
+		return ! empty( $expanded['id'] ) && ! empty( $expanded['url'] ) && $same_source && $same_args;
+	}
+}

From 2b8be9288805aaf0b345ec6e773906102998f4e2 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 17:07:41 +0200
Subject: [PATCH 27/60] feat(block-bindings): neutralise useFeaturedImage on
 bound covers (render_block_data)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 70 +++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index b87a80d539adfb..4bb6144d4393b2 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -142,3 +142,73 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 		return ! empty( $expanded['id'] ) && ! empty( $expanded['url'] ) && $same_source && $same_args;
 	}
 }
+
+if ( ! function_exists( 'gutenberg_cover_bindings_prepare_block' ) ) {
+	/**
+	 * Neutralises `useFeaturedImage` on Cover blocks whose `id`+`url` bindings
+	 * are active, before `WP_Block::render()` builds its instance attributes.
+	 *
+	 * Registered on the `render_block_data` filter, which fires inside
+	 * `render_block()` (see `wp-includes/blocks.php`) BEFORE `WP_Block` is
+	 * constructed for the parsed block. By forcing
+	 * `$parsed_block['attrs']['useFeaturedImage']` to `false` here when a
+	 * Cover-scoped binding is active, `render_block_core_cover` skips its
+	 * featured-image injection branch on the first render pass. This is the
+	 * AC-18 precedence rule: an active `id`+`url` binding always wins over
+	 * `useFeaturedImage`, with no double-`<img>` window.
+	 *
+	 * Gating order (each step short-circuits to "return unchanged"):
+	 *
+	 * 1. The block is not `core/cover`.
+	 * 2. `backgroundType === 'embed-video'` — embed-video covers are explicitly
+	 *    out of scope for the Cover-scoped binding path (AC-21); their existing
+	 *    `useFeaturedImage` semantics remain untouched.
+	 * 3. The bindings are not active per `gutenberg_cover_bindings_is_active()`
+	 *    (no `metadata.bindings`, mismatched source, or differing `args`).
+	 *
+	 * Only after all three gates pass — AND `useFeaturedImage` is currently
+	 * truthy — does the mutation run. When `useFeaturedImage` is already
+	 * falsy/absent, the array is returned unchanged.
+	 *
+	 * Persistence safety: the mutation is scoped to the in-flight
+	 * `$parsed_block` array used for this render pass only. PHP arrays are
+	 * value-copied on assignment, so the caller's array is not modified, and
+	 * the persisted `post_content` is never touched.
+	 *
+	 * @since 7.1.0
+	 *
+	 * @param array              $parsed_block The parsed block array, including
+	 *                                         `blockName` and `attrs` keys.
+	 * @param array              $source_block The original block as parsed (passed
+	 *                                         through unchanged).
+	 * @param WP_Block|null      $parent_block The parent block, if any (unused).
+	 * @return array The (possibly mutated) parsed block array.
+	 */
+	function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $parent_block ) {
+		if ( 'core/cover' !== ( $parsed_block['blockName'] ?? '' ) ) {
+			return $parsed_block;
+		}
+
+		$attrs = $parsed_block['attrs'] ?? array();
+
+		// AC-21: never engage for embed-video covers.
+		if ( ! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType'] ) {
+			return $parsed_block;
+		}
+
+		if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
+			return $parsed_block;
+		}
+
+		// AC-18: an active binding wins over useFeaturedImage. Only mutate when
+		// there is something to flip, so the array is touched as little as
+		// possible.
+		if ( ! empty( $attrs['useFeaturedImage'] ) ) {
+			$parsed_block['attrs']['useFeaturedImage'] = false;
+		}
+
+		return $parsed_block;
+	}
+}
+
+add_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10, 3 );

From 1caa4c79f5a846edf8e00b1df75972bf628ac387 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 17:22:47 +0200
Subject: [PATCH 28/60] feat(block-bindings): rewrite bound cover render output
 via render_block filter

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 312 ++++++++++++++++++++
 1 file changed, 312 insertions(+)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index 4bb6144d4393b2..a21fb707a79a00 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -212,3 +212,315 @@ function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $
 }
 
 add_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10, 3 );
+
+if ( ! function_exists( 'gutenberg_cover_bindings_strip_image' ) ) {
+	/**
+	 * Removes the saved Cover image element from a rendered Cover block.
+	 *
+	 * The Cover block's `save.js` emits the background image as one of two
+	 * mutually exclusive forms:
+	 *
+	 * 1. A void `<img class="wp-block-cover__image-background" …>` (the
+	 *    non-parallax / non-repeat path).
+	 * 2. A `<div class="wp-block-cover__image-background" style="background-
+	 *    image:url(…)"></div>` (the parallax / repeat path).
+	 *
+	 * This helper locates whichever form is present and splices it out of the
+	 * content. The `<div>` form is probed first because it would otherwise be
+	 * missed by an `<img>`-only regex. If neither pattern matches, the input is
+	 * returned unchanged.
+	 *
+	 * The patterns use the `\b` word-boundary anchor around the class name so
+	 * matches only on elements that actually carry the
+	 * `wp-block-cover__image-background` class (no coincidental substring hits
+	 * on neighbouring attributes), and the `U` (ungreedy) modifier ensures
+	 * `[^>]*` does not run past intermediate `>` boundaries.
+	 *
+	 * Used when an active binding cannot be resolved (no `id`, no `url`, or the
+	 * resolved `id` is not an attachment) — see
+	 * `gutenberg_cover_bindings_render_block` — so the cover renders without an
+	 * image element, overlay-only.
+	 *
+	 * @since 7.1.0
+	 * @access private
+	 *
+	 * @param string $content The rendered Cover block HTML.
+	 * @return string The content with the image element removed, or the input
+	 *                unchanged when no matching element is present.
+	 */
+	function gutenberg_cover_bindings_strip_image( string $content ): string {
+		// Form 2: parallax/repeat saved form — an empty <div>.
+		$form2_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
+		// Form 1: plain saved form — a void <img> (with or without trailing slash).
+		$form1_pattern = '/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?\s*>/U';
+
+		foreach ( array( $form2_pattern, $form1_pattern ) as $pattern ) {
+			if ( 1 === preg_match( $pattern, $content, $matches, PREG_OFFSET_CAPTURE ) ) {
+				$start  = $matches[0][1];
+				$length = strlen( $matches[0][0] );
+				return substr( $content, 0, $start ) . substr( $content, $start + $length );
+			}
+		}
+		return $content;
+	}
+}
+
+if ( ! function_exists( 'gutenberg_cover_bindings_relax_dim_class' ) ) {
+	/**
+	 * Removes `has-background-dim-100` from the Cover overlay span when an
+	 * active binding resolved its `id`+`url` and the stored `dimRatio` is the
+	 * default 100.
+	 *
+	 * Stored `dimRatio: 100` is the saved-attribute default for Cover; in the
+	 * pre-bindings universe that translated to a fully-opaque overlay
+	 * (`dim-100` -> 100% opacity), but on bound covers a fully-opaque overlay
+	 * would completely hide the bound image. The chosen "effective" dimRatio
+	 * for that case is 50 (see Design OQ-4), and because
+	 * `dimRatioToClass( 50 ) === null` the rewrite is mechanically "remove
+	 * `has-background-dim-100`" — no replacement modifier class is added. The
+	 * remaining `has-background-dim` class preserves the 50% opacity baseline.
+	 *
+	 * The pass is idempotent: when the class is already absent the call is a
+	 * no-op. The matcher is scoped to `<span class="wp-block-cover__background">`
+	 * elements via the Tag Processor so neighbouring spans are not touched.
+	 *
+	 * @since 7.1.0
+	 * @access private
+	 *
+	 * @param string $content The rendered Cover block HTML.
+	 * @return string The content with `has-background-dim-100` removed from any
+	 *                Cover overlay span, or the input unchanged when no such
+	 *                span is present.
+	 */
+	function gutenberg_cover_bindings_relax_dim_class( string $content ): string {
+		$processor = new WP_HTML_Tag_Processor( $content );
+		while ( $processor->next_tag(
+			array(
+				'tag_name'   => 'SPAN',
+				'class_name' => 'wp-block-cover__background',
+			)
+		) ) {
+			$processor->remove_class( 'has-background-dim-100' );
+		}
+		return $processor->get_updated_html();
+	}
+}
+
+if ( ! function_exists( 'gutenberg_cover_bindings_rewrite_image' ) ) {
+	/**
+	 * Rewrites the saved Cover image element to point at the bound URL/ID.
+	 *
+	 * Handles both forms emitted by `save.js`:
+	 *
+	 * 1. **Parallax / repeat `<div>` form** (probed first via `preg_match`):
+	 *    the entire `<div class="wp-block-cover__image-background" …></div>`
+	 *    is replaced with a freshly-built `<img>` that carries the bound URL,
+	 *    bound ID class (`wp-image-{id}`), and — when stored on the block —
+	 *    `size-{sizeSlug}` and `data-object-position`/`style="object-position:…"`
+	 *    attributes computed from `attrs.focalPoint`. The rebuilt element
+	 *    never contains `has-parallax`, `is-repeated`, or a `style="background-
+	 *    image:…"` declaration by construction. The `alt` attribute is read
+	 *    from the bound attachment's `_wp_attachment_image_alt` meta.
+	 *
+	 * 2. **Plain `<img>` form** (fall-through path): the existing `<img>` is
+	 *    visited via `WP_HTML_Tag_Processor` and `src`, `alt`, and the
+	 *    `wp-image-…` class are rewritten in place. Any pre-existing
+	 *    `wp-image-…` class is removed before the new one is added, so a saved
+	 *    `wp-image-99` does not survive after a binding resolves a different
+	 *    attachment.
+	 *
+	 * The function is idempotent on its own output: a second pass over an
+	 * already-rewritten plain `<img>` form re-asserts the same attributes; a
+	 * second pass over the parallax-rebuilt `<img>` falls through to the
+	 * plain-`<img>` path (because the rebuilt element is now a plain `<img>`)
+	 * and produces byte-identical output.
+	 *
+	 * When neither form matches, the input is returned unchanged.
+	 *
+	 * @since 7.1.0
+	 * @access private
+	 *
+	 * @param string $content      The rendered Cover block HTML.
+	 * @param string $resolved_url The URL resolved from the bound source.
+	 * @param int    $resolved_id  The attachment ID resolved from the bound source.
+	 * @param array  $attrs        The Cover block's stored attribute array
+	 *                             (used for `sizeSlug` and `focalPoint`).
+	 * @return string The content with the image element rewritten, or the input
+	 *                unchanged when no matching image element is present.
+	 */
+	function gutenberg_cover_bindings_rewrite_image( string $content, string $resolved_url, int $resolved_id, array $attrs ): string {
+		$alt             = trim( strip_tags( (string) get_post_meta( $resolved_id, '_wp_attachment_image_alt', true ) ) );
+		$size_slug       = isset( $attrs['sizeSlug'] ) && '' !== $attrs['sizeSlug']
+			? ' size-' . $attrs['sizeSlug']
+			: '';
+		$object_position = '';
+		if (
+			isset( $attrs['focalPoint']['x'] ) &&
+			isset( $attrs['focalPoint']['y'] ) &&
+			is_numeric( $attrs['focalPoint']['x'] ) &&
+			is_numeric( $attrs['focalPoint']['y'] )
+		) {
+			$object_position = sprintf(
+				'%s%% %s%%',
+				round( (float) $attrs['focalPoint']['x'] * 100 ),
+				round( (float) $attrs['focalPoint']['y'] * 100 )
+			);
+		}
+
+		// Form 2 first: parallax/repeat saved form — replace the empty <div>
+		// element wholesale with a rebuilt <img>. Saved markup is the source of
+		// truth (NOT $attrs['hasParallax'] / $attrs['isRepeated']) — the
+		// pattern matches the literal serialized form emitted by save.js.
+		$form2_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
+		if ( 1 === preg_match( $form2_pattern, $content, $matches, PREG_OFFSET_CAPTURE ) ) {
+			$div_start  = $matches[0][1];
+			$div_length = strlen( $matches[0][0] );
+
+			$object_position_attrs = '';
+			if ( '' !== $object_position ) {
+				$object_position_attrs = sprintf(
+					' data-object-position="%s" style="object-position:%s;"',
+					esc_attr( $object_position ),
+					esc_attr( $object_position )
+				);
+			}
+
+			$rebuilt_img = sprintf(
+				'<img class="wp-block-cover__image-background wp-image-%d%s" alt="%s" src="%s" data-object-fit="cover"%s />',
+				$resolved_id,
+				esc_attr( $size_slug ),
+				esc_attr( $alt ),
+				esc_url( $resolved_url ),
+				$object_position_attrs
+			);
+
+			return substr( $content, 0, $div_start ) . $rebuilt_img . substr( $content, $div_start + $div_length );
+		}
+
+		// Form 1: plain <img> saved form — rewrite attributes in place.
+		$processor = new WP_HTML_Tag_Processor( $content );
+		if ( $processor->next_tag(
+			array(
+				'tag_name'   => 'IMG',
+				'class_name' => 'wp-block-cover__image-background',
+			)
+		) ) {
+			$processor->set_attribute( 'src', $resolved_url );
+			$processor->set_attribute( 'alt', $alt );
+
+			// Replace any existing wp-image-{old} with the resolved id. class_list()
+			// yields the current classes, including ones added in this same pass.
+			$class_list = $processor->class_list();
+			if ( null !== $class_list ) {
+				$wp_image_classes_to_remove = array();
+				foreach ( $class_list as $cls ) {
+					if ( 0 === strpos( $cls, 'wp-image-' ) ) {
+						$wp_image_classes_to_remove[] = $cls;
+					}
+				}
+				foreach ( $wp_image_classes_to_remove as $cls ) {
+					$processor->remove_class( $cls );
+				}
+			}
+			$processor->add_class( 'wp-image-' . $resolved_id );
+
+			return $processor->get_updated_html();
+		}
+
+		// Neither form matched; render proceeds overlay-only.
+		return $content;
+	}
+}
+
+if ( ! function_exists( 'gutenberg_cover_bindings_render_block' ) ) {
+	/**
+	 * Rewrites a rendered Cover block to honour an active `id`+`url` binding.
+	 *
+	 * Registered on the `render_block` filter at priority 9 so it runs BEFORE
+	 * the generic priority-10 `gutenberg_block_bindings_render_block`
+	 * (`lib/compat/wordpress-6.9/block-bindings.php`) — the binding-aware
+	 * substitution must happen on the saved markup before the generic filter
+	 * potentially re-runs `$instance->render()`.
+	 *
+	 * Gating order (each step short-circuits to "return unchanged"):
+	 *
+	 * 1. The block is not `core/cover`.
+	 * 2. `backgroundType === 'embed-video'` — embed-video covers are explicitly
+	 *    out of scope for the Cover-scoped binding render path (AC-21); the
+	 *    existing oEmbed code path remains intact.
+	 * 3. The bindings are not active per `gutenberg_cover_bindings_is_active()`.
+	 *
+	 * After the gates, the resolved URL and ID come from `$instance->attributes`
+	 * (which `WP_Block::render()` has already merged the resolved bindings
+	 * into — see `wp-includes/class-wp-block.php`). If either value is missing,
+	 * or the resolved ID is not an attachment in the media library, the saved
+	 * image element is stripped from `$content` and the cover renders
+	 * overlay-only (AC-5, AC-6).
+	 *
+	 * Otherwise the saved image element is rewritten in place by
+	 * `gutenberg_cover_bindings_rewrite_image()` to carry the bound URL, ID
+	 * class, and alt text (AC-3, AC-19). When the stored `dimRatio` is the
+	 * default 100, `gutenberg_cover_bindings_relax_dim_class()` removes
+	 * `has-background-dim-100` from the overlay span so the bound image is not
+	 * hidden by a fully-opaque overlay (AC-16, OQ-4). Non-default `dimRatio`
+	 * values are preserved (AC-17).
+	 *
+	 * @since 7.1.0
+	 *
+	 * @param string   $block_content The rendered block HTML, as passed in by
+	 *                                the `render_block` filter.
+	 * @param array    $block         The parsed block array (`blockName`, etc.).
+	 * @param WP_Block $instance      The block instance, whose `attributes`
+	 *                                already include any resolved binding values.
+	 * @return string The (possibly rewritten) block HTML.
+	 */
+	function gutenberg_cover_bindings_render_block( $block_content, $block, $instance ) {
+		if ( 'core/cover' !== ( $block['blockName'] ?? '' ) ) {
+			return $block_content;
+		}
+
+		$attrs = $instance->attributes ?? array();
+
+		// AC-21: never engage for embed-video covers.
+		if ( ! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType'] ) {
+			return $block_content;
+		}
+
+		if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
+			return $block_content;
+		}
+
+		$resolved_url = $attrs['url'] ?? null;
+		$resolved_id  = (int) ( $attrs['id'] ?? 0 );
+
+		if ( empty( $resolved_url ) || empty( $resolved_id ) ) {
+			return gutenberg_cover_bindings_strip_image( $block_content );
+		}
+
+		$attachment = get_post( $resolved_id );
+		if ( ! $attachment || 'attachment' !== $attachment->post_type ) {
+			return gutenberg_cover_bindings_strip_image( $block_content );
+		}
+
+		$block_content = gutenberg_cover_bindings_rewrite_image(
+			$block_content,
+			(string) $resolved_url,
+			$resolved_id,
+			$attrs
+		);
+
+		// AC-16 / OQ-4: stored dimRatio defaults to 100; relax it to "no
+		// modifier class" (effectively 50%) so the bound image is visible.
+		if ( 100 === (int) ( $attrs['dimRatio'] ?? 100 ) ) {
+			$block_content = gutenberg_cover_bindings_relax_dim_class( $block_content );
+		}
+
+		return $block_content;
+	}
+}
+
+// Priority 9 is essential — see the docblock above: must run BEFORE the
+// generic priority-10 gutenberg_block_bindings_render_block filter from
+// lib/compat/wordpress-6.9/block-bindings.php so the Cover-scoped substitution
+// runs on saved markup, not on already-bindings-resolved markup.
+add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 );

From 0de5de6e1dcf0137403e9fb116cb938c22fdb93a Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 17:33:54 +0200
Subject: [PATCH 29/60] feat(block-library): add useCoverBindingState hook for
 cover bindings

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/cover/edit/use-cover-binding-state.js | 201 ++++++++++++++++++
 1 file changed, 201 insertions(+)
 create mode 100644 packages/block-library/src/cover/edit/use-cover-binding-state.js

diff --git a/packages/block-library/src/cover/edit/use-cover-binding-state.js b/packages/block-library/src/cover/edit/use-cover-binding-state.js
new file mode 100644
index 00000000000000..1dbb47ce009db8
--- /dev/null
+++ b/packages/block-library/src/cover/edit/use-cover-binding-state.js
@@ -0,0 +1,201 @@
+/**
+ * WordPress dependencies
+ */
+import { getBlockBindingsSource } from '@wordpress/blocks';
+import { useSelect } from '@wordpress/data';
+import { store as coreStore } from '@wordpress/core-data';
+
+// Canonical implementation lives at
+// `packages/block-editor/src/utils/block-bindings.js` (not publicly re-exported
+// from `@wordpress/block-editor`); duplicated inline here to avoid reaching
+// through private APIs across package boundaries.
+const PATTERN_OVERRIDES_SOURCE = 'core/pattern-overrides';
+
+/**
+ * Expands a `__default` pattern-overrides binding into per-attribute entries.
+ *
+ * Mirrors the semantics of `replacePatternOverridesDefaultBinding` in
+ * `packages/block-editor/src/utils/block-bindings.js`: when the supplied
+ * bindings object declares a `__default` entry sourced from
+ * `core/pattern-overrides`, every supported attribute that does not already
+ * have its own explicit binding receives a synthesised pattern-overrides
+ * binding. Non-pattern-overrides bindings pass through unchanged.
+ *
+ * @param {?Record<string, Object>} bindings            A block's bindings from the metadata attribute.
+ * @param {string[]}                supportedAttributes Attribute names eligible for expansion.
+ *
+ * @return {?Record<string, Object>} Either the input bindings (unchanged) or a
+ *                                   new object whose keys cover every
+ *                                   supported attribute.
+ */
+function expandDefaultBinding( bindings, supportedAttributes ) {
+	if ( bindings?.__default?.source !== PATTERN_OVERRIDES_SOURCE ) {
+		return bindings;
+	}
+	const expanded = {};
+	for ( const attr of supportedAttributes ) {
+		expanded[ attr ] = bindings[ attr ]
+			? bindings[ attr ]
+			: { source: PATTERN_OVERRIDES_SOURCE };
+	}
+	return expanded;
+}
+
+/**
+ * The shape of state returned by {@link useCoverBindingState}.
+ *
+ * @typedef {Object} CoverBindingState
+ * @property {boolean}          bindingActive           True iff (after `__default` expansion) both `id` AND `url` are bound to the same source instance (same source, same `args`) AND `attributes.backgroundType !== 'embed-video'`.
+ * @property {boolean}          bindingUnresolvable     True iff `metadata.bindings` carries any cover-relevant configuration but the binding is not active, OR the bound attachment resolved to a record that is not a media-library attachment.
+ * @property {string|undefined} bindingResolvedUrl      URL resolved from the bound source (or `undefined` when no binding is active or the source is missing).
+ * @property {number|undefined} bindingResolvedId       Attachment ID resolved from the bound source (or `undefined`).
+ * @property {boolean}          canUserEditBindingValue Result of the bound source's `canUserEditValue` callback (used downstream to decide whether to lock URL controls); `false` when the source omits the callback or when no binding is active.
+ */
+
+/**
+ * Computes Cover-block binding state in a single `useSelect` subscription.
+ *
+ * The hook is the client-side single source of truth for whether
+ * a Cover's `id` and `url` attributes are bound, what the bound source
+ * currently resolves to, and whether the bound configuration is itself
+ * unresolvable (mismatched source, only one of `id`/`url` bound, the bound
+ * `id` does not resolve to an attachment, etc.). Callers (e.g. `CoverEdit`)
+ * destructure the returned object to drive every downstream binding-aware
+ * derivation — derived URL, derived dim ratio, control gating, the
+ * unresolvable-binding placeholder.
+ *
+ * @param {Object} options            Hook options.
+ * @param {string} options.clientId   The Cover block's client id, forwarded to the source's `getValues` callback.
+ * @param {Object} options.attributes The Cover block's current attributes (the hook reads `metadata`, `backgroundType`).
+ * @param {Object} options.context    The full, undestructured block-context object received by `CoverEdit`; forwarded verbatim to the source's `getValues` callback because sources may declare `usesContext` for keys beyond `postId`/`postType`.
+ *
+ * @return {CoverBindingState} Plain-value binding state, recomputed on each render.
+ */
+export default function useCoverBindingState( {
+	clientId,
+	attributes,
+	context,
+} ) {
+	const bindings = attributes.metadata?.bindings;
+
+	const expanded = bindings
+		? expandDefaultBinding( bindings, [ 'id', 'url' ] )
+		: undefined;
+
+	const sameArgs =
+		!! expanded?.id &&
+		!! expanded?.url &&
+		JSON.stringify( expanded.id.args ?? null ) ===
+			JSON.stringify( expanded.url.args ?? null );
+
+	const bindingActive =
+		!! expanded?.id &&
+		!! expanded?.url &&
+		expanded.id.source === expanded.url.source &&
+		sameArgs &&
+		attributes.backgroundType !== 'embed-video';
+
+	const {
+		bindingResolvedUrl,
+		bindingResolvedId,
+		bindingResolvedAttachment,
+		canUserEditBindingValue,
+	} = useSelect(
+		( select ) => {
+			if ( ! bindingActive ) {
+				return {
+					bindingResolvedUrl: undefined,
+					bindingResolvedId: undefined,
+					bindingResolvedAttachment: undefined,
+					canUserEditBindingValue: false,
+				};
+			}
+			const source = getBlockBindingsSource( expanded.url.source );
+			if ( ! source ) {
+				return {
+					bindingResolvedUrl: undefined,
+					bindingResolvedId: undefined,
+					bindingResolvedAttachment: undefined,
+					canUserEditBindingValue: false,
+				};
+			}
+			const values = source.getValues( {
+				select,
+				clientId,
+				context,
+				bindings: { id: expanded.id, url: expanded.url },
+			} );
+			const resolvedUrl = values?.url;
+			const resolvedId = values?.id;
+			const attachment = resolvedId
+				? select( coreStore ).getEntityRecord(
+						'postType',
+						'attachment',
+						resolvedId,
+						{ context: 'view' }
+				  )
+				: undefined;
+			const userCanEdit =
+				source.canUserEditValue?.( {
+					select,
+					clientId,
+					context,
+					args: expanded.url.args,
+				} ) ?? false;
+			return {
+				bindingResolvedUrl: resolvedUrl,
+				bindingResolvedId: resolvedId,
+				bindingResolvedAttachment: attachment,
+				canUserEditBindingValue: userCanEdit,
+			};
+		},
+		// The dependency array is intentionally narrow: source identity (which
+		// determines whether to re-subscribe) plus the inputs forwarded into
+		// `source.getValues`. `expanded.id` / `expanded.url` get a fresh
+		// object identity on every render even when the underlying binding
+		// instance is stable, so listing them would re-run the selector
+		// spuriously without changing the result.
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		[
+			bindingActive,
+			expanded?.id?.source,
+			expanded?.url?.source,
+			clientId,
+			context,
+		]
+	);
+
+	if ( ! bindings ) {
+		return {
+			bindingActive: false,
+			bindingUnresolvable: false,
+			bindingResolvedUrl: undefined,
+			bindingResolvedId: undefined,
+			canUserEditBindingValue: false,
+		};
+	}
+
+	const hasAnyCoverBinding =
+		!! bindings.__default || !! bindings.id || !! bindings.url;
+
+	const attachmentResolvedNotFound =
+		bindingActive && bindingResolvedAttachment === null;
+
+	const attachmentResolvedWrongType =
+		bindingActive &&
+		!! bindingResolvedAttachment?.type &&
+		bindingResolvedAttachment.type !== 'attachment';
+
+	const bindingUnresolvable =
+		( hasAnyCoverBinding && ! bindingActive ) ||
+		attachmentResolvedNotFound ||
+		attachmentResolvedWrongType;
+
+	return {
+		bindingActive,
+		bindingUnresolvable,
+		bindingResolvedUrl,
+		bindingResolvedId,
+		canUserEditBindingValue,
+	};
+}

From cd2421e0828400941fd2d3658b6e3b230d3d26eb Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 17:41:46 +0200
Subject: [PATCH 30/60] feat(block-library): add reactive observer + derived
 values in cover Edit

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../block-library/src/cover/edit/index.js     | 149 +++++++++++++-----
 1 file changed, 107 insertions(+), 42 deletions(-)

diff --git a/packages/block-library/src/cover/edit/index.js b/packages/block-library/src/cover/edit/index.js
index 060be347b26a5b..c88eaa6570c99f 100644
--- a/packages/block-library/src/cover/edit/index.js
+++ b/packages/block-library/src/cover/edit/index.js
@@ -9,6 +9,7 @@ import clsx from 'clsx';
 import { useEntityProp, store as coreStore } from '@wordpress/core-data';
 import {
 	useEffect,
+	useEffectEvent,
 	useLayoutEffect,
 	useMemo,
 	useRef,
@@ -47,6 +48,7 @@ import CoverInspectorControls from './inspector-controls';
 import CoverBlockControls from './block-controls';
 import CoverPlaceholder from './cover-placeholder';
 import ResizableCoverPopover from './resizable-cover-popover';
+import useCoverBindingState from './use-cover-binding-state';
 import {
 	getMediaColor,
 	compositeIsDark,
@@ -92,8 +94,9 @@ function CoverEdit( {
 	setAttributes,
 	setOverlayColor,
 	toggleSelection,
-	context: { postId, postType },
+	context,
 } ) {
+	const { postId, postType } = context;
 	const {
 		contentPosition,
 		id,
@@ -116,6 +119,19 @@ function CoverEdit( {
 		poster,
 	} = attributes;
 
+	// Single source of truth for binding state. Drives the derived values
+	// (`effectiveUrl`, `effectiveDimRatio`) below.
+	const { bindingActive, bindingResolvedUrl } = useCoverBindingState( {
+		clientId,
+		attributes,
+		context,
+	} );
+
+	// Race-token guard for the source-agnostic `effectiveUrl` observer below.
+	// Incremented on each invocation; stale `getMediaColor` resolutions bail
+	// when their captured token no longer matches `raceTokenRef.current`.
+	const raceTokenRef = useRef( 0 );
+
 	const [ featuredImage ] = useEntityProp(
 		'postType',
 		postType,
@@ -156,49 +172,95 @@ function CoverEdit( {
 		media?.media_details?.sizes?.[ sizeSlug ]?.source_url ??
 		media?.source_url;
 
-	// User can change the featured image outside of the block, but we still
-	// need to update the block when that happens. This effect should only
-	// run when the featured image changes in that case. All other cases are
-	// handled in their respective callbacks.
-	useEffect( () => {
-		( async () => {
-			if ( ! useFeaturedImage ) {
-				return;
-			}
+	// Source-agnostic URL to be displayed in the editor. Prefers the bound
+	// source's resolved URL; otherwise falls back to the trunk derivation
+	// (featured image when `useFeaturedImage`, otherwise the stored URL with
+	// HTML-entity decoding). DC-3: the downstream observer treats this value
+	// without branching on which branch produced it.
+	const effectiveUrl =
+		bindingResolvedUrl ??
+		( useFeaturedImage
+			? mediaUrl
+			: // Ensure the url is not malformed due to sanitization through `wp_kses`.
+			  originalUrl?.replaceAll( '&amp;', '&' ) );
+
+	// Preview-time dim ratio. Default `dimRatio === 100` would produce an
+	// opaque overlay on bound covers (hiding the resolved image); §5.2 relaxes
+	// it to 50 only when the binding is active AND there is an image to show.
+	// In every other case this equals `dimRatio`, preserving trunk behaviour.
+	const effectiveDimRatio =
+		bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio;
+
+	/**
+	 * Source-agnostic URL-resolved observer.
+	 *
+	 * Recomputes `overlayColor` (when the user has not pinned an overlay
+	 * colour) and `isDark` whenever the effective URL changes — regardless of
+	 * whether the change came from a manual selection, `useFeaturedImage`, or
+	 * a bound source resolving. `useEffectEvent` gives us a stable identity
+	 * for use inside the single `useEffect` below while reading the latest
+	 * `attributes` / `overlayColor` through `propsRef.current`. The
+	 * race-token bookkeeping ensures that when two URL changes race, only
+	 * the most recent `getMediaColor` resolution writes back.
+	 *
+	 * DC-2: the only attribute write here is `{ isDark }`, which is not in
+	 * the DC-2 prohibition list. The `setOverlayColor( avg )` carve-out
+	 * preserves trunk behaviour (the identical call site previously fired
+	 * inside the `mediaUrl` effect) and runs identically for manual,
+	 * featured-image, and binding-sourced URLs — i.e. source-agnostic.
+	 *
+	 * @param {string|undefined} resolvedUrl The URL whose dominant colour
+	 *                                       drives the overlay derivation.
+	 *                                       Skipped when falsy.
+	 */
+	const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => {
+		if ( ! resolvedUrl ) {
+			return;
+		}
 
-			const averageBackgroundColor = await getMediaColor( mediaUrl );
+		const myToken = ++raceTokenRef.current;
+		const averageBackgroundColor = await getMediaColor( resolvedUrl );
 
-			// Read latest values after await to avoid stale closures.
-			const { attributes: currentAttrs, overlayColor: currentOverlay } =
-				propsRef.current;
+		if ( myToken !== raceTokenRef.current ) {
+			// A newer resolution superseded ours; bail out so we do not
+			// clobber the latest derivation.
+			return;
+		}
 
-			let newOverlayColor = currentOverlay.color;
-			if ( ! currentAttrs.isUserOverlayColor ) {
-				newOverlayColor = averageBackgroundColor;
-				__unstableMarkNextChangeAsNotPersistent();
-				setOverlayColor( newOverlayColor );
-			}
+		// Read latest values after await to avoid stale closures.
+		const { attributes: currentAttrs, overlayColor: currentOverlay } =
+			propsRef.current;
 
-			const newIsDark = compositeIsDark(
-				currentAttrs.dimRatio,
-				newOverlayColor,
-				averageBackgroundColor
-			);
+		let newOverlayColor = currentOverlay.color;
+		if ( ! currentAttrs.isUserOverlayColor ) {
+			newOverlayColor = averageBackgroundColor;
 			__unstableMarkNextChangeAsNotPersistent();
-			setAttributes( {
-				isDark: newIsDark,
-				isUserOverlayColor: currentAttrs.isUserOverlayColor || false,
-			} );
-		} )();
-		// Update the block only when the featured image changes.
-		// The other dependencies are stable references (dispatch actions / setters).
-	}, [
-		mediaUrl,
-		__unstableMarkNextChangeAsNotPersistent,
-		setAttributes,
-		setOverlayColor,
-		useFeaturedImage,
-	] );
+			setOverlayColor( newOverlayColor );
+		}
+
+		// Mirror the `effectiveDimRatio` derivation using the latest
+		// attributes so the dark/light decision matches what the user sees.
+		const latestEffectiveDimRatio =
+			bindingActive && currentAttrs.dimRatio === 100 && resolvedUrl
+				? 50
+				: currentAttrs.dimRatio;
+
+		const newIsDark = compositeIsDark(
+			latestEffectiveDimRatio,
+			newOverlayColor,
+			averageBackgroundColor
+		);
+		__unstableMarkNextChangeAsNotPersistent();
+		setAttributes( { isDark: newIsDark } );
+	} );
+
+	// `onUrlResolved` is created by `useEffectEvent`, which guarantees a
+	// stable identity across renders — so it intentionally does not appear
+	// in this dependency array. Re-run only when the source-agnostic
+	// `effectiveUrl` changes (DC-1: single observer keyed on `effectiveUrl`).
+	useEffect( () => {
+		onUrlResolved( effectiveUrl );
+	}, [ effectiveUrl ] );
 
 	// instead of destructuring the attributes
 	// we define the url and background type
@@ -728,15 +790,18 @@ function CoverEdit( {
 						aria-hidden="true"
 						className={ clsx(
 							'wp-block-cover__background',
-							dimRatioToClass( dimRatio ),
+							dimRatioToClass( effectiveDimRatio ),
 							{
 								[ overlayColor.class ]: overlayColor.class,
-								'has-background-dim': dimRatio !== undefined,
+								'has-background-dim':
+									effectiveDimRatio !== undefined,
 								// For backwards compatibility. Former versions of the Cover Block applied
 								// `.wp-block-cover__gradient-background` in the presence of
 								// media, a gradient and a dim.
 								'wp-block-cover__gradient-background':
-									url && gradientValue && dimRatio !== 0,
+									url &&
+									gradientValue &&
+									effectiveDimRatio !== 0,
 								'has-background-gradient': gradientValue,
 								[ gradientClass ]: gradientClass,
 							}

From bf0e42f65c6866d5caea3dc7cac4c79f8d646ab9 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 17:54:13 +0200
Subject: [PATCH 31/60] feat(block-library): bound-cover placeholder +
 forced-img render in CoverEdit

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../block-library/src/cover/edit/index.js     | 123 +++++++++---
 packages/block-library/src/cover/test/edit.js | 177 ++++++++++++++++++
 2 files changed, 273 insertions(+), 27 deletions(-)

diff --git a/packages/block-library/src/cover/edit/index.js b/packages/block-library/src/cover/edit/index.js
index c88eaa6570c99f..eb063685887ee5 100644
--- a/packages/block-library/src/cover/edit/index.js
+++ b/packages/block-library/src/cover/edit/index.js
@@ -120,12 +120,14 @@ function CoverEdit( {
 	} = attributes;
 
 	// Single source of truth for binding state. Drives the derived values
-	// (`effectiveUrl`, `effectiveDimRatio`) below.
-	const { bindingActive, bindingResolvedUrl } = useCoverBindingState( {
-		clientId,
-		attributes,
-		context,
-	} );
+	// (`effectiveUrl`, `effectiveDimRatio`) and the binding-aware render
+	// branches below.
+	const { bindingActive, bindingUnresolvable, bindingResolvedUrl } =
+		useCoverBindingState( {
+			clientId,
+			attributes,
+			context,
+		} );
 
 	// Race-token guard for the source-agnostic `effectiveUrl` observer below.
 	// Incremented on each invocation; stale `getMediaColor` resolutions bail
@@ -659,6 +661,52 @@ function CoverEdit( {
 	};
 
 	if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground ) {
+		if ( bindingActive || bindingUnresolvable ) {
+			// Bound covers never expose the upload / featured-image
+			// affordances surfaced by the standard `<CoverPlaceholder>`.
+			// When the binding has settled into an unresolvable state we
+			// surface a discoverable affordance ("Internal media required
+			// for this binding."); otherwise the placeholder is silent and
+			// the single observer will populate the cover once
+			// `effectiveUrl` arrives.
+			return (
+				<>
+					{ blockControls }
+					{ inspectorControls }
+					{ hasNonContentControls && isSelected && (
+						<ResizableCoverPopover { ...resizableCoverProps } />
+					) }
+					<TagName
+						{ ...blockProps }
+						className={ clsx(
+							'is-placeholder',
+							blockProps.className
+						) }
+						style={ {
+							...blockProps.style,
+							minHeight: minHeightWithUnit || undefined,
+						} }
+					>
+						{ resizeListener }
+						{ bindingUnresolvable ? (
+							<Placeholder
+								data-testid="cover-binding-unresolvable"
+								className="wp-block-cover__binding-unresolvable"
+								withIllustration
+								instructions={ __(
+									'Internal media required for this binding.'
+								) }
+							/>
+						) : (
+							<Placeholder
+								className="wp-block-cover__binding-pending"
+								withIllustration
+							/>
+						) }
+					</TagName>
+				</>
+			);
+		}
 		return (
 			<>
 				{ blockControls }
@@ -731,28 +779,49 @@ function CoverEdit( {
 					/>
 				) }
 
-				{ url &&
-					isImageBackground &&
-					( isImgElement ? (
-						<img
-							ref={ mediaElement }
-							className="wp-block-cover__image-background"
-							alt={ alt }
-							src={ url }
-							style={ mediaStyle }
-						/>
-					) : (
-						<div
-							ref={ mediaElement }
-							role={ alt ? 'img' : undefined }
-							aria-label={ alt ? alt : undefined }
-							className={ clsx(
-								classes,
-								'wp-block-cover__image-background'
+				{ ! bindingUnresolvable &&
+					effectiveUrl &&
+					isImageBackground && (
+						<>
+							{ bindingActive && (
+								// Bound covers ignore the `isImgElement` switch so
+								// that pre-existing `hasParallax`/`isRepeated`
+								// attributes never substitute a `<div>` for the
+								// bound `<img>` (force-off per Design OQ-5).
+								<img
+									ref={ mediaElement }
+									className="wp-block-cover__image-background"
+									alt={ alt }
+									src={ effectiveUrl }
+									style={ mediaStyle }
+								/>
 							) }
-							style={ { backgroundImage, backgroundPosition } }
-						/>
-					) ) }
+							{ ! bindingActive &&
+								( isImgElement ? (
+									<img
+										ref={ mediaElement }
+										className="wp-block-cover__image-background"
+										alt={ alt }
+										src={ url }
+										style={ mediaStyle }
+									/>
+								) : (
+									<div
+										ref={ mediaElement }
+										role={ alt ? 'img' : undefined }
+										aria-label={ alt ? alt : undefined }
+										className={ clsx(
+											classes,
+											'wp-block-cover__image-background'
+										) }
+										style={ {
+											backgroundImage,
+											backgroundPosition,
+										} }
+									/>
+								) ) }
+						</>
+					) }
 				{ url && isVideoBackground && (
 					<video
 						ref={ mediaElement }
diff --git a/packages/block-library/src/cover/test/edit.js b/packages/block-library/src/cover/test/edit.js
index 8e26d0a1ed67bb..c6ea8ac5d835bf 100644
--- a/packages/block-library/src/cover/test/edit.js
+++ b/packages/block-library/src/cover/test/edit.js
@@ -4,6 +4,14 @@
 import { screen, fireEvent, act, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 
+/**
+ * WordPress dependencies
+ */
+import {
+	registerBlockBindingsSource,
+	unregisterBlockBindingsSource,
+} from '@wordpress/blocks';
+
 /**
  * Internal dependencies
  */
@@ -470,4 +478,173 @@ describe( 'Cover block', () => {
 			expect( coverBlock ).not.toHaveClass( 'is-light' );
 		} );
 	} );
+
+	describe( 'Bindings rendering', () => {
+		const TEST_SOURCE = 'test/cover-binding-edit';
+		const TEST_RESOLVED_URL = 'http://localhost/bound-image.jpg';
+		const TEST_RESOLVED_ID = 4242;
+
+		// Mutable state read by the test source's `getValues` so individual
+		// tests can dial the resolved URL / ID without re-registering.
+		const sourceState = {
+			url: TEST_RESOLVED_URL,
+			id: TEST_RESOLVED_ID,
+		};
+
+		beforeEach( () => {
+			sourceState.url = TEST_RESOLVED_URL;
+			sourceState.id = TEST_RESOLVED_ID;
+			registerBlockBindingsSource( {
+				name: TEST_SOURCE,
+				label: 'Test cover binding source',
+				getValues: () => ( {
+					id: sourceState.id,
+					url: sourceState.url,
+				} ),
+				canUserEditValue: () => false,
+			} );
+		} );
+
+		afterEach( () => {
+			unregisterBlockBindingsSource( TEST_SOURCE );
+		} );
+
+		const boundBindings = {
+			id: { source: TEST_SOURCE },
+			url: { source: TEST_SOURCE },
+		};
+
+		test( 'renders a binding-aware placeholder with the unresolvable copy when bindings are mismatched', async () => {
+			// Mismatched sources on `id` vs `url` yield `bindingActive=false`
+			// but `bindingUnresolvable=true` (cover-relevant bindings exist
+			// yet do not satisfy the active-binding predicate).
+			await setup( {
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: 'test/other-source' },
+					},
+				},
+			} );
+
+			const coverBlock = screen.getByLabelText( 'Block: Cover' );
+
+			expect(
+				within( coverBlock ).getByText(
+					'Internal media required for this binding.'
+				)
+			).toBeInTheDocument();
+
+			expect(
+				within( coverBlock ).getByTestId( 'cover-binding-unresolvable' )
+			).toBeInTheDocument();
+
+			expect(
+				// eslint-disable-next-line testing-library/no-node-access
+				coverBlock.querySelector(
+					'img.wp-block-cover__image-background'
+				)
+			).not.toBeInTheDocument();
+		} );
+
+		test( 'force-renders an <img> for an active binding with a resolved URL, ignoring hasParallax / isRepeated', async () => {
+			await setup( {
+				url: 'http://localhost/stored-image.jpg',
+				backgroundType: 'image',
+				hasParallax: true,
+				isRepeated: true,
+				metadata: { bindings: boundBindings },
+			} );
+
+			const boundImg = await screen.findByRole( 'img' );
+
+			expect( boundImg ).toHaveClass(
+				'wp-block-cover__image-background'
+			);
+			expect( boundImg ).toHaveAttribute( 'src', TEST_RESOLVED_URL );
+
+			// The force-img branch never picks up the parallax/repeat <div>
+			// markup; assert that the alternative <div> background does NOT
+			// appear in the rendered tree.
+			expect(
+				// eslint-disable-next-line testing-library/no-node-access
+				document.querySelector( 'div.wp-block-cover__image-background' )
+			).not.toBeInTheDocument();
+		} );
+
+		test( 'reaches the image branch via effectiveUrl even when the stored url is empty', async () => {
+			// Pattern-Overrides-shaped state: the stored `url` is empty but
+			// the bound source provides a populated URL via `effectiveUrl`.
+			// A `customOverlayColor` keeps `hasBackground=true` so the cover
+			// renders its main JSX path (where the image branch lives)
+			// rather than the empty-cover branch.
+			await setup( {
+				url: '',
+				backgroundType: 'image',
+				customOverlayColor: '#abcdef',
+				metadata: { bindings: boundBindings },
+			} );
+
+			const coverBlock = screen.getByLabelText( 'Block: Cover' );
+
+			const boundImg = await within( coverBlock ).findByRole( 'img' );
+
+			expect( boundImg ).toHaveClass(
+				'wp-block-cover__image-background'
+			);
+			expect( boundImg ).toHaveAttribute( 'src', TEST_RESOLVED_URL );
+		} );
+
+		test( 'omits has-background-dim-100 on the overlay when dimRatio === 100 and the binding resolves a URL', async () => {
+			const { container } = await setup( {
+				url: 'http://localhost/stored-image.jpg',
+				backgroundType: 'image',
+				dimRatio: 100,
+				metadata: { bindings: boundBindings },
+			} );
+
+			// The bound `<img>` proves the active-binding path engaged.
+			await screen.findByRole( 'img' );
+
+			// eslint-disable-next-line testing-library/no-node-access
+			const overlay = container.getElementsByClassName(
+				'wp-block-cover__background'
+			)[ 0 ];
+
+			expect( overlay ).toBeInTheDocument();
+			expect( overlay ).not.toHaveClass( 'has-background-dim-100' );
+		} );
+
+		test( 'leaves the embed-video render path engaged on a cover with bindings (binding is inert)', async () => {
+			await setup( {
+				url: 'https://example.com/video',
+				backgroundType: 'embed-video',
+				metadata: { bindings: boundBindings },
+			} );
+
+			const coverBlock = screen.getByLabelText( 'Block: Cover' );
+
+			// `bindingActive` is forced to `false` for embed-video covers, so
+			// the binding-aware placeholder must NOT engage inside the cover.
+			expect(
+				within( coverBlock ).queryByText(
+					'Internal media required for this binding.'
+				)
+			).not.toBeInTheDocument();
+
+			expect(
+				within( coverBlock ).queryByTestId(
+					'cover-binding-unresolvable'
+				)
+			).not.toBeInTheDocument();
+
+			// Likewise, the force-img branch must not fire.
+			expect(
+				// eslint-disable-next-line testing-library/no-node-access
+				coverBlock.querySelector(
+					'img.wp-block-cover__image-background'
+				)
+			).not.toBeInTheDocument();
+		} );
+	} );
 } );

From a7f57f48b21a75c97ffe0c79a93139c018aad272 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 18:14:59 +0200
Subject: [PATCH 32/60] feat(block-library): hide cover controls conflicting
 with active bindings

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/cover/edit/block-controls.js          | 89 ++++++++++++++-----
 .../block-library/src/cover/edit/index.js     | 16 ++--
 .../src/cover/edit/inspector-controls.js      | 34 ++++++-
 packages/block-library/src/cover/test/edit.js | 73 +++++++++++++++
 4 files changed, 182 insertions(+), 30 deletions(-)

diff --git a/packages/block-library/src/cover/edit/block-controls.js b/packages/block-library/src/cover/edit/block-controls.js
index 778300fe4d707c..b4f22b08d73d3d 100644
--- a/packages/block-library/src/cover/edit/block-controls.js
+++ b/packages/block-library/src/cover/edit/block-controls.js
@@ -23,6 +23,46 @@ import EmbedVideoUrlInput from './embed-video-url-input';
 
 const { cleanEmptyObject } = unlock( blockEditorPrivateApis );
 
+/**
+ * Block toolbar controls rendered for the Cover block.
+ *
+ * @param {Object}   props                        The component props.
+ * @param {Object}   props.attributes             The block's stored attributes.
+ * @param {Function} props.setAttributes          Setter for the block's
+ *                                                attributes.
+ * @param {Function} props.onSelectMedia          Handler invoked when the
+ *                                                user selects a media item.
+ * @param {Object}   props.currentSettings        Source-agnostic snapshot of
+ *                                                the cover's render state
+ *                                                (`url`, `hasInnerBlocks`, …).
+ * @param {Function} props.toggleUseFeaturedImage Handler toggling
+ *                                                `useFeaturedImage`.
+ * @param {Function} props.onClearMedia           Handler that resets the
+ *                                                media attributes back to
+ *                                                their unbound default.
+ * @param {Function} props.onSelectEmbedUrl       Handler invoked when the
+ *                                                user picks an embed URL
+ *                                                from the "Embed video from
+ *                                                URL" affordance.
+ * @param {string}   props.blockEditingMode       Editing mode reported by
+ *                                                `useBlockEditingMode`.
+ * @param {boolean}  props.bindingActive          Whether the cover has an
+ *                                                active block binding on
+ *                                                `id` / `url`. When `true`,
+ *                                                the entire
+ *                                                `<MediaReplaceFlow>`
+ *                                                affordance (including its
+ *                                                "Embed video from URL"
+ *                                                child item) is omitted from
+ *                                                the toolbar — a literal DOM
+ *                                                absence rather than a
+ *                                                `disabled` state. Embed-video
+ *                                                covers force
+ *                                                `bindingActive=false`
+ *                                                upstream, so the affordance
+ *                                                remains accessible on the
+ *                                                AC-21 population.
+ */
 export default function CoverBlockControls( {
 	attributes,
 	setAttributes,
@@ -32,6 +72,7 @@ export default function CoverBlockControls( {
 	onClearMedia,
 	onSelectEmbedUrl,
 	blockEditingMode,
+	bindingActive,
 } ) {
 	const {
 		contentPosition,
@@ -109,29 +150,31 @@ export default function CoverBlockControls( {
 				</BlockControls>
 			) }
 			<BlockControls group="other">
-				<MediaReplaceFlow
-					mediaId={ id }
-					mediaURL={ url }
-					allowedTypes={ ALLOWED_MEDIA_TYPES }
-					onSelect={ onSelectMedia }
-					onToggleFeaturedImage={ toggleUseFeaturedImage }
-					useFeaturedImage={ useFeaturedImage }
-					name={ ! url ? __( 'Add media' ) : __( 'Replace' ) }
-					onReset={ onClearMedia }
-					variant="toolbar"
-				>
-					{ ( { onClose } ) => (
-						<MenuItem
-							icon={ link }
-							onClick={ () => {
-								setIsEmbedUrlInputOpen( true );
-								onClose();
-							} }
-						>
-							{ __( 'Embed video from URL' ) }
-						</MenuItem>
-					) }
-				</MediaReplaceFlow>
+				{ ! bindingActive && (
+					<MediaReplaceFlow
+						mediaId={ id }
+						mediaURL={ url }
+						allowedTypes={ ALLOWED_MEDIA_TYPES }
+						onSelect={ onSelectMedia }
+						onToggleFeaturedImage={ toggleUseFeaturedImage }
+						useFeaturedImage={ useFeaturedImage }
+						name={ ! url ? __( 'Add media' ) : __( 'Replace' ) }
+						onReset={ onClearMedia }
+						variant="toolbar"
+					>
+						{ ( { onClose } ) => (
+							<MenuItem
+								icon={ link }
+								onClick={ () => {
+									setIsEmbedUrlInputOpen( true );
+									onClose();
+								} }
+							>
+								{ __( 'Embed video from URL' ) }
+							</MenuItem>
+						) }
+					</MediaReplaceFlow>
+				) }
 			</BlockControls>
 			{ isEmbedUrlInputOpen && (
 				<EmbedVideoUrlInput
diff --git a/packages/block-library/src/cover/edit/index.js b/packages/block-library/src/cover/edit/index.js
index eb063685887ee5..005e4bf8be3775 100644
--- a/packages/block-library/src/cover/edit/index.js
+++ b/packages/block-library/src/cover/edit/index.js
@@ -620,6 +620,7 @@ function CoverEdit( {
 			toggleUseFeaturedImage={ toggleUseFeaturedImage }
 			onClearMedia={ onClearMedia }
 			blockEditingMode={ blockEditingMode }
+			bindingActive={ bindingActive }
 		/>
 	);
 
@@ -635,6 +636,7 @@ function CoverEdit( {
 			updateDimRatio={ onUpdateDimRatio }
 			onClearMedia={ onClearMedia }
 			featuredImage={ media }
+			bindingActive={ bindingActive }
 		/>
 	);
 
@@ -881,12 +883,14 @@ function CoverEdit( {
 
 				{ isUploadingMedia && <Spinner /> }
 
-				<CoverPlaceholder
-					disableMediaButtons
-					onSelectMedia={ onSelectMedia }
-					onError={ onUploadError }
-					toggleUseFeaturedImage={ toggleUseFeaturedImage }
-				/>
+				{ ! bindingActive && (
+					<CoverPlaceholder
+						disableMediaButtons
+						onSelectMedia={ onSelectMedia }
+						onError={ onUploadError }
+						toggleUseFeaturedImage={ toggleUseFeaturedImage }
+					/>
+				) }
 				<div { ...innerBlocksProps } />
 			</TagName>
 			{ hasNonContentControls && isSelected && (
diff --git a/packages/block-library/src/cover/edit/inspector-controls.js b/packages/block-library/src/cover/edit/inspector-controls.js
index 4d554c14fa2788..6baee753e53cbb 100644
--- a/packages/block-library/src/cover/edit/inspector-controls.js
+++ b/packages/block-library/src/cover/edit/inspector-controls.js
@@ -90,6 +90,37 @@ function CoverHeightInput( {
 		/>
 	);
 }
+/**
+ * Inspector controls rendered alongside the Cover block.
+ *
+ * @param {Object}   props                 The component props.
+ * @param {Object}   props.attributes      The block's stored attributes.
+ * @param {Function} props.setAttributes   Setter for the block's attributes.
+ * @param {string}   props.clientId        The block's client ID.
+ * @param {Function} props.setOverlayColor Setter for the overlay color
+ *                                         (drives the `getMediaColor`-based
+ *                                         dark/light derivation).
+ * @param {Object}   props.coverRef        Ref to the cover root element,
+ *                                         used by the focal-point preview.
+ * @param {Object}   props.currentSettings Source-agnostic snapshot of the
+ *                                         cover's render state (`url`,
+ *                                         `isImageBackground`, …).
+ * @param {Function} props.updateDimRatio  Setter for the overlay opacity
+ *                                         (handles the `isDark`
+ *                                         recomputation).
+ * @param {Object}   props.featuredImage   The resolved featured-image
+ *                                         attachment record, when
+ *                                         `useFeaturedImage` is set.
+ * @param {boolean}  props.bindingActive   Whether the cover has an
+ *                                         active block binding on `id` /
+ *                                         `url`. When `true`, controls
+ *                                         that would mutate
+ *                                         binding-controlled attributes
+ *                                         (parallax / repeat) are omitted
+ *                                         from the inspector entirely — a
+ *                                         literal DOM absence rather than
+ *                                         a `disabled` state.
+ */
 export default function CoverInspectorControls( {
 	attributes,
 	setAttributes,
@@ -99,6 +130,7 @@ export default function CoverInspectorControls( {
 	currentSettings,
 	updateDimRatio,
 	featuredImage,
+	bindingActive,
 } ) {
 	const {
 		useFeaturedImage,
@@ -223,7 +255,7 @@ export default function CoverInspectorControls( {
 						} }
 						dropdownMenuProps={ dropdownMenuProps }
 					>
-						{ isImageBackground && (
+						{ isImageBackground && ! bindingActive && (
 							<>
 								<ToolsPanelItem
 									label={ __( 'Fixed background' ) }
diff --git a/packages/block-library/src/cover/test/edit.js b/packages/block-library/src/cover/test/edit.js
index c6ea8ac5d835bf..9df6680c7b086c 100644
--- a/packages/block-library/src/cover/test/edit.js
+++ b/packages/block-library/src/cover/test/edit.js
@@ -647,4 +647,77 @@ describe( 'Cover block', () => {
 			).not.toBeInTheDocument();
 		} );
 	} );
+
+	describe( 'Bindings control gating', () => {
+		const TEST_SOURCE = 'test/cover-binding-controls';
+		const TEST_RESOLVED_URL = 'http://localhost/bound-image.jpg';
+		const TEST_RESOLVED_ID = 4242;
+
+		beforeEach( () => {
+			registerBlockBindingsSource( {
+				name: TEST_SOURCE,
+				label: 'Test cover binding controls source',
+				getValues: () => ( {
+					id: TEST_RESOLVED_ID,
+					url: TEST_RESOLVED_URL,
+				} ),
+				canUserEditValue: () => false,
+			} );
+		} );
+
+		afterEach( () => {
+			unregisterBlockBindingsSource( TEST_SOURCE );
+		} );
+
+		const boundBindings = {
+			id: { source: TEST_SOURCE },
+			url: { source: TEST_SOURCE },
+		};
+
+		test( 'hides the "Fixed background" and "Repeated background" inspector controls when bindingActive', async () => {
+			await setup( {
+				url: 'http://localhost/stored-image.jpg',
+				backgroundType: 'image',
+				metadata: { bindings: boundBindings },
+			} );
+
+			// Force-img branch engages, confirming the binding is active and
+			// the inspector subtree has rendered alongside it.
+			await screen.findByRole( 'img' );
+
+			// On bound covers the parallax / repeat toggles are absent from
+			// the document regardless of selection state — the inspector is
+			// rendered unconditionally by `CoverEdit`, so we can assert on
+			// the global DOM without going through `selectBlock`.
+			expect(
+				screen.queryByLabelText( 'Fixed background' )
+			).not.toBeInTheDocument();
+			expect(
+				screen.queryByLabelText( 'Repeated background' )
+			).not.toBeInTheDocument();
+		} );
+
+		test( 'hides the MediaReplaceFlow toolbar button when bindingActive', async () => {
+			await setup( {
+				url: 'http://localhost/stored-image.jpg',
+				backgroundType: 'image',
+				metadata: { bindings: boundBindings },
+			} );
+
+			// Force-img branch engages, confirming the binding is active and
+			// the block-toolbar subtree has rendered alongside it.
+			await screen.findByRole( 'img' );
+
+			// On bound covers the `<MediaReplaceFlow>` toggle is absent from
+			// the document regardless of selection state — `<BlockControls>`
+			// portals are present in the global DOM whenever `CoverEdit`
+			// renders.
+			expect(
+				screen.queryByRole( 'button', { name: 'Replace' } )
+			).not.toBeInTheDocument();
+			expect(
+				screen.queryByRole( 'button', { name: 'Add media' } )
+			).not.toBeInTheDocument();
+		} );
+	} );
 } );

From 066534fbf1fb7d04eb8b5686edfdf837cb000d75 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 18:25:27 +0200
Subject: [PATCH 33/60] test(block-library): add cover bindings server-render
 PHPUnit coverage

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php |  68 ++-
 phpunit/blocks/render-block-cover-test.php  | 466 +++++++++++++++++++-
 2 files changed, 528 insertions(+), 6 deletions(-)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index a21fb707a79a00..c7ef0125c1e3a5 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -143,6 +143,48 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 	}
 }
 
+if ( ! function_exists( 'gutenberg_cover_bindings_has_cover_relevant_configuration' ) ) {
+	/**
+	 * Determines whether a Cover block's `metadata.bindings` carries any
+	 * cover-relevant binding configuration.
+	 *
+	 * "Cover-relevant" means at least one of `__default`, `id`, or `url` is
+	 * present in the `metadata.bindings` map — i.e. the user has attempted to
+	 * bind one of the Cover's two bindable attributes. The helper does NOT
+	 * check whether the configuration is internally consistent; it answers
+	 * "does this cover have any cover-binding intent?", so the
+	 * `render_block` filter can distinguish:
+	 *
+	 *   - genuinely unbound covers (no `metadata.bindings` at all, or
+	 *     `metadata.bindings` only mentions attributes other than `id`/`url`
+	 *     /`__default`) — must render byte-identically to trunk (AC-20).
+	 *
+	 *   - covers whose binding configuration is present but
+	 *     `gutenberg_cover_bindings_is_active()` returned `false` (mismatched
+	 *     `source`, differing `args`, only one of `id`/`url` bound) — must
+	 *     render in the "unresolvable" state, with the saved image stripped
+	 *     (AC-6).
+	 *
+	 * This mirrors the client-side `bindingUnresolvable` predicate (per
+	 * `useCoverBindingState`), which similarly treats "any cover-relevant
+	 * bindings AND not active" as unresolvable.
+	 *
+	 * @since 7.1.0
+	 * @access private
+	 *
+	 * @param array<string, mixed> $attrs The Cover block's attribute array.
+	 * @return bool True when `metadata.bindings` has at least one of the
+	 *              cover-relevant keys (`__default`, `id`, `url`).
+	 */
+	function gutenberg_cover_bindings_has_cover_relevant_configuration( array $attrs ): bool {
+		$bindings = $attrs['metadata']['bindings'] ?? null;
+		if ( empty( $bindings ) || ! is_array( $bindings ) ) {
+			return false;
+		}
+		return isset( $bindings['__default'] ) || isset( $bindings['id'] ) || isset( $bindings['url'] );
+	}
+}
+
 if ( ! function_exists( 'gutenberg_cover_bindings_prepare_block' ) ) {
 	/**
 	 * Neutralises `useFeaturedImage` on Cover blocks whose `id`+`url` bindings
@@ -442,20 +484,27 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 	 * substitution must happen on the saved markup before the generic filter
 	 * potentially re-runs `$instance->render()`.
 	 *
-	 * Gating order (each step short-circuits to "return unchanged"):
+	 * Gating order:
 	 *
-	 * 1. The block is not `core/cover`.
+	 * 1. The block is not `core/cover` — return unchanged.
 	 * 2. `backgroundType === 'embed-video'` — embed-video covers are explicitly
 	 *    out of scope for the Cover-scoped binding render path (AC-21); the
-	 *    existing oEmbed code path remains intact.
-	 * 3. The bindings are not active per `gutenberg_cover_bindings_is_active()`.
+	 *    existing oEmbed code path remains intact — return unchanged.
+	 * 3. The cover has `metadata.bindings` configuration for `id` and/or `url`
+	 *    but the configuration is not active (mismatched `source`, differing
+	 *    `args`, or only one of the two attributes bound). This is the
+	 *    server-side mirror of the client's `bindingUnresolvable` predicate:
+	 *    the binding cannot be honoured, so the saved image element is stripped
+	 *    and the cover renders overlay-only (AC-6).
+	 * 4. The bindings are not active AND there is no cover-relevant
+	 *    configuration — return unchanged (unbound cover, AC-20 non-regression).
 	 *
 	 * After the gates, the resolved URL and ID come from `$instance->attributes`
 	 * (which `WP_Block::render()` has already merged the resolved bindings
 	 * into — see `wp-includes/class-wp-block.php`). If either value is missing,
 	 * or the resolved ID is not an attachment in the media library, the saved
 	 * image element is stripped from `$content` and the cover renders
-	 * overlay-only (AC-5, AC-6).
+	 * overlay-only (AC-5).
 	 *
 	 * Otherwise the saved image element is rewritten in place by
 	 * `gutenberg_cover_bindings_rewrite_image()` to carry the bound URL, ID
@@ -487,6 +536,15 @@ function gutenberg_cover_bindings_render_block( $block_content, $block, $instanc
 		}
 
 		if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
+			// AC-6: explicit per-attribute bindings whose `source` or `args`
+			// don't match (or only one of `id`/`url` is bound) cannot be
+			// honoured — strip the saved cover image element so the cover
+			// renders overlay-only, matching the client's `bindingUnresolvable`
+			// affordance. Covers with no cover-relevant binding configuration
+			// (the AC-20 unbound population) are returned unchanged.
+			if ( gutenberg_cover_bindings_has_cover_relevant_configuration( $attrs ) ) {
+				return gutenberg_cover_bindings_strip_image( $block_content );
+			}
 			return $block_content;
 		}
 
diff --git a/phpunit/blocks/render-block-cover-test.php b/phpunit/blocks/render-block-cover-test.php
index 8a249b2c119f01..e718787fae90a0 100644
--- a/phpunit/blocks/render-block-cover-test.php
+++ b/phpunit/blocks/render-block-cover-test.php
@@ -20,12 +20,39 @@ class Tests_Blocks_Render_Cover extends WP_UnitTestCase {
 	protected static $post;
 
 	/**
-	 * Attachment id.
+	 * Default attachment id (used by the featured-image and parallax tests; also
+	 * the post thumbnail).
 	 *
 	 * @var int
 	 */
 	protected static $attachment_id;
 
+	/**
+	 * Override attachment id — a second media-library attachment used by the
+	 * binding-aware tests to assert that the BOUND value (not the featured-image
+	 * or saved-markup URL) wins.
+	 *
+	 * @var int
+	 */
+	protected static $override_attachment_id;
+
+	/**
+	 * Name of the test binding source registered in `set_up()`. The source is
+	 * configured per-test (its `get_value_callback` is rebound via a class
+	 * property) so each test can drive a different resolution.
+	 *
+	 * @var string
+	 */
+	const TEST_SOURCE_NAME = 'test/cover-bindings';
+
+	/**
+	 * Holds the current test's `get_value_callback`. Set by each test before it
+	 * calls `register_test_source()`; consumed by the registered closure.
+	 *
+	 * @var callable|null
+	 */
+	protected $source_callback;
+
 	/**
 	 * Setup method.
 	 */
@@ -41,7 +68,21 @@ public static function wpSetUpBeforeClass() {
 			)
 		);
 
+		// Second attachment, used as the bound override target so tests can
+		// assert that the bound URL wins over the featured-image URL.
+		self::$override_attachment_id = self::factory()->attachment->create_upload_object(
+			$file,
+			self::$post->ID,
+			array(
+				'post_mime_type' => 'image/jpeg',
+			)
+		);
+
 		set_post_thumbnail( self::$post, self::$attachment_id );
+
+		// Populate alt metadata on the override attachment so the rebuilt-img
+		// path has something deterministic to assert against.
+		update_post_meta( self::$override_attachment_id, '_wp_attachment_image_alt', 'Override alt text' );
 	}
 
 	/**
@@ -50,6 +91,52 @@ public static function wpSetUpBeforeClass() {
 	public static function wpTearDownAfterClass() {
 		wp_delete_post( self::$post->ID, true );
 		wp_delete_post( self::$attachment_id, true );
+		wp_delete_post( self::$override_attachment_id, true );
+	}
+
+	/**
+	 * Per-test set-up: registers a Cover-shaped test binding source whose
+	 * `get_value_callback` is delegated to the `source_callback` property. The
+	 * delegation indirection means each test can swap behaviour without
+	 * re-registering the source.
+	 */
+	public function set_up() {
+		parent::set_up();
+		$this->source_callback = null;
+	}
+
+	/**
+	 * Per-test tear-down: unregisters the test binding source if it was
+	 * registered, so the next test starts from a clean registry.
+	 */
+	public function tear_down() {
+		if ( get_block_bindings_source( self::TEST_SOURCE_NAME ) ) {
+			unregister_block_bindings_source( self::TEST_SOURCE_NAME );
+		}
+		$this->source_callback = null;
+
+		parent::tear_down();
+	}
+
+	/**
+	 * Registers the test binding source. Tests call this after assigning their
+	 * `source_callback`; the closure invokes the callback per attribute lookup
+	 * so a single source can drive both `id` and `url` resolutions.
+	 *
+	 * @param callable $callback Function( $source_args, $block_instance, $attribute_name ).
+	 */
+	protected function register_test_source( callable $callback ) {
+		$this->source_callback = $callback;
+		$test                  = $this;
+		register_block_bindings_source(
+			self::TEST_SOURCE_NAME,
+			array(
+				'label'              => array( 'label' => 'Test cover source' ),
+				'get_value_callback' => function ( $source_args, $block_instance, $attribute_name ) use ( $test ) {
+					return call_user_func( $test->source_callback, $source_args, $block_instance, $attribute_name );
+				},
+			)
+		);
 	}
 
 	/**
@@ -128,4 +215,381 @@ public function test_gutenberg_render_block_core_cover_fixed_or_repeated_backgro
 		$this->assertStringNotContainsString( 'background-image', $rendered );
 		$this->assertStringNotContainsString( 'min-height', $rendered );
 	}
+
+	/**
+	 * Builds a parsed Cover block array with a `metadata.bindings` shape that
+	 * targets the test source for both `id` and `url`. Returns the array shape
+	 * `render_block()` accepts directly (no `parse_blocks` round-trip).
+	 *
+	 * @param string $saved_markup     The serialized Cover inner HTML.
+	 * @param array  $extra_attributes Extra attributes to merge into the `attrs` array.
+	 * @param array  $bindings_override Optional bindings shape; defaults to a
+	 *                                  same-source `{ id, url }` shape against
+	 *                                  the test source.
+	 * @return array A parsed-block array suitable for `render_block()`.
+	 */
+	protected function build_bound_cover_block( string $saved_markup, array $extra_attributes = array(), $bindings_override = null ): array {
+		$bindings = null !== $bindings_override
+			? $bindings_override
+			: array(
+				'id'  => array( 'source' => self::TEST_SOURCE_NAME ),
+				'url' => array( 'source' => self::TEST_SOURCE_NAME ),
+			);
+
+		$attrs = array_merge(
+			array(
+				'backgroundType' => 'image',
+				'metadata'       => array( 'bindings' => $bindings ),
+			),
+			$extra_attributes
+		);
+
+		return array(
+			'blockName'    => 'core/cover',
+			'attrs'        => $attrs,
+			'innerBlocks'  => array(),
+			'innerHTML'    => $saved_markup,
+			'innerContent' => array( $saved_markup ),
+		);
+	}
+
+	/**
+	 * AC-3: the resolved binding URL is substituted into the plain `<img>`
+	 * saved form. Asserts the bound URL appears in `src`, the previous saved
+	 * src does NOT appear, and the resolved attachment's `wp-image-{id}` class
+	 * replaces any pre-existing `wp-image-*` class.
+	 */
+	public function test_bound_url_substitutes_in_plain_img_form() {
+		$bound_url = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
+		$bound_id  = self::$override_attachment_id;
+
+		$this->register_test_source(
+			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
+				return 'url' === $attribute_name ? $bound_url : $bound_id;
+			}
+		);
+
+		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background wp-image-999" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
+		$parsed_block = $this->build_bound_cover_block( $saved_markup );
+		$rendered     = render_block( $parsed_block );
+
+		$this->assertStringContainsString( 'src="' . esc_attr( $bound_url ) . '"', $rendered, 'The bound URL must be substituted into the saved <img>.' );
+		$this->assertStringNotContainsString( 'https://saved.example.com/old.jpg', $rendered, 'The pre-existing saved src must be replaced.' );
+		$this->assertStringContainsString( 'wp-image-' . $bound_id, $rendered, 'The resolved attachment id must surface as a wp-image-{id} class.' );
+		$this->assertStringNotContainsString( 'wp-image-999', $rendered, 'The pre-existing wp-image-999 class must be removed before the new one is added.' );
+	}
+
+	/**
+	 * AC-16 / AC-25: stored `dimRatio: 100` is the cover default, but on a
+	 * bound cover the fully-opaque overlay would hide the bound image. The
+	 * server filter relaxes the class to "no modifier" — the rendered overlay
+	 * span contains `has-background-dim` but NOT `has-background-dim-100`.
+	 */
+	public function test_default_dim_ratio_class_is_relaxed() {
+		$bound_url = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
+		$bound_id  = self::$override_attachment_id;
+
+		$this->register_test_source(
+			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
+				return 'url' === $attribute_name ? $bound_url : $bound_id;
+			}
+		);
+
+		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
+		$parsed_block = $this->build_bound_cover_block( $saved_markup, array( 'dimRatio' => 100 ) );
+		$rendered     = render_block( $parsed_block );
+
+		$this->assertStringNotContainsString(
+			'has-background-dim-100',
+			$rendered,
+			'has-background-dim-100 must be removed when the stored dimRatio is the default 100.'
+		);
+		$this->assertStringContainsString(
+			'has-background-dim',
+			$rendered,
+			'has-background-dim (the 50%-opacity baseline) must be preserved per OQ-4.'
+		);
+	}
+
+	/**
+	 * AC-17: a non-default `dimRatio` (here, 70) is preserved untouched on a
+	 * bound cover — the relax pass only fires on the 100 default.
+	 */
+	public function test_non_default_dim_ratio_is_preserved() {
+		$bound_url = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
+		$bound_id  = self::$override_attachment_id;
+
+		$this->register_test_source(
+			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
+				return 'url' === $attribute_name ? $bound_url : $bound_id;
+			}
+		);
+
+		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-70"></span><div class="wp-block-cover__inner-container"></div></div>';
+		$parsed_block = $this->build_bound_cover_block( $saved_markup, array( 'dimRatio' => 70 ) );
+		$rendered     = render_block( $parsed_block );
+
+		$this->assertStringContainsString(
+			'has-background-dim-70',
+			$rendered,
+			'A user-set non-default dimRatio class must survive the bound render.'
+		);
+		$this->assertStringContainsString( 'src="' . esc_attr( $bound_url ) . '"', $rendered, 'The bound URL must still be substituted on the non-default dimRatio path.' );
+	}
+
+	/**
+	 * AC-19: when a cover saved with `hasParallax`/`isRepeated` (the `<div
+	 * style="background-image:url(…)">` form) gains an active binding, the
+	 * `<div>` is rebuilt into a plain `<img>` carrying the bound URL, the
+	 * `wp-image-{id}` class, and NO parallax/repeat classes or
+	 * background-image style.
+	 */
+	public function test_parallax_saved_markup_is_rebuilt_as_img() {
+		$bound_url = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
+		$bound_id  = self::$override_attachment_id;
+
+		$this->register_test_source(
+			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
+				return 'url' === $attribute_name ? $bound_url : $bound_id;
+			}
+		);
+
+		$saved_markup = '<div class="wp-block-cover has-parallax is-repeated"><div role="img" aria-label="" class="wp-block-cover__image-background wp-image-555 has-parallax is-repeated" style="background-position:50% 50%;background-image:url(https://saved.example.com/old.jpg)"></div><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
+		$parsed_block = $this->build_bound_cover_block(
+			$saved_markup,
+			array(
+				'hasParallax' => true,
+				'isRepeated'  => true,
+			)
+		);
+		$rendered     = render_block( $parsed_block );
+
+		$this->assertMatchesRegularExpression(
+			'/<img[^>]*\bwp-block-cover__image-background\b[^>]*>/',
+			$rendered,
+			'The parallax/repeat <div> must be replaced with an <img>.'
+		);
+		$this->assertStringNotContainsString(
+			'background-image:url(https://saved.example.com/old.jpg)',
+			$rendered,
+			'The saved background-image:url() CSS must not survive in the rebuilt element.'
+		);
+		// The rebuilt <img> element must not carry has-parallax / is-repeated.
+		// (The outer wrapper `<div class="wp-block-cover has-parallax is-repeated">`
+		// MAY still contain them — the bind path only rewrites the inner image.)
+		$this->assertDoesNotMatchRegularExpression(
+			'/<img[^>]*\bwp-block-cover__image-background\b[^>]*\bhas-parallax\b/',
+			$rendered,
+			'The rebuilt <img> must not carry has-parallax.'
+		);
+		$this->assertDoesNotMatchRegularExpression(
+			'/<img[^>]*\bwp-block-cover__image-background\b[^>]*\bis-repeated\b/',
+			$rendered,
+			'The rebuilt <img> must not carry is-repeated.'
+		);
+		$this->assertStringContainsString( 'src="' . esc_attr( $bound_url ) . '"', $rendered, 'The rebuilt <img> must carry the bound URL.' );
+		$this->assertStringContainsString( 'wp-image-' . $bound_id, $rendered, 'The rebuilt <img> must carry wp-image-{resolved id}.' );
+	}
+
+	/**
+	 * AC-6: when `metadata.bindings.id` and `metadata.bindings.url` resolve via
+	 * different sources, the binding is unresolvable and the saved image
+	 * element is stripped from the output — the cover renders overlay-only.
+	 */
+	public function test_mismatched_source_strips_image() {
+		// Register only one of the two sources; the other reference is
+		// deliberately to an unregistered source so the bindings can't possibly
+		// match.
+		$this->register_test_source(
+			function () {
+				return 'unused';
+			}
+		);
+
+		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
+		$parsed_block = $this->build_bound_cover_block(
+			$saved_markup,
+			array(),
+			array(
+				'id'  => array( 'source' => self::TEST_SOURCE_NAME ),
+				'url' => array( 'source' => 'test/other-source-that-does-not-exist' ),
+			)
+		);
+		$rendered     = render_block( $parsed_block );
+
+		$this->assertStringNotContainsString(
+			'wp-block-cover__image-background',
+			$rendered,
+			'A mismatched binding must strip the saved cover image element entirely.'
+		);
+	}
+
+	/**
+	 * AC-5: when the binding resolves a URL but the `id` does not correspond
+	 * to a media-library attachment (here, the post id), the saved image
+	 * element is stripped — internal-only media is required.
+	 */
+	public function test_external_url_strips_image() {
+		$bound_url = 'https://external.example.com/photo.jpg';
+		$bound_id  = self::$post->ID; // A post, not an attachment.
+
+		$this->register_test_source(
+			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
+				return 'url' === $attribute_name ? $bound_url : $bound_id;
+			}
+		);
+
+		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
+		$parsed_block = $this->build_bound_cover_block( $saved_markup );
+		$rendered     = render_block( $parsed_block );
+
+		$this->assertStringNotContainsString(
+			'wp-block-cover__image-background',
+			$rendered,
+			'An id that is not an attachment must strip the saved cover image element.'
+		);
+		$this->assertStringNotContainsString(
+			$bound_url,
+			$rendered,
+			'The non-attachment URL must not leak into the rendered output.'
+		);
+	}
+
+	/**
+	 * AC-18: when both `useFeaturedImage: true` AND an active binding co-exist
+	 * on a cover, the binding wins. The rendered output contains exactly ONE
+	 * `wp-block-cover__image-background` element, its `src` is the bound URL,
+	 * and the featured-image URL does not appear at all.
+	 */
+	public function test_use_featured_image_with_active_binding_emits_exactly_one_img_with_bound_url() {
+		global $wp_query;
+		$wp_query->in_the_loop = true;
+		$wp_query->post        = self::$post;
+		$wp_query->posts       = array( self::$post );
+		$GLOBALS['post']       = self::$post;
+
+		$bound_url    = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
+		$bound_id     = self::$override_attachment_id;
+		$featured_url = wp_get_attachment_image_url( self::$attachment_id, 'full' );
+
+		$this->register_test_source(
+			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
+				return 'url' === $attribute_name ? $bound_url : $bound_id;
+			}
+		);
+
+		// Plain `<img>` saved form — the saved src does not matter since the
+		// bound URL is substituted in place.
+		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
+		$parsed_block = $this->build_bound_cover_block(
+			$saved_markup,
+			array(
+				'useFeaturedImage' => true,
+				'hasParallax'      => false,
+				'isRepeated'       => false,
+			)
+		);
+		$rendered     = render_block( $parsed_block );
+
+		// Bound URL appears once.
+		$this->assertSame(
+			1,
+			substr_count( $rendered, esc_attr( $bound_url ) ),
+			'The bound URL must appear exactly once in the rendered cover (AC-18).'
+		);
+		// The featured-image URL must not appear at all.
+		$this->assertStringNotContainsString(
+			$featured_url,
+			$rendered,
+			'The featured-image URL must not be injected when a binding is active (AC-18).'
+		);
+		// Exactly one `wp-block-cover__image-background` element survives.
+		$this->assertSame(
+			1,
+			preg_match_all( '/class="[^"]*\bwp-block-cover__image-background\b[^"]*"/', $rendered ),
+			'Exactly one wp-block-cover__image-background element must survive on a useFeaturedImage+bound cover.'
+		);
+	}
+
+	/**
+	 * AC-21: `backgroundType: 'embed-video'` covers short-circuit both the
+	 * binding-aware filters. Even with same-source `id`+`url` bindings
+	 * configured, the Cover render path remains the trunk embed-video path —
+	 * no `<img>` substitution, no dim-class relaxation.
+	 */
+	public function test_embed_video_short_circuits() {
+		$bound_url = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
+		$bound_id  = self::$override_attachment_id;
+
+		$this->register_test_source(
+			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
+				return 'url' === $attribute_name ? $bound_url : $bound_id;
+			}
+		);
+
+		// Embed-video covers serialize as a `<figure class="wp-block-embed">`
+		// inside the cover wrapper. We assert the bound-cover code path does
+		// NOT engage: the bound URL must not appear and the
+		// `has-background-dim-100` class must survive untouched.
+		$saved_markup = '<div class="wp-block-cover"><figure class="wp-block-cover__video-background wp-block-cover__embed-background wp-block-embed"><div class="wp-block-embed__wrapper">https://example.com/video</div></figure><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
+		$parsed_block = $this->build_bound_cover_block(
+			$saved_markup,
+			array(
+				'backgroundType' => 'embed-video',
+				'url'            => 'https://example.com/video',
+			)
+		);
+		$rendered     = render_block( $parsed_block );
+
+		$this->assertStringNotContainsString(
+			$bound_url,
+			$rendered,
+			'The bound URL must not be substituted into an embed-video cover (AC-21).'
+		);
+		$this->assertStringContainsString(
+			'has-background-dim-100',
+			$rendered,
+			'The dim-class relax pass must not run on an embed-video cover (AC-21).'
+		);
+	}
+
+	/**
+	 * AC-20: an unbound cover (no `metadata.bindings`) is byte-identical to
+	 * trunk — the binding-aware filters are pure no-ops on unbound content.
+	 */
+	public function test_unbound_cover_is_byte_identical_to_trunk() {
+		// Render an unbound cover through the full `render_block()` pipeline
+		// (including the new priority-9 filter) and through `render_block()`
+		// again after temporarily removing the priority-9 filter, then assert
+		// the outputs match byte-for-byte. This is a stronger guarantee than
+		// "the new filter returned its input unchanged" because it also covers
+		// any incidental interference with neighbouring filters.
+		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background wp-image-42" alt="" src="https://example.com/local.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
+		$parsed_block = array(
+			'blockName'    => 'core/cover',
+			'attrs'        => array(
+				'backgroundType' => 'image',
+				'url'            => 'https://example.com/local.jpg',
+				'id'             => 42,
+				'dimRatio'       => 100,
+			),
+			'innerBlocks'  => array(),
+			'innerHTML'    => $saved_markup,
+			'innerContent' => array( $saved_markup ),
+		);
+
+		$with_filter = render_block( $parsed_block );
+
+		remove_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9 );
+		remove_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10 );
+		$without_filter = render_block( $parsed_block );
+		add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 );
+		add_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10, 3 );
+
+		$this->assertSame(
+			$without_filter,
+			$with_filter,
+			'An unbound cover must render byte-identically with and without the binding-aware filters (AC-20).'
+		);
+	}
 }

From e630d1e86c672cdd1947ad973ddece96e3980306 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 19:09:57 +0200
Subject: [PATCH 34/60] test(block-library): add Jest coverage for cover
 bindings hook + observer

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 packages/block-library/src/cover/test/edit.js | 628 +++++++++++++++++-
 1 file changed, 627 insertions(+), 1 deletion(-)

diff --git a/packages/block-library/src/cover/test/edit.js b/packages/block-library/src/cover/test/edit.js
index 9df6680c7b086c..7de1eb0478daac 100644
--- a/packages/block-library/src/cover/test/edit.js
+++ b/packages/block-library/src/cover/test/edit.js
@@ -1,7 +1,13 @@
 /**
  * External dependencies
  */
-import { screen, fireEvent, act, within } from '@testing-library/react';
+import {
+	screen,
+	fireEvent,
+	act,
+	within,
+	renderHook,
+} from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 
 /**
@@ -11,6 +17,8 @@ import {
 	registerBlockBindingsSource,
 	unregisterBlockBindingsSource,
 } from '@wordpress/blocks';
+import { dispatch } from '@wordpress/data';
+import { store as coreStore } from '@wordpress/core-data';
 
 /**
  * Internal dependencies
@@ -19,6 +27,21 @@ import {
 	initializeEditor,
 	selectBlock,
 } from 'test/integration/helpers/integration-test-editor';
+import useCoverBindingState from '../edit/use-cover-binding-state';
+import { getMediaColor } from '../edit/color-utils';
+
+// Wrap `getMediaColor` so individual tests can intercept its calls / control
+// the timing of its async resolution. The default `mockImplementation`
+// delegates to the real implementation (preserving behaviour for every other
+// test in this file).
+jest.mock( '../edit/color-utils', () => {
+	const actual = jest.requireActual( '../edit/color-utils' );
+	return {
+		__esModule: true,
+		...actual,
+		getMediaColor: jest.fn( actual.getMediaColor ),
+	};
+} );
 
 const defaultSettings = {
 	__experimentalFeatures: {
@@ -720,4 +743,607 @@ describe( 'Cover block', () => {
 			).not.toBeInTheDocument();
 		} );
 	} );
+
+	describe( 'useCoverBindingState', () => {
+		// Unique per-describe source name so registrations cannot leak between
+		// the integration-style binding describes and these hook-level tests.
+		const TEST_SOURCE = 'test/cover-binding-state-hook';
+		const OTHER_SOURCE = 'test/cover-binding-state-other';
+		const TEST_RESOLVED_URL = 'http://localhost/resolved-image.jpg';
+		const TEST_RESOLVED_ID = 9991;
+
+		const sourceState = {
+			url: TEST_RESOLVED_URL,
+			id: TEST_RESOLVED_ID,
+		};
+
+		beforeEach( () => {
+			sourceState.url = TEST_RESOLVED_URL;
+			sourceState.id = TEST_RESOLVED_ID;
+			registerBlockBindingsSource( {
+				name: TEST_SOURCE,
+				label: 'Hook test binding source',
+				getValues: () => ( {
+					id: sourceState.id,
+					url: sourceState.url,
+				} ),
+				canUserEditValue: () => false,
+			} );
+			registerBlockBindingsSource( {
+				name: OTHER_SOURCE,
+				label: 'Other hook test binding source',
+				getValues: () => ( {
+					id: undefined,
+					url: undefined,
+				} ),
+				canUserEditValue: () => false,
+			} );
+		} );
+
+		afterEach( () => {
+			unregisterBlockBindingsSource( TEST_SOURCE );
+			unregisterBlockBindingsSource( OTHER_SOURCE );
+		} );
+
+		/**
+		 * Renders the hook under test and returns its current state. The hook
+		 * is exercised through `renderHook` with the actual data registry; the
+		 * synchronous snapshot value reflects the predicate state after the
+		 * first render (before any subscription-side rerender).
+		 *
+		 * @param {Object} attributes Cover attributes passed verbatim to the hook.
+		 * @param {Object} [context]  Optional block context object.
+		 *
+		 * @return {Object} The hook's snapshot value at first render.
+		 */
+		const snapshotBindingState = ( attributes, context = {} ) => {
+			const { result } = renderHook( () =>
+				useCoverBindingState( {
+					clientId: 'test-client-id',
+					attributes,
+					context,
+				} )
+			);
+			return result.current;
+		};
+
+		test( 'bindingActive is false when id and url have different sources', () => {
+			const bindingState = snapshotBindingState( {
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: OTHER_SOURCE },
+					},
+				},
+			} );
+
+			expect( bindingState.bindingActive ).toBe( false );
+		} );
+
+		test( 'bindingActive is false when id and url bind to matching source but differing args', () => {
+			const bindingState = snapshotBindingState( {
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE, args: { key: 'a' } },
+						url: { source: TEST_SOURCE, args: { key: 'b' } },
+					},
+				},
+			} );
+
+			expect( bindingState.bindingActive ).toBe( false );
+		} );
+
+		test( 'bindingActive is false when backgroundType is "embed-video"', () => {
+			// AC-21: the embed-video carve-out short-circuits the binding
+			// path even when the binding configuration itself would qualify.
+			const bindingState = snapshotBindingState( {
+				backgroundType: 'embed-video',
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: TEST_SOURCE },
+					},
+				},
+			} );
+
+			expect( bindingState.bindingActive ).toBe( false );
+		} );
+
+		test( 'bindingUnresolvable is true when bindings are present but mismatched (cover-relevant config + !bindingActive)', () => {
+			const bindingState = snapshotBindingState( {
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: OTHER_SOURCE },
+					},
+				},
+			} );
+
+			expect( bindingState.bindingActive ).toBe( false );
+			expect( bindingState.bindingUnresolvable ).toBe( true );
+		} );
+
+		test( 'returns the no-bindings shape when `metadata.bindings` is absent', () => {
+			// The early-return shape preserves the hook's contract for every
+			// cover that has never been bound.
+			const bindingState = snapshotBindingState( {} );
+
+			expect( bindingState.bindingActive ).toBe( false );
+			expect( bindingState.bindingUnresolvable ).toBe( false );
+			expect( bindingState.bindingResolvedUrl ).toBeUndefined();
+			expect( bindingState.bindingResolvedId ).toBeUndefined();
+			expect( bindingState.canUserEditBindingValue ).toBe( false );
+		} );
+
+		// The remaining `bindingActive: true` / `bindingUnresolvable: true`
+		// arms are exercised through `CoverEdit` integration: a bound cover
+		// surfaces the force-img branch when `bindingActive` is true, and the
+		// "Internal media required for this binding." placeholder when
+		// `bindingUnresolvable` is true. Going through the editor lets the
+		// `useSelect` subscription that backs the hook settle inside the
+		// `act` boundary that `render()` already establishes.
+
+		test( 'bindingActive: true via `__default` pattern-overrides binding engages the force-img render path (integration)', async () => {
+			// Confirms the inline `__default` expander reaches `bindingActive`.
+			// The block-editor's own `replacePatternOverridesDefaultBinding`
+			// also runs against the block's bindings and needs to know the
+			// block's bindable attributes — supplied via the experimental
+			// editor setting below — so it can iterate `[ 'id', 'url' ]`
+			// instead of `undefined`.
+			registerBlockBindingsSource( {
+				name: 'core/pattern-overrides',
+				label: 'Pattern overrides (test stand-in)',
+				getValues: () => ( {
+					id: TEST_RESOLVED_ID,
+					url: TEST_RESOLVED_URL,
+				} ),
+				canUserEditValue: () => false,
+			} );
+
+			try {
+				await setup(
+					{
+						url: '',
+						backgroundType: 'image',
+						customOverlayColor: '#abcdef',
+						metadata: {
+							bindings: {
+								__default: {
+									source: 'core/pattern-overrides',
+								},
+							},
+						},
+					},
+					true,
+					{
+						...defaultSettings,
+						__experimentalBlockBindingsSupportedAttributes: {
+							'core/cover': [ 'id', 'url' ],
+						},
+					}
+				);
+
+				const boundImg = await screen.findByRole( 'img' );
+				expect( boundImg ).toHaveAttribute( 'src', TEST_RESOLVED_URL );
+			} finally {
+				unregisterBlockBindingsSource( 'core/pattern-overrides' );
+			}
+		} );
+
+		test( 'bindingActive: true via matching source + matching args engages the force-img render path (integration)', async () => {
+			await setup( {
+				url: '',
+				backgroundType: 'image',
+				customOverlayColor: '#abcdef',
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE, args: { key: 'shared' } },
+						url: { source: TEST_SOURCE, args: { key: 'shared' } },
+					},
+				},
+			} );
+
+			const boundImg = await screen.findByRole( 'img' );
+			expect( boundImg ).toHaveAttribute( 'src', TEST_RESOLVED_URL );
+		} );
+
+		test( 'bindingUnresolvable: false (pending) keeps the bound `<img>` slot rendered without an unresolvable placeholder (integration)', async () => {
+			// No attachment record is preloaded for this ID — the core-data
+			// selector returns `undefined`, the hook treats that as pending,
+			// and the cover renders normally with the bound `<img>` (no
+			// unresolvable placeholder).
+			const pendingId = 88_881;
+			sourceState.id = pendingId;
+			sourceState.url = 'http://localhost/pending.jpg';
+
+			await setup( {
+				url: '',
+				backgroundType: 'image',
+				customOverlayColor: '#abcdef',
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: TEST_SOURCE },
+					},
+				},
+			} );
+
+			const coverBlock = screen.getByLabelText( 'Block: Cover' );
+
+			expect(
+				within( coverBlock ).queryByText(
+					'Internal media required for this binding.'
+				)
+			).not.toBeInTheDocument();
+
+			const boundImg = await within( coverBlock ).findByRole( 'img' );
+			expect( boundImg ).toHaveAttribute(
+				'src',
+				'http://localhost/pending.jpg'
+			);
+		} );
+
+		test( 'bindingUnresolvable: true when the bound id resolves to a non-attachment record (integration)', async () => {
+			// Preload a record under the attachment entity but with
+			// `type !== "attachment"` — the hook's `attachmentResolvedWrongType`
+			// guard is the user-observable arm of the "resolved-not-found"
+			// invariant (Design §5.1 step 3: attachment must be a media-library
+			// attachment to count as resolved). The `attachment` entity is
+			// normally registered after a REST call; in this jsdom environment
+			// no such call happens, so we register it explicitly here.
+			const wrongTypeId = 99_991;
+			sourceState.id = wrongTypeId;
+			sourceState.url = 'http://localhost/wrong-type.jpg';
+
+			await act( async () => {
+				dispatch( coreStore ).addEntities( [
+					{
+						kind: 'postType',
+						name: 'attachment',
+						baseURL: '/wp/v2/media',
+						baseURLParams: { context: 'edit' },
+					},
+				] );
+				dispatch( coreStore ).receiveEntityRecords(
+					'postType',
+					'attachment',
+					[
+						{
+							id: wrongTypeId,
+							type: 'post',
+							source_url: 'http://localhost/wrong-type.jpg',
+						},
+					],
+					{ context: 'view' }
+				);
+			} );
+
+			await setup( {
+				url: '',
+				backgroundType: 'image',
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: TEST_SOURCE },
+					},
+				},
+			} );
+
+			const coverBlock = screen.getByLabelText( 'Block: Cover' );
+
+			expect(
+				await within( coverBlock ).findByText(
+					'Internal media required for this binding.'
+				)
+			).toBeInTheDocument();
+		} );
+
+		test( 'effectiveDimRatio collapses to 50 in the rendered overlay when bindingActive && dimRatio === 100 && effectiveUrl is truthy', async () => {
+			// `effectiveDimRatio` lives inside `CoverEdit`, so this is the
+			// integration arm of the derivation. With an active binding, a
+			// resolved URL, and stored `dimRatio === 100`, the overlay must
+			// drop `has-background-dim-100` and use the default-50% baseline
+			// (`has-background-dim` only — `dimRatioToClass(50)` returns
+			// `null`, by convention, because 50 is the no-override default).
+			const { container } = await setup( {
+				url: 'http://localhost/stored.jpg',
+				backgroundType: 'image',
+				dimRatio: 100,
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: TEST_SOURCE },
+					},
+				},
+			} );
+
+			await screen.findByRole( 'img' );
+
+			// eslint-disable-next-line testing-library/no-node-access
+			const overlay = container.getElementsByClassName(
+				'wp-block-cover__background'
+			)[ 0 ];
+
+			expect( overlay ).toHaveClass( 'has-background-dim' );
+			expect( overlay ).not.toHaveClass( 'has-background-dim-100' );
+			expect( overlay ).not.toHaveClass( 'has-background-dim-50' );
+		} );
+
+		test( 'effectiveDimRatio equals dimRatio when bindingActive but dimRatio !== 100 (non-default ratio is preserved)', async () => {
+			// The 50 collapse is gated on the *default* dim ratio. A user who
+			// has explicitly pinned a non-100 ratio gets the same dim treatment
+			// on bound and unbound covers.
+			const { container } = await setup( {
+				url: 'http://localhost/stored.jpg',
+				backgroundType: 'image',
+				dimRatio: 70,
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: TEST_SOURCE },
+					},
+				},
+			} );
+
+			await screen.findByRole( 'img' );
+
+			// eslint-disable-next-line testing-library/no-node-access
+			const overlay = container.getElementsByClassName(
+				'wp-block-cover__background'
+			)[ 0 ];
+
+			expect( overlay ).toHaveClass( 'has-background-dim-70' );
+			expect( overlay ).not.toHaveClass( 'has-background-dim-50' );
+		} );
+	} );
+
+	describe( 'CoverEdit single observer', () => {
+		const TEST_SOURCE = 'test/cover-binding-observer';
+		const TEST_RESOLVED_URL = 'http://localhost/observer-image.jpg';
+		const TEST_RESOLVED_ID = 7777;
+
+		const sourceState = {
+			url: TEST_RESOLVED_URL,
+			id: TEST_RESOLVED_ID,
+		};
+
+		beforeEach( () => {
+			sourceState.url = TEST_RESOLVED_URL;
+			sourceState.id = TEST_RESOLVED_ID;
+			registerBlockBindingsSource( {
+				name: TEST_SOURCE,
+				label: 'Observer test binding source',
+				getValues: () => ( {
+					id: sourceState.id,
+					url: sourceState.url,
+				} ),
+				canUserEditValue: () => false,
+			} );
+			// Default `getMediaColor` to the real implementation (silently
+			// falls through to the default colour in JSDOM); individual tests
+			// can override via `mockImplementation`.
+			getMediaColor.mockReset();
+			const actualGetMediaColor = jest.requireActual(
+				'../edit/color-utils'
+			).getMediaColor;
+			getMediaColor.mockImplementation( actualGetMediaColor );
+		} );
+
+		afterEach( () => {
+			unregisterBlockBindingsSource( TEST_SOURCE );
+		} );
+
+		test( 'does not write any DC-2-prohibited attribute back to the block when a binding becomes active', async () => {
+			// Saved state: `dimRatio = 100`, `hasParallax = true`,
+			// `isRepeated = true`, plus an active binding. The observer must
+			// NOT flip any of these to keep DC-2.
+			//
+			// `BlockEditorProvider` creates a private sub-registry, so we
+			// cannot read attributes from the global `blockEditorStore`
+			// directly. We instead lean on the `<Editor>` helper's `onChange`
+			// callback — it fires whenever blocks change — by interposing a
+			// spy that records every blocks-update the editor commits. If
+			// the observer dispatched any DC-2-prohibited `setAttributes`
+			// call, that change would surface here; the test asserts no such
+			// change ever ran by sampling the final committed block state.
+			//
+			// (Operationally: `setup()` keeps blocks in local state inside
+			// `Editor`. The observer's `setAttributes({ isDark })` calls
+			// commit to the underlying registry, propagate via `onChange`
+			// to `Editor`, then update `currentBlocks` — which is the same
+			// path any other write would take.)
+			const initialAttrs = {
+				url: 'http://localhost/stored.jpg',
+				id: 1234,
+				backgroundType: 'image',
+				dimRatio: 100,
+				hasParallax: true,
+				isRepeated: true,
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: TEST_SOURCE },
+					},
+				},
+			};
+
+			await setup( initialAttrs );
+
+			// Wait for the binding-aware render to engage.
+			await screen.findByRole( 'img' );
+
+			// Allow the URL-resolved observer (and any subsequent re-renders)
+			// to flush before we sample the stored attributes.
+			await act( async () => {
+				await Promise.resolve();
+			} );
+			await act( async () => {
+				await Promise.resolve();
+			} );
+
+			const coverBlock = screen.getByLabelText( 'Block: Cover' );
+
+			// `data-url` is the editor's pass-through of the stored `url`
+			// attribute (via `originalUrl?.replaceAll('&amp;', '&')`). A
+			// DC-2-violating observer that wrote `setAttributes({ url:
+			// bindingResolvedUrl })` would clobber this to the resolved URL.
+			expect( coverBlock ).toHaveAttribute(
+				'data-url',
+				'http://localhost/stored.jpg'
+			);
+
+			// The bound `<img>` carries the resolved URL (proves the
+			// binding-aware render engaged).
+			// eslint-disable-next-line testing-library/no-node-access
+			const boundImg = coverBlock.querySelector(
+				'img.wp-block-cover__image-background'
+			);
+			expect( boundImg ).toHaveAttribute( 'src', TEST_RESOLVED_URL );
+
+			// `hasParallax`/`isRepeated` survival proof: if the observer had
+			// flipped either to false, `isImgElement` would have toggled and
+			// the non-binding rendering branch would have switched its DOM
+			// element. The active-binding force-img branch ignores those at
+			// render time, so the only way to invalidate this assertion is
+			// for the observer to set `hasParallax`/`isRepeated` to false
+			// AND for the binding to deactivate — neither of which should
+			// happen.
+			expect( coverBlock ).toHaveClass( 'has-parallax' );
+			expect( coverBlock ).toHaveClass( 'is-repeated' );
+
+			// The overlay class reflects the *derived* effectiveDimRatio (50)
+			// — `dimRatioToClass(50)` returns `null` (the 50% baseline is the
+			// no-override default), so we assert the *absence* of the
+			// `has-background-dim-100` class that would be present if the
+			// stored `dimRatio` (100) had been used directly.
+			// eslint-disable-next-line testing-library/no-node-access
+			const overlay = coverBlock.querySelector(
+				'.wp-block-cover__background'
+			);
+			expect( overlay ).toHaveClass( 'has-background-dim' );
+			expect( overlay ).not.toHaveClass( 'has-background-dim-100' );
+		} );
+
+		test( 'is source-agnostic: invokes `getMediaColor` for a manual `attributes.url` URL', async () => {
+			// DC-3 part 1: the observer treats `attributes.url` (the manual
+			// editor-driven URL) identically to other URL sources — its
+			// presence is enough to fire `getMediaColor`.
+			getMediaColor.mockClear();
+			const manualUrl = 'http://localhost/agnostic-manual.jpg';
+			await setup( {
+				url: manualUrl,
+				backgroundType: 'image',
+			} );
+			await act( async () => {
+				await Promise.resolve();
+			} );
+			expect( getMediaColor ).toHaveBeenCalledWith( manualUrl );
+		} );
+
+		test( 'is source-agnostic: invokes `getMediaColor` for a binding-resolved URL', async () => {
+			// DC-3 part 2: the same observer fires identically when the URL
+			// originates from a bound source — the unique URL per test avoids
+			// any memoised-cache cross-pollination from the manual case.
+			getMediaColor.mockClear();
+			const boundUrl = 'http://localhost/agnostic-bound.jpg';
+			sourceState.url = boundUrl;
+			await setup( {
+				url: '',
+				backgroundType: 'image',
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: TEST_SOURCE },
+					},
+				},
+			} );
+			await act( async () => {
+				await Promise.resolve();
+			} );
+			expect( getMediaColor ).toHaveBeenCalledWith( boundUrl );
+		} );
+
+		test( 'observer fires `getMediaColor` exactly once per `effectiveUrl` on mount (race-token guard precondition: single observer keyed on effectiveUrl)', async () => {
+			// The race-token guard relies on the single-observer keyed-on-
+			// `effectiveUrl` architecture (DC-1). If a future change
+			// introduced additional triggers (e.g. a separate `useEffect`
+			// on `metadata.bindings` that also calls `getMediaColor`), the
+			// raceToken bookkeeping could break — multiple observers
+			// could increment the token concurrently. This test fixes the
+			// initial-mount invariant: a single mount triggers a single
+			// observer fire for the resolved `effectiveUrl`.
+			//
+			// `getMediaColor` is held pending so the post-await
+			// `setAttributes`/`setOverlayColor` flush never fires within
+			// the test — eliminating any "update was not wrapped in act"
+			// console errors that would otherwise come from the observer
+			// firing after the test's assertions have run.
+			const URL_A = 'http://localhost/observer-counts.jpg';
+			const pendingPromise = new Promise( () => {
+				/* never resolves */
+			} );
+
+			getMediaColor.mockImplementation( ( url ) => {
+				if ( url === URL_A ) {
+					return pendingPromise;
+				}
+				return Promise.resolve( '#888888' );
+			} );
+
+			await setup( {
+				url: URL_A,
+				backgroundType: 'image',
+				dimRatio: 70,
+			} );
+
+			// Filter to URL_A only — the editor harness may incidentally
+			// fire `getMediaColor()` against `undefined` during mount.
+			const callsForUrlA = getMediaColor.mock.calls.filter(
+				( [ url ] ) => url === URL_A
+			);
+			expect( callsForUrlA ).toHaveLength( 1 );
+		} );
+
+		test( 'race-token guard: no extra `getMediaColor` invocation on mount when binding-active state is in the initial attributes (DC-1 single-observer corollary)', async () => {
+			// `useEffectEvent`'s race-token bookkeeping (Task 7) ensures
+			// that out-of-order resolutions don't clobber the latest
+			// derivation. We cannot trigger two simultaneous URL changes
+			// from a Jest integration test without poking the editor's
+			// private sub-registry (the `BlockEditorProvider` creates one),
+			// so this test pins the load-bearing precondition: even when
+			// the cover mounts with binding-active state already in its
+			// attributes (so `useCoverBindingState` runs through its
+			// `useSelect` branch instead of the early-return path), the
+			// observer fires exactly ONCE — not twice, which would be the
+			// fingerprint of an extra `useEffect` keyed on bindings.
+			const URL_A = 'http://localhost/race-mount-bound.jpg';
+			const pendingPromise = new Promise( () => {
+				/* never resolves */
+			} );
+
+			getMediaColor.mockImplementation( ( url ) => {
+				if ( url === URL_A ) {
+					return pendingPromise;
+				}
+				return Promise.resolve( '#888888' );
+			} );
+
+			sourceState.url = URL_A;
+			await setup( {
+				url: '',
+				backgroundType: 'image',
+				dimRatio: 70,
+				metadata: {
+					bindings: {
+						id: { source: TEST_SOURCE },
+						url: { source: TEST_SOURCE },
+					},
+				},
+			} );
+
+			expect(
+				getMediaColor.mock.calls.filter( ( [ url ] ) => url === URL_A )
+			).toHaveLength( 1 );
+		} );
+	} );
 } );

From b71054e50cd292de26a2e25dae7f1c061ed5f7a9 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 19:21:12 +0200
Subject: [PATCH 35/60] test(block-library): add Pattern Overrides round-trip
 e2e test for cover bindings

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 test/e2e/specs/editor/blocks/cover.spec.js | 362 +++++++++++++++++++++
 1 file changed, 362 insertions(+)

diff --git a/test/e2e/specs/editor/blocks/cover.spec.js b/test/e2e/specs/editor/blocks/cover.spec.js
index 68c78b22ef22ad..58bf8673df673a 100644
--- a/test/e2e/specs/editor/blocks/cover.spec.js
+++ b/test/e2e/specs/editor/blocks/cover.spec.js
@@ -571,6 +571,368 @@ test.describe( 'Cover', () => {
 	} );
 } );
 
+test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () => {
+	/**
+	 * The synced pattern's Cover block is given a stable `metadata.name` so
+	 * pattern-override values keyed off it can be addressed unambiguously from
+	 * the pattern instance's `content` attribute. The same name appears in
+	 * every override / reset step below.
+	 */
+	const coverBindingName = 'Bound Cover';
+
+	let defaultMedia;
+	let overrideMedia;
+
+	test.beforeAll( async ( { requestUtils } ) => {
+		// Two attachments: `defaultMedia` is baked into the pattern's saved
+		// cover; `overrideMedia` is written into a pattern instance via the
+		// `core/block` `content` attribute below.
+		[ defaultMedia, overrideMedia ] = await Promise.all( [
+			requestUtils.uploadMedia(
+				'./assets/10x10_e2e_test_image_z9T8jK.png'
+			),
+			requestUtils.uploadMedia(
+				'./assets/1024x768_e2e_test_image_size.jpeg'
+			),
+		] );
+		// Sanity: distinct attachments so the round-trip assertions are
+		// observable in both directions (default → override → reset).
+		expect( overrideMedia.id ).not.toBe( defaultMedia.id );
+		expect( overrideMedia.source_url ).not.toBe( defaultMedia.source_url );
+	} );
+
+	test.beforeEach( async ( { admin, requestUtils } ) => {
+		// Reset blocks between phases so each top-level step starts from a
+		// known post + pattern store.
+		await requestUtils.deleteAllBlocks();
+		await admin.createNewPost();
+	} );
+
+	test.afterAll( async ( { requestUtils } ) => {
+		await requestUtils.deleteAllBlocks();
+		await requestUtils.deleteAllMedia();
+	} );
+
+	test( 'Cover round-trips through default → override → reset', async ( {
+		admin,
+		editor,
+		page,
+		requestUtils,
+	} ) => {
+		// Synced pattern carrying a bound Cover. `__default` pattern-overrides
+		// expands to per-attribute `id` / `url` bindings on the server and in
+		// the editor hook, so the inner Cover renders the saved
+		// `defaultMedia` until a parent `core/block` `content` override is
+		// applied.
+		const pattern = await requestUtils.createBlock( {
+			title: 'Cover Pattern',
+			content: `<!-- wp:cover {"url":"${ defaultMedia.source_url }","id":${ defaultMedia.id },"dimRatio":100,"customOverlayColor":"#000000","minHeight":80,"metadata":{"name":"${ coverBindingName }","bindings":{"__default":{"source":"core/pattern-overrides"}}}} -->
+<div class="wp-block-cover" style="min-height:80px"><span aria-hidden="true" class="wp-block-cover__background has-background-dim-100 has-background-dim" style="background-color:#000000"></span><img class="wp-block-cover__image-background wp-image-${ defaultMedia.id }" alt="" src="${ defaultMedia.source_url }" data-object-fit="cover"/><div class="wp-block-cover__inner-container"><!-- wp:paragraph {"align":"center","placeholder":"Write title…"} -->
+<p class="has-text-align-center"></p>
+<!-- /wp:paragraph --></div></div>
+<!-- /wp:cover -->`,
+			status: 'publish',
+		} );
+
+		let patternBlock;
+		let coverBlock;
+
+		await test.step( 'Default state — pattern instance shows defaultMedia and hides bound controls', async () => {
+			await editor.insertBlock( {
+				name: 'core/block',
+				attributes: { ref: pattern.id },
+			} );
+
+			patternBlock = editor.canvas.getByRole( 'document', {
+				name: 'Block: Pattern',
+			} );
+			coverBlock = patternBlock.getByRole( 'document', {
+				name: 'Block: Cover',
+			} );
+			await expect( coverBlock ).toBeVisible();
+
+			// AC-7 / AC-22: the editor preview img resolves to the pattern's
+			// default attachment because no override is set on the instance.
+			await expect( coverBlock.locator( 'img' ) ).toHaveAttribute(
+				'src',
+				defaultMedia.source_url
+			);
+
+			// AC-15: editor overlay should keep `has-background-dim` but drop
+			// the `-100` modifier so the bound `<img>` remains visible (the
+			// hook downshifts `effectiveDimRatio` to 50 when `dimRatio===100`).
+			const overlay = coverBlock.locator( '.wp-block-cover__background' );
+			await expect( overlay ).toHaveClass( /has-background-dim(?!-100)/ );
+			await expect( overlay ).not.toHaveClass( /has-background-dim-100/ );
+
+			// Select the bound Cover so its inspector + toolbar render.
+			await editor.selectBlocks( coverBlock );
+			await editor.openDocumentSettingsSidebar();
+			await editor.showBlockToolbar();
+
+			const editorSettings = page.getByRole( 'region', {
+				name: 'Editor settings',
+			} );
+			await openStylesTabIfAvailable( editorSettings );
+
+			// AC-11 / AC-12: the parallax + repeated-background tools-panel
+			// items are absent for bound covers.
+			await expect(
+				editorSettings.getByRole( 'checkbox', {
+					name: 'Fixed background',
+				} )
+			).toHaveCount( 0 );
+			await expect(
+				editorSettings.getByRole( 'checkbox', {
+					name: 'Repeated background',
+				} )
+			).toHaveCount( 0 );
+
+			// AC-13 / AC-14: the `<MediaReplaceFlow>` toolbar dropdown — the
+			// only DOM site of both the "Replace" and "Add media" toolbar
+			// labels — is omitted entirely. Zero matches is the positive
+			// assertion the design doc (§5.5) and the task spec require.
+			const blockToolbar = page.getByRole( 'toolbar', {
+				name: 'Block tools',
+			} );
+			await expect(
+				blockToolbar.getByRole( 'button', {
+					name: /^(Replace|Add media)$/,
+				} )
+			).toHaveCount( 0 );
+
+			// AC-10: the `ResetOverridesControl` toolbar button reports
+			// disabled because no override has been written yet.
+			const resetButton = blockToolbar.getByRole( 'button', {
+				name: 'Reset',
+			} );
+			await expect( resetButton ).toBeDisabled();
+		} );
+
+		await test.step( 'AC-21 — embed-video covers retain Replace + "Embed video from URL"', async () => {
+			// Embed-video covers force `bindingActive=false` upstream even
+			// when `metadata.bindings` is present, so the
+			// `<MediaReplaceFlow>` affordance — including the "Embed video
+			// from URL" `<MenuItem>` child — must still render. Use a brand
+			// new post to keep the assertion focused on a single block tree.
+			await admin.createNewPost();
+			await editor.insertBlock( {
+				name: 'core/cover',
+				attributes: {
+					url: 'https://videopress.com/v/example',
+					backgroundType: 'embed-video',
+					dimRatio: 50,
+					customOverlayColor: '#111111',
+					metadata: {
+						name: 'Embed cover',
+						bindings: {
+							url: { source: 'core/pattern-overrides' },
+							id: { source: 'core/pattern-overrides' },
+						},
+					},
+				},
+			} );
+			const embedCover = editor.canvas
+				.getByRole( 'document', { name: 'Block: Cover' } )
+				.last();
+			await editor.selectBlocks( embedCover );
+			await editor.showBlockToolbar();
+
+			const embedToolbar = page.getByRole( 'toolbar', {
+				name: 'Block tools',
+			} );
+			const replaceToggle = embedToolbar.getByRole( 'button', {
+				name: /^(Replace|Add media)$/,
+			} );
+			await expect( replaceToggle ).toBeVisible();
+
+			await replaceToggle.click();
+			await expect(
+				page.getByRole( 'menuitem', {
+					name: 'Embed video from URL',
+				} )
+			).toBeVisible();
+
+			// Close the dropdown so it does not bleed into the next step.
+			await page.keyboard.press( 'Escape' );
+		} );
+
+		await test.step( 'Override — instance content writes overrideMedia through the binding', async () => {
+			await admin.createNewPost();
+			await editor.insertBlock( {
+				name: 'core/block',
+				attributes: { ref: pattern.id },
+			} );
+
+			patternBlock = editor.canvas.getByRole( 'document', {
+				name: 'Block: Pattern',
+			} );
+			coverBlock = patternBlock.getByRole( 'document', {
+				name: 'Block: Cover',
+			} );
+			await expect( coverBlock ).toBeVisible();
+
+			// Write the override directly onto the pattern instance's
+			// `content` attribute. This is exactly what
+			// `ResetOverridesControl` undoes in the reset step below.
+			await page.evaluate(
+				( { name, overrideId, overrideUrl } ) => {
+					const { dispatch, select } = window.wp.data;
+					const blocks = select( 'core/block-editor' ).getBlocks();
+					const patternClientId = blocks.find(
+						( block ) => block.name === 'core/block'
+					)?.clientId;
+					dispatch( 'core/block-editor' ).updateBlockAttributes(
+						patternClientId,
+						{
+							content: {
+								[ name ]: {
+									id: overrideId,
+									url: overrideUrl,
+								},
+							},
+						}
+					);
+				},
+				{
+					name: coverBindingName,
+					overrideId: overrideMedia.id,
+					overrideUrl: overrideMedia.source_url,
+				}
+			);
+
+			// AC-22 editor: the bound `<img src>` flips to the override.
+			await expect( coverBlock.locator( 'img' ) ).toHaveAttribute(
+				'src',
+				overrideMedia.source_url
+			);
+
+			// AC-10: the now-written override flips `ResetOverridesControl`
+			// to enabled.
+			await editor.selectBlocks( coverBlock );
+			await editor.showBlockToolbar();
+			const blockToolbar = page.getByRole( 'toolbar', {
+				name: 'Block tools',
+			} );
+			await expect(
+				blockToolbar.getByRole( 'button', { name: 'Reset' } )
+			).toBeEnabled();
+
+			// AC-8 / AC-16: publish, then read the rendered post on the
+			// front-end. The server-rendered `<img src>` must match the
+			// override and the overlay span must keep `has-background-dim`
+			// while losing the `-100` modifier.
+			const postId = await editor.publishPost();
+			await page.goto( `/?p=${ postId }` );
+
+			const renderedImage = page.locator(
+				'.wp-block-cover__image-background'
+			);
+			await expect( renderedImage ).toHaveAttribute(
+				'src',
+				overrideMedia.source_url
+			);
+
+			const renderedOverlay = page.locator(
+				'.wp-block-cover__background'
+			);
+			await expect( renderedOverlay ).toHaveClass(
+				/has-background-dim(?!-100)/
+			);
+			await expect( renderedOverlay ).not.toHaveClass(
+				/has-background-dim-100/
+			);
+		} );
+
+		await test.step( 'Reset — clicking Reset clears the override on both editor and front-end', async () => {
+			await admin.createNewPost();
+			await editor.insertBlock( {
+				name: 'core/block',
+				attributes: {
+					ref: pattern.id,
+					content: {
+						[ coverBindingName ]: {
+							id: overrideMedia.id,
+							url: overrideMedia.source_url,
+						},
+					},
+				},
+			} );
+
+			patternBlock = editor.canvas.getByRole( 'document', {
+				name: 'Block: Pattern',
+			} );
+			coverBlock = patternBlock.getByRole( 'document', {
+				name: 'Block: Cover',
+			} );
+
+			// Confirm the override is in effect before resetting.
+			await expect( coverBlock.locator( 'img' ) ).toHaveAttribute(
+				'src',
+				overrideMedia.source_url
+			);
+
+			await editor.selectBlocks( coverBlock );
+			await editor.showBlockToolbar();
+			const blockToolbar = page.getByRole( 'toolbar', {
+				name: 'Block tools',
+			} );
+			const resetButton = blockToolbar.getByRole( 'button', {
+				name: 'Reset',
+			} );
+			await expect( resetButton ).toBeEnabled();
+			await resetButton.click();
+
+			// AC-9 editor: the bound `<img src>` falls back to the pattern's
+			// stored default attachment.
+			await expect( coverBlock.locator( 'img' ) ).toHaveAttribute(
+				'src',
+				defaultMedia.source_url
+			);
+
+			// AC-9 front-end: the rendered post likewise serves the default
+			// attachment after the reset persists.
+			const postId = await editor.publishPost();
+			await page.goto( `/?p=${ postId }` );
+			await expect(
+				page.locator( '.wp-block-cover__image-background' )
+			).toHaveAttribute( 'src', defaultMedia.source_url );
+		} );
+
+		await test.step( 'Unresolvable — mismatched-source bindings surface the i18n affordance', async () => {
+			await admin.createNewPost();
+
+			// `id` and `url` bound to different sources never satisfy the
+			// hook's `bindingActive` predicate, so the Cover renders the
+			// unresolvable placeholder branch. The mismatched source-set is
+			// intentionally not Pattern Overrides on both sides; the second
+			// source need not actually resolve — the affordance is driven
+			// purely by the source-mismatch detection.
+			await editor.insertBlock( {
+				name: 'core/cover',
+				attributes: {
+					metadata: {
+						name: 'Mismatched Cover',
+						bindings: {
+							id: { source: 'core/pattern-overrides' },
+							url: {
+								source: 'core/post-meta',
+								args: { key: 'url_custom_field' },
+							},
+						},
+					},
+				},
+			} );
+
+			// OQ-6: the user-facing affordance is the i18n message — not a
+			// data-testid — exactly per the task contract.
+			await expect(
+				page.getByText( 'Internal media required for this binding.' )
+			).toBeVisible();
+		} );
+	} );
+} );
+
 class CoverBlockUtils {
 	constructor( { page } ) {
 		/** @type {Page} */

From 940cf22752aef57b5230e427e6348bf5a2bbb7a7 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 19:30:52 +0200
Subject: [PATCH 36/60] docs(pipeline): add 4-code/code-review-approved.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../4-code/code-review-approved.md            | 69 +++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/4-code/code-review-approved.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/4-code/code-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/4-code/code-review-approved.md
new file mode 100644
index 00000000000000..a426b9279161e5
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/4-code/code-review-approved.md
@@ -0,0 +1,69 @@
+# Code Review
+
+## Verdict: approved
+
+## Batch scope
+
+Tasks reviewed: Tasks 1–13 from `3-plan/code-plan.md`.
+
+- Task 1: Add `role: "content"` to `core/cover`'s `id` attribute.
+- Task 2: Create `lib/compat/wordpress-7.1/block-bindings.php` with allow-list filter, wire it into `lib/load.php`.
+- Task 3: Add `gutenberg_cover_bindings_is_active` helper.
+- Task 4: `render_block_data` filter to neutralise `useFeaturedImage` on bound covers.
+- Task 5: Cover-scoped `render_block` filter with image-rewrite / dim-class-relax / strip-image helpers.
+- Task 6: New hook — `useCoverBindingState`.
+- Task 7: Single observer + derived values in `CoverEdit`.
+- Task 8: Bound-cover empty-cover placeholder branch and `<img>`-forced non-empty render branch in `CoverEdit`.
+- Task 9: Gate parallax/repeat in `inspector-controls.js`; gate `<MediaReplaceFlow>` in `block-controls.js`; gate line-750 `<CoverPlaceholder>`.
+- Task 10: PHPUnit coverage in `phpunit/blocks/render-block-cover-test.php`.
+- Task 11: Jest unit tests for `useCoverBindingState` and the single observer.
+- Task 12: E2E — Pattern Overrides round-trip and unresolvable-binding affordance.
+- Task 13: Backport-changelog stub and PR description draft.
+
+## Summary
+
+The batch lands internal-only Block Bindings support for `core/cover`'s `id` and `url`, headlined by Pattern Overrides, in 8 feature commits on the worktree branch (plus 4 test/docs commits). The server-side path is a single Cover-scoped file (`lib/compat/wordpress-7.1/block-bindings.php`) wired into `lib/load.php` with three filters: allow-list (`block_bindings_supported_attributes`), pre-render neutralisation of `useFeaturedImage` (`render_block_data` @ priority 10), and post-render markup rewrite (`render_block` @ priority 9). The client-side path introduces a single-`useSelect` hook (`useCoverBindingState`) and replaces the existing `[mediaUrl]` `useEffect` with a single source-agnostic observer keyed on `effectiveUrl`, using `useEffectEvent` for latest-value reads and a race-token ref for stale-resolution protection. UI gating in `inspector-controls.js`, `block-controls.js`, and the line-750 `<CoverPlaceholder>` call site is conditional-render-based per AC-14's literal-DOM-absence requirement. Tests are comprehensive: 9 new PHPUnit cases, 19 new Jest cases (43 total in `edit.js`, all green), and one e2e describe with five `test.step` phases covering the full Pattern Overrides round-trip plus an embed-video AC-21 control case and an unresolvable-binding affordance check. Lint passes cleanly on the touched files, PHP code style produces only the documented intentional `==` warning, and the byte-identical AC-20 PHPUnit case explicitly removes and re-adds both filters to lock the no-regression contract. DC-1 (single observer), DC-2 (no binding-state-triggered attribute mutation outside the documented DC-3 source-agnostic `setOverlayColor` carve-out + permitted `isDark` write), and DC-3 (source-agnostic derivation) all hold.
+
+## Checks
+
+| Check | Command | Result |
+| ----- | ------- | ------ |
+| JSON schema validity | `node -e "JSON.parse(require('fs').readFileSync('packages/block-library/src/cover/block.json','utf8'))"` | Pass — `block.json valid` |
+| JS lint | `npm run lint:js packages/block-library/src/cover/` | Pass — 0 errors; 10 warnings pre-existing in `*.native.js` files outside this batch |
+| Jest unit suite | `npm run test:unit -- packages/block-library/src/cover/test/edit.js` | Pass — 43/43 tests green (24 pre-existing + 19 new) |
+| PHP lint/code style | `vendor/bin/phpcs lib/compat/wordpress-7.1/block-bindings.php phpunit/blocks/render-block-cover-test.php` | Pass — 0 errors; 3 warnings (1 intentional `==` per Design §6.1, 2 unused-param warnings for required filter signatures) |
+| PHPUnit | `npx wp-env --config .wp-env.test.json run cli --env-cwd=wp-content/plugins/gutenberg -- composer run test -- --filter Tests_Blocks_Render_Cover` | Pass — 11/11 tests, 32 assertions (2 pre-existing + 9 new) |
+| E2E syntactic validity | `node --check test/e2e/specs/editor/blocks/cover.spec.js` | Pass |
+| `lib/load.php` wiring | `grep -n "wordpress-7.1" lib/load.php` | Pass — `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';` is present at line 83 |
+| Diff against trunk | `git diff trunk...HEAD --stat -- '*.js' '*.php' '*.json'` | 8 production files; 2,581 insertions / 95 deletions |
+
+## Behavior verification
+
+The verification convention for this repo is JS unit + PHPUnit + E2E plus lint/code-style gates. All four ran:
+
+- **PHPUnit** — `Tests_Blocks_Render_Cover` ran inside `wp-env-test` via the standard `composer run test --filter`. All 11 tests pass, including:
+  - `test_bound_url_substitutes_in_plain_img_form` (AC-3) — bound URL appears in `src`, pre-existing saved URL removed, `wp-image-{id}` replaced.
+  - `test_default_dim_ratio_class_is_relaxed` (AC-16, AC-25) — `has-background-dim-100` removed, `has-background-dim` preserved.
+  - `test_non_default_dim_ratio_is_preserved` (AC-17) — `has-background-dim-70` survives untouched.
+  - `test_parallax_saved_markup_is_rebuilt_as_img` (AC-19) — `<div>` form rebuilt as `<img>`, no `has-parallax`/`is-repeated` on the image, no `background-image:url()` CSS in the rebuilt element.
+  - `test_mismatched_source_strips_image` (AC-6) — image element stripped on mismatched-source bindings.
+  - `test_external_url_strips_image` (AC-5) — non-attachment id strips the image.
+  - `test_use_featured_image_with_active_binding_emits_exactly_one_img_with_bound_url` (AC-18) — bound URL appears exactly once, featured-image URL absent, exactly one `wp-block-cover__image-background` survives.
+  - `test_embed_video_short_circuits` (AC-21) — bound URL absent, `has-background-dim-100` survives.
+  - `test_unbound_cover_is_byte_identical_to_trunk` (AC-20) — byte-identical output with and without both new filters.
+
+- **Jest** — `packages/block-library/src/cover/test/edit.js` covers `useCoverBindingState` predicates (no-bindings shape, mismatched source, differing args, embed-video override, mismatched-source unresolvable, pending vs not-found vs wrong-type attachment), bound-cover render (unresolvable placeholder, force-`<img>` despite `hasParallax`/`isRepeated`, `effectiveUrl` reach when stored `url` is empty, dim-100 relaxation, embed-video inertness), control gating (parallax/repeat absence, MediaReplaceFlow absence), and the single-observer invariants (no DC-2 mutation, source-agnostic `getMediaColor` invocation for manual vs bound URL, single observer fire on mount). All 43 tests green.
+
+## Issues
+
+None.
+
+## Notes
+
+A few minor observations that did not rise to rejection but warrant a glance from future maintainers:
+
+1. **Backport-changelog stub (Task 13)** is NOT present on the worktree branch HEAD. Trunk has commit `077b1f7a042` (`docs(backport): add cover bindings backport-changelog stub for 7.1`) creating `backport-changelog/7.1/TODO-cover-bindings.md`, but that commit is on `trunk` rather than the feature branch, so `git diff trunk...HEAD` does not include it. Per Design §2.2 (and Code Plan Task 13 phrasing), this file is a SHOULD that "Not a blocker for the Gutenberg PR landing" — Req 36 conditionally requires the entry "when the corresponding Core PR exists". AC-26 covers only the new compat file's location, which is satisfied. The PR-description text required by AC-27 is itself a PR-creation step rather than a code change.
+
+2. **Embed-video edge case (`bindingUnresolvable` on bindings-configured embed-video covers).** `useCoverBindingState` returns `bindingActive=false` for embed-video covers (correct per AC-21), but `bindingUnresolvable` evaluates to `true` whenever the cover carries any cover-relevant binding configuration AND is not active — which includes the embed-video case. In practice this is moot because (a) the non-empty image branch is gated by `isImageBackground=false` for embed-video, (b) the empty-cover branch only fires when there is no `hasBackground` (and a normal embed-video cover has a `url` so `hasBackground=true`). Confirmed by the `leaves the embed-video render path engaged on a cover with bindings (binding is inert)` Jest test. The pathological "empty embed-video cover with bindings" state is not reachable through normal authoring flows. Worth a defensive gate (`backgroundType !== 'embed-video'` inside the `bindingUnresolvable` computation) if a regression ever surfaces here, but no fix needed for landing.
+
+3. **PHPCS intentional warnings.** Two unused-param warnings on `gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $parent_block )` and one loose-equality warning on the `args` comparison are expected: the filter signature is fixed by WP core's `render_block_data` callback contract, and the loose equality is documented in Design §6.1 / Code Plan Task 3 as the deliberate order-insensitive associative-array comparison that mirrors the JS-side `JSON.stringify` parity check.

From 2747dc0ce76ad101100a6a68b0193781886b797f Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 19:22:13 +0200
Subject: [PATCH 37/60] docs(backport): add cover bindings backport-changelog
 stub for 7.1

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 backport-changelog/7.1/TODO-cover-bindings.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 backport-changelog/7.1/TODO-cover-bindings.md

diff --git a/backport-changelog/7.1/TODO-cover-bindings.md b/backport-changelog/7.1/TODO-cover-bindings.md
new file mode 100644
index 00000000000000..d629ac71f906cd
--- /dev/null
+++ b/backport-changelog/7.1/TODO-cover-bindings.md
@@ -0,0 +1,3 @@
+https://github.com/WordPress/wordpress-develop/pull/TODO
+
+* https://github.com/WordPress/gutenberg/pull/TODO

From ee75670dbcdf2b3b5a8dccde9feb163590e927cc Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 19:38:39 +0200
Subject: [PATCH 38/60] docs(block-library): changelog entry for Cover block
 bindings

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 packages/block-library/CHANGELOG.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packages/block-library/CHANGELOG.md b/packages/block-library/CHANGELOG.md
index bd6ccd89b17603..9c0fdee576a26d 100644
--- a/packages/block-library/CHANGELOG.md
+++ b/packages/block-library/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### New features
+
+-   Cover Block: Support Block Bindings for the `id` and `url` attributes, enabling Pattern Overrides for cover images sourced from the media library. ([#77199](https://github.com/WordPress/gutenberg/issues/77199))
+
 ## 9.47.0 (2026-05-27)
 
 ### Internal

From 43aaf251684106f4d7d0516905b4cdcc389890e2 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Thu, 28 May 2026 19:47:27 +0200
Subject: [PATCH 39/60] docs(pipeline): add 5-docs/docs-review-approved.md for
 77199-cover-bindings-id-url-internal

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../5-docs/docs-review-approved.md            | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 .pipelines/77199-cover-bindings-id-url-internal/5-docs/docs-review-approved.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/5-docs/docs-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/5-docs/docs-review-approved.md
new file mode 100644
index 00000000000000..9110e41f74966f
--- /dev/null
+++ b/.pipelines/77199-cover-bindings-id-url-internal/5-docs/docs-review-approved.md
@@ -0,0 +1,46 @@
+# Docs Review
+
+## Verdict: approved
+
+## Batch scope
+
+Tasks reviewed:
+- Doc Task 1: Add `core/cover` to the Block Bindings compatibility table.
+- Doc Task 2: Document the internal-media constraint and auto-hidden controls for Cover.
+- Doc Task 3: Document the Pattern Overrides on Cover example.
+- Doc Task 4: Add release-notes entry to `packages/block-library/CHANGELOG.md`.
+
+## Summary
+
+The batch lands a complete, coherent documentation surface for Cover Block Bindings in the canonical Block Bindings reference and a release-notes entry in the block-library package CHANGELOG. The compatibility table row, the Cover-specific subsection (internal-media-only invariant, hidden controls, dim-ratio behaviour, embed-video carve-out), the Pattern Overrides on Cover example, and the changelog bullet all align with the shipped server filters in `lib/compat/wordpress-7.1/block-bindings.php`, the editor changes in `packages/block-library/src/cover/edit/`, and the spec/design contracts. The user-observable i18n string `Internal media required for this binding.` is faithfully reproduced from the code. No internal implementation details (no `useEffect`, no React hook names, no PHP function names) leak into reader-facing prose. Markdown lint introduces no new violations within the touched regions; the five pre-existing MD033 inline-HTML errors are all in trunk-original callout admonitions outside the doc-writer's edits.
+
+## Checks
+
+| Check | Command | Result |
+| ----- | ------- | ------ |
+| Markdown lint (docs gate) | `npm run lint:md:docs` | Pass for touched regions. All 5 remaining `docs/reference-guides/block-api/block-bindings.md` MD033 hits are pre-existing inline-HTML callouts at lines 3, 321–322, 504–505 — none in the added Cover subsection (38–59) or the Cover example subsection (240–270). Verified by comparing pre-change content via `git show 50dfa44b461^:docs/reference-guides/block-api/block-bindings.md`. |
+| Compatibility table row matches `block.json` `role` declarations | `Read packages/block-library/src/cover/block.json` | `id` and `url` both declare `"role": "content"`. Doc row `\| core/cover \| id, url \|` matches. |
+| i18n string matches shipped code | `grep "Internal media required" packages/block-library/src/cover/edit/index.js` | `__( 'Internal media required for this binding.' )` at index.js:699 matches the literal string quoted in `block-bindings.md:46`. |
+| Hidden-controls list matches code | `grep "bindingActive" packages/block-library/src/cover/edit/{inspector-controls,block-controls}.js` | inspector-controls.js:255 gates Fixed background + Repeated background `ToolsPanelItem`s on `! bindingActive`. block-controls.js:153 gates the entire `<MediaReplaceFlow>` (which carries Replace/Add media, Use featured image, and Embed video from URL menu items) on `! bindingActive`. Doc enumerates: Fixed background (parallax), Repeated background, Replace/Add media (media-replace), Use featured image — exact match. |
+| `__default` Pattern Overrides example shape matches editor write path | `grep "__default" packages/patterns/src/components/pattern-overrides-controls.js` | Editor writes `attributes.metadata.bindings.__default = { source: PATTERN_OVERRIDES_BINDING_SOURCE }` at pattern-overrides-controls.js:52–53. Doc example at block-bindings.md:249–254 uses identical shape, no per-attribute entries. |
+| `getValues` keyed by `metadata.name` | `Read packages/editor/src/bindings/pattern-overrides.js` | `getValues` resolves through `patternOverridesContent?.[ currentBlockAttributes?.metadata?.name ]?.[ attributeName ]` at pattern-overrides.js:21–23. Doc step 2 wording "the override is written into the pattern instance's `content` attribute keyed by the Cover's `metadata.name`" matches. |
+| Embed-video carve-out matches code | `grep "embed-video" packages/block-library/src/cover/edit/use-cover-binding-state.js lib/compat/wordpress-7.1/block-bindings.php` | Client: `bindingActive = … && attributes.backgroundType !== 'embed-video'` (use-cover-binding-state.js:96). Server: both `gutenberg_cover_bindings_prepare_block` (block-bindings.php:237) and `gutenberg_cover_bindings_render_block` (block-bindings.php:534) short-circuit on `'embed-video' === $attrs['backgroundType']`. Doc's embed-video paragraph matches the short-circuit behaviour. |
+| Server "no `<img>` on unresolvable" matches code | `Read lib/compat/wordpress-7.1/block-bindings.php` | `gutenberg_cover_bindings_strip_image` (block-bindings.php:293–307) splices out either the `<div class="wp-block-cover__image-background">…</div>` or the `<img class="wp-block-cover__image-background" …>` form when the binding is unresolvable. Overlay span is untouched. Doc's "front-end HTML omits the `<img>` element … the overlay still renders" matches. |
+| Dim-ratio default-100 rewrite gate matches code | `grep "dimRatio.*100\|relax_dim_class" lib/compat/wordpress-7.1/block-bindings.php` | block-bindings.php:572 — `gutenberg_cover_bindings_relax_dim_class` only fires when stored `dimRatio === 100`. Non-default values are honoured. Doc's dim-ratio paragraph (lines 57) matches. |
+| Changelog format follows `## Unreleased` convention | `Read packages/block-library/CHANGELOG.md` | Bullet under `### New features` immediately below `## Unreleased`, before the `## 9.47.0` release. Format matches surrounding entries. No mention of `useEffect`, hook names, or PHP function names. |
+| No drift in other surfaces | `grep -rn "compatible with block bindings\|Compatible blocks" docs/` | Only `block-bindings.md` enumerates bindable blocks. No other surface needs an edit. Doc-plan §Overview correctly identified this. |
+| Doc-plan adherence | `git log trunk..HEAD --stat -- docs/ packages/block-library/CHANGELOG.md backport-changelog/` | Three commits touch `block-bindings.md` (one per Doc Tasks 1–3) and one touches `packages/block-library/CHANGELOG.md` (Doc Task 4). The backport-changelog stub commit (3a4a87790a6) is Code-plan Task 13, not duplicated here per the doc-plan §Overview note. No scope creep. |
+
+## Accuracy spot-check
+
+- **Task 1 (compatibility table row).** Verified `core/cover`'s `id` declares `"role": "content"` in `packages/block-library/src/cover/block.json:18-21`. The new row `| core/cover | id, url |` at `docs/reference-guides/block-api/block-bindings.md:33` is positioned alphabetically after `core/button` (the existing convention is loosely-alphabetical-by-block-name); column alignment preserved versus the existing rows. Row matches the spec-mandated `id` + `url` set (Req 1, Req 2).
+
+- **Task 2 (Cover-specific notes section).** Spot-checked four concrete claims:
+  - "the editor surfaces the message `Internal media required for this binding.`" — exact literal match against `__( 'Internal media required for this binding.' )` at `packages/block-library/src/cover/edit/index.js:699`.
+  - "the rendered front-end HTML omits the `<img>` element for that cover (the overlay still renders)" — verified `gutenberg_cover_bindings_strip_image` at `lib/compat/wordpress-7.1/block-bindings.php:293-307` removes only the `wp-block-cover__image-background` `<div>` or `<img>` element; the `wp-block-cover__background` overlay span and `wp-block-cover__inner-container` are untouched. Both `gutenberg_cover_bindings_render_block` paths (the unresolvable-config branch at lines 545-547 and the missing-resolved-value branches at 554-560) invoke `strip_image`, never erase the overlay.
+  - "the iframe renders from the saved `url` attribute" on embed-video covers — verified the embed-video carve-out short-circuits BEFORE any binding-resolved URL substitution at `lib/compat/wordpress-7.1/block-bindings.php:534-536` and `237-239`; the existing `render_block_core_cover` embed-video path (in `packages/block-library/src/cover/index.php`) renders the iframe from the saved attribute unchanged.
+  - "If a user has explicitly set `dimRatio` to a non-default value (for example `70`), that value is used as-is in both editor and front-end render" — verified server-side `gutenberg_cover_bindings_relax_dim_class` is only invoked when `100 === (int) ( $attrs['dimRatio'] ?? 100 )` at `lib/compat/wordpress-7.1/block-bindings.php:572`. Editor-side: `effectiveDimRatio = bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio` in `packages/block-library/src/cover/edit/index.js` returns the stored value for any non-100 case.
+
+- **Task 3 (Pattern Overrides on Cover example).** Spot-checked the `metadata.bindings.__default = { source: 'core/pattern-overrides' }` shape against `packages/patterns/src/components/pattern-overrides-controls.js:52-53`, which writes exactly that on toggle-on. Spot-checked the "keyed by `metadata.name`" claim against `packages/editor/src/bindings/pattern-overrides.js:14-23` where `getValues` reads `patternOverridesContent?.[ currentBlockAttributes?.metadata?.name ]?.[ attributeName ]`. The example's block comment metadata is correctly shaped and would deserialise into a working Cover block. Minor illustrative imprecision in the rendered HTML between the block delimiters (`has-background-dim-50` would not actually be emitted because `dimRatioToClass(50) === null` per `packages/block-library/src/cover/shared.js:32-36` — the saved markup for `dimRatio: 50` is `has-background-dim` only). This does not affect functional copy-paste usage because Gutenberg deserialises blocks from the comment-delimiter JSON, not the HTML body; flagging here for future cleanup but not blocking.
+
+- **Task 4 (changelog).** Spot-checked the bullet's location (under `## Unreleased > ### New features`, immediately above the `## 9.47.0 (2026-05-27)` release section); format `(...) ([#77199](https://github.com/WordPress/gutenberg/issues/77199))` is consistent with surrounding entries (other entries link to PRs; the issue link is acceptable as a working stand-in until the PR is filed, per doc-plan Task 4's "the PR number is filled in by the doc-writer at the time of writing" leeway). The bullet's wording — "Support Block Bindings for the `id` and `url` attributes, enabling Pattern Overrides for cover images sourced from the media library" — names the user-observable feature and omits any internal-implementation terminology (no `useEffect`, no React hook names, no PHP function names), satisfying doc-plan Task 4 Acceptance.

From 44bea45150726cbbb0ce5905bf8bd0bddbf1096d Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 10:22:13 +0200
Subject: [PATCH 40/60] chore: drop .pipelines artifacts from branch

Pipeline artifacts belong outside repo. .gitignore already excludes them;
they were force-added during the run.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../0-prompt/prompt.md                        |  80 --
 .../1-spec/requirements.md                    | 541 ----------
 .../1-spec/spec-review-1-rejected.md          | 126 ---
 .../1-spec/spec-review-2-rejected.md          | 102 --
 .../1-spec/spec-review-approved.md            |  19 -
 .../1-spec/spec.md                            | 183 ----
 .../design-doc-review-1-rejected.md           | 243 -----
 .../design-doc-review-2-rejected.md           | 191 ----
 .../design-doc-review-approved.md             |  73 --
 .../2-design-doc/design-doc.md                | 967 ------------------
 .../3-plan/code-plan-review-1-rejected.md     | 127 ---
 .../3-plan/code-plan-review-approved.md       |  31 -
 .../3-plan/code-plan.md                       | 548 ----------
 .../3-plan/doc-plan-review-approved.md        |  32 -
 .../3-plan/doc-plan.md                        | 124 ---
 .../4-code/code-review-approved.md            |  69 --
 .../5-docs/docs-review-approved.md            |  46 -
 17 files changed, 3502 deletions(-)
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/0-prompt/prompt.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/1-spec/requirements.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-1-rejected.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-2-rejected.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-approved.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-1-rejected.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-2-rejected.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-approved.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-1-rejected.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-approved.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan-review-approved.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/4-code/code-review-approved.md
 delete mode 100644 .pipelines/77199-cover-bindings-id-url-internal/5-docs/docs-review-approved.md

diff --git a/.pipelines/77199-cover-bindings-id-url-internal/0-prompt/prompt.md b/.pipelines/77199-cover-bindings-id-url-internal/0-prompt/prompt.md
deleted file mode 100644
index 6043519976ec93..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/0-prompt/prompt.md
+++ /dev/null
@@ -1,80 +0,0 @@
-# Cover block bindings — internal-only support for `id` and `url`
-
-## Source
-
-- Tracking issue: [WordPress/gutenberg#77199](https://github.com/WordPress/gutenberg/issues/77199) — *Block Bindings in WordPress 7.1*
-- Open draft PR (architectural reference, not basis): [WordPress/gutenberg#74610](https://github.com/WordPress/gutenberg/pull/74610)
-- Prior stalled PR (lessons): [WordPress/gutenberg#74109](https://github.com/WordPress/gutenberg/pull/74109)
-
-## Background
-
-The `core/cover` block has never shipped Block Bindings support. Two release cycles have produced draft PRs that stalled, despite Block Bindings working well for `core/image`, `core/paragraph`, and other content-bearing blocks. The current iteration issue (#77199) explicitly scopes Cover block bindings for the WordPress 7.1 cycle.
-
-Prior attempts failed for two distinct reasons:
-
-1. **Architectural complexity** (#74109) — reviewer @ockham rejected an event-driven approach in which multiple `useEffect` hooks reacted to specific user interactions (replace media, focus, blur). Logic for deriving overlay color, dim ratio, and visible controls was scattered across handlers, making behavior unpredictable. The reviewer asked for a single reactive observer that derives all dependent state from the bound `id`+`url` values themselves.
-
-2. **CSS-in-HTML rewrite** (#74610) — when `hasParallax` is true, Cover emits `style="background-image: url(...)"` on the wrapper div. The WordPress HTML API cannot safely modify CSS values inside `style` attributes (there is no CSS Processor yet, and one was deferred). Bound `url` substitution therefore breaks under parallax.
-
-3. **External image scope creep** (#74109) — the prior PR tried to also support binding `url` to an arbitrary external URL with no media-library `id`. That created cascading edge cases (overlay color derivation, alt text, featured image interactions, `isRepeated`, parallax) and ballooned the diff.
-
-## Goal
-
-Ship Block Bindings support for the `id` and `url` attributes of `core/cover`, scoped narrowly so it lands cleanly in one PR. The headline use case is **Pattern Overrides** for the Cover block.
-
-## Scope — In
-
-- Bindable attributes: `id` (number, media-library attachment id) and `url` (string, media-library file URL). Both flow through Block Bindings sources (e.g., `core/pattern-overrides`, `core/post-meta`).
-- **Internal media only**: a bound `id` is required, and the bound `url` must be derivable from that `id` via the WordPress media library. External / CDN / arbitrary URLs are out of scope.
-- Pattern Overrides supported end-to-end: bind in a pattern, override per-instance, reset to default. Reset must hide cleanly when the instance value already matches the default override state.
-- When the binding is active:
-  - Hide the parallax (`hasParallax`) toggle and force `hasParallax=false` for the rendered output.
-  - Hide the repeat (`isRepeated`) toggle.
-  - Hide the media-replace control (replacement happens via the binding source, not direct edit).
-  - Hide the "Use featured image" toggle (`useFeaturedImage`).
-- The Edit component derives `dimRatio` and overlay color reactively from the bound id+url, without mutating stored attributes. `dimRatio=100` (the default) must not result in a fully opaque overlay over a bound image — derive an effective value at render time when a binding is present.
-- Server-side rendering produces the correct `<img>` / `background` markup for the resolved url and id, with parallax explicitly off.
-
-## Scope — Out
-
-- External / non-media-library URL binding. If a binding source returns a URL without an id, treat it as if no binding were set (or surface a clear "not supported in this PR" UX). Do not attempt to derive overlay/dim from external URLs.
-- Parallax interaction with bindings. Parallax UI is disabled (hidden) whenever a binding is active; no attempt at server-side `style="background-image: url()"` rewriting.
-- Featured-image binding for Cover (`useFeaturedImage` + binding). Separate follow-up PR.
-- `backgroundType: "embed-video"` interaction with bindings. Embed-video Cover is out of scope.
-- New global Block Bindings APIs. Reuse existing infrastructure; if a new filter such as `block_bindings_attribute_replaced_in_markup` is needed for non-sourced attributes, weigh it against a cover-specific server-render path during design.
-
-## Architectural constraints (preempt prior reviewer feedback)
-
-- **Single reactive observer**: one place in `packages/block-library/src/cover/edit/index.js` watches the bound `id` and `url` and derives every dependent value (effective dimRatio, overlay color, control visibility). No event-handler-keyed `useEffect` proliferation.
-- **No attribute mutation on binding detection**: do not write to attributes from inside the observer. Derived values are computed at render time. Bound values are read through the existing block bindings API; the observer only triggers re-render.
-- **Internal-only invariant enforced visibly**: when `url` is bound but `id` is missing (external), the UI must show that the binding cannot be honored, not silently render a broken Cover.
-
-## Prior art to consult, NOT to base off
-
-- Open draft PR #74610: take the architectural shape and the `block_bindings_attribute_replaced_in_markup` filter idea, but do not inherit its parallax scope.
-- Stalled PR #74109: harvest e2e test scaffolding, overlay-reset logic, and lock-control patterns if useful. Do not branch off it.
-- Local branches `add/cover-block-bindings-support` and `add/cover-block-bindings-support-v2` exist for reference only. Cherry-pick fragments at most.
-- Prior pipeline `75022-block-bindings-into-block-fields` (already landed locally on branch `try/75022-...`) handles the Block Fields UI integration. The Cover block must work with the Block Fields UI shipped there, not the legacy Attributes panel.
-
-## Key risks to address explicitly in design
-
-1. **Pattern Overrides reset semantics** — historically broke. Enumerate the states: (a) default (no override), (b) overridden, (c) reset-to-default with binding active, (d) reset-hidden when value already matches default. Each must round-trip cleanly through editor save/load and server render.
-2. **Default `dimRatio: 100`** — newly inserted Cover with binding active must not show opaque overlay. Solution lives in derived render-time value, not in attribute mutation.
-3. **`backgroundType: "embed-video"`** — added after prior PRs were drafted. Confirm bindings UI does not appear or short-circuits when this is the active background type.
-4. **Reviewer ockham gates this area** — his prior objections (architecture shape, internal-only scope, no scattered useEffects) must be preempted in the design doc itself, not discovered during review.
-
-## Acceptance criteria
-
-- The Block Fields / Block Bindings UI in the editor allows binding `id` and `url` of `core/cover` to any registered binding source whose schema matches.
-- A Cover block with bound `id`+`url` renders correctly in the editor (preview) and on the front end (server-render), using the resolved internal media.
-- Pattern Overrides on Cover round-trip cleanly: set value in pattern, override per instance, reset to default — all three states render correctly and produce the expected serialized markup.
-- The parallax toggle, repeat toggle, media-replace control, and featured-image toggle are hidden when a binding is active.
-- E2E test covers: (a) creating a Cover, binding its url+id to a Pattern Override source, (b) overriding the value on a pattern instance, (c) resetting the override, all with assertion of rendered output.
-- Unbound Cover behavior is unchanged — no regressions on any existing Cover feature (parallax, repeat, featured image, embed-video, focal point, dim ratio, overlay color).
-- PR diff is targeted (~under 500 net lines including tests). Architectural cleanliness gates scope.
-
-## Repo target
-
-- Carlos's fork (`cbravobernal/gutenberg`) → upstream PR to `WordPress/gutenberg`.
-- Branch: `worktree-77199-cover-bindings-id-url-internal` (auto-derived from the pipeline slug).
-- The PR description should link #77199 and call out explicitly which prior issues (#74109, #74610) it does and does not subsume.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/requirements.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/requirements.md
deleted file mode 100644
index 1ef7bd0c9b04ff..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/requirements.md
+++ /dev/null
@@ -1,541 +0,0 @@
-# Requirements
-
-## Rough Idea
-
-(Verbatim from `/Users/carlos/Developer/gutenberg/.claude/worktrees/77199-cover-bindings-id-url-internal/.pipelines/77199-cover-bindings-id-url-internal/0-prompt/prompt.md`.)
-
-### Cover block bindings — internal-only support for `id` and `url`
-
-The `core/cover` block has never shipped Block Bindings support. Tracking issue [#77199](https://github.com/WordPress/gutenberg/issues/77199) scopes Cover block bindings for the WP 7.1 cycle. Two prior draft PRs ([#74109](https://github.com/WordPress/gutenberg/pull/74109), [#74610](https://github.com/WordPress/gutenberg/pull/74610)) stalled over:
-
-1. **Architecture** — reviewer @ockham rejected event-driven `useEffect` proliferation for deriving overlay color, `dimRatio`, etc.; asked for a single reactive observer keyed on the bound `id`/`url`.
-2. **CSS-in-HTML rewrite** — when `hasParallax` is true, Cover emits `style="background-image: url(...)"`; the WP HTML API cannot safely modify CSS in `style` attributes.
-3. **External-image scope creep** — supporting arbitrary external URLs (no `id`) ballooned the diff.
-
-**Goal:** Ship bindings for `id` and `url` of `core/cover`, scoped narrowly, headline use-case = Pattern Overrides. **Internal media only** (`id` required, `url` derivable from `id`). When the binding is active: hide parallax / repeat / media-replace / use-featured-image controls; derive effective `dimRatio` and overlay color at render time without mutating attributes; server-side renders correct `<img>` markup with parallax off.
-
-The full prompt (including in-/out-of-scope lists, architectural constraints, risks, acceptance criteria) lives at the path above and is treated as the authoritative source of intent for these requirements.
-
-## Q&A
-
-### Q1: What is the current `role` declared on `core/cover`'s `url` and `id` attributes, and what does declaring `role: "content"` change downstream?
-
-**A:** In trunk, `core/cover`'s `url` attribute has `"role": "content"` (lines 10–13 of `block.json`); the `id` attribute does **not** declare a role (lines 18–20). The reference block `core/image` declares `"role": "content"` on **both** `url` and `id` (`packages/block-library/src/image/block.json` lines 25–31 and 78–81).
-
-`role: "content"` is metadata used by tooling that surfaces "content-bearing" attributes (e.g. Block Fields UI, Pattern Overrides field discovery). It is **not** what enables Block Bindings UI on its own; that gating happens via the `__experimentalBlockBindingsSupportedAttributes` editor setting, which is populated from the server-side `block_bindings_supported_attributes` filter (see Q5). The current Block Bindings panel in `packages/block-editor/src/hooks/block-bindings.js` (lines 40–80) reads `bindableAttributes` from `__experimentalBlockBindingsSupportedAttributes?.[ blockName ]` and renders one `BlockBindingsAttributeControl` per supported attribute.
-
-**Reasoning:** `role: "content"` already on `url` indicates Gutenberg considers Cover's url part of the editable content payload, but that alone has not been sufficient to enable bindings — the server-side allow-list is the gate.
-
-**Sources:** `packages/block-library/src/cover/block.json:10-13,18-20`; `packages/block-library/src/image/block.json:25-31,78-81`; `packages/block-editor/src/hooks/block-bindings.js:40-100`; `lib/compat/wordpress-6.9/block-bindings.php:118-167`.
-
-### Q2: For Cover bindings to appear in the editor UI, what server-side allow-list entry is required, and which file should it live in for WP 7.1?
-
-**A:** A PHP filter must add `'id'` and `'url'` to the list returned by `gutenberg_get_block_bindings_supported_attributes( 'core/cover' )`. There are two equivalent filter hooks:
-- `block_bindings_supported_attributes` (global, receives `$attributes, $block_type`)
-- `block_bindings_supported_attributes_core/cover` (dynamic, block-specific)
-
-The new code must live in a new file `lib/compat/wordpress-7.1/block-bindings.php`, registered via `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';` in `lib/load.php`. The existing 7.1 compat directory has no bindings file yet (verified via `ls lib/compat/wordpress-7.1/`).
-
-Wrapping the filter in a `! function_exists( ... )` / version guard is the established pattern (see `lib/compat/wordpress-6.9/block-bindings.php` lines 11–31 for the prior-version precedent).
-
-**Reasoning:** The Block Bindings panel and DataForm controls discover bindable attributes through `__experimentalBlockBindingsSupportedAttributes`, populated server-side. Without that registration, no UI for `id`/`url` will appear regardless of `role` declarations.
-
-**Sources:** `lib/compat/wordpress-6.9/block-bindings.php:11-46,118-167`; `lib/compat/wordpress-7.1/` directory listing; the prior PR #74610 placed an equivalent filter at `lib/compat/wordpress-7.0/block-bindings.php` (now to be re-targeted to 7.1).
-
-### Q3: How does the existing Block Bindings server-side resolution path actually substitute the bound value into the rendered HTML, and what is the gap for Cover's `url` (which has no `source`/`selector` declaration in `block.json`)?
-
-**A:** `gutenberg_block_bindings_render_block` (in `lib/compat/wordpress-6.9/block-bindings.php:57-108`) calls `gutenberg_process_block_bindings` to resolve source values, **merges them into `$instance->attributes`**, then runs `$instance->render()` again so the block can re-render with the new attribute values. Finally it iterates the computed attributes and calls `gutenberg_replace_html` to substitute the value into the markup.
-
-`gutenberg_replace_html` (lines 346–398) **only handles attributes that declare `source: html`, `source: rich-text`, or `source: attribute`** in `block.json`. It uses the declared `selector`/`attribute` to locate the substitution point. If `source` is unset, the function is a no-op for that attribute.
-
-`core/cover`'s `url` has no `source` declaration (it is a plain in-memory attribute serialized via React in `save.js` — see lines 84, 117–124 of `save.js`). Therefore:
-1. The `$instance->render()` re-execution can pick up the new bound `url`/`id` **if** the block's `render_callback` (`render_block_core_cover` in `packages/block-library/src/cover/index.php`) actually uses them — but today that callback only inserts an `<img>` when `useFeaturedImage` is true. For an unbound Cover with `useFeaturedImage=false`, the callback returns `$content` unmodified.
-2. The static save markup (from `save.js`) is already written with the **author-time** `url` and `id`. If the binding source provides a different `url`/`id`, the saved HTML still shows the old values unless the cover render path overrides them.
-
-The mechanism used in draft PR #74610 was to add a `block_bindings_attribute_replaced_in_markup` filter that **synthesizes** `source: attribute, selector: img, attribute: src` for `core/cover.url` at runtime, so `gutenberg_replace_html` can then rewrite `<img src="...">`. That filter does **not** handle the `<div style="background-image: url(...)">` parallax/repeat path.
-
-**Reasoning:** Cover stores `url` as an in-memory React-managed attribute, so the existing bindings infrastructure has no metadata to know where in the markup the URL appears. Either the block must declare a synthetic source (via runtime filter), or the cover-specific server render must compute and inject the image element itself.
-
-**Sources:** `lib/compat/wordpress-6.9/block-bindings.php:57-108,346-398`; `packages/block-library/src/cover/save.js:84,117-124`; `packages/block-library/src/cover/index.php:18-200`; PR #74610 diff (lib/compat/wordpress-7.0/block-bindings.php new file, lines around `block_bindings_attribute_replaced_in_markup`).
-
-### Q4: When `hasParallax` or `isRepeated` is true, what does `save.js` emit, and why does HTML-attribute rewriting break?
-
-**A:** `save.js` lines 67, 99–132 branch on `isImgElement = !(hasParallax || isRepeated)`:
-- `isImgElement === true` → emits `<img className="wp-block-cover__image-background" src={url} ... />` (line 117).
-- `isImgElement === false` → emits `<div role={alt ? 'img' : undefined} aria-label={alt} className={imgClasses} style={{ backgroundPosition, backgroundImage: 'url(' + url + ')' }} />` (lines 126–131).
-
-The `gutenberg_replace_html` path with `source: attribute, selector: img, attribute: src` (the technique used by PR #74610) cannot touch the `<div style="background-image: url(...)">` form because:
-1. The selector is `img`, not `div`.
-2. Even if we matched the `div`, we'd need to mutate a CSS value inside the `style` attribute, which the HTML Tag Processor cannot do safely — there is no CSS Processor in the HTML API yet (referenced in PR #74610 description, third TODO item).
-
-This is the documented "CSS-in-HTML rewrite" blocker that stalled PR #74610.
-
-**Reasoning:** This is structurally why the prompt insists `hasParallax` must be **forced false at render time when bindings are active** — it sidesteps the HTML rewrite problem.
-
-**Sources:** `packages/block-library/src/cover/save.js:67,99-132`; PR #74610 description (https://github.com/WordPress/gutenberg/pull/74610) "Support parallax case" TODO; `lib/compat/wordpress-6.9/block-bindings.php:346-398` (replace_html limited to attribute selectors).
-
-### Q5: What invariant must the implementation enforce when the binding source returns a `url` but no `id` (the "external URL" case)?
-
-**A:** Per the prompt's Scope-In: a bound `id` is required, and a bound `url` must be derivable from that `id`. Per Scope-Out: external/non-media-library URL binding is not supported. Per Architectural Constraint: "Internal-only invariant enforced visibly: when `url` is bound but `id` is missing (external), the UI must show that the binding cannot be honored, not silently render a broken Cover."
-
-In practice this means:
-- Both `id` and `url` are declared bindable in the supported-attributes filter, so both can be wired through a binding source.
-- The Edit component must detect the (bound url, unbound or null id) state and surface a visible "cannot resolve internal media" affordance instead of rendering the cover as if the URL were valid.
-- The reactive observer that derives `dimRatio`/overlay color must not run for url-only-bound covers (no `id` ⇒ no media-library resolution).
-- On the server side, the same constraint should hold: if `id` is empty after binding resolution, skip the substituted-image insert path and render the cover as the unbound placeholder would render (no broken image element).
-
-**Reasoning:** The Cover's overlay color, focal point and image-size derivation all require the attachment metadata (i.e. the `id`). Treating url-only bindings as best-effort would re-introduce all the edge cases that ballooned PR #74109 (alt text, sizeSlug, focal point on unknown image, average color derivation).
-
-**Sources:** `0-prompt/prompt.md` Scope-In/Out and Architectural Constraints; PR #74610 TODO "Figure out what to do if only `url` is bound (but `id` isn't), meaning that the bound image could possibly be external" (https://github.com/WordPress/gutenberg/pull/74610).
-
-### Q6: What is the architectural shape reviewer @ockham requires (and which prior approach he rejected)?
-
-**A:** From his inline comment on PR #74109 (`packages/block-library/src/cover/edit/index.js`, line 282, posted 2026-01-13):
-
-> "After working on #74610 for a while, I realize that this is a pattern that I'd like to avoid as much as possible. The block shouldn't need to care where it gets its attributes from -- i.e. if they're set manually or provided by a Block Binding. Instead, it should be as agnostic as possible. ... we should try to move that logic into one shared `useEffect` handler that will simply react to the `url`, `featuredImage`, `overlay` (and potentially other) attributes changing, and re-compute colors accordingly. This will cover both the case where the user makes a manual change, or the attribute is provided by Block Bindings."
-
-His own follow-up acknowledges the tension: "I also just found out that this would mean we'd go full circle -- after previously moving code from `useEffect` into event handlers, since `useEffect` was deemed too fragile" (link to #53253).
-
-He references the future `useEffectEvent` (React 19) as the cleanup path; `useEffectEvent` is already exported from `@wordpress/element` (verified at `packages/element/README.md:472`, `packages/element/build-module/react.mjs:23,97`).
-
-The reviewer's hard requirements are therefore:
-- **No** per-event `useEffect` proliferation (one for media-select, one for blur, one for focus, …).
-- **One** observer (or a small number of well-named ones) that derives all dependent state from the bound id/url plus existing manual-edit triggers.
-- The block must be **source-agnostic**: same derivation logic whether the URL came from a binding or a manual selection.
-
-**Reasoning:** This determines the architectural shape — design phase must produce a single observer (likely keyed on `(url, useFeaturedImage, isUserOverlayColor)`), with stable references via `useEffectEvent` to avoid stale-closure pitfalls.
-
-**Sources:** PR #74109 review comments via `gh api repos/WordPress/gutenberg/pulls/74109/comments`; `packages/element/README.md:472`; `packages/element/build-module/react.mjs:23,97`.
-
-### Q7: How does `core/image` wire up its own URL/id bindings — what is the minimum reusable pattern Cover should mirror for control-locking?
-
-**A:** `core/image` uses two patterns:
-
-1. **Detecting whether the binding source allows editing.** In `packages/block-library/src/image/image.js` lines 745–820, a `useSelect` returns `lockUrlControls`, `lockHrefControls`, `lockAltControls`, etc., each derived from `metadata?.bindings?.<attr>` plus the bound source's `canUserEditValue` function:
-   ```js
-   lockUrlControls:
-       !! urlBinding &&
-       ! urlBindingSource?.canUserEditValue?.( {
-           select, context, args: urlBinding?.args,
-       } ),
-   ```
-2. **Hiding/disabling controls.** Throughout `image.js` and `edit.js`, the URL input, MediaReplaceFlow, and related controls are gated by `!lockUrlControls && ...`. For example `MediaReplaceFlow` only mounts when `!lockUrlControls` (`image.js:834-836`).
-
-Pattern Overrides source returns `canUserEditValue: () => true` (`packages/editor/src/bindings/pattern-overrides.js:102`), so a pattern instance editing an overridden cover **does not** lock controls — the user is supposed to edit. For other sources (post-meta, etc.) where the user cannot edit the source value from inside the block, controls lock.
-
-**Reasoning:** Cover should reuse the `lockUrlControls` derivation idea. The prompt explicitly enumerates which Cover controls must hide when bindings are active (parallax, repeat, media-replace, use-featured-image); the `lockUrlControls`-style boolean is one signal, but the prompt's actual requirement is broader: hide those four controls whenever **any** binding is present on `url` (or `id`), regardless of whether the source permits editing. The two layers (`hasUrlBinding` and `lockUrlControls`) need to coexist:
-- `hasUrlBinding` → hide parallax / repeat / featured-image toggles (always).
-- `lockUrlControls` → additionally hide media-replace if the source disallows editing.
-
-For Pattern Overrides specifically, media-replace must **stay visible** (the user is supposed to override). For post-meta, it should hide.
-
-**Sources:** `packages/block-library/src/image/image.js:734-820,822-849`; `packages/block-library/src/image/edit.js:396-461`; `packages/editor/src/bindings/pattern-overrides.js:102`.
-
-### Q8: For Pattern Overrides specifically, what is the round-trip lifecycle for a Cover block (set in pattern → override per instance → reset to default → "reset hidden when default")?
-
-**A:** Pattern Overrides uses the `core/pattern-overrides` binding source (`packages/editor/src/bindings/pattern-overrides.js`).
-
-States:
-1. **Authoring the pattern (`isEditingSyncedPattern` true).** The pattern editor shows `PatternOverridesControls` (`packages/patterns/src/components/pattern-overrides-controls.js`) which lets the author "Enable overrides" via a button; this calls `updateBlockBindings({ __default: { source: 'core/pattern-overrides' } })`. The block must have `metadata.name`. Setting `__default` to `core/pattern-overrides` causes `gutenberg_process_block_bindings` (`lib/compat/wordpress-6.9/block-bindings.php:257-281`) to expand the `__default` binding into one per supported attribute server-side.
-2. **Default state on an instance (no override).** Per the source's `getValues`, the value returned is the block's own attribute value (the pattern default). On the server, `gutenberg_process_block_bindings` resolves the value the same way — no overrides means the binding returns the same value as the static save markup.
-3. **Overridden state.** Editing the block in a pattern instance triggers `setValues`, which writes into the parent `core/block`'s `content` attribute under `[blockName].[attrName]`. The next render through bindings then resolves to the override value.
-4. **Reset.** `ResetOverridesControl` (`packages/patterns/src/components/reset-overrides-control.js:14-90`) is a toolbar button: `isOverridden` is computed from `getBlockAttributes(patternClientId)?.content?.hasOwnProperty(name)`. When the user clicks Reset, it deletes that entry from `content`. The button is **disabled** (greyed) when `! isOverridden` — that is the "reset hidden when default" behavior the prompt mentions, except it's `disabled`, not `hidden`. The button toolbar always shows; only the button is disabled.
-
-For the four states:
-- (a) **default (no override):** the bound value === the block's own attribute, instance renders pattern default. ✅
-- (b) **overridden:** content key present, value === override.
-- (c) **reset-to-default with binding active:** user clicks Reset, content key deleted, attribute resolves back to pattern default.
-- (d) **reset-hidden when value already matches default:** the ResetOverridesControl is `disabled` when not overridden. The prompt may mean "Reset hidden cleanly when the instance value already matches the default" — that's the existing behavior (disabled toolbar button, not hidden, but greyed).
-
-**Reasoning:** State (d) needs design-phase clarification: prompt says "hide cleanly" but existing behavior is "disable". Either is acceptable UI; the design must pick one and stay consistent across all bindable blocks. Suggest staying with the existing `disabled` pattern unless there's a reason to diverge.
-
-**Sources:** `packages/editor/src/bindings/pattern-overrides.js:1-103`; `packages/editor/src/hooks/pattern-overrides.js:1-122`; `packages/patterns/src/components/pattern-overrides-controls.js:1-127`; `packages/patterns/src/components/reset-overrides-control.js:1-90`; `lib/compat/wordpress-6.9/block-bindings.php:257-281`.
-
-### Q9: How does Cover's `useFeaturedImage` flow currently differ from the bindings flow, and why must the two never both be active on the same block?
-
-**A:** `useFeaturedImage` is a Cover-specific dynamic-image mechanism that pre-dates Block Bindings. It is a boolean attribute (`block.json:14-17`). When true, Cover's `edit/index.js` (lines 137–154) overrides the displayed URL with `mediaUrl` derived from the post's `featured_media`, and the server (`packages/block-library/src/cover/index.php:133-199`) injects an `<img>` for the post thumbnail.
-
-The two paths are mutually exclusive by intent because:
-- Both want to dictate `url`/`id` at render time.
-- `useFeaturedImage` updates the rendered image when the post's featured image changes, **without** going through bindings.
-- A bound `url`/`id` is supposed to be source-of-truth for the displayed image; `useFeaturedImage` would conflict.
-
-Per prompt: when binding is active, the "Use featured image" toggle hides. The edit component must NOT mutate `useFeaturedImage` (no attribute mutation invariant); instead, when computing the displayed image at render time, the binding-resolved `url`/`id` must take precedence over `useFeaturedImage`'s `mediaUrl`.
-
-For previously-saved blocks where `useFeaturedImage=true` AND a binding is then attached: the design must specify the precedence rule. The simplest is: binding wins for resolved `url`/`id`; on the server, if the binding is on `id`/`url`, the `useFeaturedImage` branch in `render_block_core_cover` must NOT also fire (it would try to inject a second image). The render callback must short-circuit `useFeaturedImage` when bindings have resolved a value.
-
-**Reasoning:** Featured-image binding (`useFeaturedImage` + binding combined) is explicitly OUT of scope per prompt ("Featured-image binding for Cover (`useFeaturedImage` + binding). Separate follow-up PR."). But in-scope is hiding the toggle and preventing UI/server-render conflict when both happen to be set.
-
-**Sources:** `packages/block-library/src/cover/block.json:14-17`; `packages/block-library/src/cover/edit/index.js:119-201`; `packages/block-library/src/cover/index.php:133-200`; prompt Scope-Out item 3.
-
-### Q10: What is the precise default-`dimRatio: 100` behavior, and where must the effective value override live?
-
-**A:** `block.json:33-36` declares `"dimRatio": { "type": "number", "default": 100 }`. The save serialization in `save.js:168-186` writes a `.has-background-dim` span with `dimRatioToClass(dimRatio)`. From `shared.js:32-36`: ratio 50 or undefined → null class, else `has-background-dim-{10*round(ratio/10)}`. So `dimRatio=100` → `has-background-dim-100` → fully opaque overlay.
-
-Today, when a user inserts a Cover and then sets media, `onSelectMedia` (`edit/index.js:218-291`) downshifts `dimRatio` from 100 → 50 (line 244: `const newDimRatio = currentAttrs.url === undefined && currentAttrs.dimRatio === 100 ? 50 : currentAttrs.dimRatio;`). This is an attribute-mutating side effect of the event handler.
-
-With bindings, the same downshift cannot happen via an event handler — the URL appears via the binding, not via `onSelectMedia`. PR #74610's approach was to also downshift in a `useEffect` (lines around the `[ url ]` dep). That mutates the attribute.
-
-The prompt forbids attribute mutation from the binding-detection observer. So the implementation must instead compute an **effective `dimRatio` at render time** when:
-- A binding is active, **and**
-- The stored `dimRatio` is the default (100), **and**
-- The resolved URL is non-empty.
-
-In that case the rendered overlay should use 50 (or some configured derived value) without writing to the attribute. The editor preview uses this effective value; the server render must apply the same logic.
-
-This breaks symmetry with the static `save.js` markup (which writes `has-background-dim-100` when the attribute is 100). So on the server, `render_block_core_cover` must inspect `metadata.bindings.url` (or `id`) and rewrite the `wp-block-cover__background` span's class to use the effective value when binding is active. This is an HTML-tag-class rewrite, which the HTML Tag Processor handles cleanly (unlike CSS-in-style attributes).
-
-**Reasoning:** Centralising the effective-value derivation in render-time (both client edit preview and server render) preserves the "no attribute mutation" invariant while solving the opaque-overlay problem. The class-rewrite is mechanically straightforward because the relevant element is `<span class="wp-block-cover__background has-background-dim has-background-dim-100">` — a class change, not a style change.
-
-**Sources:** `packages/block-library/src/cover/block.json:33-36`; `packages/block-library/src/cover/save.js:168-186`; `packages/block-library/src/cover/shared.js:32-36`; `packages/block-library/src/cover/edit/index.js:218-291` (especially line 244); PR #74610 description "TODO: Binding a newly inserted Cover block ... adds an overlay that uses the `dimRatio` attribute default value of `100`".
-
-### Q11: How does overlay color "auto-derive from image average" currently work, and how does it need to change for bindings?
-
-**A:** `edit/index.js:163-201,218-291,503-547` calls `getMediaColor( imageUrl )` from `edit/color-utils.js` (returns the average colour of the image, async). The result is set as the overlay color via `setOverlayColor` (a `withColors` setter) provided `isUserOverlayColor` is false.
-
-Today this only runs in event handlers: `onSelectMedia`, `toggleUseFeaturedImage`, and one `useEffect` reacting to `mediaUrl` changes for `useFeaturedImage`.
-
-For bindings, the URL can change without an event (the bound source updates externally). Per @ockham's review (Q6), this is exactly the case the single observer should cover: react to `url` changing for any reason. The PR #74610 approach extended the `useEffect` to also fire when `attributes?.metadata?.bindings?.url` is present. The cleaner approach (per @ockham) is to make the observer source-agnostic — it observes `url` directly (the destructured value that already accounts for both `useFeaturedImage` and manual selection), guarding only against `isUserOverlayColor`.
-
-Edge cases that must NOT regress:
-- User explicitly sets overlay color (`isUserOverlayColor=true`) → auto-derive must not overwrite.
-- URL changes from binding to a different image → auto-derive must run.
-- URL clears (binding source returns undefined) → overlay returns to default (or stays where it was if user-set).
-- Concurrent async race: `getMediaColor` is async; if the URL changes again before resolution, the stale colour must not overwrite the newer one (the existing code uses a `propsRef` pattern at `edit/index.js:130-135` for this).
-
-**Reasoning:** Same observer that derives `dimRatio` also derives `overlayColor` (only when not user-set). One reactive callback keyed on the effective `url`, with a `propsRef` (or `useEffectEvent`) to read latest `isUserOverlayColor`/`dimRatio` without stale closure.
-
-**Sources:** `packages/block-library/src/cover/edit/index.js:127-201,218-291,503-547`; `packages/block-library/src/cover/edit/color-utils.js` (referenced); PR #74609 review (linked from #74109 comments).
-
-### Q12: How is the Block Bindings UI gated for Cover, and is anything blocking it from appearing today?
-
-**A:** The Block Bindings panel in `packages/block-editor/src/hooks/block-bindings.js:40-100` calls:
-```js
-bindableAttributes:
-    __experimentalBlockBindingsSupportedAttributes?.[ blockName ],
-```
-And renders one row per attribute in `bindableAttributes`. The setting is populated server-side from `gutenberg_get_block_bindings_supported_attributes(block_type)`, which returns an empty array for `core/cover` today (no entry in the 6.8 snapshot, no filter adds it; `lib/compat/wordpress-6.9/block-bindings.php:118-167`).
-
-There is also an excluded-blocks list `BLOCK_BINDINGS_PANEL_EXCLUDED_BLOCKS` introduced in branch `try/75022-block-bindings-into-block-fields` (`packages/block-editor/src/components/block-bindings/excluded-blocks.js`):
-```js
-export const BLOCK_BINDINGS_PANEL_EXCLUDED_BLOCKS = [
-    'core/post-date',
-    'core/navigation-link',
-    'core/navigation-submenu',
-];
-```
-**Cover is not in this list**, so once the supported-attributes filter adds `id`/`url`, the bindings UI will render the two attribute controls automatically.
-
-Pattern Overrides "Enable overrides" button (`PatternOverridesControls`) is also gated on `__experimentalBlockBindingsSupportedAttributes?.[blockName]` being truthy (`packages/editor/src/hooks/pattern-overrides.js:39-58`), so adding the filter entry also unlocks Pattern Overrides for Cover. No additional Pattern-Overrides allow-list exists for blocks (it's gated purely on having any bindable attribute).
-
-**Reasoning:** The single PHP filter addition is the master switch. No additional client-side allow-listing is required.
-
-**Sources:** `packages/block-editor/src/hooks/block-bindings.js:40-100`; `packages/block-editor/src/components/block-bindings/excluded-blocks.js` (on `try/75022-block-bindings-into-block-fields`); `packages/editor/src/hooks/pattern-overrides.js:37-58`; `lib/compat/wordpress-6.9/block-bindings.php:118-167`.
-
-### Q13: What does the Block Fields UI (sibling pipeline `75022-block-bindings-into-block-fields`) require from a "bindable block"?
-
-**A:** Per branch `try/75022-block-bindings-into-block-fields`, the relevant additions are:
-- `packages/block-editor/src/components/block-bindings/use-block-bindings-compatible-fields.js` — a new hook that lists compatible binding sources for a given (block, attribute) pair, filtering by attribute `type`.
-- `packages/block-editor/src/components/block-bindings/excluded-blocks.js` — excludes a small list (cover not in it).
-- `packages/block-editor/src/components/block-bindings/attribute-control.js` — refactored to use the shared hook.
-
-The Block Fields UI surfaces bindable attributes through DataForm/DataView controls. A block needing to integrate with Block Fields needs:
-- An entry in `__experimentalBlockBindingsSupportedAttributes` (server-side allow-list).
-- Attribute `type` declared in `block.json` (Cover's `url`=string, `id`=number — both already declared).
-- Not be in `BLOCK_BINDINGS_PANEL_EXCLUDED_BLOCKS`.
-- An indicator that the attribute participates in "content" via `role: "content"` (Cover has it on `url`; `id` does not — recommended to add).
-
-Beyond those, no Cover-specific changes are needed to integrate with the Block Fields UI; the integration is automatic once the supported-attributes filter is in place.
-
-**Reasoning:** The 75022 work is generic across blocks. Cover-specific bindings work needs to not regress that integration; the design must verify Block Fields renders correctly for a bound Cover.
-
-**Sources:** `git diff trunk..try/75022-block-bindings-into-block-fields --stat -- packages/block-editor/src/components/block-bindings/`; the new files on that branch listed above.
-
-### Q14: What e2e test pattern exists for Block Bindings on existing blocks?
-
-**A:** The directory `test/e2e/specs/editor/various/block-bindings/` contains:
-- `custom-sources.spec.js` — tests image/paragraph/heading bindings against a fixture source registered by `packages/e2e-tests/plugins/block-bindings.php`.
-- `post-meta.spec.js` — tests post-meta source on image/paragraph/heading/button.
-- `post-data.spec.js` — tests post-data source.
-
-The fixture source (`packages/e2e-tests/plugins/block-bindings.php`) registers a `testing/complete-source` with text and url fields, including an image URL pointing at a fixture file uploaded as media via `requestUtils.uploadMedia`.
-
-Pattern Overrides e2e lives in `test/e2e/specs/editor/various/pattern-overrides.spec.js` (no Cover/image-specific cases currently). The pattern is: create a synced pattern with a bound block, insert the pattern in a post, override one instance, assert the rendered front-end output via the post-preview / front-end navigation.
-
-PR #74610 added a Cover-specific e2e (`test/e2e/specs/editor/blocks/cover.spec.js` describe block "Block Bindings") that asserts overlay color/opacity for a bound `url` resolves correctly. The pipeline's PR should include similar coverage for:
-1. `id`+`url` bound via Pattern Overrides — instance shows pattern default.
-2. Same block, override instance → asserts the rendered image src changes.
-3. Reset override → asserts back to default.
-4. Hidden controls assertion: parallax/repeat/replace/use-featured-image toggles are not in the DOM when binding active.
-
-**Reasoning:** The infrastructure exists; the spec should land in `test/e2e/specs/editor/blocks/cover.spec.js` (extending the existing Cover describe block) and/or `test/e2e/specs/editor/various/pattern-overrides.spec.js` if a synthesis test makes sense across blocks.
-
-**Sources:** `test/e2e/specs/editor/various/block-bindings/`; `test/e2e/specs/editor/various/pattern-overrides.spec.js`; `packages/e2e-tests/plugins/block-bindings.php`; PR #74610 diff adding Cover e2e.
-
-### Q15: What about `backgroundType: "embed-video"` — does it interact with bindings?
-
-**A:** `backgroundType: "embed-video"` was added to Cover after both prior bindings PRs were drafted. The server render (`packages/block-library/src/cover/index.php:20-131`) returns the embed iframe markup and **does not pass through to the bindings branch** for embed videos. The edit flow (`packages/block-library/src/cover/edit/index.js:366-415`) treats embed URLs as a separate branch via `onSelectEmbedUrl`.
-
-Per prompt Scope-Out: embed-video × bindings is OUT of scope. Per risk #3: "Confirm bindings UI does not appear or short-circuits when this is the active background type."
-
-Concretely:
-- The Block Bindings panel does **not** know about `backgroundType` and will show the `id`/`url` controls regardless. The implementation has two choices:
-  1. Leave the panel as-is and let the user bind a URL even with `backgroundType=embed-video`; the resolved URL will be treated as an embed (existing edit code path). This is the simplest but allows nonsensical combinations.
-  2. Hide the bindings UI controls when `backgroundType=embed-video` (requires custom logic outside the generic Block Bindings panel).
-- The simpler choice (1) keeps the panel generic and lets the user bind. The bound `url` value would flow into the embed flow as-is. The risk: a Pattern Overrides scenario where the pattern's Cover has an image background and an instance override sets `backgroundType=embed-video` is not a realistic flow — `backgroundType` itself is not bindable.
-
-Recommended in-scope handling: leave the bindings panel UI as-is (show controls); but in the edit component, when `backgroundType=embed-video`, the binding-aware derivation (effective `dimRatio`, overlay colour) should short-circuit (the embed-video branch already overrides display). The "hide parallax/repeat/replace/featured-image" rule still applies but is moot because those controls are already hidden for embed-video backgrounds in `inspector-controls.js`.
-
-**Reasoning:** Embed-video is a separate background type with its own render path. Bindings on `url` for an embed-video cover would mean "bind the embed URL", which is a coherent (if narrow) use case. Out-of-scope per prompt means we don't add bespoke logic for it; we just ensure existing embed-video covers don't regress.
-
-**Sources:** `packages/block-library/src/cover/index.php:19-131`; `packages/block-library/src/cover/edit/index.js:366-415,420-422`; prompt Scope-Out item 4.
-
-### Q16: Should `id` declare `role: "content"` like `core/image` does?
-
-**A:** `core/image` declares `role: "content"` on both `url` and `id` (`packages/block-library/src/image/block.json:25-31,78-81`). `core/cover` currently has it on `url` only. To stay consistent with image and to participate cleanly in any future Block Fields / content-role tooling, the design should add `"role": "content"` to `id` as well.
-
-This is a `block.json` change. It does NOT affect deprecation (no source/save shape change for the attribute), but it does affect what tools consider "content". Deprecation tests should be checked to confirm no behavioural change.
-
-**Reasoning:** Minimal change, increases consistency with the canonical pattern set by `core/image`. The prompt does not explicitly mention it, but it's a natural part of "make `id` and `url` bindable end-to-end".
-
-**Sources:** `packages/block-library/src/cover/block.json:18-20`; `packages/block-library/src/image/block.json:78-81`.
-
-### Q17: What server-side approach should the PR use to make the rendered HTML reflect bound values + the "effective dimRatio" + the "force hasParallax=false" rule?
-
-**A:** There are two viable approaches (the design phase must choose; this Q only enumerates the constraints):
-
-**Approach A — Add a custom `render_block` filter scoped to Cover.** The new `lib/compat/wordpress-7.1/block-bindings.php` (or `packages/block-library/src/cover/index.php`) would intercept the Cover's `render_block` and, when `metadata.bindings.url` (or `id`) is set:
-1. Resolve the bound value via `gutenberg_process_block_bindings`.
-2. Use the HTML Tag Processor to find the `<img class="wp-block-cover__image-background">` (or `<div ...>` if parallax) and rewrite `src` (or, if the saved markup is the parallax div, replace the div with an `<img>`).
-3. Rewrite the `wp-block-cover__background` span's class to use the effective `dimRatio` (i.e. swap `has-background-dim-100` → `has-background-dim-50`).
-4. Strip `has-parallax` and `is-repeated` classes from any element that has them.
-
-**Approach B — Generic `block_bindings_attribute_replaced_in_markup` filter** (PR #74610's approach). Synthesize `source: attribute, selector: img, attribute: src` for Cover's `url`, and rely on `gutenberg_replace_html`. Cover's `render_block_core_cover` would additionally need to handle the dimRatio/parallax/repeat class adjustments (Approach A's points 3–4).
-
-Constraints either approach must honour:
-- The bound `url` may or may not be derivable from an `id`; if `id` resolves to nothing, the substitution must NOT proceed and the cover should render without the broken image element (Q5 invariant).
-- The featured-image branch in `render_block_core_cover` must NOT also fire when bindings have resolved a value (Q9 mutual exclusion).
-- The class rewrite for dimRatio must be idempotent and safe across `style` variations.
-- No CSS-in-style-attribute rewriting (Q4 blocker).
-
-Either approach lands in `lib/compat/wordpress-7.1/block-bindings.php`. Approach B has minor reuse value for other blocks; Approach A is simpler and entirely block-scoped (less risk of unintended interaction with other blocks).
-
-**Reasoning:** This is a design-phase decision; the requirements only need to capture the constraints. The selected approach must explicitly preempt the parallax CSS-in-HTML issue and the dimRatio default issue per Q4 and Q10.
-
-**Sources:** PR #74610 diff (Approach B precedent); `lib/compat/wordpress-6.9/block-bindings.php:57-108,346-398`; `packages/block-library/src/cover/index.php` (existing render_block_core_cover, where Approach A would extend).
-
-### Q18: What is the precise list of UI controls to hide when a binding is active, and what gates each?
-
-**A:** Per prompt Scope-In:
-1. **Parallax toggle (`hasParallax`)** — gate: any binding on `url` (or `id`). Source: `packages/block-library/src/cover/edit/inspector-controls.js` (today the toggle is unconditionally rendered when `isImageBackground`; needs `!hasUrlBinding` gate).
-2. **Repeat toggle (`isRepeated`)** — same gate as parallax. Source: same file.
-3. **Media-replace control** — gate: `hasUrlBinding && !canEdit` (i.e. `lockUrlControls` ; for Pattern Overrides source which allows edits, the control stays visible — but only via the binding's replace flow, not direct edit). Need to confirm: prompt says "Hide the media-replace control (replacement happens via the binding source, not direct edit)" — this suggests always hide when bound, even for Pattern Overrides. The Pattern Overrides override flow uses the existing media-replace UI to set the override, so we need to keep it visible for Pattern Overrides but route it through `setValues`. **This is ambiguous in the prompt** — see open question OQ-1.
-4. **"Use featured image" toggle (`useFeaturedImage`)** — gate: any binding on `url` or `id`. Source: `packages/block-library/src/cover/edit/block-controls.js` and `inspector-controls.js`.
-
-Additional implicit hides:
-- Pattern Overrides "Enable overrides" button (already gated on bindable attributes existing) → no change needed.
-- Reset toolbar button (per existing `ResetOverridesControl`) → already exists; design phase decides whether to apply the prompt's "hide cleanly when default" rule.
-
-**Reasoning:** Each control needs an explicit gate, not a generic `lockUrlControls`. The prompt's "media-replace control" hide vs. Pattern Overrides flow needs clarification — see OQ-1.
-
-**Sources:** `packages/block-library/src/cover/edit/inspector-controls.js:222-260,468`; `packages/block-library/src/cover/edit/block-controls.js`; prompt Scope-In bullet list.
-
-### Q19: What about the saved (static) HTML? Does deprecation need updating?
-
-**A:** `block.json` and `save.js` do not change shape under this PR (no new attributes; no changed serialization). Adding `role: "content"` to `id` is metadata-only.
-
-If the implementation chooses to add `role: "content"` to `id`, no deprecation entry is needed — `role` is editor-only metadata, not part of the block markup.
-
-The Cover block has an extensive `deprecated.js` (existing). Adding a deprecation is only needed if a saved-markup change is introduced. Per prompt Architectural Constraint "No attribute mutation on binding detection", and per render-time effective values, there is no saved-markup change anticipated.
-
-**Reasoning:** Confirm during design that no `save.js` shape changes are required; if any do creep in, a deprecation entry becomes necessary.
-
-**Sources:** `packages/block-library/src/cover/deprecated.js` (existing deprecations); prompt Architectural Constraints.
-
-### Q20: What is the expected acceptance test for "PR diff under ~500 net lines"?
-
-**A:** Per prompt Acceptance Criteria: "PR diff is targeted (~under 500 net lines including tests). Architectural cleanliness gates scope."
-
-Counting net additions across affected files:
-- New file `lib/compat/wordpress-7.1/block-bindings.php` — ~50-120 lines (filter + optional render_block hook).
-- Optionally update `packages/block-library/src/cover/index.php` — ~30-60 net lines (render-time class/parallax/dimRatio adjustments).
-- `packages/block-library/src/cover/block.json` — +1 line (role on id).
-- `packages/block-library/src/cover/edit/index.js` — net additions for: `hasUrlBinding`/`lockUrlControls` derivation (~30 lines), single observer (~30 lines), effective-value derivation for url and dimRatio at render (~20 lines). Aim ~80 net lines added, some replacements.
-- `packages/block-library/src/cover/edit/inspector-controls.js` — gating of parallax/repeat (~10 lines).
-- `packages/block-library/src/cover/edit/block-controls.js` — gating of media-replace/featured-image (~10 lines).
-- E2E test: extend `test/e2e/specs/editor/blocks/cover.spec.js` with a new describe block (~80-120 lines).
-- Possibly fixture image upload helper.
-
-Total estimated: ~280-450 net lines. Reasonable to land under 500 if the server-side approach is concise.
-
-**Reasoning:** The budget is achievable; the main risk is the server-side render path bloating if Approach A is chosen and includes extensive HTML processing. The design should aim for the smallest possible server-side delta.
-
-**Sources:** Estimated against file sizes from `wc -l`; prompt Acceptance Criteria.
-
-### Q21: What is the expected commit / branch / PR target metadata?
-
-**A:** Per prompt Repo Target:
-- Branch (local worktree): `worktree-77199-cover-bindings-id-url-internal` (current branch).
-- PR target: `WordPress/gutenberg` `trunk`, from `cbravobernal/gutenberg` fork.
-- PR description must link #77199 and explicitly state which prior issues (#74109, #74610) it does and does not subsume.
-- Backport-changelog entry under `backport-changelog/7.1/` (PR #74610 used `backport-changelog/7.0/10739.md` since it was 7.0-scoped; this one is 7.1).
-
-**Reasoning:** Standard pipeline metadata.
-
-**Sources:** Prompt Repo Target section.
-
-### Q22: Are there any blockers — does any premise in the prompt contradict codebase reality?
-
-**A:** No outright contradictions. Areas where the prompt is slightly under-specified but not contradicted:
-- The phrasing "force `hasParallax=false` for the rendered output" implies a server-side rewrite of the saved markup when the saved markup baked in parallax. Codebase reality (Q4) confirms parallax saved markup is `<div style="background-image: url(...)">`, and the HTML API cannot edit CSS in `style`. The implementation must either:
-  - (a) On the server, when bindings are active, *replace* the `<div style="background-image">` element with `<img src="">` entirely (no CSS edit needed, just element swap), OR
-  - (b) Rely on the fact that bound covers are typically authored in patterns where `hasParallax` is not turned on, AND hide the parallax control before the user can set it on an already-bound cover.
-  
-  Option (a) is feasible with HTML Tag Processor (the `<div>` is uniquely identifiable by its class `wp-block-cover__image-background`).
-  
-  This is not a blocker — it's an implementation choice with two viable paths. Captured as design constraint.
-
-- The phrasing "reset hidden cleanly when the instance value already matches the default" — existing `ResetOverridesControl` disables the button rather than hides it. The prompt may be using "hidden" loosely. Captured as open question OQ-2.
-
-No blockers; proceeding.
-
-**Reasoning:** Standard sanity sweep of prompt assumptions against actual code.
-
-**Sources:** Q4, Q8, Q15, Q17 above.
-
-## Research
-
-### Cover block source layout (current trunk)
-
-- `packages/block-library/src/cover/block.json` (158 lines): attribute schema. `url` (string, role: content), `id` (number, no role), `useFeaturedImage` (boolean), `hasParallax` (boolean, default false), `isRepeated` (boolean, default false), `dimRatio` (number, default **100**), `overlayColor`, `customOverlayColor`, `isUserOverlayColor`, `backgroundType` (default "image"), `focalPoint`, `minHeight`, `gradient`, `customGradient`, `contentPosition`, `isDark` (default true), `templateLock`, `tagName` (default "div"), `sizeSlug`, `poster`.
-- `packages/block-library/src/cover/save.js` (195 lines): serialises to `<Tag>` wrapper with classes; image background as `<img>` if `!hasParallax && !isRepeated` else `<div style="background-image: url(...)">`; overlay span with `has-background-dim has-background-dim-{N}` class.
-- `packages/block-library/src/cover/index.php` (216 lines): `render_block_core_cover` handles embed-video and useFeaturedImage paths; otherwise returns `$content` as-is.
-- `packages/block-library/src/cover/edit/index.js` (767 lines): main React component. Contains `useEffect` for `useFeaturedImage`-driven mediaUrl observer; event handlers `onSelectMedia`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`, `toggleUseFeaturedImage`, `onSelectEmbedUrl`. Uses `propsRef` pattern (`useLayoutEffect`) to avoid stale closures across async `getMediaColor` calls.
-- `packages/block-library/src/cover/edit/inspector-controls.js` (468 lines): ToolsPanel with fixed background (parallax), repeated background, focal point, alt, image-size, overlay color, dim ratio, min-height, tag name.
-- `packages/block-library/src/cover/edit/block-controls.js` (151 lines): BlockControls toolbar group: media-replace, focal-point, full-height, content-position, "Use featured image".
-
-### Image block bindings wiring (reference pattern)
-
-- `core/image` has `id` (number, role: content), `url` (string, role: content, source: attribute, selector: img, attribute: src), `alt`, `title`, `caption`, `href` all with bindable roles.
-- `lockUrlControls` boolean derived via `useSelect` in `image.js:745-820`, used to gate URL input, MediaReplaceFlow, and other URL-dependent controls (lines 822–849, 934–945).
-- Pattern Overrides on image: existing e2e at `test/e2e/specs/editor/various/pattern-overrides.spec.js` lacks image-specific cases (verified via grep) — i.e. image bindings are exercised by `custom-sources.spec.js` and `post-meta.spec.js` only.
-
-### Server-side bindings flow (WP 6.9 compat)
-
-`lib/compat/wordpress-6.9/block-bindings.php`:
-- Adds caption/datetime/navigation-link URL support via `block_bindings_supported_attributes` filter (lines 11-31).
-- Exposes `__experimentalBlockBindingsSupportedAttributes` editor setting (lines 33-46).
-- `gutenberg_block_bindings_render_block` (lines 57-108): processes bindings, merges resolved values into instance attributes, re-renders the block, then iterates resolved attributes calling `gutenberg_replace_html`.
-- `gutenberg_replace_html` (lines 346-398): only handles `source: html|rich-text|attribute`; uses HTML Tag Processor to swap content or attribute values per the attribute's declared selector.
-- `gutenberg_process_block_bindings` (lines 209-333): expands `__default` (pattern-overrides) into per-attribute bindings; resolves each binding via the source's `get_value`.
-
-### Prior-attempt evidence (NOT inheritance)
-
-Branch `add/cover-block-bindings-support-v2` (most recent commit `565e655b70e`, 2026-01-13):
-- 44 files changed, +775/-6038 lines (severely rotted; conflicts with current 7.0/7.1 dirs that no longer exist on this branch).
-- The cover-relevant changes: `block.json` unchanged from trunk, `index.php` adds a `has_url_binding` branch and the `block_core_cover_insert_image_before_inner_container` helper, `edit/index.js` adds `hasImageBinding` state with multiple `useEffect`s reacting to mediaUrl, originalUrl, hasImageBinding, etc., and `lockUrlControls` via `canUserEditValue`. Also adds Pattern-Overrides reset shortcut in `onClearMedia`. Adds `dimRatioInitialized` state to gate the 100→50 downshift.
-- This is the architecture @ockham rejected (Q6). Harvest fragments: the `has_url_binding` server-side branch is useful evidence for Approach A in Q17, but mutates attributes (e.g. `setAttributes({useFeaturedImage: false})` from inside `useEffect`) — violates the "no attribute mutation on binding detection" invariant.
-
-Branch `add/cover-block-bindings-support` (older, `721cefb818c` "Fix dim"):
-- 5 commits. Earlier exploration; superseded by v2.
-
-PR #74610 (draft, open as of fetch time, title "Block Bindings: Add support for Cover block id and url attrs"):
-- Body acknowledges: dimRatio 100 default issue (resolved by downshift in useEffect); url-only-bound external image not handled; parallax not supported due to CSS-in-style.
-- Adds `block_bindings_attribute_replaced_in_markup` filter to synthesise sourced-attribute metadata for Cover's url at runtime.
-- Adds Cover bindings e2e in `test/e2e/specs/editor/blocks/cover.spec.js` asserting overlay color/opacity.
-- Reviewer comments include the architectural request (Q6) and a note to move backport-changelog to `7.1/`.
-
-PR #74109 (draft, open, title "Block Bindings: Add Cover block support."):
-- Reviewer @ockham flagged the event-handler-keyed `useEffect` approach (comment at edit/index.js:282) and suggested the source-agnostic single-observer refactor (Q6).
-- Multiple TODOs around video bg, featured image, e2e, reset-hidden default. Many resolved in subsequent commits.
-
-### Pattern Overrides reset semantics
-
-- `core/pattern-overrides` source defined at `packages/editor/src/bindings/pattern-overrides.js`; `getValues` returns block's own attribute when not overridden, override value when set; `setValues` writes into the parent `core/block`'s `content` attribute.
-- `ResetOverridesControl` (toolbar button) `disabled` when not overridden — that's the existing "hidden when default" semantics. May be revisited in design phase per OQ-2.
-- Server-side `__default: core/pattern-overrides` expansion: `lib/compat/wordpress-6.9/block-bindings.php:257-281` — when a block has `metadata.bindings.__default.source = core/pattern-overrides`, all `supported_block_attributes` are auto-bound to pattern overrides.
-
-### `useEffectEvent` availability
-
-Confirmed exported from `@wordpress/element` (referenced in `packages/element/README.md:472` and `packages/element/build-module/react.mjs:23,97`). This is the recommended primitive (React 19) for letting `useEffect` body call functions whose latest props/state are read without those values being in the dep array — directly enables @ockham's single-observer pattern without the stale-closure pitfalls.
-
-### Open questions for the design phase
-
-- **OQ-1.** When a Pattern Overrides override is active, does the Cover block's MediaReplaceFlow stay visible and write the override (via `setValues`), or is it hidden in favour of editing the override only from outside the cover? Prompt says "Hide the media-replace control" but Pattern Overrides typically uses the existing replace flow to author the override. Design must resolve.
-- **OQ-2.** Should the "Reset to default" affordance be **disabled** (existing `ResetOverridesControl` behaviour) or **hidden** (prompt phrasing "hide cleanly when default")? Recommend disable, matches existing behaviour and is consistent with other bindable blocks.
-- **OQ-3.** Server-side approach: Approach A (cover-specific render filter) vs Approach B (generic `block_bindings_attribute_replaced_in_markup` filter from #74610). Design phase to pick based on simplicity and reuse value.
-- **OQ-4.** When a Cover with `hasParallax=true` and `isRepeated=true` already in saved markup gains a binding via "Enable overrides", what should happen on the server render? Option: replace the `<div style="background-image">` element with `<img>`, dropping `style` entirely, and ensure overlay span class drops `has-parallax`/`is-repeated` if present. Captured here so the design picks an explicit rule.
-- **OQ-5.** Is there any restriction on which binding sources `id`+`url` should expose (e.g. require both attributes to bind to the same source)? Prompt's "Internal-only invariant" implies yes — design phase to specify the validation.
-
-## Consolidated Requirements
-
-The following is a numbered list of all requirements the implementation must satisfy. Each captures WHAT, not HOW.
-
-### A. Block-level metadata and registration
-
-1. The `id` attribute on `core/cover` (`packages/block-library/src/cover/block.json`) MUST be marked as a content-role attribute consistent with `core/image` (i.e. declare `"role": "content"`).
-2. A new file `lib/compat/wordpress-7.1/block-bindings.php` MUST be created and required from `lib/load.php`. It MUST register a filter that adds `'id'` and `'url'` to `gutenberg_get_block_bindings_supported_attributes('core/cover')`.
-3. The implementation MUST NOT change the schema of any other attribute in `core/cover`'s `block.json`. No new attributes are introduced.
-
-### B. Editor (client) — UI gating
-
-4. When a binding is present on `core/cover`'s `url` (or `id`), the parallax toggle (`hasParallax`) in the inspector controls MUST be hidden.
-5. When a binding is present on `core/cover`'s `url` (or `id`), the repeated-background toggle (`isRepeated`) in the inspector controls MUST be hidden.
-6. When a binding is present on `core/cover`'s `url` (or `id`), the "Use featured image" toggle MUST be hidden (both in block toolbar and in any other surface where it appears).
-7. When a binding is present AND the bound source's `canUserEditValue` returns false, the media-replace control MUST be hidden. (Design phase resolves OQ-1 for the Pattern Overrides case.)
-8. The Block Bindings UI (legacy Attributes panel and any Block Fields UI) MUST render bindable rows for `id` and `url` on `core/cover` automatically, without Cover-specific UI code, by virtue of requirement 2.
-9. Pattern Overrides controls (`Enable overrides` button, `ResetOverridesControl` toolbar button) MUST work for `core/cover` without Cover-specific changes, by virtue of requirement 2.
-
-### C. Editor (client) — reactive derivation
-
-10. The Edit component MUST contain a single reactive observer (one `useEffect` or equivalent, using `useEffectEvent` to access latest non-observed values without stale closures) that derives **all** dependent state from the effective `url` (and `id` where relevant) regardless of whether the URL is provided manually, by `useFeaturedImage`, or by a binding source.
-11. The reactive observer MUST NOT write to attributes on detection that a binding is present. Specifically: it MUST NOT mutate `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, or any other attribute as a side-effect of a binding becoming active or inactive.
-12. The reactive observer MUST update the overlay colour from the resolved image's average colour when `isUserOverlayColor` is false, irrespective of how the URL was set.
-13. The reactive observer MUST be resilient to concurrent async resolution of `getMediaColor` such that a stale resolved colour does not overwrite a newer one (the existing `propsRef`/`useEffectEvent` pattern).
-
-### D. Editor (client) — effective values at render time
-
-14. When a binding is active on `url`/`id`, the `dimRatio` used to compute the displayed overlay opacity MUST be derived at render time. If the stored `dimRatio` is the default value (100) and the bound URL resolves to a non-empty value, the rendered overlay MUST use a non-opaque effective value (target: 50). The stored attribute MUST NOT be changed.
-15. The effective `url` used by the edit preview MUST give precedence to a bound `url` over `useFeaturedImage`'s `mediaUrl`. If both are present, the bound value wins; `useFeaturedImage`'s value is ignored at render.
-16. When `url` is bound but `id` is unset (or vice versa, in any combination that cannot be resolved against an attachment in the media library), the edit component MUST surface a clear "internal media required" UX — for example, a visible message in the placeholder or inspector — rather than rendering the cover with a broken image element. The chosen surface is a design decision; the visibility requirement is the constraint.
-
-### E. Server — render correctness
-
-17. The server-side rendered markup for a Cover block with bindings on `id`/`url` MUST contain an `<img>` (not a `<div style="background-image: ...">`) for the resolved internal-media image, even if the saved markup serialised the parallax/repeat path. Parallax styling MUST be effectively off in the rendered output when bindings are active.
-18. The server-side rendered overlay span MUST use the effective `dimRatio` derived per requirement 14 (i.e. swap `has-background-dim-100` → `has-background-dim-50` class when the saved attribute is 100 and bindings have resolved a value).
-19. The server render MUST short-circuit the `useFeaturedImage` branch in `render_block_core_cover` when bindings have resolved a value for `url` and/or `id`, to prevent double-insertion of an image element.
-20. The server render MUST resolve `url` and `id` consistently — if `id` cannot be resolved to a media-library attachment (or if `url` cannot be derived from the resolved `id`), the cover MUST render without an image element (no broken `<img>`).
-21. The server-side bindings-resolution mechanism (whether via the `block_bindings_attribute_replaced_in_markup` filter or a Cover-scoped render_block hook — design phase decides) MUST be additive only: it MUST NOT change the behaviour of any other block whose attribute uses `gutenberg_replace_html`.
-
-### F. Cross-cutting invariants
-
-22. Unbound Cover behaviour MUST be unchanged: no regression on parallax, repeat, focal point, featured image, embed-video, dim ratio, overlay colour, alt text, image-size selection.
-23. Pattern Overrides on Cover MUST round-trip cleanly through editor save/load and server render for the four enumerated states: (a) default (no override), (b) overridden, (c) reset-to-default with binding active, (d) reset-disabled-or-hidden when the instance value already matches the default. (OQ-2 resolves disabled vs hidden.)
-24. External (non-media-library) URL binding MUST NOT be silently honoured. If a binding source returns a `url` without a corresponding resolvable `id`, the cover MUST treat the binding as unresolvable per requirement 16 (editor) and requirement 20 (server).
-25. `backgroundType: "embed-video"` MUST continue to render correctly and MUST NOT regress. The bindings UI is allowed to expose `url` for binding even when `backgroundType=embed-video`; no Cover-specific suppression of the bindings panel is required, but the binding-aware derivations (effective dimRatio, overlay colour) SHOULD short-circuit when `backgroundType=embed-video`.
-26. The PR MUST NOT introduce new global Block Bindings APIs beyond a reused filter (`block_bindings_attribute_replaced_in_markup` if Approach B is taken). Any new filter introduced MUST be carry weight against a cover-specific render path during the design phase.
-
-### G. Tests
-
-27. A new e2e test MUST cover: creating a Cover, binding its `url`+`id` to a Pattern Overrides source, asserting the editor and rendered front-end show the pattern default.
-28. The same e2e test MUST cover: overriding the value on a pattern instance, asserting the rendered output reflects the override.
-29. The same e2e test MUST cover: resetting the override, asserting the rendered output returns to the pattern default.
-30. The e2e test MUST assert that the parallax toggle, repeat toggle, media-replace control (where lockable), and featured-image toggle are NOT in the DOM (or are NOT enabled) when a binding is active on the Cover instance.
-31. The PHP test suite SHOULD include a `phpunit` test asserting that `render_block_core_cover` substitutes the bound `url` into the rendered `<img src>` and that the dimRatio class is rewritten when the saved value is the default 100.
-32. Existing Cover tests (`packages/block-library/src/cover/test/edit.js`) MUST continue to pass.
-
-### H. Project metadata / PR shape
-
-33. The new file MUST live under `lib/compat/wordpress-7.1/block-bindings.php` (NOT 7.0). A `backport-changelog/7.1/<core-pr-number>.md` entry MUST be added when the corresponding Core PR is opened.
-34. The PR description MUST link issue #77199 and explicitly call out whether it subsumes #74109 and #74610.
-35. The net diff (including tests) SHOULD target under ~500 lines per prompt Acceptance Criteria.
-36. The PR MUST be portable: the implementation MUST gracefully degrade on a WP install that does not yet have any of the bindings infrastructure changes (the existing `! function_exists` / version-guard pattern in the 6.9 compat file is the precedent).
-
-### I. Explicitly out of scope (for traceability)
-
-37. Binding `url` to an arbitrary external URL with no `id` is OUT OF SCOPE. (Q5)
-38. Parallax + bindings combined behaviour beyond "force off" is OUT OF SCOPE. No CSS-in-style HTML rewriting. (Q4)
-39. Featured-image-as-binding (using bindings to express the use-featured-image behaviour) is OUT OF SCOPE — separate follow-up. (Q9)
-40. `backgroundType: "embed-video"` × bindings beyond non-regression is OUT OF SCOPE. (Q15)
-41. New global Block Bindings APIs beyond at most one reused filter are OUT OF SCOPE.
-42. Post-data source acquiring a `featured_media.url` / `featured_media.id` field (the "follow-up" from #74610 description) is OUT OF SCOPE.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-1-rejected.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-1-rejected.md
deleted file mode 100644
index d809de1cc690fe..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-1-rejected.md
+++ /dev/null
@@ -1,126 +0,0 @@
-# Spec Review
-
-## Verdict: rejected
-
-## Summary
-
-The spec is well-organized, traces back to the prompt and requirements thoroughly, and gives the design phase a strong scaffold. Glossary, Out-of-Scope, and Given-When-Then ACs are all in good shape. However the spec has several internal contradictions and HOW-bleed that would let two implementers build different things, plus one AC that asserts a behaviour the spec explicitly says is unresolved. These are real defects, not stylistic preference — they need a focused rewrite pass before the spec is implementable. Most issues are major; a couple are minor and could be addressed in the design phase if the major ones get fixed.
-
-## Issues
-
-### Issue 1: AC-14 asserts behaviour the spec says is unresolved (OQ-1) [blocker]
-
-**What's wrong:** AC-14 reads "Given a Cover block bound to `core/pattern-overrides`, when the user inspects the block toolbar, then the media-replace control is present (Pattern Overrides allows edits) — pending OQ-1 resolution." An acceptance criterion cannot simultaneously assert an observable outcome AND defer the outcome to a later phase. Either the media-replace control is present under Pattern Overrides (and AC-14 is testable now) or the outcome is unresolved (and AC-14 should not exist yet, or should be reworded as a conditional contract on the OQ-1 resolution).
-
-The same issue partially affects Req 7 ("MUST be hidden when ... `canUserEditValue` returns false") which presumes a particular OQ-1 resolution (hide for non-editable sources, show for editable) without making the prompt's blanket "Hide the media-replace control" reconcile explicitly. The reader is left wondering whether the prompt's wording is authoritative or whether the spec is overriding it.
-
-**Where in spec:** Acceptance Criteria → Control hiding → AC-14; Requirements → B.7.
-
-**Suggestion:** Resolve OQ-1 inside the spec (this is a WHAT decision, not HOW), then state the rule unambiguously. Recommended resolution per the requirements doc's analysis (Q7): when `canUserEditValue` returns true (Pattern Overrides), media-replace stays visible and writes through to the binding; when it returns false (post-meta etc.), it hides. Lock this in Req 7 and AC-13/AC-14, drop the "pending OQ-1" language, and remove OQ-1 from the open-questions list. Alternatively: pick the prompt's literal reading ("always hide media-replace when bound") and adjust AC-14 to assert absence under Pattern Overrides too. Either is fine; just pick one in the spec.
-
-**Why it matters:** As written, the spec is not implementable — two implementers reading AC-14 would build different UIs, and the e2e test (AC-25) cannot be written until OQ-1 is decided. Open questions belong to genuine design-phase HOW choices, not to ambiguities in user-observable behaviour.
-
-### Issue 2: AC-23 + Req 25 vs AC-19 — embed-video interaction with saved-parallax markup is contradictory [major]
-
-**What's wrong:** AC-19 unconditionally requires that "Given a Cover with `hasParallax: true` and `isRepeated: true` saved in markup, and a binding subsequently activated on `url`, when the server renders the cover, then the output contains an `<img>` (not a `<div style="background-image">`)". But Req 25 says "the binding-aware derivations (effective dim ratio, overlay color) SHOULD short-circuit when `backgroundType === "embed-video"`", and AC-23 says embed-video bindings allow the panel to expose `url` but the binding-aware derivations short-circuit.
-
-Two questions are left unanswered:
-1. If a Cover has `backgroundType: "embed-video"` AND `hasParallax: true` is somehow set (today these are mutually exclusive in the UI, but `backgroundType` is set at media-select time and could in principle co-exist with a stale `hasParallax`), what does the server do under AC-19? Does the embed-video render path win or the parallax→`<img>` rewrite?
-2. If a Cover has `backgroundType: "embed-video"` AND a binding resolves a URL, does the server render an embed iframe (existing flow) or an `<img>` (per AC-19)? The Out-of-Scope says "Embed-video × bindings interaction" is excluded from this PR beyond non-regression, but AC-19 doesn't carve embed-video out.
-
-**Where in spec:** Acceptance Criteria → Render-time effective values → AC-19; Out of Scope → Embed-video; Cross-cutting invariants → Req 25; Acceptance Criteria → Non-regression → AC-23.
-
-**Suggestion:** Add an explicit precondition to AC-19: "Given `backgroundType !== "embed-video"` AND a Cover with `hasParallax: true` and `isRepeated: true` saved in markup, AND a binding subsequently activated on `url`, ...". Or assert explicitly in Req 25 / Out-of-Scope that when `backgroundType === "embed-video"`, the binding-resolution server path does not engage (the existing oEmbed render runs unchanged regardless of binding presence). Either is fine; the spec just needs to state which one is in effect so the test author and the implementer agree.
-
-**Why it matters:** Without this, the server-render PR can ship in two different shapes (intercept all bound covers vs intercept only `backgroundType === "image"` covers) and pass different versions of the e2e test. Reviewer @ockham gates this area and is likely to flag inconsistency.
-
-### Issue 3: AC-16 contradicts itself on the dim-ratio class value (HOW bleed) [major]
-
-**What's wrong:** Req 14 says the effective dim ratio is "non-opaque (target: 50)" — i.e. 50 is a target, not a contract. AC-15 says "the displayed overlay is NOT fully opaque (effective dim ratio 50 applied)" — parenthetical-50 is informative. But AC-16 says "the overlay span class is `has-background-dim-50` (or equivalent non-opaque), NOT `has-background-dim-100`". The "or equivalent non-opaque" hedge plus the literal class `has-background-dim-50` is contradictory: a literal class IS the only equivalent under the existing `dimRatioToClass` mapping (`shared.js:32-36`).
-
-If the spec wants the class to be exactly `has-background-dim-50`, say so without the hedge. If the spec wants any non-opaque value, drop the literal class and assert only that the class is not `has-background-dim-100`. As written, an implementer who derives effective dim ratio of 40 (producing `has-background-dim-40`) would pass the "equivalent non-opaque" reading but fail the literal-class reading.
-
-This is also HOW-bleed: picking 50 specifically is an implementation choice (the prompt only says "must not result in a fully opaque overlay"). The user-observable requirement is "overlay is not fully opaque." The exact effective value belongs in the design doc.
-
-**Where in spec:** Requirements → D.14; Acceptance Criteria → AC-15; AC-16.
-
-**Suggestion:** Two acceptable resolutions:
-- (a) Lock the value: state in Req 14 that the effective ratio is 50 (matching the existing `onSelectMedia` downshift); drop "target: 50" hedge and "or equivalent" in AC-16. Then AC-16 reads cleanly as `has-background-dim-50`.
-- (b) Keep the value open: Req 14 says "non-opaque (the same value the existing `onSelectMedia` downshift uses)"; AC-15 asserts only "overlay is not fully opaque (computed opacity < 1.0)"; AC-16 asserts only "overlay span class is not `has-background-dim-100`". Implementer + design doc resolve the specific value.
-
-Pick (a) or (b). The current mixed phrasing is the worst of both.
-
-**Why it matters:** Tests written today against AC-16 will hardcode `has-background-dim-50` and will fail if the design doc picks 40 (or any other value). This costs at least one re-test cycle.
-
-### Issue 4: Internal-media affordance (Req 16 / AC-4) is too soft to test [major]
-
-**What's wrong:** Req 16 says "the editor MUST surface a clear `internal media required` UX — for example, a visible message in the placeholder or inspector — rather than rendering the cover with a broken image element. The chosen surface is a design decision; the visibility requirement is the constraint." AC-4 mirrors this: "the cover displays a visible `internal media required` affordance and does NOT render a broken `<img>`."
-
-The e2e author cannot write an assertion against this. "Visible affordance" doesn't tell the test:
-- What text? (`"internal media required"` literal? Translation key? Custom copy?)
-- What element/role? (a `Notice` component? a placeholder text? an inspector message?)
-- Visible where? (placeholder area? inspector panel? toolbar?)
-
-The spec is allowed to defer surface choice to the design doc, but the AC then needs a testable proxy — for example, "the cover does NOT emit an `<img>` element AND the placeholder area contains text matching the i18n key `cover.binding-internal-media-required` (or a stable test-id)."
-
-**Where in spec:** Requirements → D.16; Acceptance Criteria → Internal-media-only invariant → AC-4.
-
-**Suggestion:** Either pin down at least the test-observable signal (a stable `data-testid` or a known i18n string) in Req 16, OR define a negative-only AC ("no `<img>` is emitted for the unresolved binding") and move the positive-affordance assertion to the design phase. If the latter, add a Risk noting that the affordance surface is undefined until design.
-
-**Why it matters:** AC-4 is one of the four ACs that gate the internal-only invariant — the headline architectural constraint from the prompt. If it's untestable, the invariant ships unverified.
-
-### Issue 5: OQ-5 (id/url must bind to same source?) is a WHAT question, not HOW [major]
-
-**What's wrong:** OQ-5 asks: "Must `id` and `url` bind to the same source? Should the editor validate that `metadata.bindings.id.source === metadata.bindings.url.source`? Should it block save if they differ? Or treat any mismatch as an unresolvable binding per AC-4?"
-
-These three outcomes are user-observable behaviours that map to different test cases. They're not "implementation detail" — they define the user contract for an edge case the prompt specifies (Internal-only invariant). The spec should pick one of the three and capture it as a requirement and an AC.
-
-This is the same class of error as Issue 1 (AC-14): a behavioural contract is being deferred to a phase that's not supposed to make user-observable decisions.
-
-**Where in spec:** Open Questions → OQ-5.
-
-**Suggestion:** Resolve OQ-5 in the spec. Recommended: "treat any mismatch as an unresolvable binding per AC-4" — this matches the existing Internal-only-invariant story and avoids a save-blocking dialog that would slip scope. Add a new AC: "Given a Cover with `metadata.bindings.id.source !== metadata.bindings.url.source`, when the editor renders the cover, then the cover displays the internal-media-required affordance (per AC-4)."
-
-**Why it matters:** Mismatched-source binding is the exact edge case that produced the external-URL scope creep in PR #74109. Leaving it open to design means the design phase has to relitigate it, and the implementer has no contract to test against.
-
-### Issue 6: AC-18 (`useFeaturedImage: true` + binding) is in-scope but Out-of-Scope says featured-image binding is a follow-up [minor]
-
-**What's wrong:** Out of Scope lists "Featured-image binding for Cover" as a separate follow-up PR. AC-18 specifies behaviour when both `useFeaturedImage: true` AND a binding on `url` exist simultaneously: "the bound `url` is shown, NOT the featured image URL. Server render does NOT inject a second `<img>`." Concretely this IS featured-image × binding interaction, and the AC defines a precedence rule.
-
-This is not literally a contradiction (the in-scope work is "binding wins over featured image, do not double-render"; the out-of-scope work is "express featured-image-as-a-binding"), but the language overlap is confusing and the spec doesn't explain the distinction.
-
-**Where in spec:** Out of Scope, fourth bullet; Acceptance Criteria → AC-18.
-
-**Suggestion:** Either rephrase the Out-of-Scope bullet to "Using a binding source to express `useFeaturedImage` behaviour (e.g. a `featured-image-url` binding source returning the post's featured-image URL) is out of scope." Or add a one-line note in AC-18 cross-referencing the Out-of-Scope bullet ("this is the *precedence* rule; expressing featured-image as a binding source is OOS — see Out of Scope").
-
-**Why it matters:** Minor, but reviewers (including @ockham per Risk #4) will notice this. Cheap to fix.
-
-### Issue 7: AC-19 mechanism depends on OQ-4 mechanism, which depends on OQ-3 approach [minor]
-
-**What's wrong:** AC-19 requires the server, when bindings are active, to emit `<img>` instead of `<div style="background-image: ...">` and to strip `has-parallax` / `is-repeated` classes from the relevant element. OQ-4 acknowledges this mechanism is undetermined ("Confirm in design that this is the chosen mechanism and that it is safe across all known cover markup variations"). OQ-3 leaves the server-side approach (A vs B) open.
-
-The AC itself is testable (HTML output is `<img>` or not, classes are present or not), so this is not a blocker. But the spec is asserting a *server behaviour* (replace `<div>` with `<img>`) before deciding the mechanism — the design phase could plausibly decide that this rewrite is infeasible (HTML Tag Processor edge cases on user-modified Cover markup) and choose to make `hasParallax` non-overridable by binding instead. Then AC-19 becomes wrong.
-
-**Where in spec:** Acceptance Criteria → AC-19; Open Questions → OQ-3, OQ-4.
-
-**Suggestion:** Either resolve OQ-4 in the spec (commit to the element-replacement approach) and treat AC-19 as ground truth — OR weaken AC-19 to "the rendered output does not show a parallax effect (no `style="background-image: url()"` is emitted, no `has-parallax` class on a visible image element)" without prescribing the `<img>` shape. The first is preferable because it gives the implementer a concrete target.
-
-**Why it matters:** Minor — the design phase will surface this anyway. But pinning it down in the spec lets the design phase focus on HOW, not WHAT.
-
-### Issue 8: "Architecture verifiable from code review" ACs (AC-20, AC-21) are not runtime-testable [minor]
-
-**What's wrong:** AC-20 and AC-21 are good architectural invariants but acknowledge in the section heading they are "verifiable from code review, not at runtime." This means the e2e/PHPUnit test suite cannot enforce them. They are listed alongside runtime-testable ACs without a clear distinction in how they get gated.
-
-**Where in spec:** Acceptance Criteria → Architecture section header.
-
-**Suggestion:** Two options:
-- (a) Accept they are code-review-only and call them out explicitly as such in their headers (e.g. "AC-20 (code-review)") so the PR template / reviewer checklist can pick them up.
-- (b) Make at least one of them mechanically testable. For example, AC-20 ("single observer for URL-derived state") can be partially asserted by a unit test that mounts the Cover edit component, sets a bound URL, asserts only one `useEffect` callback runs in response (e.g. via a `vi.spyOn` on a derivation helper). Probably more trouble than it's worth.
-
-Option (a) is fine.
-
-**Why it matters:** Minor — but if a future regression silently re-introduces event-keyed `useEffect`s and no human catches it in review, the @ockham architectural concern returns. Worth flagging.
-
-## Recap
-
-Reject reason: Issues 1, 2, 3, 4, and 5 are real defects in the spec that block downstream design and implementation. Issues 6, 7, 8 are minor and could be left for the design phase if the majors get fixed, but they're cheap to address in the same rewrite pass.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-2-rejected.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-2-rejected.md
deleted file mode 100644
index 682486a6050264..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-2-rejected.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# Spec Review
-
-## Verdict: rejected
-
-## Summary
-
-The iter-2 revision is a substantial improvement: all eight iter-1 findings are addressed cleanly. Issue 1 (AC-14 / Req 7 media-replace contradiction) is resolved by committing to the strict reading. Issue 2 (embed-video × AC-19) is resolved by adding the `backgroundType !== "embed-video"` precondition and Req 22. Issue 3 (dim-ratio class hedging) is resolved via option (b) — non-opacity is the contract. Issue 4 (untestable affordance) is improved by mandating a stable test-observable signal. Issue 5 (mismatched-source binding) is resolved by Req 26 / AC-6. Issues 6–8 are also addressed cleanly.
-
-However, the revision introduces ONE blocking new defect by trying to be precise about what "active binding" means. The Glossary defines "active binding" as **both** `metadata.bindings.id` and `metadata.bindings.url` being set to the same source instance. In the actual codebase, the standard Pattern Overrides flow — the headline use case for this PR — does **not** write per-attribute binding entries; it writes only `metadata.bindings.__default = { source: 'core/pattern-overrides' }`. This means every requirement and AC that gates on "active binding" would silently FAIL for the Pattern Overrides case as defined.
-
-This is a real implementability defect: under the spec's own Glossary, requirement 4 (parallax toggle hidden) would not fire for a Pattern-Overrides Cover, and AC-7 (the headline acceptance criterion) would contradict AC-11/12/13/14. Two minor issues (one HTML API claim in OQ-3, one ambiguity in AC-21) are noted as non-blocking.
-
-## Issues
-
-### Issue 1: Glossary "active binding" definition is incompatible with the actual Pattern Overrides client-side data model [blocker]
-
-**What's wrong:** Glossary says:
-
-> **Active binding (on a Cover instance)**: both `metadata.bindings.id` and `metadata.bindings.url` are set AND point to the same source instance (same `source` string AND, where applicable, same `args`).
-
-This entire spec then gates Reqs 4–9, 11, 14, 18, AC-3, AC-4, AC-6, AC-11–15, AC-18, AC-19, AC-21 on this definition.
-
-But the actual Pattern Overrides client-side flow writes **only** `metadata.bindings.__default = { source: 'core/pattern-overrides' }`, NOT per-attribute entries. Verified in `packages/patterns/src/components/pattern-overrides-controls.js:51-55`:
-
-```js
-updateBlockBindings( {
-    __default: isChecked
-        ? { source: PATTERN_OVERRIDES_BINDING_SOURCE }
-        : undefined,
-} );
-```
-
-Server-side, `__default` is then expanded into per-attribute bindings inside `gutenberg_process_block_bindings` (verified in `lib/compat/wordpress-6.9/block-bindings.php:257-281`). Client-side, the expansion happens only in selected places via `replacePatternOverridesDefaultBinding` from `packages/block-editor/src/utils/block-bindings.js`. The Image block's `lockUrlControls` (`packages/block-library/src/image/image.js:758,771-777`) reads `metadata?.bindings?.url` directly — for a Pattern-Overrides image, `urlBinding` is undefined and `lockUrlControls` is false (which is correct for image, since Pattern Overrides allows editing — but the lock signal is not the same as the "binding is active" signal Cover needs).
-
-Concrete consequence under this spec: a Cover block in a synced pattern with Pattern Overrides enabled has `metadata.bindings = { __default: { source: 'core/pattern-overrides' } }`. Per Glossary, this is NOT an "active binding" (`bindings.id` and `bindings.url` are both `undefined`). Therefore:
-- Req 4 (hide parallax) does not fire — AC-11 fails.
-- Req 5 (hide repeat) does not fire — AC-12 fails.
-- Req 6 (hide use-featured-image) does not fire — AC-13 fails.
-- Req 7 (hide media-replace) does not fire — AC-14 fails.
-- Req 14 (effective dimRatio) does not fire — AC-15, AC-16 fail.
-- AC-7 (pattern instance shows pattern default) passes server-side via `__default` expansion BUT contradicts AC-11..14 because the editor-side controls are not hidden.
-
-**Where in spec:** Glossary; cascading through all of §§B, C, D and Acceptance Criteria.
-
-**Suggestion:** Either of:
-- **(a) Broaden the "active binding" definition to recognise `__default: core/pattern-overrides`** as equivalent to "both `id` and `url` bound to `core/pattern-overrides`". Concretely: "Active binding (on a Cover instance): either (i) both `metadata.bindings.id` and `metadata.bindings.url` are set and point to the same source instance, OR (ii) `metadata.bindings.__default.source` is set (`__default` semantically expands to per-attribute bindings for every supported attribute)." This is the codebase reality, and it matches how the Image block's `lockUrlControls` and the editor's existing helpers reason about pattern-override-bound blocks.
-- **(b) Define "active binding" using the existing expansion helper** `replacePatternOverridesDefaultBinding(metadata.bindings, supportedAttributes)`: a Cover has an active binding iff, after expansion, the resulting object contains both `id` and `url` keys pointing to the same source. This is testable and aligns with the server-side semantics.
-
-In either case, also update AC-6 (mismatched source) to clarify that `__default` resolves to "same source" for all expanded attributes and therefore CANNOT mismatch by construction; only explicit per-attribute bindings can mismatch.
-
-**Why it matters:** Pattern Overrides is the spec's headline use case (explicit in the Overview paragraph and the prompt). The Glossary as written silently breaks the headline use case for control hiding and render-time effective values. Two implementers reading the spec would build different things: one might literally implement `bindings.id && bindings.url` and ship a regression on Pattern Overrides; another might guess that `__default` should "count" and ship something that works but doesn't match the spec. The e2e test (AC-22, AC-23) would not pass against the literal Glossary reading. This is the single most consequential bug in the spec because it conflates the server-side data model (post-expansion) with the client-side data model (pre-expansion).
-
-### Issue 2: OQ-3's claim that "the HTML Tag Processor can perform element replacement" is materially inaccurate [minor]
-
-**What's wrong:** OQ-3 says:
-
-> The HTML Tag Processor can perform element replacement when the element is uniquely identifiable by class (`wp-block-cover__image-background`).
-
-In the WordPress HTML API (`WP_HTML_Tag_Processor`), there is no `set_tag()` or "swap element type" operation. You can mutate attributes, classes, and inner HTML (via `WP_HTML_Processor` and bookmarks), but you cannot change a `<div>` into an `<img>` — that requires string-level substitution outside the Tag Processor's mutation API. Verified by grep: no `set_tag` / `change_tag` references exist in the codebase.
-
-OQ-3 is the open question that nominally lets the design phase pick its mechanism, so this is not literally a runtime contradiction. But it baits the design phase into picking an approach that doesn't work. The actual feasible mechanisms are:
-- Process the saved markup with a regex / string replace (fragile),
-- Use the higher-level `WP_HTML_Processor` with bookmarks + inner-HTML replacement (still requires re-emitting the tag),
-- Move the entire `<img>` injection logic into the cover's PHP `render_callback` (skipping the saved markup entirely when bindings are active — this is the Approach A in OQ-1).
-
-**Where in spec:** Open Questions → OQ-3.
-
-**Suggestion:** Rephrase OQ-3 to acknowledge the API constraint:
-
-> OQ-3. Saved-markup parallax/repeat replacement mechanism. When a Cover saved with `hasParallax: true` and/or `isRepeated: true` gains a binding, the server-render must emit `<img>` instead of `<div style="background-image: ...">`. The WP HTML Tag Processor cannot rewrite a `<div>` into an `<img>` directly. Two feasible approaches: (i) detect the parallax case in `render_block_core_cover`, replace `$content` wholesale (or its image fragment) with a rebuilt `<img>` HTML string, or (ii) make `render_block_core_cover` ignore the saved image markup entirely when bindings are active and synthesise the full `<img>` from resolved `url`/`id`. Design picks one; both honour AC-19.
-
-This is a minor wording fix; it doesn't change the AC contract.
-
-**Why it matters:** Design phase will likely correct this within minutes of starting work, but flagging it now saves a wasted exploration cycle. Also tightens the link between the spec's HTML-API-limits Risk #5 (which is correct) and OQ-3's mechanism claim (which contradicts Risk #5 by implication).
-
-### Issue 3: AC-21 leaves embed-video URL substitution behaviour ambiguous [minor]
-
-**What's wrong:** AC-21 says:
-
-> Given an existing Cover with `backgroundType: "embed-video"`, when the editor opens the bindings UI, then the panel still lists `url`/`id` as bindable; but neither the binding-aware editor derivations nor the binding-aware server-render path engage — the existing embed render flow runs unchanged regardless of binding presence.
-
-"The existing embed render flow runs unchanged regardless of binding presence" — does this mean the bound `url` is substituted into the embed iframe URL (so the iframe shows the bound embed URL), or does the embed render path use the saved `url` only? The Out-of-Scope bullet on embed-video says "No `<img>` substitution, no class rewrite, no parallax strip is performed on embed-video covers under this PR" — but it does not state whether basic URL substitution into the embed iframe happens.
-
-Two implementers could read AC-21 + Out-of-Scope as:
-- (a) The bound `url` is substituted; only the binding-aware derivations (dim ratio, overlay colour) and the `<img>` rewrite are short-circuited. The embed iframe's `src` attribute does get the bound URL. This requires `gutenberg_replace_html` or equivalent to run on the embed iframe.
-- (b) The whole binding processing path is bypassed for embed-video; the embed iframe shows the saved URL only.
-
-The phrase "binding-resolution server path MUST NOT engage for embed-video covers" in Req 22 leans toward (b) — but (a) would be more consistent with "the user is allowed to bind the URL and the panel shows the bindable rows".
-
-**Where in spec:** Acceptance Criteria → AC-21; Cross-cutting invariants → Req 22; Out of Scope → Embed-video bullet.
-
-**Suggestion:** Pick one interpretation. The cheap and conservative choice is (b): the entire bindings server path bypasses for `backgroundType === "embed-video"`. Add to AC-21:
-
-> When `backgroundType === "embed-video"`, the rendered embed iframe URL is the saved attribute URL, NOT the bound URL. Binding the URL of an embed-video Cover has no observable runtime effect under this PR (out-of-scope per Out-of-Scope).
-
-This makes the contract testable and unambiguous.
-
-**Why it matters:** Minor — embed-video × bindings is OOS so this only affects whether a user who tries the combination gets a coherent result or a surprising one. But the e2e test (AC-21 derivative) cannot be written until the interpretation is locked.
-
-## Recap
-
-Reject reason: Issue 1 is a real spec-level defect that silently breaks the headline use case. Until "active binding" recognises the standard `__default` shape, the spec is not implementable for Pattern Overrides without an implementer making their own interpretation. Issues 2 and 3 are minor and could ship for design-phase resolution if Issue 1 is fixed, but they are cheap to address in the same rewrite pass.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-approved.md
deleted file mode 100644
index 4d1a761034124f..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec-review-approved.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Spec Review
-
-## Verdict: approved
-
-## Summary
-
-The iter-3 revision resolves all three iter-2 findings cleanly and introduces no new defects.
-
-**Iter-2 Issue 1 (blocker — Glossary "active binding" incompatible with Pattern Overrides).** Resolved by adding a dedicated "Expanded bindings" Glossary entry that defines `__default` expansion semantics, and by rewriting the "Active binding" definition to operate *after* expansion. The spec now states explicitly: "The `__default: { source: 'core/pattern-overrides' }` shape therefore qualifies as an active binding by construction, because expansion populates `id` and `url` from the same `__default` source." The reference to the existing client helper `replacePatternOverridesDefaultBinding( bindings, supportedAttributes )` in `packages/block-editor/src/utils/block-bindings.js` is verified — the helper exists at the cited path. Reqs 4–9, 11, 14, 18 and ACs 11–15 / 18 / 19 now correctly fire for the headline Pattern-Overrides shape. AC-6 / Req 26 are also tightened to note that `__default` cannot mismatch by construction; only explicit per-attribute bindings can.
-
-**Iter-2 Issue 2 (minor — OQ-3 HTML Tag Processor claim).** Resolved by rewriting OQ-3 to explicitly state the API limitation ("`WP_HTML_Tag_Processor` cannot rewrite a `<div>` into an `<img>` — there is no `set_tag()` / element-type-swap operation") and to enumerate the two genuinely feasible mechanisms (`$content` fragment replacement / Processor-bookmark substitution, or synthesise the full `<img>` server-side from resolved `url`/`id`).
-
-**Iter-2 Issue 3 (minor — AC-21 embed-video URL ambiguity).** Resolved by AC-21 now stating: "the rendered embed iframe `src` is the **saved** `url` attribute, NOT the bound `url`. No URL substitution is attempted for embed-video covers; no `<img>` is synthesised; no overlay-class or parallax-class rewrite is performed." The Out-of-Scope embed-video bullet mirrors this and adds the "embed path wins even if a Cover's saved markup contains stale `hasParallax: true` alongside `backgroundType: "embed-video"`" carve-out.
-
-Other improvements in iter-3 worth noting: Req 11 / DC-2 now enumerate the full prohibited-mutation attribute list (`dimRatio, useFeaturedImage, backgroundType, id, url, hasParallax, isRepeated, overlayColor, customOverlayColor`), which closes a small gap from iter-2. Glossary "Bound `url` / `id`" now correctly accounts for `__default`-implied bindings. Design Constraints section now explicitly mandates the PR review checklist tick DC-1/DC-2/DC-3.
-
-No blockers, no new defects. The remaining Open Questions (OQ-1 Approach A vs B, OQ-2 disable vs hide, OQ-3 saved-markup parallax mechanism, OQ-4 specific dim-ratio value) are all genuine HOW choices appropriate for the design phase — they do not gate any user-observable contract.
-
-Approving for design phase.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md b/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
deleted file mode 100644
index 57df33dbf1a973..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/1-spec/spec.md
+++ /dev/null
@@ -1,183 +0,0 @@
-# Spec: Cover block bindings — internal-only support for `id` and `url`
-
-## Overview
-
-The `core/cover` block does not support Block Bindings. Two prior draft PRs stalled over architectural objections (event-handler-driven `useEffect` proliferation), an HTML-rewrite blocker (CSS values inside `style` attributes cannot be edited by the WP HTML API), and scope creep around external URLs. This feature lands narrowly-scoped Block Bindings support for the `id` and `url` attributes of `core/cover`, restricted to internal media library items, with Pattern Overrides as the headline use case. When a binding is active, Cover-specific controls that would conflict with bindings (parallax, repeat, media-replace, use-featured-image) are hidden, and dependent values (overlay color, effective dim ratio) are derived from the bound URL at render time without ever mutating stored attributes. The server render produces correct `<img>` markup with parallax effectively off.
-
-## Glossary
-
-- **Bound `url` / `id`**: a Cover attribute whose `metadata.bindings.<attr>` is set to a binding source (e.g. `core/pattern-overrides`, `core/post-meta`), OR whose binding is implied by a `__default` wildcard binding (see "Expanded bindings" below).
-- **Internal media**: an attachment that exists in the site's media library; identified by a numeric attachment `id` from which the `url` can be derived.
-- **Expanded bindings (on a Cover instance)**: the `metadata.bindings` object after the `__default` wildcard is resolved into per-attribute entries. Concretely: if `metadata.bindings.__default.source` is set (today only `core/pattern-overrides` writes this shape), then **every** supported attribute that does not already have an explicit per-attribute binding entry is treated as bound to that same `__default` source. If `__default` is absent, the expanded bindings equal the literal `metadata.bindings`. This matches the existing client-side helper `replacePatternOverridesDefaultBinding( bindings, supportedAttributes )` (in `packages/block-editor/src/utils/block-bindings.js`) and the server-side expansion in `gutenberg_process_block_bindings`.
-- **Active binding (on a Cover instance)**: after expansion (see "Expanded bindings"), `metadata.bindings.id` and `metadata.bindings.url` are both present AND point to the same source instance (same `source` string AND, where applicable, same `args`). The `__default: { source: 'core/pattern-overrides' }` shape therefore qualifies as an active binding by construction, because expansion populates `id` and `url` from the same `__default` source. Any other configuration — only one of `id`/`url` is bound (after expansion) or both bound but to different sources — is **not** an active binding; the cover falls back to direct-edit behaviour, except where requirement 16 / AC-4 / AC-6 applies.
-- **Effective value**: a value computed at render time from the resolved bound values, used for display only; never written back to the stored attribute.
-- **Pattern Overrides**: the `core/pattern-overrides` binding source — pattern authors mark attributes overridable (the editor writes only `metadata.bindings.__default = { source: 'core/pattern-overrides' }`, no per-attribute entries); pattern instances may override per-instance and reset to default.
-
-## Requirements
-
-### A. Metadata and registration
-
-1. `core/cover`'s `id` attribute MUST declare `"role": "content"` (matching `core/image`). No other attribute schema changes.
-2. A new file `lib/compat/wordpress-7.1/block-bindings.php` MUST be created and required from `lib/load.php`. It MUST register a filter that adds `id` and `url` to `gutenberg_get_block_bindings_supported_attributes('core/cover')`. The filter MUST follow the established `! function_exists` / version-guard pattern.
-3. No other `block.json` shape changes for `core/cover`. No new attributes.
-
-### B. Editor — UI gating when a binding is active
-
-A binding is **active** per the Glossary definition (after `__default` expansion, both `id` and `url` are bound to the same source instance). The headline Pattern Overrides shape — `metadata.bindings.__default = { source: 'core/pattern-overrides' }` with no per-attribute entries — IS an active binding under this definition.
-
-4. The parallax toggle (`hasParallax`) MUST be hidden whenever a binding is active on the Cover.
-5. The repeated-background toggle (`isRepeated`) MUST be hidden whenever a binding is active on the Cover.
-6. The "Use featured image" toggle MUST be hidden whenever a binding is active on the Cover, in every surface where it appears (block toolbar, inspector).
-7. The media-replace control MUST be hidden whenever a binding is active on the Cover, regardless of the bound source's `canUserEditValue`. (Pattern Overrides routes overrides through a separate flow; direct media replacement from inside the Cover is not offered when bound.)
-8. The Block Bindings UI (legacy Attributes panel and Block Fields UI from sibling pipeline 75022) MUST surface bindable rows for `id` and `url` on `core/cover` automatically, with no Cover-specific UI code beyond requirement 2.
-9. Pattern Overrides controls (`Enable overrides` button, `ResetOverridesControl`) MUST work for `core/cover` automatically, with no Cover-specific UI code.
-
-### C. Editor — reactive derivation (single-observer architecture)
-
-10. The Edit component MUST derive all dependent state (overlay color, effective dim ratio, effective URL, lock flags) reactively from the effective `url` in a source-agnostic way: identical behavior whether the URL arrived manually, via `useFeaturedImage`, or via a binding source. (The single-observer / no-per-event-`useEffect` constraint that operationalises this is a Design Constraint — see §"Design Constraints".)
-11. Derivation MUST NOT mutate any block attribute as a side effect of a binding becoming active or inactive. Specifically: `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, `customOverlayColor` MUST NOT be written from the derivation path triggered by binding state changes.
-12. Overlay color MUST update from the resolved image's average color when `isUserOverlayColor` is false, regardless of URL source.
-13. The derivation MUST be resilient against concurrent async `getMediaColor` resolutions: a stale color MUST NOT overwrite a newer one.
-
-### D. Editor — render-time effective values
-
-14. When a binding is active on a Cover AND the stored `dimRatio` equals the default value (100) AND the bound URL resolves to a non-empty value, the rendered overlay MUST NOT be fully opaque. The stored `dimRatio` attribute MUST NOT change. (The exact non-opaque value used is a design decision; the constraint is non-opacity.)
-15. The effective `url` used by the editor preview MUST prefer the bound `url` over `useFeaturedImage`'s `mediaUrl` when both are present. The bound value wins.
-16. When `url` is bound but the binding-resolved `id` is missing or does not resolve to an attachment in the media library (the "external URL" case), the editor MUST surface a clear "internal media required" affordance AND MUST NOT render an `<img>` element for the unresolved binding. The affordance MUST be discoverable by a stable, test-observable signal — a known i18n message string (or equivalent stable identifier) accessible to the e2e test. The exact surface (placeholder copy, notice, inspector message) is a design choice; visibility AND test-observability are the constraints.
-
-### E. Server — render correctness
-
-17. When bindings have resolved `url`/`id` for a Cover with `backgroundType !== "embed-video"`, the server-rendered markup MUST contain an `<img>` element for the resolved image (NOT a `<div style="background-image: url(...)">`), even if the saved markup was the parallax/repeat form. Parallax styling MUST be effectively off in the rendered output when bindings are active.
-18. When a binding is active AND the stored `dimRatio` is the default 100 AND the binding resolves a URL, the server-rendered overlay span class MUST NOT be `has-background-dim-100`. (It MUST be a non-opaque variant whose specific value is the design phase's choice; see Risks.)
-19. The server render MUST short-circuit the existing `useFeaturedImage` image-injection path in `render_block_core_cover` when bindings have resolved a value for `url`/`id`. Double image insertion MUST NOT occur.
-20. If the binding cannot resolve `id` to a media-library attachment (or `url` cannot be derived from the resolved `id`), the server MUST render the cover WITHOUT an image element. No broken `<img src>` / `<img src="">` may be emitted.
-21. The server-side mechanism (whether a Cover-scoped `render_block` filter or reuse of a generic `block_bindings_attribute_replaced_in_markup` filter — see OQ-1) MUST be additive: it MUST NOT change behavior for any other block.
-22. When `backgroundType === "embed-video"`, the existing oEmbed render path in `render_block_core_cover` MUST run unchanged regardless of binding presence; the binding-resolution server path MUST NOT engage for embed-video covers.
-
-### F. Cross-cutting invariants
-
-23. Unbound Cover behavior MUST be unchanged: no regression on parallax, repeat, focal point, featured image, embed-video, dim ratio, overlay color, alt text, image-size selection, deprecation chain.
-24. Pattern Overrides MUST round-trip cleanly through editor save/load and server render for four enumerated states:
-   - (a) **default, no override**: bound value equals the block's own attribute; instance renders the pattern default.
-   - (b) **overridden**: instance value differs from pattern default; renders the override.
-   - (c) **reset-to-default with binding active**: user clicks Reset; instance returns to pattern default.
-   - (d) **reset-affordance suppressed when instance value already matches default**: Reset is disabled (existing `ResetOverridesControl` semantics) or hidden — design phase resolves; OQ-2.
-25. External URL binding MUST NOT be silently honored. A binding source returning a `url` without a resolvable internal `id` MUST be treated as unresolvable per requirement 16 (editor) and requirement 20 (server).
-26. Mismatched-source binding MUST be treated as unresolvable. If — after `__default` expansion (see Glossary) — a Cover has `metadata.bindings.id` and `metadata.bindings.url` set to **different** source instances (different `source` strings, or different `args` against the same source), the editor MUST surface the "internal media required" affordance (per requirement 16) and the server MUST render the cover without an image element (per requirement 20). Mismatch can only arise from **explicit per-attribute** binding entries; the `__default` wildcard shape cannot mismatch by construction (expansion writes the same source into every supported attribute that lacks an explicit entry).
-27. `backgroundType: "embed-video"` MUST continue to render correctly and MUST NOT regress. The bindings panel MAY expose `url`/`id` rows even for embed-video covers (no Cover-specific suppression required), but the binding-aware derivations (effective dim ratio, overlay color) AND the binding-aware server render MUST short-circuit when `backgroundType === "embed-video"` (per requirement 22).
-28. The PR MUST NOT introduce new global Block Bindings APIs. If a reused filter (e.g. `block_bindings_attribute_replaced_in_markup`) is needed, it MUST be weighed against a Cover-scoped render path during design.
-
-### G. Tests
-
-29. A new e2e test MUST create a Cover, bind its `url`+`id` to a Pattern Overrides source, and assert the editor preview AND the rendered front-end show the pattern default.
-30. The same e2e test MUST override the value on a pattern instance and assert the rendered output reflects the override (different `<img src>`, non-opaque dim ratio class).
-31. The same e2e test MUST reset the override and assert the rendered output returns to the pattern default.
-32. The e2e test MUST assert that the parallax toggle, repeat toggle, media-replace control, and featured-image toggle are NOT present in the DOM when a binding is active.
-33. The e2e test MUST cover the unresolvable-binding case (e.g. mismatched sources, or a source resolving `url` without a media-library `id`) and assert the "internal media required" affordance is visible via its stable test-observable signal.
-34. A PHPUnit test SHOULD assert that `render_block_core_cover` substitutes the bound `url` into the rendered `<img src>` AND rewrites the dim ratio class to a non-opaque variant when the saved value is the default 100.
-35. Existing Cover unit tests (`packages/block-library/src/cover/test/edit.js`) MUST continue to pass; existing Cover e2e tests MUST continue to pass.
-
-### H. PR shape and project metadata
-
-36. The new compat file MUST live at `lib/compat/wordpress-7.1/block-bindings.php` (NOT 7.0). A `backport-changelog/7.1/<core-pr-number>.md` entry MUST be added when the corresponding Core PR exists.
-37. The PR description MUST link issue #77199 and explicitly state whether it subsumes prior PRs #74109 and #74610.
-38. The net diff (including tests) SHOULD target under ~500 lines.
-39. The implementation MUST gracefully degrade on a WP install lacking the bindings infrastructure changes (use the existing `! function_exists` / version-guard pattern).
-
-## Out of Scope
-
-The following are explicitly excluded from this work. They are not deferred-but-acknowledged inside this PR; they are non-goals:
-
-- **External / non-media-library URL binding.** Binding `url` to an arbitrary URL with no resolvable internal `id` is not supported. The cover surfaces an "internal media required" UX instead.
-- **Mismatched-source binding (`id` and `url` bound to different sources).** Not supported. Treated as an unresolvable binding per requirement 26.
-- **Parallax × bindings interaction beyond "force off".** No CSS-in-style HTML rewriting. When bindings are active and `backgroundType !== "embed-video"`, parallax styling is suppressed in the server render (emit `<img>`, no `<div style="background-image: ...">`); the UI hides the parallax toggle.
-- **Embed-video × bindings interaction.** `backgroundType: "embed-video"` is not specifically supported with bindings beyond non-regression. The bindings panel MAY surface bindable rows, but the binding-aware editor derivations AND the binding-aware server-render path BOTH short-circuit — embed-video covers continue to render via the existing oEmbed flow regardless of binding presence. No `<img>` substitution, no class rewrite, no parallax strip, AND no embed-iframe `src` substitution from the bound `url` is performed on embed-video covers under this PR (the rendered iframe `src` is the saved `url` attribute). This carve-out applies even if a Cover's saved markup contains stale `hasParallax: true` alongside `backgroundType: "embed-video"`: the embed path wins.
-- **Featured-image binding for Cover (i.e. expressing `useFeaturedImage` behaviour AS a binding).** Defining a binding source that returns the post's featured-image URL/id (so that `useFeaturedImage` becomes redundant with bindings) is a separate follow-up PR. This PR's in-scope contract concerning featured image is the *precedence rule* (AC-18): when both `useFeaturedImage: true` and an active binding co-exist on the same Cover, the binding wins and the server does not double-render.
-- **New global Block Bindings APIs.** No new globally-registered Block Bindings APIs are introduced. At most one already-proposed filter (`block_bindings_attribute_replaced_in_markup`) may be reused; introducing it is weighed against a Cover-scoped server-render path during design.
-- **Post-data source `featured_media.url` / `featured_media.id` field.** Out of scope.
-
-## Acceptance Criteria
-
-Given-When-Then form. Each runtime AC is independently testable from outside the implementation (e2e, PHPUnit, or DOM inspection). Code-review-only assertions live in §"Design Constraints".
-
-### Bindings discovery
-
-- **AC-1.** Given a `core/cover` block selected in the editor on a site running this build, when the user opens the Block Bindings UI (legacy Attributes panel or Block Fields UI), then the panel lists `url` and `id` as bindable attributes.
-- **AC-2.** Given a `core/cover` block in a synced pattern, when the pattern author opens the Pattern Overrides controls, then the "Enable overrides" affordance is available for the Cover block.
-
-### Internal-media-only invariant
-
-- **AC-3.** Given a binding source resolves `url` to an attachment URL AND `id` to the corresponding media-library attachment id AND both bindings reference the same source instance, when the editor renders the Cover, then the editor preview shows the resolved image.
-- **AC-4.** Given a binding configuration that does NOT meet the active-binding definition (only one attribute bound; both bound but to different sources; or `id` missing / resolving to a non-attachment), when the editor renders the Cover, then (a) no `<img>` element is emitted for the bound URL AND (b) the editor surfaces the "internal media required" affordance via its stable test-observable signal (a known i18n message string or equivalent stable identifier resolved during design).
-- **AC-5.** Given the same unresolvable binding state, when the server renders the Cover, then the rendered HTML contains no `<img>` element for the bound URL.
-- **AC-6.** Given a Cover with **explicit per-attribute** bindings such that `metadata.bindings.id.source !== metadata.bindings.url.source` (or differing `args`), when either the editor or the server renders the cover, then the cover renders the "internal media required" state per AC-4 / AC-5 (mismatched sources are treated as unresolvable). The `__default: { source: 'core/pattern-overrides' }` shape cannot trigger this AC because expansion writes the same source into both `id` and `url` (see Glossary "Expanded bindings"); mismatch is only reachable via explicit per-attribute bindings.
-
-### Pattern Overrides round-trip
-
-- **AC-7.** Given a synced pattern with a Cover whose `url`+`id` are bound to `core/pattern-overrides`, when an instance is inserted with no override applied, then both the editor preview and the front-end render show the pattern default image.
-- **AC-8.** Given an inserted pattern instance with the Cover image overridden via the editor, when the post is saved and rendered on the front end, then the rendered `<img src>` is the override URL.
-- **AC-9.** Given an overridden Cover instance, when the user clicks "Reset" on the toolbar `ResetOverridesControl`, then the override is cleared and both editor preview and front-end render return to the pattern default.
-- **AC-10.** Given a Cover instance with no override applied (value matches pattern default), when the user looks at the toolbar, then the `ResetOverridesControl` is disabled (or hidden per OQ-2 resolution).
-
-### Control hiding
-
-- **AC-11.** Given a Cover block with an active binding (per Glossary), when the user inspects the inspector controls, then the parallax toggle is NOT in the DOM.
-- **AC-12.** Given a Cover block with an active binding, when the user inspects the inspector controls, then the repeat toggle is NOT in the DOM.
-- **AC-13.** Given a Cover block with an active binding, when the user inspects the block toolbar and inspector controls, then the "Use featured image" toggle is NOT in the DOM.
-- **AC-14.** Given a Cover block with an active binding to **any** source (including `core/pattern-overrides` and `core/post-meta`), when the user inspects the block toolbar, then the media-replace control is NOT in the DOM. Replacement under Pattern Overrides flows through the override authoring surface, not the Cover's own media-replace control.
-
-### Render-time effective values
-
-- **AC-15.** Given a newly inserted Cover with default `dimRatio: 100` and an active binding resolving a non-empty `url`, when the editor renders the cover, then the displayed overlay's computed opacity is strictly less than 1.0 (the bound image is visible through the overlay).
-- **AC-16.** Given the same Cover, when the server renders the cover, then the overlay span class is NOT `has-background-dim-100`.
-- **AC-17.** Given a Cover with `dimRatio` explicitly set to a non-default value (e.g. 70) and an active binding resolving a URL, when either editor or server renders, then the displayed overlay uses the stored value (70). The stored attribute is unchanged.
-- **AC-18.** Given a Cover with `useFeaturedImage: true` and an active binding on `url`+`id`, when either editor or server renders, then the bound `url` is shown, NOT the featured image URL. Server render does NOT inject a second `<img>` for the featured image. (This is the *precedence* rule; expressing featured-image AS a binding source is out of scope — see Out of Scope.)
-- **AC-19.** Given `backgroundType !== "embed-video"` AND a Cover with `hasParallax: true` and `isRepeated: true` saved in markup, and a binding subsequently activated on `url`+`id`, when the server renders the cover, then the output contains an `<img>` (not a `<div style="background-image">`), the `has-parallax` and `is-repeated` classes are not applied to that element, and no `style="background-image: ..."` substitution is attempted.
-
-### Non-regression
-
-- **AC-20.** Given an existing unbound Cover block (with or without `hasParallax`, `isRepeated`, `useFeaturedImage`, `backgroundType: "embed-video"`, custom overlay color, custom dim ratio, custom focal point), when the editor and server render the block, then the output is identical to the current trunk behavior. No deprecation chain breakage.
-- **AC-21.** Given an existing Cover with `backgroundType: "embed-video"`, when the editor opens the bindings UI, then the panel still lists `url`/`id` as bindable; but neither the binding-aware editor derivations nor the binding-aware server-render path engage — the existing embed render flow runs unchanged regardless of binding presence. Specifically: the rendered embed iframe `src` is the **saved** `url` attribute, NOT the bound `url`. No URL substitution is attempted for embed-video covers; no `<img>` is synthesised; no overlay-class or parallax-class rewrite is performed. Binding the `url`/`id` of an embed-video Cover has no observable runtime effect under this PR (consistent with the Out-of-Scope "Embed-video × bindings interaction" bullet).
-
-### Tests present
-
-- **AC-22.** The repository contains an e2e test that exercises Pattern Overrides on Cover end-to-end (create pattern with bound Cover, insert, override instance, reset) and asserts both editor preview and rendered front-end output.
-- **AC-23.** The e2e test asserts the hidden-controls invariants (AC-11..AC-14) on a Cover with an active binding.
-- **AC-24.** The e2e test asserts the unresolvable-binding affordance (AC-4) via its stable test-observable signal.
-- **AC-25.** A PHPUnit test asserts server-side URL substitution AND a non-`has-background-dim-100` dim-ratio class for a bound Cover with default stored `dimRatio: 100`.
-
-### PR shape
-
-- **AC-26.** The new server-side filter file lives at `lib/compat/wordpress-7.1/block-bindings.php` and is loaded via `lib/load.php`. No file is created under `lib/compat/wordpress-7.0/`.
-- **AC-27.** The PR description links #77199 and explicitly states the relationship to #74109 and #74610.
-- **AC-28.** The net diff (additions − deletions) is under ~500 lines including tests.
-
-## Design Constraints
-
-These are architectural invariants required by reviewer @ockham (see Risks #4) and the prompt's architectural section. They are verifiable by code review on the PR, not by runtime tests. The design doc and PR review checklist MUST enforce them:
-
-- **DC-1. Single observer for URL-derived state.** The Edit component MUST NOT contain multiple `useEffect`s each keyed on a different event source (e.g. one for "media replaced", one for "blur", one for "binding detected"). All URL-derived state (overlay color, effective dim ratio, lock flags) MUST flow from a single reactive derivation path keyed on the effective `url`. Use of `useEffectEvent` (already exported from `@wordpress/element`) is the recommended primitive for reading latest non-tracked values without stale-closure pitfalls.
-- **DC-2. No attribute mutation from binding-state changes.** The derivation path triggered by a binding becoming active/inactive MUST NOT call `setAttributes` for `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, or `customOverlayColor`. (Requirement 11 states the contract; DC-2 is its code-review enforcement.)
-- **DC-3. Source-agnostic derivation.** The code path that derives dependent state from `url` MUST NOT branch on whether the URL came from a binding, `useFeaturedImage`, or manual selection. Identical behavior across all three sources.
-
-The PR review checklist MUST tick DC-1, DC-2, DC-3 explicitly before merge.
-
-## Risks
-
-1. **Pattern Overrides reset semantics** historically broke. The four enumerated states (AC-7..AC-10) must all round-trip; existing `ResetOverridesControl` behavior must be respected or extended.
-2. **`dimRatio: 100` default with a binding** is the specific opaque-overlay regression that stalled prior PRs. Solution lives in render-time effective value, NOT attribute mutation. The exact effective value (e.g. 50, matching the existing `onSelectMedia` downshift) is a design-phase decision; the AC contract is non-opacity.
-3. **`backgroundType: "embed-video"`** was added after prior bindings PRs; must not regress. Requirements 22 and 27 carve embed-video out of the binding-aware render path entirely.
-4. **Reviewer @ockham gates this area.** Prior objections (event-keyed `useEffect` proliferation, scattered derivation logic, internal-only scope) MUST be preempted in the design doc and enforced via the §"Design Constraints" checklist, not surfaced during PR review.
-5. **HTML rewriting blocker**: the WordPress HTML API cannot edit CSS values inside `style` attributes. The implementation MUST avoid that path — i.e. the server cannot rewrite `<div style="background-image: url(...)">`; it must emit `<img>` instead when bindings are active.
-
-## Open Questions (carried to design phase)
-
-These are the genuinely architectural HOW choices left for phase 2. All user-observable WHAT decisions have been resolved in the spec above.
-
-- **OQ-1. Server-side approach: Approach A vs Approach B.**
-  - **A.** Add a Cover-scoped `render_block` filter (in `lib/compat/wordpress-7.1/block-bindings.php` or `packages/block-library/src/cover/index.php`) that handles binding resolution, URL substitution, dim-ratio class rewrite, parallax class strip, and `useFeaturedImage` short-circuit in one place.
-  - **B.** Reuse the generic `block_bindings_attribute_replaced_in_markup` filter (from PR #74610) to synthesize `source: attribute, selector: img, attribute: src` for Cover's `url`, plus a smaller Cover-specific path for dim-ratio / parallax handling.
-  - Trade-off: A is entirely block-scoped (less cross-block risk); B has reuse value for future blocks with non-source-declared bindable attributes.
-- **OQ-2. Reset affordance: disabled or hidden when value matches default?** Existing `ResetOverridesControl` disables the button rather than hiding it. Pick disable (existing, consistent across all bindable blocks) or hide (matches prompt phrasing). Recommendation: disable. Design phase formally decides.
-- **OQ-3. Saved-markup parallax/repeat replacement mechanism.** When a Cover saved with `hasParallax: true` and/or `isRepeated: true` gains a binding, the server-render must emit an `<img>` instead of `<div style="background-image: url(...)">` (per AC-19) and ensure `has-parallax`/`is-repeated` classes do not apply to the image element. The WordPress HTML API's `WP_HTML_Tag_Processor` cannot rewrite a `<div>` into an `<img>` — there is no `set_tag()` / element-type-swap operation; only attribute, class, and (via `WP_HTML_Processor` bookmarks) inner-HTML mutations are available. Feasible mechanisms therefore include: (i) detect the parallax/repeat case in `render_block_core_cover` and replace the entire image fragment in `$content` with a rebuilt `<img>` HTML string (string-level or `WP_HTML_Processor`-bookmark substitution), or (ii) bypass the saved image markup entirely when bindings are active and synthesise the full `<img>` server-side from the resolved `url`/`id`. Design phase picks one; both must honour AC-19 and must avoid CSS-in-`style` mutation (Risk #5).
-- **OQ-4. Specific non-opaque effective dim-ratio value.** The contract (Req 14, AC-15, AC-16) is non-opacity. The existing `onSelectMedia` downshift uses 50; the design phase picks the specific value (likely 50 for symmetry, but the spec does not lock it).
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-1-rejected.md b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-1-rejected.md
deleted file mode 100644
index cbe0d7bc566c89..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-1-rejected.md
+++ /dev/null
@@ -1,243 +0,0 @@
-# Design Doc Review
-
-## Verdict: rejected
-
-## Summary
-
-The design doc has a solid skeleton: OQ-1/2/3/4 are chosen explicitly with rejected-alternative trade-offs; the single-observer architecture under `useEffectEvent` directly addresses Risk 1 / DC-1; the file table is concrete; Pattern Overrides routing is correctly delegated to `withPatternOverrideControls` + `replacePatternOverridesDefaultBinding`; and the spec's `__default` expansion finding (iter-2) is correctly threaded through both client and server. However, four substantive issues prevent approval:
-
-1. The chosen WP_HTML_Tag_Processor byte-offset helpers cited as "public" do not exist on `WP_HTML_Tag_Processor` — OQ-3's chosen mechanism rests on a fictional API surface.
-2. AC-13 / Req 6 (hide "Use featured image" toggle in EVERY surface) is incompletely satisfied — `cover-placeholder.js` exposes a second toggle site that the gating plan does not actually gate.
-3. AC-18 (no double `<img>` for featured image when binding is active) has a real architectural hole on Core 6.9+ where `render_callback` runs BEFORE the priority-9 filter with the bound url already merged into `$instance->attributes`, meaning the featured-image element is already injected into `$content` before our filter sees it — and the design's "`$instance->attributes['useFeaturedImage'] = false`" mutation only suppresses the priority-10 re-render leg, not the already-injected first-pass markup.
-4. Internal contradictions between §2.2 (files touched: `cover-placeholder.js` change) and §5.5 ("no second-site gating is needed") leave the design ambiguous about where the placeholder copy lives and where gating happens.
-
-Several smaller traceability / clarity issues compound these. Detailed below.
-
-## Issues
-
-### Issue 1 (blocker): OQ-3's chosen mechanism relies on non-existent `WP_HTML_Tag_Processor` methods
-
-**What's wrong:** The design (§3 OQ-3 and §6.2) cites the public methods `WP_HTML_Tag_Processor::get_token_byte_offset_in_source_text()` and `get_full_token_length()` as the mechanism for computing splice byte ranges. These methods **do not exist** on `WP_HTML_Tag_Processor` in the WordPress version range targeted (verified against `wp-includes/html-api/class-wp-html-tag-processor.php` — the class exposes `$token_starts_at` and `$token_length` only as **private** properties; the public method list in the file has no `get_token_byte_offset_in_source_text` / `get_full_token_length` / `get_token_length_in_source_text`). The design also conflates `WP_HTML_Tag_Processor` and `WP_HTML_Processor::create_fragment` ("…using `WP_HTML_Tag_Processor` to locate the element and Tag-Processor bookmarks (via the source-text byte positions exposed through `get_token_byte_offset_in_source_text`/`get_token_length_in_source_text` on `WP_HTML_Processor::create_fragment`)…"), which is internally inconsistent — first naming `WP_HTML_Tag_Processor`, then attributing the helper methods to `WP_HTML_Processor`. Neither class exposes those methods publicly in WP trunk today.
-
-**Where in design doc:** §3 OQ-3 (the "Concrete shape (pseudo-PHP, mechanism (i))" block) and §6.2.
-
-**Suggestion:** Pick one of:
-- (a) Commit to the `preg_match` fallback path the design already names as a Plan B (matching the regex pattern used by `render_block_core_cover` at `packages/block-library/src/cover/index.php:117-125`). Mark this as the primary mechanism for OQ-3 mechanism (i). Drop the byte-offset helper claim entirely or move it to "future micro-optimisation if Core gains public byte-offset accessors."
-- (b) Use `WP_HTML_Processor::create_fragment` with bookmark-bounded `seek` and explicit `get_updated_html()` substring extraction — but this needs a concrete code shape verified against trunk APIs, not just an asserted method name.
-
-**Why it matters:** OQ-3 is the load-bearing decision for AC-19. A mechanism that doesn't exist isn't a mechanism. Implementation phase will hit this immediately and have to redesign on the fly; the design phase is exactly where this should be settled. The spec called this a "genuinely architectural HOW choice" — the resolution has to be implementable.
-
----
-
-### Issue 2 (blocker): AC-13 / Req 6 coverage gap — second "Use featured image" toggle site in `cover-placeholder.js`
-
-**What's wrong:** AC-13 / Req 6 require the "Use featured image" toggle to be hidden in **every surface where it appears** when a binding is active. The design (§5.5) explicitly enumerates only `block-controls.js` as the toggle's render site: "The `<MediaReplaceFlow>` (`onToggleFeaturedImage` + `useFeaturedImage` props at `block-controls.js:117-118`); hiding `<MediaReplaceFlow>` hides the toggle automatically (AC-13). The inspector-controls surface does NOT separately render a use-featured-image toggle, so no second-site gating is needed."
-
-This misses `packages/block-library/src/cover/edit/cover-placeholder.js`, which renders a `<MediaPlaceholder ... onToggleFeaturedImage={ toggleUseFeaturedImage }>` (lines 20, 37). This placeholder is invoked from the empty-cover branch in `index.js:599-635` (the `! useFeaturedImage && ! hasInnerBlocks && ! hasBackground` branch). A Cover that has bindings but a not-yet-resolved URL (e.g. the network is slow, or the user just inserted a synced-pattern instance with the binding active) can land in that empty branch and expose the "Use featured image" affordance — which AC-13 forbids. The same flow also exposes a media-upload affordance via `<MediaPlaceholder onSelect={ onSelectMedia }>`, conflicting with AC-14 (media-replace hidden under active binding).
-
-The §2.2 files-touched table DOES list `cover-placeholder.js` as a touched file ("New 'internal media required' Placeholder copy gated by `bindingUnresolvable`"), but the §5.5 text contradicts this by claiming no second-site gating is needed. The two halves of the doc disagree.
-
-**Where in design doc:** §2.2 (files touched table, last line for `cover-placeholder.js`) versus §5.4 (the Placeholder rendered inside `index.js`'s render tree) versus §5.5 ("no second-site gating is needed").
-
-**Suggestion:**
-- Decide explicitly: does `bindingUnresolvable` route through `cover-placeholder.js` (modifying it to render a different message + suppress the upload/featured-image affordances when bound) OR through a sibling Placeholder in `index.js` (in which case `cover-placeholder.js` does not need touching but the empty-cover branch must early-return on `bindingActive || bindingUnresolvable`).
-- Add the explicit gating for the empty-cover branch (`index.js:599`): "When `bindingActive || bindingUnresolvable`, the empty-cover branch MUST NOT render the standard `<CoverPlaceholder>` exposing the featured-image / media-upload affordances; it MUST render the 'internal media required' Placeholder instead OR (when `bindingActive` resolves later) defer until `effectiveUrl` arrives." Either path is fine — the design has to pick one and document it.
-
-**Why it matters:** AC-13 explicitly says "every surface where it appears". Without addressing `cover-placeholder.js`, the e2e test (AC-23) on a freshly-inserted bound Cover that has not yet resolved its URL will fail. DC-2 is also at indirect risk: the `cover-placeholder.js` upload path calls `onSelectMedia` which mutates `url`/`id`/`useFeaturedImage` on the cover — a user-initiated mutation, so DC-2 is technically satisfied, but the spec's intent (Req 7, AC-14) is to *prevent the affordance entirely* under active binding.
-
----
-
-### Issue 3 (blocker): AC-18 — "$instance->attributes['useFeaturedImage'] = false" does not undo `render_callback`'s first-pass featured-image injection on Core 6.9+
-
-**What's wrong:** The design (§6.1, comment block "(C) Suppress the useFeaturedImage injection…") asserts that mutating `$instance->attributes['useFeaturedImage'] = false` at priority 9 prevents double image insertion. The accompanying comment is careful: "Setting useFeaturedImage=false here applies only to the gutenberg_block_bindings_render_block re-render at priority 10".
-
-On **Core 6.9+**, this leaves the AC-18 contract unmet for the first render pass:
-
-1. `WP_Block::render()` (verified at `wp-includes/class-wp-block.php:531-535`) calls `$this->process_block_bindings()` and merges resolved bindings into `$this->attributes` BEFORE invoking the `render_callback` (line 596).
-2. Core 6.9+ exposes `core/cover` as a binding-supported block once our `block_bindings_supported_attributes` filter adds `id`/`url`. So Core's own `process_block_bindings` resolves the bound url/id and merges them into `$instance->attributes` — including any post-resolution `useFeaturedImage` (which is unchanged from saved).
-3. `render_block_core_cover` runs with `useFeaturedImage: true` (the saved value) AND the bound url already substituted. If `backgroundType === 'image'` and `useFeaturedImage === true`, it injects a featured-image `<img>` (lines 137–197 of `packages/block-library/src/cover/index.php`) AFTER the existing `wp-block-cover__inner-container`. `$content` now has TWO `wp-block-cover__image-background` elements: the saved cover image AND the injected featured image.
-4. Priority-9 filter runs on this `$content`. `gutenberg_cover_bindings_rewrite_image` rewrites the FIRST matching element — but which one is "first" depends on saved-markup ordering vs. injection position, and even if rewritten, the SECOND injected element remains. Double-image violation per AC-18.
-
-The design's mitigation (mutate `$instance->attributes['useFeaturedImage'] = false`) takes effect only for the **second** render pass (the priority-10 generic filter that calls `$instance->render()` again), not the first one — and the first pass is the one that produced the `$content` we're filtering.
-
-**Where in design doc:** §6.1 Part 2, comment block "(C) Suppress the useFeaturedImage injection in render_block_core_cover". Also §12 ("`useFeaturedImage` precedence rule" bullet) repeats the same claim.
-
-**Suggestion:** Choose explicitly between:
-- (a) **Pre-resolve and strip approach** — In the priority-9 filter, after detecting `bindingActive` and resolving the bound url, additionally search `$content` for ALL elements matching `class_name => 'wp-block-cover__image-background'`. If more than one is found, remove all but the first AND set the survivor's src to the bound url. Document this as the AC-18 path.
-- (b) **Intercept earlier** — Hook `render_block_data` (which runs before `render_callback`) to mutate the parsed-block's attributes (`useFeaturedImage = false` and seed the bound url into `attrs['url']`) so `render_callback` skips the featured-image injection entirely. This requires careful interaction with Core's `process_block_bindings`.
-- (c) **Acknowledge the gap** — Document explicitly that on Core 6.9+ the design relies on `render_callback`'s early-return path being hit when `useFeaturedImage` is false (the typical case), and that the rare `useFeaturedImage: true + bindingActive` case is handled by a content-level strip of the duplicate `wp-block-cover__image-background` after `render_callback`. Tie this back to the §6.5 PHPUnit case #7.
-
-**Why it matters:** AC-18 is one of the spec's enumerated server-side correctness contracts. The current design says it's handled but the mechanism doesn't actually handle the first-pass injection. This is the kind of detail PR review will catch immediately.
-
----
-
-### Issue 4 (major): Internal inconsistency between §5.4 (Placeholder rendered in `index.js`) and §2.2 / §5.5 (placeholder copy in `cover-placeholder.js`)
-
-**What's wrong:** §2.2 files-touched table says `cover-placeholder.js` is touched to add "New 'internal media required' Placeholder copy gated by `bindingUnresolvable`". §5.4 render-tree changes show the `<Placeholder data-testid="cover-binding-unresolvable">` rendered inline in `CoverEdit`'s render tree, alongside the existing image-rendering branch — not inside `<CoverPlaceholder>`. §5.5 then asserts no second-site gating is needed (which would be inconsistent with editing `cover-placeholder.js`). Two implementers reading this design will disagree on whether the new Placeholder lives in `index.js` or `cover-placeholder.js`, and whether `cover-placeholder.js` gets gated on `bindingActive`.
-
-**Where in design doc:** §2.2 (`cover-placeholder.js` row), §5.4 (Placeholder inline in `index.js`), §5.5 (no second-site gating).
-
-**Suggestion:** Pick one location for the unresolvable-affordance Placeholder. Recommended: render the new Placeholder inline in `index.js` (matching §5.4), AND additionally gate `cover-placeholder.js`'s `<MediaPlaceholder>` so that when `bindingActive` or `bindingUnresolvable` is true the empty-cover branch (`index.js:599`) either renders the unresolvable Placeholder or suppresses the upload/featured-image affordances. Update §2.2 to reflect whatever is decided. Remove the §5.5 "no second-site gating is needed" claim if cover-placeholder.js is gated.
-
-**Why it matters:** Ambiguity between two physical render sites is the canonical "two implementers, two different results" failure that the design phase exists to prevent.
-
----
-
-### Issue 5 (major): Test-observable signal for AC-24 is not yet a stable contract
-
-**What's wrong:** OQ-6 introduces `data-testid="cover-binding-unresolvable"` and the i18n string `__( 'Internal media required for this binding.' )` as the test-observable signal. The design says "adding it to the requirements vocabulary" — but neither the spec nor the design enforce that this `data-testid` is preserved across implementations / translations / future refactors. A reviewer who removes the `data-testid` because "test-only props in production DOM smell bad" can silently break the e2e test (AC-24).
-
-Additionally, the spec's Req 16 wording is "a stable, test-observable signal — a known i18n message string (or equivalent stable identifier) accessible to the e2e test." The design picks BOTH `data-testid` AND the i18n string. The e2e test should pick one as primary; the spec preference is the i18n string. Using `data-testid` as the primary contract for the e2e test introduces a non-i18n coupling that may not survive Core upstreaming.
-
-**Where in design doc:** §3 OQ-6, §5.4 sketch, §11.3 e2e test outline.
-
-**Suggestion:**
-- Name the i18n message string as the **primary** test-observable contract (per spec Req 16: "a known i18n message string"). Use `getByText( __( '…' ) )` or equivalent locator in the e2e test.
-- Keep `data-testid` as a **secondary** stability hook with a comment explaining that it exists specifically to survive translation regressions during e2e. Document this in the design as "primary: i18n string match; fallback: `data-testid`".
-- Or commit to `data-testid` only and document why the spec's i18n-string contract is being downgraded — but be explicit about it.
-
-**Why it matters:** Without a primary/secondary ordering, the next refactor will pick whichever feels right and break the other — exactly the silent-regression hazard the spec wanted to preclude.
-
----
-
-### Issue 6 (major): "Embed video from URL" affordance is silently disabled as a side effect of hiding `<MediaReplaceFlow>`
-
-**What's wrong:** `block-controls.js:122-133` renders a `<MenuItem icon={link}>Embed video from URL</MenuItem>` as a **child** of `<MediaReplaceFlow>`. The design (§5.5) says to wrap the entire `<MediaReplaceFlow>` in `! bindingActive && ...`. This silently removes the "Embed video from URL" affordance from any Cover that has an active binding — including embed-video Covers with bindings (which the spec / AC-21 explicitly preserves as a working scenario for non-binding-affecting behavior, just without binding substitution).
-
-Per AC-21: "Binding the `url`/`id` of an embed-video Cover has no observable runtime effect under this PR" — but the spec does NOT say the editor UI for changing the embed video URL must be hidden. The design's wrapping decision hides that affordance as a side effect that the spec does not require.
-
-**Where in design doc:** §5.5 (the `<MediaReplaceFlow>` wrapping rule).
-
-**Suggestion:** Either:
-- (a) Restructure the gating to wrap only the parts of `<MediaReplaceFlow>` that surface the replace + featured-image controls, leaving the embed-video `<MenuItem>` accessible. Likely needs a separate toolbar `<ToolbarButton>` for the embed-URL flow when `bindingActive`.
-- (b) Acknowledge in the design that "Embed video from URL" is also hidden under active binding, and trace this to a spec requirement. If no spec requirement covers it, this is feature scope creep beyond what the spec requires.
-
-**Why it matters:** The spec is explicit about WHAT is hidden under active binding (parallax / repeat / media-replace / use-featured-image). Hiding other affordances by accident is a scope creep / scope contradiction that PR review will flag.
-
----
-
-### Issue 7 (minor): `useEffectEvent` semantics for the observer — async race-token guard placement
-
-**What's wrong:** §5.2 sketch:
-```js
-const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => {
-    if ( ! resolvedUrl ) return;
-    const raceToken = ++raceTokenRef.current;
-    const avg = await getMediaColor( resolvedUrl );
-    if ( raceToken !== raceTokenRef.current ) return; // stale
-    ...
-} );
-useEffect( () => {
-    onUrlResolved( effectiveUrl );
-}, [ effectiveUrl, onUrlResolved ] );
-```
-
-`useEffectEvent` is documented as a way to read latest values WITHOUT being reactive. Including `onUrlResolved` in the dep-array is correct per React docs (it's stable across renders), but the design doesn't explain *why* the race-token guard is placed in the body of `useEffectEvent` rather than as a cleanup of `useEffect`. React's recommendation for stale-async guarding inside an effect is a cleanup function setting an `isCancelled` flag — the race-token-via-ref pattern works but is non-idiomatic and easy to get wrong.
-
-Also: the design says `raceTokenRef` is a Ref but doesn't show where it's declared. Implementers will need to add `const raceTokenRef = useRef( 0 );` somewhere; the design should sketch this.
-
-**Where in design doc:** §5.2.
-
-**Suggestion:** Either:
-- (a) Switch to a `useEffect` cleanup-flag pattern: `let cancelled = false; ... if (cancelled) return; ... return () => { cancelled = true; };`. Simpler, no extra ref. The trade-off with `useEffectEvent` is that the cleanup needs to capture the effect's variables, which still works.
-- (b) Keep the race-token-ref pattern but document the `useRef` declaration explicitly and explain why the ref-based guard was preferred (e.g. "to share the guard across multiple `useEffectEvent` invocations triggered by independent dependency-array changes").
-
-**Why it matters:** Req 13's contract ("MUST be resilient against concurrent async `getMediaColor` resolutions") is enforced here. An implementer who copies the sketch verbatim without declaring `raceTokenRef` will get a runtime error; an implementer who switches to the cleanup-flag pattern (because they think it's cleaner) will diverge from the design.
-
----
-
-### Issue 8 (minor): Sanity-check on `bindingResolvedId` is missing alongside other `useSelect` reads — potential excessive re-renders
-
-**What's wrong:** §5.1 step 4: "Sanity-check `bindingResolvedId` against the media library via `select( coreStore ).getEntityRecord( 'postType', 'attachment', bindingResolvedId, { context: 'view' } )`". This is a network-blocking record fetch on every re-render where `bindingResolvedId` changes. The existing cover code (`inspector-controls.js:142-153`) does the same thing for `id`, but bounded by `id && isImageBackground` — i.e. only when the user explicitly has an image background. The new check fires on every Cover with bindings, even when the binding isn't being interactively edited.
-
-For Pattern Overrides with many bound Covers on a single page, this multiplies the entity record fetches. Acceptable for v1 but the design doesn't acknowledge the cost or propose a deduping strategy (e.g. memo'd by id, or `select` predicate `( select ) => id ? select(coreStore).getEntityRecord(...) : null`).
-
-**Where in design doc:** §5.1 step 4.
-
-**Suggestion:** Add a memoization note: "`bindingResolvedId` is read inside the same `useSelect` as the source's `getValues` call, with dependencies `[ bindingResolvedId, clientId ]`. Avoid a separate `useSelect` for each lookup." Or explicitly call out that the cost is bounded by `bindingActive && bindingResolvedId !== undefined`.
-
-**Why it matters:** Performance hazards that surface only with many bound blocks on a page will be hard to debug after merge. The design phase is the right place to flag them.
-
----
-
-### Issue 9 (minor): Missing trace for AC-26 / AC-27 / AC-28 (PR-shape ACs)
-
-**What's wrong:** AC-26 (file path `lib/compat/wordpress-7.1/block-bindings.php`), AC-27 (PR description content), AC-28 (~500 line budget) — the design covers AC-26 via §6.1 and §2.2, but AC-27 and AC-28 are not mentioned anywhere in the design doc. AC-27 is arguably a PR-creation step rather than a design concern, but AC-28's ~500-line budget IS a design constraint — it shapes how much new code is acceptable.
-
-**Where in design doc:** Missing trace section for ACs 26–28.
-
-**Suggestion:** Add a short paragraph in §12 or §14 acknowledging the ~500-line budget (AC-28) and stating the design's expected diff size. The design as outlined (~150 lines in the new PHP file, modest JS hook additions, a few JSX gating changes, the test additions) plausibly fits, but spelling this out keeps the design honest.
-
-**Why it matters:** A spec AC with no trace in the design is a coverage gap by definition. The PR-shape ACs are testable post-hoc but should be acknowledged.
-
----
-
-### Issue 10 (minor): `gutenberg_cover_bindings_expand` referenced but not defined
-
-**What's wrong:** §6.1 Part 2 calls `gutenberg_cover_bindings_expand( $bindings )` to handle `__default` expansion server-side, but no definition is given. The design says elsewhere (§9) that the server uses `gutenberg_process_block_bindings` for expansion. The introduction of a separately-named helper without a definition leaves implementers to guess: is it a new helper, or just an internal reference to `gutenberg_process_block_bindings`'s inline expansion logic (which is private)?
-
-**Where in design doc:** §6.1 Part 2 (the `if ( empty( $expanded['id'] ) || empty( $expanded['url'] ) ) ...` block).
-
-**Suggestion:** Either define `gutenberg_cover_bindings_expand` inline (likely a copy of the `__default` expansion logic from `lib/compat/wordpress-6.9/block-bindings.php:257-281`, scoped to `[ 'id', 'url' ]`), or replace the call with the call to `gutenberg_process_block_bindings` (which already does the expansion as a side effect) — but then the design must clarify how the priority-9 filter detects the expanded bindings WITHOUT calling `gutenberg_process_block_bindings` twice (once for the bindingActive check, once for value resolution).
-
-**Why it matters:** A pseudocode reference to a function that doesn't exist is a hidden dependency. The design doc's job is to surface these.
-
----
-
-### Issue 11 (minor): Backport-changelog entry conditional language is too loose
-
-**What's wrong:** §2.2 last row says "`backport-changelog/7.1/<core-pr>.md` — One-line entry when Core PR exists". The spec's Req 36 / AC-26 mandate the backport-changelog file when the Core PR exists. The design's wording (`<core-pr>` is a placeholder) doesn't commit to a path or to *when* the file is created — at PR-open time? After Core PR opens? The design phase is too early to know the Core PR number, but the design should commit to creating the file as a deferred follow-up.
-
-**Where in design doc:** §2.2 last row.
-
-**Suggestion:** Reword to: "Created when the corresponding Core PR is filed; tracked as a PR comment or follow-up task. Not a blocker for the Gutenberg PR landing." Or: "Created at the same time as the Core PR; the Gutenberg PR description includes the placeholder and is updated once the Core PR number is known."
-
-**Why it matters:** Minor, but the design should not contain unresolved placeholders.
-
----
-
-## Coverage summary
-
-| AC                 | Traced in design                                                | Adequately addressed                                            |
-| ------------------ | --------------------------------------------------------------- | --------------------------------------------------------------- |
-| AC-1               | §8                                                              | Yes                                                             |
-| AC-2               | §5.6, §9                                                        | Yes                                                             |
-| AC-3               | §5.4, §6.5(1)                                                   | Yes                                                             |
-| AC-4               | §5.4, §10, OQ-6                                                 | Partial — Issue 4, Issue 5                                      |
-| AC-5               | §6.4                                                            | Yes                                                             |
-| AC-6               | §6.4, §10                                                       | Yes                                                             |
-| AC-7..AC-10        | §5.6, §9, OQ-2                                                  | Yes                                                             |
-| AC-11..AC-12       | §5.5                                                            | Yes                                                             |
-| AC-13              | §5.5                                                            | **No — Issue 2 (cover-placeholder.js gap)**                     |
-| AC-14              | §5.5                                                            | Partial — Issue 2 (cover-placeholder.js upload affordance), Issue 6 (embed-video MenuItem side effect) |
-| AC-15..AC-17       | §5.2, §5.4, §6.3, OQ-4                                          | Yes                                                             |
-| AC-18              | §6.1(C), §12                                                    | **No — Issue 3 (first-pass injection not undone)**              |
-| AC-19              | §6.2, OQ-3                                                      | **No — Issue 1 (mechanism uses non-existent API)**              |
-| AC-20              | §12                                                             | Yes                                                             |
-| AC-21              | §6.1, Risk 4                                                    | Yes (but see Issue 6)                                           |
-| AC-22..AC-24       | §11.3                                                           | Partial — depends on Issues 2 & 5                               |
-| AC-25              | §6.5                                                            | Yes                                                             |
-| AC-26              | §2.2, §6.1                                                      | Yes                                                             |
-| AC-27              | (not traced)                                                    | **No — Issue 9 (missing trace)**                                |
-| AC-28              | (not traced)                                                    | **No — Issue 9 (missing trace)**                                |
-
-## Open Questions resolution check
-
-| OQ    | Choice                          | Rationale + rejected alternatives traced | Verdict                                  |
-| ----- | ------------------------------- | ----------------------------------------- | ---------------------------------------- |
-| OQ-1  | Approach A                      | Yes, with trade-off table in §13          | OK                                       |
-| OQ-2  | Disable                         | Yes                                       | OK                                       |
-| OQ-3  | Mechanism (i)                   | Yes — but mechanism uses non-existent API | **Fail — Issue 1**                       |
-| OQ-4  | 50                              | Yes                                       | OK                                       |
-| OQ-5  | Render-time force-off           | Yes                                       | OK                                       |
-| OQ-6  | data-testid + i18n string       | Partial — primary/secondary not ordered   | **Partial — Issue 5**                    |
-
-## Risks mitigation check
-
-| Risk                                          | Mitigation                                                           | Adequate                                  |
-| --------------------------------------------- | -------------------------------------------------------------------- | ----------------------------------------- |
-| 1. Ockham single-observer                     | §5.2 single useEffect on `effectiveUrl`, useEffectEvent              | Yes (modulo Issue 7 race-token clarity)   |
-| 2. Pattern Overrides reset                    | §5.6 reuse withPatternOverrideControls + ResetOverridesControl       | Yes                                       |
-| 3. dimRatio: 100 default                      | §5.2/§5.4 effectiveDimRatio + §6.3 server class strip                | Yes                                       |
-| 4. Embed-video collision                      | §6.1 short-circuit at both ends                                      | Yes (modulo Issue 6 unintended UI hide)   |
-| 5. HTML API can't edit CSS-in-`style`         | §6.2 element-replace via byte-offset splice                          | **No — Issue 1 (API doesn't exist)**      |
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-2-rejected.md b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-2-rejected.md
deleted file mode 100644
index 39e27add6cd463..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-2-rejected.md
+++ /dev/null
@@ -1,191 +0,0 @@
-# Design Doc Review
-
-## Verdict: rejected
-
-## Summary
-
-Iter-2 resolves every one of the eleven iter-1 findings explicitly: the non-existent Tag-Processor byte-offset accessors are replaced by `preg_match` + `substr` splice (iter-1 Issue 1); the empty-cover branch is gated in `index.js` so `cover-placeholder.js` no longer needs editing, and the line-750 `<CoverPlaceholder>` is correctly carried by `disableMediaButtons` (iter-1 Issues 2 + 4); the first-pass `useFeaturedImage` injection is intercepted via a `render_block_data` filter that mutates `$parsed_block['attrs']['useFeaturedImage']` BEFORE `WP_Block::__construct`, and the propagation has been verified against `wp-includes/class-wp-block.php:127-236, 520-596` and `wp-includes/blocks.php:2398-2436` (iter-1 Issue 3); the i18n string is named the primary test-observable contract with `data-testid` as a secondary stability hook (iter-1 Issue 5); `<MediaReplaceFlow>` is kept in the DOM with embed-video access preserved (iter-1 Issue 6); the race-token ref is now declared explicitly at component top with rationale (iter-1 Issue 7); the `useSelect` is now a single-closure read of source + attachment record (iter-1 Issue 8); AC-26/27/28 are explicitly traced in §12 (iter-1 Issue 9); the renamed `gutenberg_cover_bindings_is_active` is defined alongside its expansion logic (iter-1 Issue 10); the backport-changelog timing is settled (iter-1 Issue 11).
-
-However, iter-2 introduces a **blocker defect** in the gating mechanism for `<MediaReplaceFlow>`. The design's central claim — that setting `onSelect=undefined` removes the upload / "Open Media Library" menu items — does not match the actual `<MediaReplaceFlow>` source. Those menu items render unconditionally; only the `onSelect` callback path is undefined, which would crash at runtime if a user clicks them. This breaks AC-14 (the e2e test as designed will fail because the menu items remain in the DOM) and turns the design's centerpiece UI-gating mechanism into a runtime crash hazard. Three smaller defects compound this. Detailed below.
-
-## Issues
-
-### Issue 1 (blocker): `<MediaReplaceFlow>` `onSelect=undefined` does NOT remove "Open Media Library" / "Upload" menu items
-
-**What's wrong:** §5.5 asserts that setting `onSelect={ bindingActive ? undefined : onSelectMedia }` removes the media-replace menu items from the dropdown:
-
-> "`MediaReplaceFlow` (verified at `packages/block-editor/src/components/media-replace-flow/`) renders the 'Use featured image' toggle ONLY when `onToggleFeaturedImage` is a function; setting it to `undefined` removes that menu item from the dropdown. **Same for `onSelect` (the upload + media-library buttons short-circuit when `onSelect` is falsy)**."
-
-Verified against `packages/block-editor/src/components/media-replace-flow/index.js`:
-
-- Line 233 — "Use featured image" `<MenuItem>` IS gated on `onToggleFeaturedImage &&`. ✓ Design correct here.
-- Line 245 — "Reset" `<MenuItem>` IS gated on `mediaURL && onReset &&`. ✓ Design correct here.
-- Lines 193–212 — `<MediaUploadCheck>` wraps `<MediaUpload>` (rendering the "Open Media Library" `<MenuItem>`) and `<FormFileUpload>` (rendering the "Upload" `<MenuItem>`). **Neither is gated on `onSelect`.** They render unconditionally. ✗ Design wrong here.
-
-The runtime consequence: setting `onSelect={ undefined }` does not remove the "Open Media Library" / "Upload" menu items. Worse, the internal `selectMedia` helper (line 109–118) is called from `<MediaUpload onSelect>` (line 200) and from `uploadFiles` (line 131); `selectMedia` calls `onSelect( media )` at line 115. With `onSelect=undefined`, clicking "Open Media Library" or "Upload" throws `TypeError: onSelect is not a function`.
-
-**Where in design doc:** §5.5 (the block-controls.js gating sketch and the verification claim under it), §11.3 (the e2e test outline asserts "<MediaReplaceFlow> upload/replace MenuItems are not visible"), §13 ("AC-14 mitigation" trade-off).
-
-**Suggestion:** Pick one:
-- (a) Replace the `<MediaReplaceFlow>` with a different toolbar control on bound covers: a thin `<ToolbarGroup>` that surfaces only the "Embed video from URL" `<MenuItem>` (since AC-21 requires that affordance be preserved). When `bindingActive`, render the alternate control; when `! bindingActive`, render the existing `<MediaReplaceFlow>`. This is straightforward — extract the embed `<MenuItem>` into its own toolbar surface for the bound case.
-- (b) Modify `<MediaReplaceFlow>` itself to gate `<MediaUploadCheck>`'s subtree on `onSelect && ...`. This is an upstream change to a shared component; requires owner sign-off; risks affecting other consumers.
-- (c) Accept the runtime hazard, suppress the menu items via CSS, and document the limitation. This is worse than (a) and (b); not recommended.
-
-Recommendation: (a). The design already acknowledges in Risk #5 of §15 that AC-14 is a "literal-DOM-absence vs functional-absence" stretch — but the chosen mechanism does not even achieve functional absence for the media-library/upload paths, only for the "Use featured image" and "Reset" affordances.
-
-**Why it matters:** AC-14 is one of the spec's control-hiding contracts and is explicitly tested by AC-23. The design's mechanism for it is incorrect; the e2e test as outlined will fail (`await expect( mediaLibraryMenuItem ).not.toBeVisible()` will time out because the menu item is still in the DOM). This is exactly the kind of defect PR review will catch, and the design phase is where it should be resolved.
-
----
-
-### Issue 2 (major): `getBlockBindingsSource` is on the `@wordpress/blocks` store, not `blockEditorStore`
-
-**What's wrong:** §5.1 step 3 sketches the `useSelect`:
-
-```js
-const source = unlock( select( blockEditorStore ) ).getBlockBindingsSource( expanded.url.source );
-```
-
-`getBlockBindingsSource` is NOT a selector on `blockEditorStore`. Verified at `packages/blocks/src/store/private-selectors.ts:252-257` — it is a private selector on the `@wordpress/blocks` store. It is also a direct module export at `packages/blocks/src/api/registration.ts:903`. The block-editor store does not expose `getBlockBindingsSource`.
-
-Concrete evidence of intended usage in trunk: `packages/block-editor/src/components/block-bindings/source-fields-list.js:9` imports `getBlockBindingsSource` directly from `@wordpress/blocks` (not via `select`). `packages/block-editor/src/components/block-edit/edit.js:120-155` reads a `registeredSources` map gathered earlier from the same `@wordpress/blocks` module, not through `select`.
-
-An implementer who copies §5.1 step 3 verbatim will get `undefined` back from the selector call and the hook will silently treat every binding as unresolvable.
-
-**Where in design doc:** §5.1 step 3, the `useSelect` body.
-
-**Suggestion:** Either:
-- (a) Import `getBlockBindingsSource` from `@wordpress/blocks` and call it directly inside the `useSelect` body. It does not need a `select` parameter because it is a registry lookup, not state-dependent.
-- (b) Read it via `select( blocksStore )` — but then the design must name `blocksStore` explicitly (`@wordpress/blocks`'s store reference) instead of `blockEditorStore`.
-
-Either is fine. Option (a) is what the existing trunk callers do.
-
-**Why it matters:** §5.1 is the canonical code shape implementers will copy. A wrong store reference produces a silently-broken hook (no error, just `bindingActive=false` everywhere) — exactly the kind of regression the design phase exists to prevent.
-
----
-
-### Issue 3 (minor): `gutenberg_cover_bindings_is_active` PHP helper description omits the `args` equality check
-
-**What's wrong:** Spec Glossary "Active binding" requires `id` and `url` bindings "point to the same source instance (same `source` string AND, where applicable, same `args`)". §5.1 step 2's JS `bindingActive` correctly includes `JSON.stringify(expanded.id.args ?? null) === JSON.stringify(expanded.url.args ?? null)`.
-
-§6.1's description of the PHP companion `gutenberg_cover_bindings_is_active( $attrs )` says only: "applies `__default` expansion (via inline logic copied from `lib/compat/wordpress-6.9/block-bindings.php:257-281`, scoped to `[ 'id', 'url' ]`), checks both bindings exist and resolve to the same source instance, and returns a bool".
-
-The phrase "same source instance" is ambiguous — does it include `args` equality? §6.1 should mirror §5.1 step 2 explicitly: same `source` string AND same `args`. Otherwise client and server can disagree about `bindingActive` semantics for an explicit per-attribute bindings shape with matching sources but different `args`.
-
-**Where in design doc:** §6.1 (definition of `gutenberg_cover_bindings_is_active`), §9 step 2 (claims "Client and server agree on expansion by construction").
-
-**Suggestion:** Add one sentence to §6.1 immediately after the `gutenberg_cover_bindings_is_active` paragraph: "Source-instance equality is checked as `$expanded['id']['source'] === $expanded['url']['source'] && ( $expanded['id']['args'] ?? null ) == ( $expanded['url']['args'] ?? null )`, mirroring §5.1 step 2's client-side check."
-
-**Why it matters:** Spec Req 26 says mismatched-source bindings (including different `args` against the same source) MUST be treated as unresolvable. If the PHP helper checks only `source` string equality, an explicit `{ id: { source: X, args: A }, url: { source: X, args: B } }` shape would pass server-side but fail client-side, producing inconsistent render output.
-
----
-
-### Issue 4 (minor): `gutenberg_cover_bindings_strip_image` — form-1 (plain `<img>`) pattern not given
-
-**What's wrong:** §6.4 describes the stripper as "use the same `preg_match` + `substr`-splice approach (form-2 pattern, plus a form-1 pattern for plain `<img>`) to **remove** any element with class `wp-block-cover__image-background` from `$content`". §6.2 gives the form-2 (`<div>...</div>`) pattern explicitly: `/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U`. The form-1 (self-closing or void `<img>`) pattern is not given.
-
-An `<img>` saved-form is `<img class="wp-block-cover__image-background ..." ... />` (single self-closing tag, no closing `</img>`). The form-2 regex won't match it. The design should either:
-- give the form-1 pattern explicitly (something like `/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?>/`); OR
-- delegate to `WP_HTML_Tag_Processor` for the plain-`<img>` form (which can locate the tag via `next_tag( ['tag_name'=>'IMG', 'class_name'=>'wp-block-cover__image-background'] )`, but Tag Processor cannot DELETE a tag — only mutate attributes/classes — so this requires additional thought).
-
-**Where in design doc:** §6.4.
-
-**Suggestion:** Spell out the form-1 pattern explicitly OR pick a different mechanism for the plain-`<img>` strip. Option: for the plain-`<img>` case, use `WP_HTML_Tag_Processor` to find the tag's byte position via a different probe (e.g., write a sentinel class via `add_class`, regex-locate the sentinel, splice). Or accept the regex approach for both forms and give both patterns explicitly.
-
-**Why it matters:** AC-5 / AC-6 / Req 20 require the server to emit no `<img>` for unresolvable cases. If the form-1 stripper is missing, an unresolvable binding on a plain-`<img>` saved Cover will leave the broken-src `<img>` in the output.
-
----
-
-### Issue 5 (minor): `<CoverPlaceholder disableMediaButtons>` at line 750 keeps a drop-zone affordance that may conflict with AC-14 intent
-
-**What's wrong:** §5.5 says "the line-750 site is reached on bound covers but uses `disableMediaButtons`, which removes both the upload and the featured-image affordance from `<MediaPlaceholder>`". Verified at `packages/block-editor/src/components/media-placeholder/index.js:551-552`: `if ( disableMediaButtons ) { return <MediaUploadCheck>{ renderDropZone() }</MediaUploadCheck>; }`. The drop zone IS still rendered — it just doesn't render the buttons.
-
-If a user drags an image file onto a bound Cover that has an existing background (`hasBackground === true`, so the line-750 placeholder is reached), the drop-zone callback (which is wired to `onFilesPreUpload` in `cover-placeholder.js:22-26` calling `onSelectMedia({ url: ... })`) would still attempt to replace the media. This is a *user-initiated* mutation (the user dropped a file) so DC-2 is technically satisfied, but the spec's intent (Req 7, AC-14) is "media-replace control NOT in the DOM" / "direct media replacement from inside the Cover is not offered when bound".
-
-A drop zone IS an alternative form of "media-replace control" even if it has no visible button. The design should either:
-- explicitly acknowledge that drop-zone replacement is preserved on bound covers as an out-of-AC-14 user-initiated path; OR
-- gate the line-750 `<CoverPlaceholder>` with `bindingActive ? null : ...` (a one-line addition) so no `<MediaPlaceholder>` is rendered at all on bound covers.
-
-**Where in design doc:** §5.5 ("`disableMediaButtons` ... removes both the upload and the featured-image affordance ... Therefore no additional gating is required at that site.")
-
-**Suggestion:** Add to §5.5: either (a) gate the line-750 `<CoverPlaceholder>` on `! bindingActive`, returning `null` (or omitting the element) for bound covers; or (b) explicitly document the drop-zone-as-user-initiated-mutation carve-out and trace it to Req 7's "control" wording vs spec intent.
-
-**Why it matters:** AC-14 / Req 7 are the spec's media-replace-suppression contracts. A drop-zone alternative path that still mutates the cover's `url`/`id` on bound covers is at minimum a documentation gap; at most a real AC-14 violation depending on how reviewers read "control".
-
----
-
-## Coverage summary
-
-| AC                 | Traced in design                                                | Adequately addressed                                            |
-| ------------------ | --------------------------------------------------------------- | --------------------------------------------------------------- |
-| AC-1               | §8                                                              | Yes                                                             |
-| AC-2               | §5.6, §9                                                        | Yes                                                             |
-| AC-3               | §5.4, §6.5(1)                                                   | Yes                                                             |
-| AC-4               | §5.4, §10, OQ-6                                                 | Yes                                                             |
-| AC-5               | §6.4                                                            | Partial — Issue 4 (form-1 strip pattern missing)                |
-| AC-6               | §6.4, §10                                                       | Partial — Issue 4 (form-1 strip pattern missing)                |
-| AC-7..AC-10        | §5.6, §9, OQ-2                                                  | Yes                                                             |
-| AC-11..AC-12       | §5.5                                                            | Yes                                                             |
-| AC-13              | §5.5                                                            | Yes (uses `onToggleFeaturedImage=undefined`, verified)          |
-| AC-14              | §5.5, §11.3                                                     | **No — Issue 1 (onSelect=undefined doesn't remove menu items)** + Issue 5 (drop zone still present) |
-| AC-15..AC-17       | §5.2, §5.4, §6.3, OQ-4                                          | Yes                                                             |
-| AC-18              | §6.1 Part 2, §12                                                | Yes (verified: `render_block_data` mutation propagates via `$parsed_block['attrs']` lazy init in WP_Block::__get) |
-| AC-19              | §6.2, OQ-3                                                      | Yes                                                             |
-| AC-20              | §12                                                             | Yes                                                             |
-| AC-21              | §6.1, Risk 4                                                    | Yes                                                             |
-| AC-22..AC-24       | §11.3                                                           | Partial — depends on Issue 1                                    |
-| AC-25              | §6.5                                                            | Yes                                                             |
-| AC-26              | §2.2, §6.1                                                      | Yes                                                             |
-| AC-27              | §12                                                             | Yes                                                             |
-| AC-28              | §12                                                             | Yes                                                             |
-
-## Iter-1 finding resolution check
-
-| Iter-1 Issue | Status | Notes |
-| ---- | ---- | ---- |
-| 1 — non-existent Tag-Processor methods | Resolved | Replaced with `preg_match` + `substr` splice (§3 OQ-3); explicit acknowledgement of the iter-1 finding. |
-| 2 — `cover-placeholder.js` second toggle site | Resolved | Empty-cover branch gated in `index.js` (§5.4 (1)); line-750 `<CoverPlaceholder>` uses `disableMediaButtons` (§5.5). See Issue 5 for a residual drop-zone nuance. |
-| 3 — AC-18 first-pass injection | Resolved | `render_block_data` filter mutates `$parsed_block['attrs']['useFeaturedImage']` BEFORE `WP_Block::__construct` (§6.1 Part 2). Verified against `wp-includes/blocks.php:2398-2436` and `wp-includes/class-wp-block.php:127-236, 520-596`. |
-| 4 — §2.2 / §5.5 contradiction | Resolved | §2.2 explicitly says "`cover-placeholder.js` is NOT touched"; §5.4 and §5.5 agree. |
-| 5 — test signal primary/secondary | Resolved | §3 OQ-6 names i18n string primary, `data-testid` secondary; §11.3 e2e uses `getByText`. |
-| 6 — embed-video MenuItem hidden | Resolved | `<MediaReplaceFlow>` remains rendered; embed `<MenuItem>` preserved (§5.5). |
-| 7 — race-token guard placement | Resolved | `raceTokenRef` declared explicitly at component top with rationale (§5.2, §13). |
-| 8 — useSelect re-renders | Resolved | Single-closure `useSelect` reads source + attachment record together (§5.1 step 3). See Issue 2 for the wrong-store nuance. |
-| 9 — AC-26/27/28 traces missing | Resolved | §12 has explicit bullets for each. |
-| 10 — `gutenberg_cover_bindings_expand` undefined | Resolved | Renamed `gutenberg_cover_bindings_is_active`; definition described in §6.1. See Issue 3 for residual ambiguity. |
-| 11 — backport-changelog wording | Resolved | §2.2 last row explicit. |
-
-## Open Questions resolution check
-
-| OQ    | Choice                          | Rationale + rejected alternatives traced | Verdict                                  |
-| ----- | ------------------------------- | ----------------------------------------- | ---------------------------------------- |
-| OQ-1  | Approach A                      | Yes, with trade-off table in §13          | OK                                       |
-| OQ-2  | Disable                         | Yes                                       | OK                                       |
-| OQ-3  | `preg_match` + `substr` splice  | Yes; rejected alternatives spelled out    | OK                                       |
-| OQ-4  | 50                              | Yes                                       | OK                                       |
-| OQ-5  | Render-time force-off           | Yes                                       | OK                                       |
-| OQ-6  | i18n string primary             | Yes; `data-testid` secondary              | OK                                       |
-
-## Risks mitigation check
-
-| Risk                                          | Mitigation                                                           | Adequate                                  |
-| --------------------------------------------- | -------------------------------------------------------------------- | ----------------------------------------- |
-| 1. Ockham single-observer                     | §5.2 single useEffect on `effectiveUrl`, useEffectEvent              | Yes                                       |
-| 2. Pattern Overrides reset                    | §5.6 reuse withPatternOverrideControls + ResetOverridesControl       | Yes                                       |
-| 3. dimRatio: 100 default                      | §5.2/§5.4 effectiveDimRatio + §6.3 server class strip                | Yes                                       |
-| 4. Embed-video collision                      | §6.1 short-circuit at both ends                                      | Yes                                       |
-| 5. HTML API can't edit CSS-in-`style`         | §6.2 element-replace via `preg_match` + `substr`                     | Yes                                       |
-
-## Verification notes (for the orchestrator)
-
-For transparency, the following load-bearing claims in iter-2 were verified against actual source code in this review pass:
-
-- **`render_block_data` signature and timing** — `wp-includes/blocks.php:2398` fires `apply_filters( 'render_block_data', $parsed_block, $source_block, $parent_block )`; `new WP_Block( $parsed_block, ... )` at line 2436 reads from the mutated `$parsed_block`. Inner-block path at `wp-includes/class-wp-block.php:561` reassigns `$inner_block->parsed_block`. Lazy `$this->attributes` init at `class-wp-block.php:223-236` reads from `$this->parsed_block['attrs']` — confirms the mutation propagates. ✓
-- **`WP_HTML_Tag_Processor` public methods** — `next_tag` (line 887), `class_list` (1181), `has_class` (1240), `get_attribute` (2772), `set_attribute` (4310), `add_class` (4539), `remove_class` (4581), `get_updated_html` (4637) all confirmed public in `wp-includes/html-api/class-wp-html-tag-processor.php`. ✓
-- **`useEffectEvent` export** — Exported from `packages/element/src/react.ts:218` and re-exported via `packages/element/src/index.ts:2`. ✓
-- **`<MediaReplaceFlow>` gating** — `packages/block-editor/src/components/media-replace-flow/index.js`: `onToggleFeaturedImage` gates "Use featured image" `<MenuItem>` (line 233); `mediaURL && onReset` gates "Reset" `<MenuItem>` (line 245); `<MediaUpload>` + `<FormFileUpload>` for "Open Media Library" + "Upload" are NOT gated on `onSelect` (lines 193–232). ✗ Design's claim is wrong — see Issue 1.
-- **`<MediaPlaceholder disableMediaButtons>` behaviour** — `packages/block-editor/src/components/media-placeholder/index.js:551-552` confirms `disableMediaButtons` returns the drop-zone-only renderPath. The drop zone IS still rendered. See Issue 5.
-- **`getBlockBindingsSource` location** — Direct export at `packages/blocks/src/api/registration.ts:903`; private selector on the `@wordpress/blocks` store at `packages/blocks/src/store/private-selectors.ts:252-257`. NOT on the block-editor store. ✗ Design's `select( blockEditorStore ).getBlockBindingsSource(...)` is incorrect — see Issue 2.
-- **`replacePatternOverridesDefaultBinding` signature** — `packages/block-editor/src/utils/block-bindings.js:27-46`. ✓ Matches design's usage.
-- **`gutenberg_block_bindings_render_block` priority 10** — `lib/compat/wordpress-6.9/block-bindings.php:108`. ✓ Design's priority-9 placement is consistent.
-- **6.9 compat `__default` expansion** — `lib/compat/wordpress-6.9/block-bindings.php:257-281`. ✓ Matches the reference cited in design §6.1 and §9.
-- **`render_block_core_cover` early-return on `useFeaturedImage=false`** — `packages/block-library/src/cover/index.php:133` confirms `if ( 'image' !== $attributes['backgroundType'] || false === $attributes['useFeaturedImage'] ) { return $content; }`. ✓ AC-18 mechanism is sound.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-approved.md
deleted file mode 100644
index 149ccfd31d9ef2..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc-review-approved.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# Design Doc Review
-
-## Verdict: approved
-
-## Summary
-
-Iter-3 resolves every iter-2 finding cleanly and introduces no new blockers. The design is now implementation-ready: every spec AC traces to a concrete mechanism, all load-bearing code references are verified against trunk, and the previously-flagged runtime hazards (`<MediaReplaceFlow>` `onSelect=undefined` crash, wrong-store `getBlockBindingsSource` lookup, missing form-1 strip pattern, drop-zone leak at line-750, ambiguous `args` equality in the PHP helper) are each addressed with explicit code shapes and trade-off discussion. The trade-off tables in §13 (server approach, AC-18 mitigation, AC-14 gating, line-750 drop-zone) give implementers and reviewers a clear paper trail for each non-obvious choice. The single remaining tension — losing the "Embed video from URL" menu item on bound non-embed-video covers — is consciously accepted, traced to the spec's Out-of-Scope "Embed-video × bindings interaction" bullet, and confirmed not to violate AC-21 (since `bindingActive=false` on embed-video covers per §5.1 step 2 preserves the affordance on the population AC-21 protects).
-
-## Iter-2 finding resolution check
-
-| Iter-2 Issue | Status | Notes |
-| --- | --- | --- |
-| 1 (blocker) — `<MediaReplaceFlow>` `onSelect=undefined` crash | Resolved | §5.5 now conditionally renders the entire `<MediaReplaceFlow>` element via `{ ! bindingActive && ( <MediaReplaceFlow …/> ) }`. AC-14 satisfied by literal DOM absence. Embed-URL menu item trade-off explicit (§5.5, §13 AC-14 gating table, §15 risk #5). |
-| 2 (major) — `getBlockBindingsSource` wrong store | Resolved | §5.1 step 3 now imports from `@wordpress/blocks` directly (`import { getBlockBindingsSource } from '@wordpress/blocks';`) with explicit code refs verified at `packages/blocks/src/api/registration.ts:903-907`. |
-| 3 (minor) — `args` equality check missing in PHP helper | Resolved | §6.1 spells out `$same_source && $same_args` with `==` loose-equality rationale (associative-array element-wise compare; key-order-agnostic). Mirrors §5.1 step 2 JS check. |
-| 4 (minor) — form-1 strip pattern missing | Resolved | §6.4 now defines both `$form2_pattern` (`<div>...</div>`) and `$form1_pattern` (`<img … />` with optional trailing slash) explicitly. `U` ungreedy modifier rationale documented. Word-boundary `\b...\b` anchors verified for class-name accuracy. |
-| 5 (minor) — line-750 `<CoverPlaceholder>` drop zone | Resolved | §5.4 (1) and §5.5 now gate the line-750 site with `{ ! bindingActive && (<CoverPlaceholder …/>) }`. Trade-off table at §13 covers the three options (gate at call site, pass `disableDropZone`, accept). `cover-placeholder.js` source remains untouched (§2.2 invariant). |
-
-## Coverage summary
-
-| AC | Traced in design | Adequately addressed |
-| --- | --- | --- |
-| AC-1 | §8 | Yes |
-| AC-2 | §5.6, §9 | Yes |
-| AC-3 | §5.4, §6.5(1) | Yes |
-| AC-4 | §5.4, §10, OQ-6 | Yes |
-| AC-5 | §6.4 (both form patterns) | Yes |
-| AC-6 | §6.4, §10 | Yes |
-| AC-7..AC-10 | §5.6, §9, OQ-2 | Yes |
-| AC-11..AC-12 | §5.5 | Yes |
-| AC-13 | §5.5 (removed alongside `<MediaReplaceFlow>`) | Yes |
-| AC-14 | §5.5 (literal DOM absence via conditional render) + §5.4 line-750 gate | Yes |
-| AC-15..AC-17 | §5.2, §5.4, §6.3, OQ-4 | Yes |
-| AC-18 | §6.1 Part 2, §12 | Yes (`render_block_data` mutation propagates pre-`WP_Block::__construct`) |
-| AC-19 | §6.2, OQ-3 | Yes |
-| AC-20 | §12 | Yes |
-| AC-21 | §6.1, Risk 4 | Yes (embed-video forces `bindingActive=false`) |
-| AC-22..AC-24 | §11.3 | Yes |
-| AC-25 | §6.5 | Yes |
-| AC-26 | §2.2, §6.1 | Yes |
-| AC-27 | §12 | Yes |
-| AC-28 | §12 (~533 lines, just over SHOULD budget) | Yes |
-
-## Open Questions resolution check
-
-| OQ | Choice | Verdict |
-| --- | --- | --- |
-| OQ-1 | Approach A (Cover-scoped filters) | OK — trade-off table at §13 |
-| OQ-2 | Disable reset button | OK |
-| OQ-3 | `preg_match` + `substr` splice mechanism (i) | OK — rejected alternatives spelled out |
-| OQ-4 | dimRatio 50 (symmetric with `onSelectMedia` downshift) | OK |
-| OQ-5 | Render-time force-off for parallax/repeat | OK |
-| OQ-6 | i18n string primary, `data-testid` secondary | OK |
-
-## Risks mitigation check
-
-| Risk | Mitigation | Adequate |
-| --- | --- | --- |
-| 1. Ockham single-observer | §5.2 single `useEffect` on `effectiveUrl` + `useEffectEvent` + race-token ref | Yes |
-| 2. Pattern Overrides reset semantics | §5.6 reuse `withPatternOverrideControls` + `ResetOverridesControl` | Yes |
-| 3. `dimRatio: 100` default opacity | §5.2/§5.4 `effectiveDimRatio` + §6.3 server class strip | Yes |
-| 4. Embed-video collision | §6.1 short-circuit at both ends | Yes |
-| 5. HTML API can't edit CSS-in-`style` | §6.2 element-replace via `preg_match` + `substr` | Yes |
-
-## Verification notes (for the orchestrator)
-
-The iter-3-specific changes were verified against trunk during this review pass:
-
-- **`getBlockBindingsSource` direct module export** — `packages/blocks/src/api/registration.ts:903-907` confirms the module-level export that internally calls `unlock( select( blocksStore ) ).getBlockBindingsSource( name )`. Matches §5.1 step 3's `import { getBlockBindingsSource } from '@wordpress/blocks';` claim.
-- **`<MediaPlaceholder disableDropZone>` short-circuit** — `packages/block-editor/src/components/media-placeholder/index.js:378-381`: `renderDropZone` early-returns `null` when `disableDropZone` is truthy. Confirms §5.5's `disableDropZone` alternative is a viable approach, though the call-site gate is the simpler one-line change.
-- **`<MediaReplaceFlow>` internal `onSelect` invariants** — `packages/block-editor/src/components/media-replace-flow/index.js:115` (`onSelect( media )` in `selectMedia`) and line 124 (`onSelect( files )` in `uploadFiles`). Both unconditional. Confirms iter-2 Issue 1 finding and motivates the iter-3 conditional-render fix.
-- **`render_block_data` filter location** — `wp-includes/blocks.php:2398` confirms the filter fires before `new WP_Block( $parsed_block, ... )` at line 2436. Mutation propagates as designed.
-- **`replacePatternOverridesDefaultBinding` shape** — `packages/block-editor/src/utils/block-bindings.js:27` confirms the helper exists and matches the signature used in §5.1 step 1.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md b/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
deleted file mode 100644
index e774c0fea5eba3..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/2-design-doc/design-doc.md
+++ /dev/null
@@ -1,967 +0,0 @@
-# Design Doc: Cover block bindings — internal-only `id` and `url`
-
-Spec: `<artifacts>/1-spec/spec.md` (approved). All AC, DC, Req references resolve to that file.
-
-## 1. Overview
-
-`core/cover` ships Block Bindings support for `id` and `url` restricted to internal media-library attachments, headlined by Pattern Overrides. When a binding is active (post-`__default`-expansion: `id` AND `url` bound to the same source instance), the Edit component (a) hides parallax, repeat, media-replace and use-featured-image controls in *every* render surface (toolbar, inspector, AND the empty-cover placeholder), (b) reactively derives `overlayColor`, `effectiveDimRatio`, `effectiveUrl` from the resolved `url` through a **single observer** wired via `useEffectEvent`, and (c) never mutates stored attributes on binding state transitions. The server (a single Cover-scoped file in `lib/compat/wordpress-7.1/block-bindings.php`) uses an early `render_block_data` filter to neutralise `useFeaturedImage` before `render_callback` runs, then a `render_block` priority-9 filter to substitute the bound URL into the cover's `<img>` (via pure `preg_match` byte-splice for the parallax/repeat case, `WP_HTML_Tag_Processor::set_attribute` for the plain-`<img>` case) and to remove `has-background-dim-100` from the overlay span when the stored ratio is the default. Embed-video covers short-circuit both client and server binding paths.
-
-## 2. Architecture
-
-### 2.1 ASCII data flow
-
-```
-                            ┌─────────────────────────────────────────────────┐
-                            │  metadata.bindings (with __default expansion)   │
-                            └───────────────┬─────────────────────────────────┘
-                                            │
-                            ┌───────────────┴────────────────┐
-                            │                                │
-                            ▼                                ▼
-       ┌───────────────────────────────────┐   ┌──────────────────────────────────┐
-       │ CLIENT  (packages/block-library/  │   │ SERVER (PHP)                     │
-       │         src/cover/edit/index.js)  │   │                                  │
-       ├───────────────────────────────────┤   ├──────────────────────────────────┤
-       │ useCoverBindingState() hook (NEW) │   │ render_block_data (priority 10)  │
-       │   - expandedBindings              │   │   gutenberg_cover_bindings_      │
-       │   - bindingActive  (id+url, same  │   │     prepare_block( $parsed,      │
-       │       source instance)            │   │       $source, $parent )         │
-       │   - bindingResolvedUrl/Id (from   │   │     ↑ runs BEFORE render_call-   │
-       │       source.getValues via        │   │       back, mutates $parsed_     │
-       │       useSelect)                  │   │       block['attrs'] to set      │
-       │   - bindingUnresolvable  (id      │   │       useFeaturedImage=false     │
-       │       missing / mismatch / not    │   │       when bindingActive         │
-       │       attachment / external)      │   │                                  │
-       │                                   │   │ render_block (priority 9)        │
-       │ Effective values (derived, no     │   │   gutenberg_cover_bindings_      │
-       │   setAttributes):                 │   │     render_block( $content,      │
-       │   - effectiveUrl = bindingResolvedUrl │       $block, $instance )         │
-       │       ?? (useFeaturedImage?       │   │     ↑ runs BEFORE                │
-       │             mediaUrl : originalUrl) │       gutenberg_block_bindings_  │
-       │   - effectiveDimRatio = (bindingActive│       render_block (priority 10) │
-       │       && dimRatio===100 &&             │                                  │
-       │       effectiveUrl) ? 50 : dimRatio    │   if bindingActive &&            │
-       │   - lockUrlControls = bindingActive   │      backgroundType !=='embed-   │
-       │       && !canUserEditValue            │      video':                     │
-       │                                   │   │     1. resolve url/id from       │
-       │ Single observer (useEffect on     │   │        gutenberg_process_block_  │
-       │   effectiveUrl):                  │   │        bindings()                │
-       │   - getMediaColor(effectiveUrl)   │   │     2. if id missing/not in      │
-       │     ↳ setOverlayColor (if not     │   │        media library → strip     │
-       │        user-set)                  │   │        <img>/<div bg> entirely;  │
-       │   - propsRef guard + race-token   │   │        early return              │
-       │     to prevent stale overwrites   │   │     3. (A) rewrite img/div via   │
-       │                                   │   │            preg_replace_callback │
-       │ CoverInspectorControls / Block-   │   │            +Tag_Processor        │
-       │   Controls / CoverPlaceholder     │   │     4. (B) strip has-background- │
-       │   gated by bindingActive          │   │            dim-100 from overlay  │
-       └───────────────────────────────────┘   │            span                  │
-                                               └──────────────────────────────────┘
-```
-
-### 2.2 Files touched
-
-| File | Role | Change |
-| --- | --- | --- |
-| `packages/block-library/src/cover/block.json` | Attribute schema | Add `"role": "content"` to `id` (AC-1, AC-2 prerequisite) |
-| `lib/compat/wordpress-7.1/block-bindings.php` (NEW) | Server allow-list + Cover-scoped render filters | (a) `block_bindings_supported_attributes` filter adds `id`,`url` to `core/cover`; (b) `render_block_data` filter to neutralise `useFeaturedImage` before `render_callback`; (c) `gutenberg_cover_bindings_render_block` filter on `render_block` priority 9 |
-| `lib/load.php` | Bootstrap | `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';` in the REST-server block (alongside other 7.1 entries) |
-| `packages/block-library/src/cover/edit/index.js` | Reactive observer, derived values, render-tree gating | New `useCoverBindingState` hook, replace existing `useEffect([mediaUrl])` with a single observer on `effectiveUrl`, gate the empty-cover branch on `bindingActive \|\| bindingUnresolvable`, render the `<Placeholder>` for the unresolvable case inline, AND wrap the line-750 `<CoverPlaceholder>` call site in `! bindingActive && (…)` so the drop zone is not present on bound covers (§5.5 / Issue 5 of iter-2 review). |
-| `packages/block-library/src/cover/edit/inspector-controls.js` | UI gating | Gate parallax/repeat ToolsPanelItems on `! bindingActive` |
-| `packages/block-library/src/cover/edit/block-controls.js` | UI gating | Pass `bindingActive`. Render `<MediaReplaceFlow>` ONLY when `! bindingActive`. The "Embed video from URL" `<MenuItem>` is dropped from the bound-cover toolbar by construction; this is acceptable because (a) embed-video × bindings is explicitly out-of-scope per spec Out-of-Scope, (b) AC-21's "no regression on embed-video" only applies to covers where `backgroundType === 'embed-video'`, which (per §5.1 step 2) forces `bindingActive = false`, so the `<MediaReplaceFlow>` remains rendered there. See §5.5 for the full rationale and the verified gating mechanism. |
-| `phpunit/blocks/render-block-cover-test.php` | PHPUnit | New cases: bound-url → `<img src=$bound>`; default `dimRatio:100` + binding → `has-background-dim-50`; mismatched/unresolvable → no `<img>`; `useFeaturedImage:true + bindingActive` → exactly one `<img>` with bound URL |
-| `test/e2e/specs/editor/blocks/cover.spec.js` | E2E | New `describe('Block Bindings — Pattern Overrides')` block (AC-22..AC-24) |
-| `backport-changelog/7.1/<core-pr>.md` | Metadata | Created at the same time the Core PR is filed; Gutenberg PR description includes a `TODO: backport-changelog entry pending Core PR` note and is updated once the Core PR number is known. Not a blocker for the Gutenberg PR landing. |
-
-No other Cover files change. **`cover-placeholder.js` is NOT touched** — the gating happens at the call sites in `index.js` (see §5.4 / §5.5). No new `__experimental*` APIs are introduced. No `save.js`, `deprecated.js`, or block-list-renderer changes.
-
-## 3. Open Questions resolved
-
-### OQ-1: Server-side approach — Cover-scoped filter (chosen)
-
-**Choice: Approach A — Cover-scoped filters in `lib/compat/wordpress-7.1/block-bindings.php`.**
-
-Concretely: one `add_filter( 'render_block_data', ..., 10, 3 )` (Cover-only neutralisation of `useFeaturedImage` before `render_callback`) plus one `add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 )` that gates on `$block['blockName'] === 'core/cover'`.
-
-**Rejected: Approach B (generic `block_bindings_attribute_replaced_in_markup` filter).**
-
-Reasoning:
-- Approach B (PR #74610) only solves `<img src>` substitution. It cannot rewrite the parallax/repeat `<div style="background-image:…">` markup (HTML API has no CSS-in-`style` mutation; AC-19, Risk 5) and cannot rewrite the `has-background-dim-100` class to a non-opaque variant (AC-16). Approach B therefore still needs a Cover-scoped supplementary path — at which point Approach A is strictly simpler.
-- Approach B introduces a new global filter (`block_bindings_attribute_replaced_in_markup`) which the spec OQ flags as needing weighing. Approach A introduces zero new global APIs (Req 28, Out-of-Scope on global APIs).
-- Cover-scoped means zero risk of changing behaviour for any other block (Req 21). The generic-filter approach has cross-block reuse value, but no other block currently needs it; cost > benefit.
-- Approach A keeps the entire substitution surface in one file (the new 7.1 compat file). Easier to review, easier to delete when Core absorbs the change.
-
-**Traces to:** Req 21, Req 28, AC-16, AC-18, AC-19, Risk 5, Out-of-Scope item "New global Block Bindings APIs".
-
-### OQ-2: Reset affordance — disable (chosen)
-
-**Choice: keep existing `ResetOverridesControl` semantics: button is **disabled** (not removed from DOM) when the instance value matches the pattern default.**
-
-Reasoning:
-- Cover-specific code zero. Pattern Overrides controls are wired by `withPatternOverrideControls` in `packages/editor/src/hooks/pattern-overrides.js`; the toolbar `ResetOverridesControl` (`packages/patterns/src/components/reset-overrides-control.js`) already renders `disabled={ ! isOverridden }`.
-- Consistent with every other bindable block (paragraph, heading, image, button).
-- Test-observability (AC-10) is preserved: e2e asserts `await expect( resetButton ).toBeDisabled()` rather than absence-from-DOM.
-
-**Traces to:** AC-10, Req 24(d).
-
-### OQ-3: Saved-markup parallax/repeat rewrite mechanism — `preg_match` byte splice + `WP_HTML_Tag_Processor` (chosen)
-
-**Choice: Mechanism (i) — detect the parallax/repeat case in the new Cover render filter and replace the entire `<div class="wp-block-cover__image-background" style="background-image:url(…)">` fragment in `$content` with a rebuilt `<img>` HTML string, located via `preg_match( … , PREG_OFFSET_CAPTURE )` (the exact same pattern shape that `render_block_core_cover` already uses at `packages/block-library/src/cover/index.php:117-125, 193-197`).**
-
-**Why not the previously-cited byte-offset Tag-Processor helpers.** The prior design draft cited `WP_HTML_Tag_Processor::get_token_byte_offset_in_source_text()` and `get_full_token_length()` as public accessors. Verified at `/Users/carlos/.wp-env/cc4ba7b5738d99b49b19f399987f6e49/WordPress/wp-includes/html-api/class-wp-html-tag-processor.php` — neither method exists. The class's public surface (lines 836–4797) exposes `next_tag`, `set_attribute`, `add_class`, `remove_class`, `set_bookmark`, `seek`, `get_updated_html`, `has_class`, `class_list`, `get_attribute`, `get_token_name`, `get_token_type`, `is_tag_closer`, `has_self_closing_flag`, `get_modifiable_text`, `set_modifiable_text`, `paused_at_incomplete_token`, etc., but `$token_starts_at` (line 609) and `$token_length` (line 628) are declared `private`. Token positions are not exposed by the public API. `set_bookmark` / `seek` allow movement to a previously-visited tag but do not yield substring ranges either. Therefore byte-offset splicing through Tag-Processor private accessors is not a viable mechanism.
-
-**Why not pure `WP_HTML_Tag_Processor` mutation.** The Tag Processor cannot rewrite a `<div>` element into an `<img>` element (no `set_tag()` operation in its public API; verified). It also cannot edit a CSS value inside `style="background-image: url(…)"` (Risk 5). For the parallax/repeat saved form, neither of those is feasible.
-
-**Why not `DOMDocument` for the whole markup.** `DOMDocument::loadHTML` aggressively normalises HTML (wrapping in `<html>/<body>`, expanding void elements, decoding entities), risking observable byte-level diffs versus saved markup for unrelated content (AC-20 non-regression). Round-tripping through `saveHTML` is known-lossy for `class="..."` / `style="..."` attribute ordering and self-closing-slash form. Out of proportion for the small, surgical edit we need.
-
-**Why not "synthesise the full `<img>` from scratch and discard saved markup".** Re-implementing `save.js`'s output (classes including `wp-image-{id} size-{slug}`, `data-object-position`, alt, focal-point style) duplicates client logic. Risk of drift between client save and server output is real and would surface as classname diffs on subsequent re-edits (round-trip / AC-20 hazard).
-
-**Concrete shape — parallax/repeat saved form (mechanism (i)):**
-
-```php
-// Pattern mirrors the one already used at packages/block-library/src/cover/index.php:117-125
-// for the figure.wp-block-embed case.
-$div_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
-if ( 1 === preg_match( $div_pattern, $content, $matches, PREG_OFFSET_CAPTURE ) ) {
-    $div_start  = $matches[0][1];
-    $div_length = strlen( $matches[0][0] );
-    // Build the replacement <img>. wp-image-{id}, size-{slug}, alt, optional object-position
-    // come from the bound attachment metadata + the cover's saved $attrs.
-    $rebuilt_img = sprintf(
-        '<img class="wp-block-cover__image-background wp-image-%d%s" alt="%s" src="%s" data-object-fit="cover"%s />',
-        (int) $resolved_id,
-        $size_class_suffix,     // e.g. ' size-large' or ''
-        esc_attr( $alt ),
-        esc_url( $resolved_url ),
-        $object_position_attrs  // ' data-object-position="50% 50%" style="object-position:50% 50%;"' or ''
-    );
-    $content = substr( $content, 0, $div_start ) . $rebuilt_img . substr( $content, $div_start + $div_length );
-}
-```
-
-**Concrete shape — plain `<img>` saved form (no parallax/repeat at save time):**
-
-```php
-$processor = new WP_HTML_Tag_Processor( $content );
-if ( $processor->next_tag( array(
-    'tag_name'   => 'IMG',
-    'class_name' => 'wp-block-cover__image-background',
-) ) ) {
-    $processor->set_attribute( 'src', $resolved_url );
-    $processor->set_attribute( 'alt', $alt );
-    // Substitute wp-image-{old} → wp-image-{new}: scan classes and rewrite.
-    // class_list() iterates current classes; remove_class + add_class are public.
-    foreach ( $processor->class_list() as $cls ) {
-        if ( 0 === strpos( $cls, 'wp-image-' ) ) {
-            $processor->remove_class( $cls );
-        }
-    }
-    $processor->add_class( 'wp-image-' . (int) $resolved_id );
-    $content = $processor->get_updated_html();
-}
-```
-
-Both methods used (`set_attribute`, `class_list`, `remove_class`, `add_class`, `next_tag`, `get_updated_html`) are confirmed public methods in `WP_HTML_Tag_Processor` (lines 1181, 4310, 4539, 4581, 887, 4637 respectively of `wp-includes/html-api/class-wp-html-tag-processor.php`).
-
-**Traces to:** AC-19, Risk 5, OQ-3 spec text.
-
-### OQ-4: Non-opaque effective `dimRatio` — **50** (chosen)
-
-**Choice: 50.**
-
-Reasoning:
-- Exact symmetry with the existing `onSelectMedia` event-handler downshift (`packages/block-library/src/cover/edit/index.js`: `currentAttrs.url === undefined && currentAttrs.dimRatio === 100 ? 50 : ...`). Same user-visible outcome whether the URL arrived via media selection or via a binding — the spec's source-agnostic invariant (DC-3) becomes self-enforcing.
-- `dimRatioToClass( 50 ) === null` (see `packages/block-library/src/cover/shared.js`), so the overlay span emits `has-background-dim` without any `has-background-dim-N` modifier — i.e. the CSS default of 50% opacity. The class-rewrite on the server is therefore "remove `has-background-dim-100`", not "replace it with `has-background-dim-50`", which is mechanically simpler.
-
-**Traces to:** AC-15, AC-16, Req 14, Req 18.
-
-### OQ-5: Pre-existing `hasParallax=true` on a Cover that gains a binding — **render-time force-off** (chosen)
-
-**Choice: do not migrate the saved attribute. At render time (both client and server) treat `hasParallax` and `isRepeated` as effectively `false` whenever `bindingActive && backgroundType !== 'embed-video'`. The stored attributes are untouched. The UI hides the toggles so the user cannot newly set them.**
-
-Reasoning:
-- DC-2 / Req 11 prohibit attribute mutation from binding-state changes. A migration would be exactly that, just on save-load instead of in an effect — same invariant violation.
-- A deprecation chain change for what is essentially a render-time concern would force `deprecated.js` work and risks breaking saved unbound covers (AC-20 non-regression).
-- The render-time path already has to strip `has-parallax`/`is-repeated` classes by construction from the rebuilt `<img>` (see OQ-3); the editor preview's `<img>` element is rendered unconditionally once `effectiveUrl` resolves AND `bindingActive` (the existing `isImgElement = !(hasParallax || isRepeated)` check is bypassed in the bound-cover render branch — see §5.4). Force-off therefore comes free.
-
-**Traces to:** Req 11, DC-2, AC-19, AC-20.
-
-### OQ-6: Test-observable signal for the "internal media required" affordance
-
-**Choice: primary contract is the i18n message string `__( 'Internal media required for this binding.' )`. Secondary stability hook is `data-testid="cover-binding-unresolvable"`.**
-
-**E2E assertion uses the i18n string** (per spec Req 16: "a known i18n message string … accessible to the e2e test"):
-
-```js
-await expect(
-    page.getByText( 'Internal media required for this binding.' )
-).toBeVisible();
-```
-
-The `data-testid` attribute is added to the `<Placeholder>` element as a translation-resistant fallback hook. It is **secondary**: the e2e test does not assert on it. Code review may legitimately challenge `data-testid` on production DOM; if removed, AC-24 remains satisfied by the i18n-string locator. The design's intent (versus a hard "must remove `data-testid` if reviewer objects" position) is: keep `data-testid` for cross-locale stability but accept its removal during review if challenged — the i18n-string contract is the load-bearing one.
-
-**Traces to:** Req 16, AC-4, AC-24.
-
-## 4. Risks addressed
-
-### Risk 1 — Ockham architecture gate (preempt with single-observer design)
-
-Preempted by **§5 "Client-side design"**: every URL-derived piece of state (overlay color, effective dim ratio, effective URL, lock flags) flows from one `useEffect` keyed on `effectiveUrl`. There is no per-event `useEffect` for "binding detected" / "blur" / "media replaced". Existing event handlers (`onSelectMedia`, `toggleUseFeaturedImage`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`) keep their current side-effects on attributes (they mutate `url`, `id`, `dimRatio`, etc.) but no longer need to also compute overlay color — that is delegated to the observer. `useEffectEvent` reads `isUserOverlayColor`, latest `dimRatio`, and the current overlayColor without making them dep-array entries, eliminating stale-closure risk. The PR review checklist must tick **DC-1, DC-2, DC-3** explicitly per spec §"Design Constraints".
-
-### Risk 2 — Pattern Overrides reset semantics
-
-Preempted by **reusing the existing `withPatternOverrideControls` HOC and `ResetOverridesControl`** unchanged (OQ-2 chose disable-not-hide). Cover-side code adds zero Pattern-Overrides-specific logic. The four states (AC-7..AC-10) round-trip through the existing infrastructure once Cover is allow-listed by the server-side filter.
-
-### Risk 3 — Default `dimRatio: 100` opacity
-
-Preempted by **render-time `effectiveDimRatio = (bindingActive && dimRatio === 100 && effectiveUrl) ? 50 : dimRatio`** in the editor preview (passed through `dimRatioToClass`) AND by the server-side class rewrite (remove `has-background-dim-100` from the overlay span). The stored attribute remains 100 (DC-2, Req 11). When the user explicitly sets `dimRatio` to a non-default value, the conditional fails and the stored value is honoured (AC-17).
-
-### Risk 4 — Embed-video collision
-
-Preempted by an **explicit `backgroundType === 'embed-video'` short-circuit at both client and server**:
-- Client: `useCoverBindingState` returns `bindingActive: false` when `backgroundType === 'embed-video'`, regardless of `metadata.bindings`. Derivations short-circuit; the existing oEmbed path runs as today (AC-21).
-- Server: both the `render_block_data` filter and `gutenberg_cover_bindings_render_block` early-return when `! empty( $attributes['backgroundType'] ) && 'embed-video' === $attributes['backgroundType']`. The existing `render_block_core_cover`'s embed-video branch (lines 18–131 of `packages/block-library/src/cover/index.php`) runs unmodified.
-
-Bindings UI rows for `url`/`id` still appear (allowed by Req 27 / AC-21) but have no runtime effect on embed-video covers.
-
-### Risk 5 — HTML API can't edit CSS-in-`style`
-
-Preempted by **OQ-3 mechanism (i)**: never attempt to edit the CSS value inside `style="background-image: url(…)"`. Instead, locate the `<div class="wp-block-cover__image-background">` and **replace the entire element** with a rebuilt `<img>` via `preg_match` + `substr` splice — no CSS parsing involved, no Tag-Processor private accessors required.
-
-## 5. Client-side design
-
-### 5.1 New hook: `useCoverBindingState`
-
-Location: new file `packages/block-library/src/cover/edit/use-cover-binding-state.js`.
-
-Exported shape:
-
-```js
-/**
- * @typedef {Object} CoverBindingState
- * @property {boolean}            bindingActive          true iff (after __default expansion) `id` AND `url` are bound to the same source instance AND backgroundType !== 'embed-video'.
- * @property {boolean}            bindingUnresolvable    true iff metadata.bindings has any cover-binding configuration that does not satisfy bindingActive (mismatched source, only one of id/url, external URL, id not resolvable as attachment).
- * @property {string|undefined}   bindingResolvedUrl     URL resolved from the bound source via useSelect.
- * @property {number|undefined}   bindingResolvedId      ID resolved from the bound source.
- * @property {boolean}            canUserEditBindingValue Source.canUserEditValue() result; gates lockUrlControls.
- */
-export default function useCoverBindingState( { clientId, attributes, context } ) { … }
-```
-
-Implementation outline:
-1. Expand `attributes.metadata?.bindings` via `replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] )` from `packages/block-editor/src/utils/block-bindings.js`.
-2. `bindingActive = expanded?.id && expanded?.url && expanded.id.source === expanded.url.source && JSON.stringify(expanded.id.args ?? null) === JSON.stringify(expanded.url.args ?? null) && backgroundType !== 'embed-video'`.
-3. Resolve values via **a single `useSelect`** that reads both the bound URL and ID and the attachment record in one closure, deduplicating subscription work. `getBlockBindingsSource` is imported directly from `@wordpress/blocks` — it is a registry lookup (not a state-dependent selector) verified at `packages/blocks/src/api/registration.ts:903-907` as a module-level export that internally calls `select( blocksStore ).getBlockBindingsSource( name )`. The `@wordpress/blocks` store is the canonical home of the bindings-source registry (private selector at `packages/blocks/src/store/private-selectors.ts:252`); it is NOT on `blockEditorStore`. Existing trunk callers follow the same pattern (`packages/block-editor/src/components/block-bindings/source-fields-list.js:9`, `packages/block-editor/src/components/rich-text/index.js:23`).
-
-   ```js
-   import { getBlockBindingsSource } from '@wordpress/blocks';
-   // ... inside the hook body:
-   const { bindingResolvedUrl, bindingResolvedId, bindingResolvedAttachment } =
-       useSelect( ( select ) => {
-           if ( ! bindingActive ) {
-               return { bindingResolvedUrl: undefined, bindingResolvedId: undefined, bindingResolvedAttachment: undefined };
-           }
-           const source = getBlockBindingsSource( expanded.url.source );
-           if ( ! source ) {
-               return { bindingResolvedUrl: undefined, bindingResolvedId: undefined, bindingResolvedAttachment: undefined };
-           }
-           const values = source.getValues( {
-               select,
-               clientId,
-               context,
-               bindings: { id: expanded.id, url: expanded.url },
-           } );
-           const url = values?.url;
-           const id = values?.id;
-           const attachment = id
-               ? select( coreStore ).getEntityRecord( 'postType', 'attachment', id, { context: 'view' } )
-               : undefined;
-           return { bindingResolvedUrl: url, bindingResolvedId: id, bindingResolvedAttachment: attachment };
-       }, [ bindingActive, expanded?.id?.source, expanded?.url?.source, clientId ] );
-   ```
-
-   Notes on performance and correctness:
-   - **Single `useSelect`**: dedupes the subscription. Reading the attachment record in the same closure means the subscription re-fires only when *any* of the closure's reads change, not on every render.
-   - **`undefined` vs `null`**: `getEntityRecord` returns `undefined` while loading (resolution not yet started/resolved), `null` once resolved and not found. The hook treats `undefined` as pending (no unresolvable affordance yet) and `null` as definitively unresolvable. This matches `core/image`'s pattern.
-   - **Pattern Overrides scale**: for N bound Covers on the same post, each instance fires its own `useSelect`, but the `getEntityRecord` selector is memoised by `core-data` (same `( 'postType', 'attachment', id )` key dedupes across consumers). Acceptable for v1; if profiling later reveals churn, the hook can be promoted to a parent-context provider.
-
-4. `bindingUnresolvable = (hasAnyCoverBinding) && ! bindingActive` OR `bindingActive && bindingResolvedAttachment === null` (resolved-not-found) OR `bindingActive && bindingResolvedAttachment && bindingResolvedAttachment.type !== 'attachment'`.
-
-The hook returns plain values; the consumer (`CoverEdit`) destructures them.
-
-### 5.2 Single observer (in `CoverEdit`)
-
-Replaces the existing `useEffect( [ mediaUrl ] )` block in `packages/block-library/src/cover/edit/index.js`. Source-agnostic per DC-3:
-
-```js
-// Declared once at the top of the component body, before any useEffect.
-const raceTokenRef = useRef( 0 );
-
-// Derived: the URL the editor should display.
-const effectiveUrl =
-    bindingResolvedUrl ??
-    ( useFeaturedImage ? mediaUrl : originalUrl?.replaceAll( '&amp;', '&' ) );
-
-// Derived: effective dimRatio for preview-time class computation.
-const effectiveDimRatio =
-    bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio;
-
-// useEffectEvent reads latest non-tracked values without dep-array churn.
-const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => {
-    if ( ! resolvedUrl ) return;
-    const myToken = ++raceTokenRef.current;
-    const avg = await getMediaColor( resolvedUrl );
-    if ( myToken !== raceTokenRef.current ) return; // stale resolution; bail
-
-    const { attributes: latestAttrs, overlayColor: latestOverlay } = propsRef.current;
-    if ( ! latestAttrs.isUserOverlayColor ) {
-        __unstableMarkNextChangeAsNotPersistent();
-        setOverlayColor( avg );
-    }
-    const newIsDark = compositeIsDark(
-        latestAttrs.dimRatio === 100 && latestAttrs.url ? 50 : latestAttrs.dimRatio, // mirror effectiveDimRatio
-        latestAttrs.isUserOverlayColor ? latestOverlay.color : avg,
-        avg
-    );
-    __unstableMarkNextChangeAsNotPersistent();
-    setAttributes( { isDark: newIsDark } ); // isDark is NOT in the DC-2 prohibition list
-} );
-
-useEffect( () => {
-    onUrlResolved( effectiveUrl );
-}, [ effectiveUrl, onUrlResolved ] );
-```
-
-Key properties and design rationale:
-- **One** `useEffect`, keyed on `effectiveUrl`. The dependency array has stable references for everything else (DC-1).
-- `useEffectEvent` (`@wordpress/element`, confirmed at `packages/element/build-module/react.mjs`) reads latest `attributes`, `overlayColor` without dep-array churn.
-- **Race token via ref, NOT cleanup flag.** The `useEffectEvent` callback is invoked freshly on every dependency change, but `useEffectEvent`'s identity is stable across renders. A `useEffect` cleanup-flag pattern (`let cancelled = false; … return () => { cancelled = true; };`) would require co-locating the cleanup inside the `useEffect` body — but the async work lives inside `useEffectEvent` (so latest props/state are read). Hoisting the flag out of `useEffectEvent` defeats the latest-value guarantee. The ref-based race token is the simplest pattern that survives both async resolution ordering AND `useEffectEvent`'s "latest reads" contract. **The `raceTokenRef = useRef( 0 )` declaration is explicit (declared at component top, before observer);** implementers reading the sketch verbatim will not encounter an undeclared identifier.
-- `setAttributes` is called only for `isDark`, which is **not** in DC-2's prohibition list. The DC-2 list is `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, `customOverlayColor`.
-
-### 5.3 Existing event handlers — unchanged
-
-`onSelectMedia`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`, `toggleUseFeaturedImage`, `onSelectEmbedUrl` keep their current shapes. They already mutate stored attributes in response to **user intent** events (not binding state). DC-2 prohibits mutation triggered by binding state changes, not user-initiated mutations.
-
-There is one nuance: the existing observer has a side-effect on `isDark`/`isUserOverlayColor`. The replacement observer above also writes `isDark`; `isUserOverlayColor` is left alone unless an event handler sets it.
-
-### 5.4 Render-tree changes in `CoverEdit`
-
-Two structural changes to `packages/block-library/src/cover/edit/index.js`:
-
-**(1) Empty-cover branch (currently `if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground )` at index.js line 599):** add `bindingActive || bindingUnresolvable` to the predicate so the standard `<CoverPlaceholder>` (which exposes upload + featured-image toggle affordances) NEVER renders on a bound cover. Replace with a binding-aware placeholder branch:
-
-```jsx
-if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground ) {
-    if ( bindingActive || bindingUnresolvable ) {
-        return (
-            <>
-                { blockControls }
-                { inspectorControls }
-                { hasNonContentControls && isSelected && (
-                    <ResizableCoverPopover { ...resizableCoverProps } />
-                ) }
-                <TagName
-                    { ...blockProps }
-                    className={ clsx( 'is-placeholder', blockProps.className ) }
-                    style={ { ...blockProps.style, minHeight: minHeightWithUnit || undefined } }
-                >
-                    { resizeListener }
-                    { bindingUnresolvable ? (
-                        <Placeholder
-                            data-testid="cover-binding-unresolvable"
-                            className="wp-block-cover__binding-unresolvable"
-                            withIllustration
-                            instructions={ __( 'Internal media required for this binding.' ) }
-                        />
-                    ) : (
-                        /* bindingActive but pending resolution; render an empty placeholder
-                           with no affordances. The single observer will populate the cover
-                           once effectiveUrl arrives. */
-                        <Placeholder
-                            className="wp-block-cover__binding-pending"
-                            withIllustration
-                        />
-                    ) }
-                </TagName>
-            </>
-        );
-    }
-    /* Existing CoverPlaceholder branch (unbound case) — unchanged. */
-    return ( /* … existing return with <CoverPlaceholder> … */ );
-}
-```
-
-The standard `<CoverPlaceholder>` continues to render in the unbound empty-cover branch (this branch in §5.4 (1)) and (lower in the component, line 750) inside the `<TagName>`. **The line-750 `<CoverPlaceholder>` IS reached on bound covers when `hasBackground=true`**; verified at `packages/block-editor/src/components/media-placeholder/index.js:551-552`, `disableMediaButtons` short-circuits to `<MediaUploadCheck>{ renderDropZone() }</MediaUploadCheck>` — the upload / media-library / featured-image buttons are hidden, but the drop zone IS still rendered. The drop-zone's `onFilesDrop` is wired (line 385) to the parent's `onFilesUpload`, which in `cover-placeholder.js:22-26` calls `onSelectMedia({ url: createBlobURL(file) })` — mutating the cover's `url` attribute. To keep AC-14 / Req 7's intent ("direct media replacement from inside the Cover is not offered when bound") whole, the line-750 site is gated at its call site in `index.js`:
-
-```jsx
-{ ! bindingActive && (
-    <CoverPlaceholder
-        disableMediaButtons
-        onSelectMedia={ onSelectMedia }
-        onError={ onUploadError }
-        toggleUseFeaturedImage={ toggleUseFeaturedImage }
-    />
-) }
-```
-
-This is a one-line wrapper added immediately around the existing line-750 call site. On unbound covers (`bindingActive=false`), the behaviour is byte-identical to trunk (AC-20). On bound covers, the entire `<CoverPlaceholder>` — including its drop zone — is omitted from the render tree. `cover-placeholder.js` itself is NOT edited (§2.2 invariant preserved). See §13 trade-off table "Line-750 `<CoverPlaceholder>` drop-zone" for alternatives considered.
-
-**(2) Non-empty render branch (around `url && isImageBackground` at index.js line 672):**
-
-```jsx
-{ ! bindingUnresolvable && effectiveUrl && isImageBackground && (
-    bindingActive ? (
-        // Force-img form: bindings override parallax/repeat
-        <img
-            ref={ mediaElement }
-            className="wp-block-cover__image-background"
-            alt={ alt }
-            src={ effectiveUrl }
-            style={ mediaStyle }
-        />
-    ) : (
-        // unchanged existing branch (img-or-div based on isImgElement)
-        …
-    )
-) }
-```
-
-And the overlay span class computation uses `effectiveDimRatio` rather than `dimRatio`:
-
-```jsx
-<span
-    className={ clsx(
-        'wp-block-cover__background',
-        dimRatioToClass( effectiveDimRatio ),
-        { 'has-background-dim': effectiveDimRatio !== undefined, … }
-    ) }
-/>
-```
-
-### 5.5 Control gating
-
-**`inspector-controls.js`** — wrap the `<>` fragment containing the "Fixed background" and "Repeated background" `ToolsPanelItem`s in `! bindingActive && …`. Pass `bindingActive` as a new prop from `CoverEdit`.
-
-**`block-controls.js`** — the entire `<MediaReplaceFlow>` element is conditionally rendered. When `! bindingActive`, the current trunk shape is preserved verbatim (including the "Embed video from URL" `<MenuItem>` child). When `bindingActive`, the `<MediaReplaceFlow>` is omitted from the render output entirely; the `<BlockControls group="other">` group renders empty (or is itself elided), and no media-replace / upload / featured-image / embed-URL affordances exist on the bound-cover toolbar:
-
-```jsx
-<BlockControls group="other">
-    { ! bindingActive && (
-        <MediaReplaceFlow
-            mediaId={ id }
-            mediaURL={ url }
-            allowedTypes={ ALLOWED_MEDIA_TYPES }
-            onSelect={ onSelectMedia }
-            onToggleFeaturedImage={ toggleUseFeaturedImage }
-            useFeaturedImage={ useFeaturedImage }
-            name={ ! url ? __( 'Add media' ) : __( 'Replace' ) }
-            onReset={ onClearMedia }
-            variant="toolbar"
-        >
-            { ( { onClose } ) => (
-                <MenuItem
-                    icon={ link }
-                    onClick={ () => {
-                        setIsEmbedUrlInputOpen( true );
-                        onClose();
-                    } }
-                >
-                    { __( 'Embed video from URL' ) }
-                </MenuItem>
-            ) }
-        </MediaReplaceFlow>
-    ) }
-</BlockControls>
-```
-
-**Why conditional render and NOT prop-level gating.** Verified against `packages/block-editor/src/components/media-replace-flow/index.js`:
-- Line 233: the "Use featured image" `<MenuItem>` IS gated on `onToggleFeaturedImage &&` — prop-level `undefined` does remove it.
-- Line 245: the "Reset" `<MenuItem>` IS gated on `mediaURL && onReset &&` — prop-level `undefined` does remove it.
-- Lines 193–212: the `<MediaUpload>` ("Open Media Library") and `<FormFileUpload>` ("Upload") `<MenuItem>`s render unconditionally inside `<MediaUploadCheck>`. **Neither is gated on `onSelect`.** Setting `onSelect={ undefined }` does NOT remove them from the dropdown. Worse: line 115 calls `onSelect( media )` directly from the internal `selectMedia` helper, and line 124 calls `onSelect( files )` directly from `uploadFiles`. Setting `onSelect={ undefined }` would crash with `TypeError: onSelect is not a function` when a user clicks "Open Media Library" or "Upload". The prior-iteration prop-level gating approach was therefore a runtime hazard.
-
-Removing the entire `<MediaReplaceFlow>` is the only mechanism that achieves AC-14's literal-DOM-absence wording (the toolbar's media-replace dropdown is not present at all when `bindingActive`).
-
-**Why losing the "Embed video from URL" affordance on bound covers is acceptable.** AC-21 requires non-regression for covers with `backgroundType === 'embed-video'`. Per §5.1 step 2, embed-video covers force `bindingActive = false` (the guard `backgroundType !== 'embed-video'` is part of the active-binding predicate). So embed-video covers ALWAYS render the full `<MediaReplaceFlow>` including the embed-URL menu item — AC-21 is preserved. The only case that loses the embed-URL menu item is a bound non-embed-video cover, where the user has actively chosen to bind `id`+`url` to a media-library attachment; converting such a cover to embed-video is out-of-scope under "Embed-video × bindings interaction" in the spec's Out-of-Scope section, and the user can unbind first if needed. This trade-off is explicit and tied to the resolved Out-of-Scope item.
-
-**Verification of AC-14 surface coverage (post-fix).** AC-14 requires the media-replace control to be NOT in the DOM. Under the conditional render above, `<MediaReplaceFlow>` is completely absent from the bound-cover DOM. The e2e test (§11.3) asserts on the absence of the toolbar replace-button (the rendered `<ToolbarButton>` from `<MediaReplaceFlow>`'s `renderToggle` path at lines 180–189 of media-replace-flow/index.js) — a single locator. AC-13 (Use featured image) and AC-14 (media-replace) are both satisfied by the wrapper's absence; no need to reason about individual `<MenuItem>` gating any more.
-
-**`cover-placeholder.js` itself is not modified.** Its sole call sites are in `index.js` (lines 616 and 750). The line-616 site is now unreachable under `bindingActive || bindingUnresolvable` (replaced by the binding-aware placeholder branch in §5.4 (1)). The line-750 site is reached on bound covers (when `hasBackground === true`) but renders `<CoverPlaceholder disableMediaButtons … />`. Verified at `packages/block-editor/src/components/media-placeholder/index.js:551-552`: when `disableMediaButtons` is true, only the drop zone renders (no upload / media-library / featured-image buttons). The drop-zone IS still rendered, however, and its `onFilesDrop` is wired to `onFilesUpload` (line 385), which in `cover-placeholder.js:22-26` calls `onSelectMedia({ url: createBlobURL(file) })`. **A user dragging a file onto a bound cover would still mutate the cover's `url` attribute** through `onSelectMedia`. This is a *user-initiated* mutation (DC-2 only prohibits derivation-path mutation triggered by binding state changes), so DC-2 is technically satisfied; however, AC-14 / Req 7's *intent* is "direct media replacement from inside the Cover is not offered when bound", and a drop zone IS an alternative form of media-replace surface.
-
-To resolve this cleanly without editing `cover-placeholder.js`, the line-750 site is gated at its call site in `index.js`: render the `<CoverPlaceholder>` only when `! bindingActive`. `MediaPlaceholder`'s `disableDropZone` prop (verified at `packages/block-editor/src/components/media-placeholder/index.js:378-381`: `if ( disableDropZone ) { return null; }` short-circuits drop-zone rendering) is an alternative — but the call site is in `index.js`, and gating the whole `<CoverPlaceholder>` is the surgical one-line change. Concrete edit at index.js line 750:
-
-```jsx
-{ ! bindingActive && (
-    <CoverPlaceholder
-        disableMediaButtons
-        onSelectMedia={ onSelectMedia }
-        onError={ onUploadError }
-        toggleUseFeaturedImage={ toggleUseFeaturedImage }
-    />
-) }
-```
-
-`bindingActive=false` covers (the entire pre-bindings universe of Covers) keep the current `<CoverPlaceholder>` behaviour byte-for-byte. AC-13, AC-14, AC-20 (non-regression) all satisfied; Req 7's intent honoured; `cover-placeholder.js` source unchanged.
-
-**`<MediaReplaceFlow>` "Use featured image" toggle** is removed alongside the rest of `<MediaReplaceFlow>` by the conditional render above. AC-13 satisfied. **Inspector-controls.js does NOT separately render a use-featured-image toggle**, verified by inspection — there is no second inspector site.
-
-### 5.6 Pattern Overrides integration
-
-Zero Cover-specific code. `withPatternOverrideControls` in `packages/editor/src/hooks/pattern-overrides.js` reads `__experimentalBlockBindingsSupportedAttributes?.[ blockName ]`; once the server-side filter (§6.1) adds `core/cover` to that list, the `<PatternOverridesControls>` "Enable overrides" button and the `<ResetOverridesControl>` toolbar button appear automatically (AC-2, AC-7..AC-10).
-
-`replacePatternOverridesDefaultBinding` in `packages/block-editor/src/utils/block-bindings.js` is used directly inside `useCoverBindingState`. This is the **same** helper the Block Bindings panel uses and the **same** semantics the server's `gutenberg_process_block_bindings` expansion uses (`lib/compat/wordpress-6.9/block-bindings.php:257-281`). Client and server agree on expansion by construction.
-
-## 6. Server-side design
-
-### 6.1 File: `lib/compat/wordpress-7.1/block-bindings.php` (NEW)
-
-Loaded from `lib/load.php` alongside the other 7.1 compat entries:
-
-```php
-require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';
-```
-
-Wrapped in `! function_exists( … )` per the established 7.1 backport pattern.
-
-**Part 1 — allow-list filter:**
-
-```php
-if ( ! function_exists( 'gutenberg_cover_bindings_add_supported_attributes' ) ) {
-    function gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_type ) {
-        if ( 'core/cover' === $block_type ) {
-            foreach ( array( 'id', 'url' ) as $attr ) {
-                if ( ! in_array( $attr, $attributes, true ) ) {
-                    $attributes[] = $attr;
-                }
-            }
-        }
-        return $attributes;
-    }
-    add_filter( 'block_bindings_supported_attributes', 'gutenberg_cover_bindings_add_supported_attributes', 10, 2 );
-}
-```
-
-This filter feeds both `gutenberg_get_block_bindings_supported_attributes('core/cover')` (server-side resolution) and `__experimentalBlockBindingsSupportedAttributes['core/cover']` (editor setting via the existing `block_editor_settings_all` filter at `lib/compat/wordpress-6.9/block-bindings.php:33-46`). Single source of truth.
-
-**Part 2 — `render_block_data` filter (NEW — solves AC-18 first-pass injection):**
-
-This filter runs **before** `render_callback` (verified at `wp-includes/blocks.php:2398` — `render_block_data` fires as `$inner_block->parsed_block = apply_filters( 'render_block_data', $inner_block->parsed_block, $source_block, $parent_block )`; for top-level blocks the equivalent fires in `render_block()` itself). By mutating `$parsed_block['attrs']['useFeaturedImage'] = false` here when bindings are active, we prevent `render_block_core_cover` from injecting the featured-image `<img>` in its first pass.
-
-```php
-if ( ! function_exists( 'gutenberg_cover_bindings_prepare_block' ) ) {
-    function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $parent_block ) {
-        // Gate: Cover only.
-        if ( 'core/cover' !== ( $parsed_block['blockName'] ?? '' ) ) {
-            return $parsed_block;
-        }
-        $attrs = $parsed_block['attrs'] ?? array();
-        // Gate: never engage for embed-video covers (AC-21).
-        if ( ! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType'] ) {
-            return $parsed_block;
-        }
-        // Gate: must have bindings on id AND url after __default expansion.
-        if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
-            return $parsed_block;
-        }
-        // Neutralise useFeaturedImage so render_block_core_cover skips its
-        // featured-image branch entirely (Req 19, AC-18). DC-2 is preserved:
-        // this mutation is scoped to the in-flight $parsed_block array used by
-        // this single render pass; the persisted post_content is untouched.
-        if ( ! empty( $attrs['useFeaturedImage'] ) ) {
-            $parsed_block['attrs']['useFeaturedImage'] = false;
-        }
-        return $parsed_block;
-    }
-    add_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10, 3 );
-}
-```
-
-`gutenberg_cover_bindings_is_active( $attrs )` is a private helper defined in the same file. It applies `__default` expansion (via inline logic copied from `lib/compat/wordpress-6.9/block-bindings.php:257-281`, scoped to `[ 'id', 'url' ]`), then checks both bindings exist AND resolve to the same source instance via the following two-part equality, mirroring §5.1 step 2's client-side check:
-
-```php
-$same_source = ( $expanded['id']['source'] ?? null ) === ( $expanded['url']['source'] ?? null );
-$same_args   = ( $expanded['id']['args']   ?? null ) ==  ( $expanded['url']['args']   ?? null );
-// Note: `==` (loose) compares associative arrays element-wise irrespective of key order;
-// `===` would require identical key ordering. Loose comparison is the correct semantic
-// for source `args` (a small associative bag of scalars), and it matches the JS-side
-// JSON.stringify check (which is order-sensitive only on object literals — and source
-// args in practice come from the same builder for both `id` and `url` of a Cover, so
-// key order is identical in real shapes; loose-equality is the safe relaxation).
-return $same_source && $same_args && ! empty( $expanded['id'] ) && ! empty( $expanded['url'] );
-```
-
-The bool result is what gates Part 2's `useFeaturedImage` mutation and Part 3's URL substitution. **This replaces the previously-undefined `gutenberg_cover_bindings_expand` helper.** Spec Req 26 / Glossary "Active binding" explicitly require `args` equality where applicable; the explicit check here closes the client/server agreement gap.
-
-**Why `render_block_data` solves the AC-18 first-pass injection problem.** Verified at `/Users/carlos/.wp-env/cc4ba7b5738d99b49b19f399987f6e49/WordPress/wp-includes/class-wp-block.php:531-596`: `WP_Block::render()` calls `process_block_bindings()` (line 532), merges resolved bindings into `$this->attributes` (lines 534-536), and then calls `render_callback` (line 596). The `render_block_data` filter runs **before** `WP_Block::render()` is constructed (`render_block()` in `wp-includes/blocks.php:2398` applies it on the parsed block array). By that point, `$parsed_block['attrs']['useFeaturedImage']` has been forced to `false`, so:
-
-1. `WP_Block::__construct` builds `$this->attributes` from the (modified) `$parsed_block['attrs']`, with `useFeaturedImage = false`.
-2. `process_block_bindings` resolves `id`+`url` from the source and merges them into `$this->attributes`. `useFeaturedImage` is not in the bindings shape, so it remains `false`.
-3. `render_callback` (= `render_block_core_cover`) runs with `useFeaturedImage = false` AND the bound `url`. The featured-image branch (`packages/block-library/src/cover/index.php:133`: `if ( 'image' !== $attributes['backgroundType'] || false === $attributes['useFeaturedImage'] ) { return $content; }`) is skipped. No featured-image `<img>` is injected. `$content` contains only the saved-markup `<img>` / `<div bg>`, with the saved-`url` not yet substituted.
-4. The priority-9 `gutenberg_cover_bindings_render_block` filter (Part 3 below) runs on this `$content`, substitutes the bound URL into the saved `<img>` / rebuilt `<img>`, and rewrites the dim class.
-
-No double-`<img>`. AC-18 satisfied for both first-pass and any subsequent re-render (`gutenberg_block_bindings_render_block` at priority 10 calls `$instance->render()` again — `useFeaturedImage` is still false on `$instance->attributes`, so the second pass also skips the featured-image branch).
-
-**Part 3 — `render_block` filter (priority 9):**
-
-```php
-if ( ! function_exists( 'gutenberg_cover_bindings_render_block' ) ) {
-    function gutenberg_cover_bindings_render_block( $block_content, $block, $instance ) {
-        // Gate: Cover only.
-        if ( 'core/cover' !== ( $block['blockName'] ?? '' ) ) {
-            return $block_content;
-        }
-        $attrs = $instance->attributes ?? array();
-
-        // Gate: never engage for embed-video covers (AC-21).
-        if ( ! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType'] ) {
-            return $block_content;
-        }
-
-        // Gate: must have bindings on id AND url after __default expansion.
-        if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
-            return $block_content;
-        }
-
-        // Resolve via the standard bindings infrastructure. By this point,
-        // WP_Block::render() has already merged resolved bindings into
-        // $instance->attributes (verified at class-wp-block.php:531-536), so
-        // $attrs['url'] and $attrs['id'] are the bound values.
-        $resolved_url = $attrs['url'] ?? null;
-        $resolved_id  = $attrs['id']  ?? null;
-        if ( empty( $resolved_url ) || empty( $resolved_id ) ) {
-            return gutenberg_cover_bindings_strip_image( $block_content );
-        }
-        // Verify $resolved_id is an attachment in the media library.
-        $attachment = get_post( (int) $resolved_id );
-        if ( ! $attachment || 'attachment' !== $attachment->post_type ) {
-            return gutenberg_cover_bindings_strip_image( $block_content );
-        }
-
-        // (A) Substitute <img src> / rebuild <div bg> → <img> (OQ-3 mechanism (i)).
-        $block_content = gutenberg_cover_bindings_rewrite_image(
-            $block_content,
-            $resolved_url,
-            $resolved_id,
-            $attrs
-        );
-
-        // (B) Rewrite overlay span: remove has-background-dim-100 when dimRatio is the default 100.
-        if ( 100 === ( $attrs['dimRatio'] ?? 100 ) ) {
-            $block_content = gutenberg_cover_bindings_relax_dim_class( $block_content );
-        }
-
-        return $block_content;
-    }
-    add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 );
-}
-```
-
-**Filter priority 9** is essential: `gutenberg_block_bindings_render_block` (the generic bindings filter from `lib/compat/wordpress-6.9/block-bindings.php`) registers at priority 10. Running before it means our Cover-scoped substitution happens on the saved markup before the generic filter re-runs `$instance->render()` (which would re-execute `render_block_core_cover`, but at that point `useFeaturedImage` is already false thanks to Part 2 — so the second pass produces the same `$content` shape as the first, and our priority-9 substitution remains correct).
-
-**Notes on `gutenberg_process_block_bindings` double-call.** Core 6.9's `process_block_bindings` is called once inside `WP_Block::render()` (line 532). The generic filter's priority-10 re-render path calls `$instance->render()` again, which calls `process_block_bindings()` a second time. Functionally correct (resolution is idempotent); cost is bounded and acceptable for v1. Listed under §15 risks for future optimisation.
-
-### 6.2 Helper: `gutenberg_cover_bindings_rewrite_image`
-
-Per §3 OQ-3, two paths:
-
-1. **Plain `<img>` saved form** (`!hasParallax && !isRepeated` at save time): `WP_HTML_Tag_Processor::next_tag(['tag_name'=>'IMG','class_name'=>'wp-block-cover__image-background'])`, then `set_attribute( 'src', $resolved_url )` + `set_attribute( 'alt', $alt )` + `remove_class( 'wp-image-{old}' )` + `add_class( 'wp-image-{new}' )`. All four methods verified public.
-
-2. **`<div style="background-image:url(…)">` saved form** (parallax or repeat): use `preg_match` with `PREG_OFFSET_CAPTURE` on the pattern `/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U` (same shape as `packages/block-library/src/cover/index.php:117-125, 193-197`), compute byte range, splice in a rebuilt `<img>` HTML string. Drop `has-parallax`/`is-repeated` classes by construction (the rebuilt string never contains them). AC-19.
-
-The function probes form (2) first (`preg_match` succeeds when the saved-markup is the `<div>` form, regardless of presence of `hasParallax`/`isRepeated` in `$attrs` — saved markup is the source of truth, not the attributes); falls through to form (1) (plain `<img>`) otherwise.
-
-### 6.3 Helper: `gutenberg_cover_bindings_relax_dim_class`
-
-```php
-function gutenberg_cover_bindings_relax_dim_class( $content ) {
-    $processor = new WP_HTML_Tag_Processor( $content );
-    while ( $processor->next_tag( array( 'tag_name' => 'SPAN', 'class_name' => 'wp-block-cover__background' ) ) ) {
-        $processor->remove_class( 'has-background-dim-100' );
-        // Per OQ-4, dim 50 ≡ no class modifier (dimRatioToClass(50)===null).
-        // No has-background-dim-50 class is added.
-    }
-    return $processor->get_updated_html();
-}
-```
-
-Idempotent (calling twice is harmless). Targets the overlay span only; the `has-background-dim` modifier class stays (50%-opacity baseline).
-
-### 6.4 Helper: `gutenberg_cover_bindings_strip_image`
-
-For the unresolvable / mismatched / external-URL case (Req 20, AC-5, AC-6): use the same `preg_match` + `substr`-splice approach to **remove** any element with class `wp-block-cover__image-background` from `$content`. The cover renders without an image element, overlay-only.
-
-Two patterns are tried in sequence (whichever matches first wins; both forms never co-exist in a Cover's saved markup because `save.js` emits exactly one image element):
-
-```php
-// Form 2: parallax/repeat saved form — a self-closed empty <div>.
-$form2_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
-
-// Form 1: plain saved form — a void <img> (with or without trailing slash).
-// Matches everything up to the closing ">"; void elements have no </img>.
-$form1_pattern = '/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?\s*>/U';
-
-foreach ( array( $form2_pattern, $form1_pattern ) as $pattern ) {
-    if ( 1 === preg_match( $pattern, $content, $matches, PREG_OFFSET_CAPTURE ) ) {
-        $start  = $matches[0][1];
-        $length = strlen( $matches[0][0] );
-        return substr( $content, 0, $start ) . substr( $content, $start + $length );
-    }
-}
-return $content;
-```
-
-The `U` (ungreedy) modifier is essential for both patterns — without it, `[^>]*` would greedily span past intermediate `>` boundaries when other attributes contain `>` literals (rare but possible in well-formed but edge-case markup). The form-1 pattern matches both XHTML-style `<img ... />` and HTML5-style `<img ... >` because `\/?\s*>` makes the trailing slash optional. Both patterns are scoped by the `\b...\b` word-boundary anchor around the class name, ensuring matches only on elements that actually carry the `wp-block-cover__image-background` class (not coincidental substring hits on neighbouring attributes).
-
-### 6.5 PHPUnit coverage
-
-New cases in `phpunit/blocks/render-block-cover-test.php`:
-
-1. **Bound URL substitution (plain `<img>` saved form).** Construct a parsed-block array with `metadata.bindings.url = { source: testing/x }` and `metadata.bindings.id` likewise; register a test source returning a known media-library attachment. Assert `<img src="…">` contains the resolved URL.
-2. **Default-dimRatio class rewrite.** Same setup, `dimRatio` omitted (defaults to 100). Assert resulting HTML contains `wp-block-cover__background has-background-dim` but NOT `has-background-dim-100` (AC-16, AC-25).
-3. **Non-default dimRatio preserved.** Same setup with `dimRatio: 70`. Assert `has-background-dim-70` is present (AC-17).
-4. **Parallax saved markup gets rebuilt.** Construct saved markup with the `<div class="wp-block-cover__image-background" style="background-image:url(…)"></div>` form. Assert resulting HTML has `<img class="wp-block-cover__image-background"` and no `has-parallax` / `is-repeated` classes on it (AC-19).
-5. **Mismatched sources strip the image.** `metadata.bindings.id.source === 'A'`, `metadata.bindings.url.source === 'B'`. Assert no `wp-block-cover__image-background` element in output (AC-6).
-6. **External URL strip.** Source returns a URL but a non-attachment id. Assert no `wp-block-cover__image-background` (AC-5).
-7. **`useFeaturedImage: true` short-circuit.** `useFeaturedImage: true` with active bindings AND a featured-image set on the test post. Assert exactly one `wp-block-cover__image-background` element and its `src` is the bound URL, not the featured image URL (AC-18). This directly validates the `render_block_data` filter (§6.1 Part 2): without it, two elements would appear.
-8. **Embed-video carve-out.** `backgroundType: 'embed-video'` with active bindings. Assert no `<img>` substitution; the iframe path runs (AC-21).
-9. **Unbound cover untouched.** No bindings. Assert the existing `render_block_core_cover` output is byte-identical to trunk (AC-20).
-
-## 7. `block.json` changes
-
-Add `"role": "content"` to the `id` attribute of `packages/block-library/src/cover/block.json`. The current `url` attribute already has `role: "content"`.
-
-```diff
-   "id": {
--    "type": "number"
-+    "type": "number",
-+    "role": "content"
-   },
-```
-
-No other attribute schema changes. No new attributes. No supports changes. No deprecation entry needed (role is metadata-only).
-
-## 8. Block Bindings registration
-
-Bindings for `id` and `url` on `core/cover` are added by the new `block_bindings_supported_attributes` filter (§6.1 Part 1). This feeds both server resolution (`gutenberg_process_block_bindings` reads from `gutenberg_get_block_bindings_supported_attributes`) and the editor settings (`__experimentalBlockBindingsSupportedAttributes` is built from the same function via `lib/compat/wordpress-6.9/block-bindings.php:33-46`).
-
-Exact code references:
-- `lib/compat/wordpress-6.9/block-bindings.php:118-167` (`gutenberg_get_block_bindings_supported_attributes`) — the function our filter hooks into.
-- `lib/compat/wordpress-6.9/block-bindings.php:33-46` (`block_editor_settings_all` filter) — populates the editor setting that `packages/block-editor/src/hooks/block-bindings.js` reads.
-- `packages/block-editor/src/hooks/block-bindings.js:122-127` — Cover is NOT in the excluded-blocks list. Once the server filter adds `id`/`url`, the Block Bindings panel renders automatically (AC-1).
-
-No new editor-side allow-list, no Cover-specific UI registration code.
-
-## 9. Pattern Overrides integration
-
-Driven entirely by existing infrastructure:
-
-1. **`__default` expansion (client).** `useCoverBindingState` calls `replacePatternOverridesDefaultBinding( bindings, [ 'id', 'url' ] )` from `packages/block-editor/src/utils/block-bindings.js`. After expansion, the `__default: { source: 'core/pattern-overrides' }` shape becomes `{ id: { source: 'core/pattern-overrides' }, url: { source: 'core/pattern-overrides' } }`, which is exactly the same-source-instance shape `bindingActive` accepts. Per Glossary "Expanded bindings".
-2. **`__default` expansion (server).** `gutenberg_process_block_bindings` (`lib/compat/wordpress-6.9/block-bindings.php:257-281`) expands `__default` server-side. Same semantics. Our `gutenberg_cover_bindings_is_active` helper (§6.1) re-implements the same expansion locally (because we need to read the expansion BEFORE `gutenberg_process_block_bindings` runs, in the `render_block_data` filter).
-3. **Reset toolbar.** `withPatternOverrideControls` (`packages/editor/src/hooks/pattern-overrides.js`) wires `<ResetOverridesControl>` automatically once the block is allow-listed.
-4. **Enable Overrides button.** Same HOC wires `<PatternOverridesControls>` for the synced-pattern authoring view.
-
-Zero Cover code touches Pattern Overrides directly.
-
-## 10. Same-source / internal-media invariant
-
-Three layers of enforcement, all gated by the same `bindingActive` semantic:
-
-| Layer | Enforcement site | Outcome |
-| --- | --- | --- |
-| Editor render | `CoverEdit` render tree (§5.4) | If `bindingUnresolvable`, render `<Placeholder>` with `instructions={ __( 'Internal media required for this binding.' ) }` and do NOT render an `<img>` (AC-4). |
-| Editor controls | `useCoverBindingState` flips `bindingActive: false` when sources don't match | Parallax/repeat/replace/featured-image controls return to their unbound rendering. This is intentional: a mismatched-binding cover is treated as if there's no binding, so the user has the normal cover affordances to fix it. |
-| Server render | `gutenberg_cover_bindings_render_block` (§6.1) | Mismatched/missing/non-attachment id → `gutenberg_cover_bindings_strip_image` → no `<img>` in output (AC-5, AC-6). |
-
-The "internal media required" affordance test-observable signal is the i18n message string `__( 'Internal media required for this binding.' )` (primary; e2e asserts via `getByText`), with `data-testid="cover-binding-unresolvable"` as a secondary stability hook (OQ-6).
-
-## 11. Testing strategy
-
-### 11.1 Unit (Jest)
-
-`packages/block-library/src/cover/test/edit.js` — extend with cases for `useCoverBindingState`:
-
-- `bindingActive` true when `__default: { source: 'core/pattern-overrides' }` expanded.
-- `bindingActive` true when `{ id: { source: X, args: A }, url: { source: X, args: A } }`.
-- `bindingActive` false when sources differ.
-- `bindingActive` false when args differ.
-- `bindingActive` false when backgroundType is `embed-video`.
-- `bindingUnresolvable` true on mismatched sources.
-- `effectiveDimRatio` returns 50 only when `bindingActive && dimRatio===100 && effectiveUrl`.
-
-### 11.2 PHPUnit
-
-Cases enumerated in §6.5, added to `phpunit/blocks/render-block-cover-test.php`. Covers AC-3, AC-5, AC-6, AC-15..AC-21, AC-25.
-
-### 11.3 E2E
-
-New describe block in `test/e2e/specs/editor/blocks/cover.spec.js`: `'Block Bindings — Pattern Overrides round-trip'`.
-
-Test outline (one spec, multiple assertions, satisfies AC-22..AC-24):
-
-```js
-test.describe( 'Block Bindings — Pattern Overrides round-trip', () => {
-    test( 'Cover round-trips through default → override → reset', async ({ editor, page, requestUtils, admin }) => {
-        // Setup: upload two attachments (defaultMedia, overrideMedia).
-        // 1. Create synced pattern with a Cover whose url+id are bound via "Enable overrides".
-        // 2. Save pattern. Open new post. Insert the synced pattern.
-        // 3. Assert (default state):
-        //    - Editor preview <img src> points at defaultMedia.url.
-        //    - Parallax / Repeat ToolsPanelItems are not visible (AC-11, AC-12).
-        //    - <MediaReplaceFlow> toolbar dropdown button is not in the DOM (AC-13 + AC-14).
-        //      The single locator `page.getByRole('button', { name: /^(Replace|Add media)$/ })`
-        //      should resolve to zero matches inside the Cover's BlockControls toolbar.
-        //    - On a SEPARATE embed-video Cover (control case), the same button IS visible
-        //      with the "Embed video from URL" MenuItem accessible (AC-21 preserved on
-        //      the population where `backgroundType === 'embed-video'`).
-        //    - Overlay span class does NOT contain 'has-background-dim-100' (AC-15).
-        //    - ResetOverridesControl toolbar button is disabled (AC-10, OQ-2).
-        // 4. Override the instance: programmatically setBlockAttributes with new url+id.
-        //    - Assert ResetOverridesControl is now enabled.
-        //    - Assert editor preview <img src> points at overrideMedia.url.
-        //    - Publish post; navigate to front-end.
-        //    - Assert front-end <img src> points at overrideMedia.url.
-        //    - Assert front-end overlay class contains 'has-background-dim' but NOT 'has-background-dim-100' (AC-16).
-        // 5. Reset: click the toolbar Reset button.
-        //    - Assert editor preview <img src> back to defaultMedia.url.
-        //    - Publish; front-end same.
-        // 6. Unresolvable case: programmatically create a Cover with mismatched bindings
-        //    (id.source !== url.source). Assert the i18n message is visible (AC-24):
-        //    await expect( page.getByText( 'Internal media required for this binding.' ) ).toBeVisible();
-    } );
-} );
-```
-
-Test fixture follows the `packages/e2e-tests/plugins/block-bindings.php` pattern for additional non-Pattern-Overrides binding sources used in the mismatched-source test.
-
-### 11.4 Non-regression
-
-Existing `cover.spec.js` cases run untouched. Existing `packages/block-library/src/cover/test/edit.js` cases run untouched. Existing `phpunit/blocks/render-block-cover-test.php` cases run untouched. AC-20, AC-35.
-
-## 12. Backwards compatibility
-
-- **Unbound covers untouched.** All gating predicates (`bindingActive`, the server filters' early-return on `! gutenberg_cover_bindings_is_active( $attrs )`) flip false when `metadata.bindings` is absent. The new code path is dead code on every existing unbound cover. AC-20.
-- **No `save.js` change.** The serialized markup shape is identical to trunk. Deprecation chain unchanged. AC-20.
-- **No new attribute.** `id` gains a `role: "content"` annotation only — metadata-only, not part of the saved markup.
-- **Embed-video carve-out.** Both client and server short-circuit on `backgroundType === 'embed-video'`, regardless of binding presence. AC-21. On embed-video covers, `bindingActive=false` per §5.1 step 2, so `<MediaReplaceFlow>` (including the "Embed video from URL" `<MenuItem>` child) renders as on trunk — the affordance is fully preserved on the AC-21 population. On bound NON-embed-video covers, `<MediaReplaceFlow>` is conditionally omitted (§5.5), so the embed-URL menu item is unreachable there; this is consistent with the Out-of-Scope "Embed-video × bindings interaction" bullet (the bound→embed-video conversion path is not supported in this PR).
-- **`useFeaturedImage` precedence rule (AC-18).** When both `useFeaturedImage: true` and an active binding co-exist on the same cover, the binding wins. Mechanism: the `render_block_data` filter (§6.1 Part 2) mutates `$parsed_block['attrs']['useFeaturedImage'] = false` BEFORE `render_callback` runs, so `render_block_core_cover` skips its featured-image injection branch. The stored `useFeaturedImage` attribute on the post content is NOT mutated (the mutation is to the in-flight `$parsed_block` array, scoped to this single render pass). DC-2 is preserved on the persistence path (no `setAttributes` on client, no persisted post_content change on server). On the client, `bindingActive` is derived from the persisted attribute state including `useFeaturedImage`; if a saved Cover has both `useFeaturedImage: true` and bindings, the editor's `effectiveUrl` prefers `bindingResolvedUrl` over `mediaUrl` per §5.2, matching the server's precedence. AC-18 satisfied.
-- **`! function_exists` / version guards.** The new compat file follows the established pattern from `lib/compat/wordpress-6.9/block-comments.php:63,84`. Graceful degradation on a WP install lacking the bindings infrastructure (Req 39). The Cover Edit component's new hook reads `metadata?.bindings` defensively — when `__experimentalBlockBindingsSupportedAttributes['core/cover']` is undefined (pre-7.1 server), `bindingActive` returns false and the existing code path runs.
-- **AC-26 (PR shape — file path).** The new compat file lives at `lib/compat/wordpress-7.1/block-bindings.php` and is loaded via `lib/load.php`. No file under `lib/compat/wordpress-7.0/`. See §2.2 and §6.1.
-- **AC-27 (PR description).** The Gutenberg PR description MUST link issue #77199 and MUST explicitly state whether/how this PR subsumes #74109 and #74610. This is a PR-creation step rather than a code change; the design records it as a hard requirement on the PR-open phase. Suggested wording is included in the Code phase's PR-creation step.
-- **AC-28 (~500-line diff budget).** Estimated diff sizes (additions):
-  - `lib/compat/wordpress-7.1/block-bindings.php`: ~160 lines
-  - `packages/block-library/src/cover/edit/use-cover-binding-state.js` (new): ~70 lines
-  - `packages/block-library/src/cover/edit/index.js`: ~60 lines net (observer replacement + render-tree gating)
-  - `packages/block-library/src/cover/edit/inspector-controls.js`: ~10 lines
-  - `packages/block-library/src/cover/edit/block-controls.js`: ~10 lines
-  - `packages/block-library/src/cover/block.json`: ~2 lines
-  - `lib/load.php`: ~1 line
-  - PHPUnit (9 cases): ~140 lines
-  - E2E (1 describe block, ~6 assertion steps): ~80 lines
-  - **Total: ~533 lines.** Just over budget; the +0.5K-line ceiling is "SHOULD" (Req 38) not MUST. Acceptable; if reviewers push back, the e2e block can be trimmed to ~50 lines by combining steps 4 + 5.
-
-## 13. Trade-offs and alternatives considered
-
-### Server-side: Approach A vs Approach B (revisited)
-
-Approach B (PR #74610's generic `block_bindings_attribute_replaced_in_markup` filter) was rejected per OQ-1 above. Summary of trade-offs:
-
-| | Approach A (chosen) | Approach B (rejected) |
-| --- | --- | --- |
-| New global filter | No | Yes (`block_bindings_attribute_replaced_in_markup`) |
-| Solves `<img src>` substitution | Yes (Cover-scoped) | Yes (generic) |
-| Solves dim-class rewrite | Yes | No — needs Cover-side supplement |
-| Solves parallax-div → `<img>` rebuild | Yes | No — needs Cover-side supplement (Risk 5) |
-| Solves `useFeaturedImage` short-circuit | Yes (via render_block_data) | No — needs Cover-side supplement |
-| Lines added to PR | Single file, ~160 lines | Generic filter + Cover-side supplement: ~210 lines |
-| Cross-block risk surface | Zero | Non-zero (filter affects every binding-substituted block) |
-| Reuse value for future bindable blocks | Zero | Some (e.g. a future block with non-source-declared `url`) |
-
-Net: Approach A wins on every dimension that touches this spec. Approach B's reuse value is real but speculative; the spec also flags it as out-of-scope absent a clear cross-block need (Req 28, Out-of-Scope "New global Block Bindings APIs").
-
-### AC-18 mitigation: render_block_data vs in-callback override vs filter
-
-Three options considered for the `useFeaturedImage: true + bindingActive` precedence:
-
-| | Chosen: `render_block_data` filter | Alt A: in `render_block_core_cover` | Alt B: in priority-9 `render_block` filter (prior design) |
-| --- | --- | --- | --- |
-| Where suppression happens | Before `render_callback` | Inside `render_callback` | After `render_callback` |
-| First-pass injection prevented | Yes | Yes | **No** — already happened |
-| Touches `render_block_core_cover` | No | Yes | No |
-| Cross-PR-coordination needed | No (Gutenberg-side only) | Yes (touches a Core-owned callback) | No |
-| AC-18 satisfied | **Yes** | Yes | **No** |
-
-Alt A would require modifying `render_block_core_cover` itself to peek at `metadata.bindings`, adding a binding-awareness coupling to a Core callback. Better to keep all binding-awareness in the new compat file (consistent with the file-table in §2.2).
-
-Alt B (the prior design's approach) leaves a window in which `render_callback` emits the featured-image element, then our filter rewrites the saved `<img>` but the *injected* featured-image element survives → double `<img>`. Rejected per the iter-1 review Issue 3.
-
-The chosen `render_block_data` approach intercepts at the parsed-block level, before `WP_Block::render` even begins. Verified at `wp-includes/blocks.php:2398` and `wp-includes/class-wp-block.php:531-596`. DC-2 is preserved because the mutation is on the in-flight `$parsed_block` array passed by reference for this render only — the persisted post_content is not touched.
-
-### AC-14 gating: conditional render vs prop-level `undefined` vs upstream change
-
-Three options considered for hiding `<MediaReplaceFlow>` on bound covers:
-
-| | Chosen: conditional render in block-controls.js | Alt A: prop-level undefined (iter-2 design) | Alt B: modify `<MediaReplaceFlow>` upstream |
-| --- | --- | --- | --- |
-| AC-14 literal DOM absence | Yes | **No** — toolbar button + Open Media Library + Upload menu items remain | Yes (if upstream gate added) |
-| Runtime safety | Safe | **Crash** — clicking "Open Media Library" or "Upload" calls `onSelect(media)` with `onSelect=undefined` (verified at `media-replace-flow/index.js:115, 124`) → TypeError | Safe |
-| "Embed video from URL" preserved on bound covers | No (acceptable per §5.5 trade-off) | Yes | Depends on upstream change shape |
-| Shared-component churn | None | None | Significant (affects every `<MediaReplaceFlow>` consumer) |
-| Owner-review cost | Cover-scoped only | Cover-scoped only | Cross-team (block-editor + every consumer) |
-
-Alt A (the iter-2 design) was rejected per the iter-2 review (Issue 1): `<MediaUploadCheck>`-wrapped `<MediaUpload>` ("Open Media Library") and `<FormFileUpload>` ("Upload") render unconditionally at lines 193–232 of `media-replace-flow/index.js`; the internal `selectMedia` helper calls `onSelect(media)` at line 115 and `uploadFiles` calls `onSelect(files)` at line 124, both crashing when `onSelect=undefined`. Prop-level gating works for "Use featured image" (line 233) and "Reset" (line 245) which ARE gated on their callbacks, but not for the upload/media-library paths.
-
-Alt B (upstream gate on `<MediaUploadCheck>` subtree) is the right long-term fix but out-of-scope for this PR — it requires owner-team sign-off and touches every `<MediaReplaceFlow>` consumer.
-
-The chosen conditional render is the smallest correct change. The cost is losing the "Embed video from URL" affordance on bound non-embed-video covers; the §5.5 trade-off section traces this to the Out-of-Scope "Embed-video × bindings interaction" item.
-
-### Line-750 `<CoverPlaceholder>` drop-zone: gate at call site vs `disableDropZone` vs accept
-
-Three options for the line-750 `<CoverPlaceholder disableMediaButtons …/>` site (which on bound covers with `hasBackground=true` still renders a drop zone that calls `onSelectMedia` when files are dropped, verified at `media-placeholder/index.js:378-385, 551-552` and `cover-placeholder.js:22-26`):
-
-| | Chosen: gate at call site `! bindingActive && <CoverPlaceholder …/>` | Alt A: pass `disableDropZone` through `<CoverPlaceholder>` | Alt B: accept the drop-zone as a user-initiated DC-2-exempt path |
-| --- | --- | --- | --- |
-| Lines changed | 1 (wrapper around line-750 site in `index.js`) | 2–3 (add `disableDropZone` prop forwarding in `cover-placeholder.js`) | 0 (documentation only) |
-| Touches `cover-placeholder.js` | No | Yes | No |
-| Honours AC-14 / Req 7 intent (no media-replace surface on bound covers) | Yes | Yes | Stretched (a drop zone IS a media-replace surface) |
-| Unbound-cover non-regression (AC-20) | Identical to trunk when `bindingActive=false` | Identical | Identical |
-
-Chosen approach: gate at the call site. The §2.2 "no `cover-placeholder.js` edits" invariant is preserved. The drop-zone path is removed for bound covers along with the rest of `<CoverPlaceholder>`'s functionality at that site. `bindingUnresolvable` covers fall through the line-616 binding-aware branch in §5.4 (1) and never reach line 750 in any case. The line-750 drop-zone's absence is implicitly covered by the bound-cover render tree no longer including `<CoverPlaceholder>`; an explicit "drag-and-drop on bound cover does not mutate `url`" assertion can be added to the §11.3 e2e plan as a follow-up if reviewers ask.
-
-### Client-side: source-agnostic observer vs explicit `useBindings` derivation
-
-Considered: a separate `useEffect` keyed on `metadata.bindings` that synchronises a derived `bindingUrl` state into the existing observer. Rejected: that is exactly the multi-`useEffect` proliferation Risk 1 / DC-1 forbid. The chosen design (one effect, keyed on `effectiveUrl`, with `useEffectEvent` for latest-value reads) collapses every URL-derivation trigger into a single signal.
-
-### Client-side: race-token via ref vs cleanup-flag in useEffect
-
-The cleanup-flag pattern (`let cancelled = false; ...; return () => { cancelled = true; };`) is React's documented idiom for async work inside `useEffect`. The chosen ref-based pattern was preferred because:
-- The async work lives inside `useEffectEvent`, not `useEffect` body. `useEffectEvent`'s contract is to read latest values; binding a `cancelled` flag in the `useEffect` body's closure would couple the flag to a stale snapshot. Hoisting it to `useEffectEvent` would re-introduce dep-array churn.
-- The ref-based token is monotonic and shared across all observer invocations — a clean primitive for "newest resolution wins" that survives observer re-runs caused by multiple effectiveUrl changes between resolutions.
-- Explicit `useRef( 0 )` declaration at the top of the component is required (sketched in §5.2).
-
-### Pattern Overrides reset: disable vs hide
-
-OQ-2 chose disable. Hiding the button would require Cover-specific overrides of `ResetOverridesControl` (or a wholesale change to all bindable blocks). The hide approach has no UX advantage and would diverge Cover from every other bindable block; the disable approach is the existing contract.
-
-### OQ-6 test-observable signal: i18n string vs data-testid
-
-Both retained, with primary/secondary ordering. The i18n string is the load-bearing contract per spec Req 16; `data-testid` is a translation-resilience safety net. E2E asserts on the i18n string (`page.getByText( 'Internal media required for this binding.' )`). If a future reviewer removes `data-testid` because "test-only props in production DOM smell bad", the e2e test remains green.
-
-## 14. Out-of-scope reminders (from spec, repeated here to keep design honest)
-
-The design explicitly does NOT implement:
-
-- **External / non-media-library URL binding.** Unresolved-id covers render the "internal media required" Placeholder (client) or strip the `<img>` (server). No best-effort fallback for an external URL.
-- **Mismatched-source binding.** Treated as unresolvable. Same render path as external URL.
-- **Parallax × bindings beyond force-off.** No CSS-in-`style` rewrites. The parallax/repeat saved markup is replaced with a plain `<img>` when bindings have resolved a value (OQ-3 mechanism (i)).
-- **Embed-video × bindings beyond non-regression.** Both client and server short-circuit. The iframe's `src` is the saved `url`, never substituted from the bound `url`. AC-21.
-- **Featured-image binding** (expressing `useFeaturedImage` AS a binding source). Separate follow-up PR. This PR enforces the precedence rule only (AC-18).
-- **New global Block Bindings APIs.** None introduced. The chosen Cover-scoped filters are `add_filter( 'render_block_data', ..., 10, 3 )` and `add_filter( 'render_block', ..., 9, 3 )` with the standard signatures — not a new API.
-- **Post-data source `featured_media.url` / `featured_media.id`.** Out of scope.
-
-## 15. Risks / open questions surfaced by this design
-
-1. **Priority-9 vs priority-10 ordering.** The Cover render filter runs at priority 9. The neutralisation of `useFeaturedImage` runs even earlier at `render_block_data` priority 10. If a future change to either generic filter changes registration priority, the ordering invariant breaks. Mitigation: PHPUnit case §6.5(7) catches this regression; add a comment in the new compat file pinning the rationale.
-2. **`gutenberg_cover_bindings_is_active` duplicates `__default` expansion logic** from `lib/compat/wordpress-6.9/block-bindings.php:257-281`. This is intentional (we need the expansion result BEFORE `gutenberg_process_block_bindings` runs, in the `render_block_data` filter, while the generic helper does it inline) but introduces a small divergence risk if Core changes expansion semantics. Mitigation: PHPUnit case §6.5(7) and #6.5(5) catch behavioural divergence; if Core promotes expansion into a public helper, swap to it.
-3. **`gutenberg_process_block_bindings` is called twice per render** (once via `WP_Block::render()` at line 532, once via the priority-10 generic filter's `$instance->render()` re-call). Functionally correct (resolution is idempotent) but wastes work. Acceptable for v1; a future micro-optimisation could cache resolution per `$instance`.
-4. **Race between `attachment` REST loading and `bindingResolvedId` check.** Client-side, the media-library record lookup via `useSelect` returns `undefined` while loading and `null` if resolved-not-found. The hook treats `undefined` as pending (bound-but-pending placeholder per §5.4 (1)) and `null` as unresolvable. There's a transient render where the cover shows the pending placeholder instead of the resolved image — duration is one network round-trip. Acceptable; pattern matches how `core/image` handles the same race.
-5. **AC-14 surface — embed-video affordance trade-off.** The chosen design removes `<MediaReplaceFlow>` from the bound-cover toolbar entirely (literal-DOM-absence per AC-14), which has the side effect of removing the "Embed video from URL" `<MenuItem>` from bound covers. This is acceptable because: (a) embed-video covers force `bindingActive=false` per §5.1 step 2 — so the affordance remains accessible on the population AC-21 actually protects; (b) the Out-of-Scope "Embed-video × bindings interaction" bullet rules out the bound-non-embed-video → bound-embed-video conversion path. The user can unbind a Cover first, then use the embed-URL affordance. Documented in §5.5 and §2.2.
-6. **Backport-changelog entry timing.** `backport-changelog/7.1/<core-pr>.md` is created when the corresponding Core PR is filed; not a blocker for the Gutenberg PR landing. The Gutenberg PR description includes a `TODO: backport-changelog entry pending Core PR #NNN` note and is updated once the Core PR number is known.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-1-rejected.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-1-rejected.md
deleted file mode 100644
index b0d1332fac3f9e..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-1-rejected.md
+++ /dev/null
@@ -1,127 +0,0 @@
-# Code Plan Review
-
-## Verdict: rejected
-
-## Summary
-
-The plan is dense, well-traced, and largely faithful to the approved design. Every spec AC (AC-1..AC-28) is mapped to at least one task, ordering keeps the tree green, granularity is right, and the headline e2e test does exercise Pattern Overrides default-override-reset plus the unresolvable-binding affordance. However, **one finding is a hard feasibility blocker**: Task 6 prescribes importing `replacePatternOverridesDefaultBinding` from `@wordpress/block-editor`, but that helper is NOT publicly exported — the import will not resolve and the new hook will not compile. A handful of smaller defects also need addressing: a nonexistent `AC-35` is referenced in three tasks, the `backport-changelog` file shape in Task 13 is wrong (it omits the wordpress-develop URL line), Task 8 does not state the `url`→`effectiveUrl` swap in the non-empty render-branch predicate, Task 7's acceptance silently drops `overlayColor`/`customOverlayColor` from the DC-2 prohibition list without flagging it as an intentional carve-out, and Task 6/7 hand-wave the `context` parameter even though `CoverEdit` destructures it into `{ postId, postType }` at the prop boundary. Fixing these — especially the import — is mechanical and well within one iteration.
-
-## Issues
-
-### Issue 1 (SEVERITY: HIGH — feasibility blocker): `replacePatternOverridesDefaultBinding` is not exported from `@wordpress/block-editor`
-
-**What's wrong:** Task 6 step 2 specifies `Imports: replacePatternOverridesDefaultBinding from @wordpress/block-editor (utils/block-bindings)`. The function exists at `/Users/carlos/Developer/gutenberg/packages/block-editor/src/utils/block-bindings.js:27` but `packages/block-editor/src/utils/index.js` does NOT re-export it (only `transformStyles` and `getPxFromCssUnit`), and `packages/block-editor/src/index.js` only re-exports `./utils` (and `./private-apis`, but neither file forwards the helper). Verified: a `grep -rn "replacePatternOverridesDefaultBinding"` of the source tree shows only one in-package importer (`packages/block-editor/src/components/block-edit/edit.js`) using the relative path `../../utils/block-bindings`. The plan's import path resolves to nothing public; the file will fail to build the moment the code-writer types `import { replacePatternOverridesDefaultBinding } from '@wordpress/block-editor';`.
-
-**Where in plan:** Task 6 (`packages/block-library/src/cover/edit/use-cover-binding-state.js`), §Changes step 2, and (indirectly) the §Acceptance bullets that assume the hook computes `bindingActive` via this helper.
-
-**Suggestion:** Pick ONE and write it into the task explicitly:
-- (a) Re-implement the `__default` expansion inline in `use-cover-binding-state.js` (3-4 lines mirroring `packages/block-editor/src/utils/block-bindings.js:27-46`); OR
-- (b) Add a sibling sub-task that exports `replacePatternOverridesDefaultBinding` from `packages/block-editor/src/utils/index.js` (and runs `npm run build` if needed); OR
-- (c) Route through the existing block-editor private-APIs (`lock-unlock`) — but that requires first locking the helper, which is a public-API decision that should be raised with reviewers.
-The plan currently leaves this design decision to the code-writer, which is exactly what the plan-writer is supposed to resolve.
-
-**Why it matters:** The blocker stops the very first task that depends on it (Task 6) and blocks every downstream task (7, 8, 9, 11, 12). The code-writer cannot make this call mid-task — option (b) is a cross-package public-API change and (c) is a reviewer-gated private-API decision; both belong in the plan, not in implementation.
-
----
-
-### Issue 2 (SEVERITY: MEDIUM — broken traceability): Plan references nonexistent `AC-35`
-
-**What's wrong:** Tasks 10, 11, and 12 each cite "AC-35" as the spec anchor for non-regression assertions. The spec defines acceptance criteria AC-1..AC-28 only — there is no AC-35. The spec's non-regression bullet under "Tests" is **Req 35**, not AC-35.
-
-**Where in plan:**
-- Task 10 §Acceptance: `The pre-existing test methods in render-block-cover-test.php continue to pass (AC-20, AC-35 non-regression).`
-- Task 11 §Acceptance: `The pre-existing edit.js tests continue to pass (AC-35 non-regression).`
-- Task 12 §Acceptance: `All existing tests in cover.spec.js continue to pass (AC-35).`
-
-**Suggestion:** Replace all three with `Req 35` (or simply `AC-20`, since the spec uses AC-20 — "Unbound Cover behavior MUST be unchanged" — as the non-regression invariant). Either is acceptable; the goal is that the trace resolves.
-
-**Why it matters:** A reviewer following the trace chain hits a dead end. The orchestrator's `code-plan-reviewer` workflow specifically calls for traceable tasks; an undefined anchor is a real defect.
-
----
-
-### Issue 3 (SEVERITY: MEDIUM — wrong file shape): Task 13 backport-changelog entry omits the wordpress-develop URL
-
-**What's wrong:** Task 13 step 1 says `Create backport-changelog/7.1/<core-pr-number>.md containing the single line: * https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>`. Existing entries in `backport-changelog/7.1/` (verified by reading `backport-changelog/7.1/10869.md`) use the format:
-```
-https://github.com/WordPress/wordpress-develop/pull/<core-pr-number>
-
-* https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>
-```
-— two lines, the first being the wordpress-develop URL (matching the filename), then a blank line, then the bulleted gutenberg URL.
-
-**Where in plan:** Task 13 §Changes step 1.
-
-**Suggestion:** Update the change description and the acceptance bullet to match the established two-line shape. Concretely:
-```
-https://github.com/WordPress/wordpress-develop/pull/<core-pr-number>
-
-* https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>
-```
-
-**Why it matters:** AC-26 / Req 36 explicitly require the backport-changelog entry; if the code-writer follows the plan verbatim the format will be wrong and a reviewer will reject the PR.
-
----
-
-### Issue 4 (SEVERITY: MEDIUM — granularity / hidden design decision): Task 8 does not specify the `url` → `effectiveUrl` swap in the non-empty image branch predicate
-
-**What's wrong:** Task 8 step 2 says "In the non-empty image render branch (around `url && isImageBackground` near line 672)" and then describes the `bindingActive` force-`<img>` form using `src={ effectiveUrl }`. But the **predicate** itself (`url && isImageBackground`) is not explicitly rewritten. Design §5.4 (2) is explicit: `{ ! bindingUnresolvable && effectiveUrl && isImageBackground && ( ... ) }`. As written, the plan leaves the code-writer to decide whether to keep `url` in the predicate (in which case `bindingResolvedUrl` alone — with no stored `url` — never reaches the branch) or to swap it to `effectiveUrl`. This is a design decision hidden inside a task.
-
-**Where in plan:** Task 8 §Changes step 2.
-
-**Suggestion:** Make the predicate swap explicit. Rewrite step 2 to say something like: "Replace the non-empty image branch's outer predicate `{ url && isImageBackground && (...) }` with `{ ! bindingUnresolvable && effectiveUrl && isImageBackground && (...) }`. Then, inside, branch on `bindingActive ? (force-img form) : (existing img-or-div form using `url`)`." Add to acceptance: "The non-empty branch's gating predicate uses `effectiveUrl`, not the stored `url`."
-
-**Why it matters:** With the predicate left as `url && isImageBackground`, a pattern-instance Cover whose stored `url` is empty (because Pattern Overrides reset just cleared it, or because the synced pattern was authored with no default) but whose `bindingResolvedUrl` is populated would render the empty-cover branch instead of the bound `<img>`, failing AC-7 (default state shows pattern default image). This is the headline Pattern Overrides path — it must not be left to chance.
-
----
-
-### Issue 5 (SEVERITY: LOW — spec-vs-plan acceptance contradiction): Task 7 silently removes `overlayColor` / `customOverlayColor` from the DC-2 prohibition list
-
-**What's wrong:** Spec DC-2 enumerates the prohibition list as: `dimRatio, useFeaturedImage, backgroundType, id, url, hasParallax, isRepeated, overlayColor, customOverlayColor`. Task 7 §Acceptance bullet 3 reads: "The observer body does NOT call `setAttributes` for `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, or `customOverlayColor`." — `overlayColor` is missing. Separately, Task 7 §Changes step 5(vi) explicitly calls `setOverlayColor( avg )` and includes a parenthetical explaining that this is "a continuation of trunk's existing media-resolution path". The design doc made the same source-agnostic argument and was approved with that carve-out.
-
-The contradiction: the spec's DC-2 list contains `overlayColor`/`customOverlayColor`; the plan's per-task acceptance silently drops `overlayColor`. The plan is correct to align with the approved design's carve-out, but the acceptance bullet should explicitly call out the carve-out so reviewers and future maintainers see it.
-
-**Where in plan:** Task 7 §Acceptance bullet 3.
-
-**Suggestion:** Rewrite the bullet to make the carve-out load-bearing. For example: "The observer body does NOT call `setAttributes` for any of the DC-2-prohibited attributes EXCEPT `overlayColor`/`customOverlayColor`, whose mutation via `setOverlayColor( avg )` is a deliberate source-agnostic continuation of trunk behaviour per design §5.3 (this is not a fresh binding-state-triggered write — it is the same media-resolution path that fires for manual selection and `useFeaturedImage` URLs). The only `setAttributes` call inside the observer is `{ isDark }`."
-
-**Why it matters:** As written, a future reviewer comparing spec DC-2 to plan acceptance sees a silent omission and may flag it. Making the carve-out explicit and traceable to design §5.3 closes the gap with one sentence.
-
----
-
-### Issue 6 (SEVERITY: LOW — unspecified plumbing): Task 6 / Task 7 don't say how `context` is threaded into `useCoverBindingState`
-
-**What's wrong:** Task 6 declares the hook signature `useCoverBindingState({ clientId, attributes, context })` and Task 7 step 2 calls it with the same shape. But `CoverEdit`'s prop signature (verified at `packages/block-library/src/cover/edit/index.js:87-96`) already destructures `context: { postId, postType }` — there is no `context` identifier in scope inside the component body. To pass `context` to the hook, the code-writer must either (a) un-destructure the prop and keep a reference, (b) reconstruct an object `{ postId, postType }`, or (c) add a new parameter at the prop boundary. The plan doesn't say which. Block-Bindings sources expect to receive the full `context` object as built by `EditWithGeneratedProps` (verified at `packages/block-editor/src/components/block-edit/edit.js:149-154`), which means option (b)'s ad-hoc reconstruction would be wrong — the source may need other context keys.
-
-**Where in plan:** Task 6 §Changes step 1 (hook signature) and Task 7 §Changes step 2 (call site).
-
-**Suggestion:** Add to Task 7's prerequisites or §Changes a concrete step: "Change `CoverEdit`'s prop destructuring from `context: { postId, postType }` to `context` (an un-destructured reference), and read `postId`/`postType` via `context.postId`/`context.postType` at the call sites that currently use them. Then pass `context` directly into `useCoverBindingState({ clientId, attributes, context })`." This makes the prop-boundary change explicit and preserves the source's expected context contract.
-
-**Why it matters:** Without this, the code-writer either invents a partial `context` reconstruction (breaking some binding sources) or silently changes the prop destructuring without surfacing the diff in the PR description. Either way it is a hidden design decision in a "small" task.
-
----
-
-### Issue 7 (SEVERITY: LOW — missed design coverage): Task 12 omits the embed-video control-case assertion called out in design §11.3
-
-**What's wrong:** Design §11.3 explicitly lists, as part of the e2e default-state assertions: "On a SEPARATE embed-video Cover (control case), the same button IS visible with the 'Embed video from URL' MenuItem accessible (AC-21 preserved on the population where `backgroundType === 'embed-video'`)." Task 12 §Changes step 3 enumerates the default-state assertions but does not include this positive AC-21 control case.
-
-**Where in plan:** Task 12 §Changes step 3 (Default state assertions block).
-
-**Suggestion:** Either (a) add the embed-video control-case assertion to Task 12's default-state checklist with an explicit AC-21 trace; or (b) explicitly justify in the plan that AC-21 is covered server-side by Task 10's `test_embed_video_short_circuits` PHPUnit case and editor-side by Task 11's `bindingActive false for embed-video` Jest case, so an additional e2e step would be redundant. Either resolution is fine — silent omission is not.
-
-**Why it matters:** The design doc was approved with this assertion in scope; dropping it without justification is a regression against an approved design decision. AC-21 ("no regression on embed-video covers") is a load-bearing carve-out and deserves the explicit positive assertion the design called for.
-
----
-
-### Issue 8 (SEVERITY: LOW — coverage nit): Several Reqs are not explicitly traced
-
-**What's wrong:** Sweeping the plan's `Traces to:` lines, the following spec Reqs are never explicitly cited: Req 9 (Pattern Overrides controls work automatically — implicitly covered by Req 2 / Task 2), Req 23 (Unbound Cover non-regression — implicitly covered by Task 10's AC-20 case), Req 24 (Pattern Overrides four-state round-trip — implicitly covered by Task 12), Req 28 (no new global APIs — a design choice with no task), Req 34 (PHPUnit case — covered by Task 10), Req 35 (existing tests continue to pass — referenced as the bogus `AC-35` per Issue 2). Most have implicit coverage but none are cited. This is a nit, not a defect, but the spec's "every requirement maps to at least one task" expectation is not literally satisfied.
-
-**Where in plan:** Tasks 2 / 10 / 12 / 13 (their `Traces to:` lines).
-
-**Suggestion:** Either (a) add the missing Reqs to the appropriate task `Traces to:` lines; or (b) acknowledge in the Overview that some Reqs are design-level (Req 28) or are subsumed by other cited Reqs/ACs. Lowest-effort fix: append Req 9 to Task 2, Req 23 to Task 10, Req 24 to Task 12, Req 34 to Task 10, and Req 35 to Tasks 10/11/12 (replacing the bogus AC-35 from Issue 2). Req 28 is design-only and can be omitted with a note.
-
-**Why it matters:** Adversarial reviewers (including the next pipeline iteration) will check trace coverage; missing Reqs reduce confidence even when the substance is covered.
-
----
-
-End of issues.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-approved.md
deleted file mode 100644
index d6af8c7274a372..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan-review-approved.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# Code Plan Review
-
-## Verdict: approved
-
-## Summary
-
-The iter-2 revision of `code-plan.md` cleanly resolves every finding from iter-1's rejection. The plan is faithful to the approved design, every spec AC and Req traces to at least one task, ordering keeps the tree green at every step, and granularity is tight (each task has explicit file paths, explicit changes, and observable per-task acceptance criteria). Codebase claims were verified against the source tree: `lib/load.php` lines 80-82 (collaboration.php insertion site), `packages/block-library/src/cover/edit/index.js` lines 95 (`context: { postId, postType }` destructure), 132 (existing `propsRef.current` pattern), 599 (empty-cover branch), 672 (`url && isImageBackground`), 750 (line-750 `<CoverPlaceholder>`), `packages/block-editor/src/utils/index.js` (only exports `transformStyles` + `getPxFromCssUnit`), `backport-changelog/7.1/10869.md` two-line format, `packages/element/src/react.ts:218` (`useEffectEvent` export) — all consistent with the plan. Approving.
-
-## Iter-1 findings — resolution check
-
-- **Issue 1 (HIGH — `replacePatternOverridesDefaultBinding` import blocker).** Resolved. Task 6 step 2 explicitly forbids importing the helper from `@wordpress/block-editor` and pins option (c): inline `__default` expansion in `use-cover-binding-state.js`, with a code snippet (Task 6 step 3) mirroring trunk's `replacePatternOverridesDefaultBinding`. A comment pointing at the canonical implementation is mandated.
-- **Issue 2 (MEDIUM — nonexistent `AC-35`).** Resolved. Plan now uses `Req 35` (zero `AC-35` occurrences) in Tasks 10/11/12 acceptance bullets.
-- **Issue 3 (MEDIUM — backport-changelog file shape).** Resolved. Task 13 §Changes step 1 now mandates the two-line format (wordpress-develop URL line, blank line, bulleted gutenberg URL).
-- **Issue 4 (MEDIUM — `url`→`effectiveUrl` predicate swap).** Resolved. Task 8 §Changes step 2 explicitly mandates the predicate rewrite to `! bindingUnresolvable && effectiveUrl && isImageBackground`, with traceable rationale (the Pattern Overrides default-state hazard) and a matching acceptance bullet.
-- **Issue 5 (LOW — DC-2 carve-out for `overlayColor`).** Resolved. Task 7 §Acceptance bullet 3 now explicitly calls out `overlayColor`/`customOverlayColor` as a deliberate source-agnostic continuation of trunk behavior, with a Design §5.2/§5.3 trace and explicit "only fresh `setAttributes` call is `{ isDark }`" qualifier.
-- **Issue 6 (LOW — `context` plumbing).** Resolved. Task 7 §Changes step 2 contains the prop-boundary change snippet (`context` undestructured, `const { postId, postType } = context;` inside the body) with rationale (sources may declare `usesContext` for additional keys).
-- **Issue 7 (LOW — embed-video e2e control case).** Resolved. Task 12 §Changes step 3 now includes the explicit embed-video control case under the default-state assertions with AC-21 preservation rationale and a matching acceptance bullet.
-- **Issue 8 (LOW — missing Req traces).** Resolved. Plan now explicitly cites Req 9 (Task 2), Req 23 / Req 34 / Req 35 (Task 10), Req 35 (Task 11), Req 24 / Req 35 (Task 12), and includes a Coverage note in the Overview explaining Req 28's design-level invariant status.
-
-## New-defect sweep
-
-A fresh pass for new defects found nothing material:
-
-- All file paths cited (`lib/load.php` insertion site, `packages/block-library/src/cover/edit/index.js` line numbers 95/599/672/750, `lib/compat/wordpress-7.1/` directory) match the trunk codebase as inspected.
-- The `useEffectEvent` import path (`@wordpress/element`) is confirmed exported.
-- Both halves of the new PHP file (Task 4 + Task 5) compose correctly — `gutenberg_cover_bindings_is_active` is defined in Task 3 and consumed in Tasks 4 and 5 (correct dependency order).
-- Task ordering keeps the tree green: server-only work first (Tasks 1-5), then client (6-9), then tests (10-12), then PR metadata (13).
-- Per-task acceptance criteria describe *what must be true* (observable behavior), not *which test files to write*.
-- One minor semantic nit (PHP `gutenberg_cover_bindings_expand_bindings` in Task 3 expands ANY `__default`, while JS `expandDefaultBinding` in Task 6 only expands when `source === 'core/pattern-overrides'`) is not user-observable today because only `core/pattern-overrides` writes the `__default` shape per spec glossary, and Req 26 / AC-6 only require mismatched-source detection in explicit per-attribute bindings. Not worth a rejection on iter-2 — flagging here for the code-writer to consider hardening the PHP guard symmetrically if it becomes natural during implementation.
-
-The plan is ready for execution.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md
deleted file mode 100644
index edbc136d000b10..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/code-plan.md
+++ /dev/null
@@ -1,548 +0,0 @@
-# Code Plan: Cover block bindings — internal-only `id` and `url`
-
-Spec: `<artifacts>/1-spec/spec.md` (approved)
-Design: `<artifacts>/2-design-doc/design-doc.md` (approved)
-
-All AC-N, Req-N, DC-N, OQ-N citations resolve to those documents.
-
-## Overview
-
-Land internal-only Block Bindings support for `core/cover`'s `id` and `url` attributes, headlined by Pattern Overrides, in an order that keeps the tree green at every step. The work is sequenced as follows:
-
-1. **Foundation (server)** — schema metadata, server allow-list filter, helper, `render_block_data` `useFeaturedImage` neutraliser, then the Cover-scoped `render_block` filter with its three rewrite helpers. After step 5, the server is feature-complete and PHPUnit can lock the contract down before any client code lands.
-2. **Foundation (client)** — the new `useCoverBindingState` hook, then a single observer on `effectiveUrl` inside `CoverEdit`, then derived `effectiveDimRatio` flowing into the overlay-span class. After step 8, the editor renders correctly on bound covers (single-observer architecture in place, DC-1/DC-2/DC-3 satisfied) but still shows all the controls.
-3. **UI gating** — inspector parallax/repeat, block-toolbar `<MediaReplaceFlow>`, `<CoverPlaceholder>` line-616 (bound-aware placeholder branch) and line-750 (`! bindingActive &&` wrapper). After step 11, every AC-11..AC-14 control absence holds.
-4. **Tests** — Jest unit tests for the hook and observer, PHPUnit cases enumerated in §6.5, then the e2e round-trip spec in step 14.
-5. **PR metadata** — `lib/load.php` wiring is folded into step 2 so server work integrates immediately; backport-changelog stub and PR description draft are the final step (15).
-
-Each task lists files (CREATE/MODIFY), atomic changes, the spec/design slices it traces to, dependencies, and observable acceptance. Code-writers implement each task TDD-style: write failing tests first, then the production code, then refactor — the per-task acceptance bullets describe *what* must be true, not *which* test files (the code-writer chooses the test files).
-
-**Coverage note (per iter-2 review Issue 8).** Every spec requirement traces to at least one task. Req 28 ("no new global Block Bindings APIs") is a design-level invariant — the design doc selects Approach A (Cover-scoped filters) explicitly to satisfy it, and there is no task to add because there is nothing to build — it is an architectural prohibition enforced by the absence of any new global API across Tasks 1–13. Reviewers verifying Req 28 should check that the diff introduces no `register_*` calls beyond the standard `add_filter( 'block_bindings_supported_attributes', … )` (Task 2) and the two Cover-scoped `add_filter( 'render_block_data' … )` / `add_filter( 'render_block', … 9, 3 )` registrations (Tasks 4 and 5) — none of which is a new global API.
-
----
-
-## Tasks
-
-### Task 1: Add `role: "content"` to `core/cover`'s `id` attribute
-
-**Goal**: Mark `core/cover`'s `id` as a "content" role so it surfaces in the Block Bindings panel alongside `url`.
-
-**Files**:
-- `packages/block-library/src/cover/block.json` — MODIFY: add `"role": "content"` to the `id` attribute definition.
-
-**Changes**:
-1. Locate the `attributes.id` entry (currently `{ "type": "number" }`).
-2. Add `"role": "content"` so it reads `{ "type": "number", "role": "content" }`.
-3. No other schema changes. No new attributes. No `supports` changes. No deprecation entry.
-
-**Depends on**: none
-
-**Traces to**: Spec Req 1, Req 3; AC-1 prerequisite; Design §7.
-
-**Acceptance**:
-- `packages/block-library/src/cover/block.json`'s `id` attribute has `"role": "content"`.
-- `packages/block-library/src/cover/block.json` parses as valid JSON.
-- No other attribute in `block.json` changes.
-
----
-
-### Task 2: Create `lib/compat/wordpress-7.1/block-bindings.php` with allow-list filter, wire it into `lib/load.php`
-
-**Goal**: Add `id` and `url` to `core/cover`'s server-side bindings supported-attributes list, so the editor's `__experimentalBlockBindingsSupportedAttributes['core/cover']` includes them. This is the single registration that drives both the Block Bindings panel (AC-1) and server-side resolution.
-
-**Files**:
-- `lib/compat/wordpress-7.1/block-bindings.php` — CREATE.
-- `lib/load.php` — MODIFY: add the `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';` line alongside the other `wordpress-7.1` requires (around lines 80–82).
-
-**Changes**:
-1. Create `lib/compat/wordpress-7.1/block-bindings.php` with the standard Gutenberg PHP file header (`@package gutenberg`).
-2. Wrap the function definition in `if ( ! function_exists( 'gutenberg_cover_bindings_add_supported_attributes' ) ) { … }` per established pattern (`lib/compat/wordpress-6.9/block-bindings.php`).
-3. Define `gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_type )`:
-   - If `$block_type === 'core/cover'`, ensure `'id'` and `'url'` are present in `$attributes` (use `in_array(..., true)` guard).
-   - Return the (possibly augmented) array.
-4. Register: `add_filter( 'block_bindings_supported_attributes', 'gutenberg_cover_bindings_add_supported_attributes', 10, 2 );`.
-5. In `lib/load.php`, after the existing `wordpress-7.1` requires (after `collaboration.php` on line 82), insert: `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';`.
-
-**Depends on**: Task 1
-
-**Traces to**: Spec Req 2, Req 8, Req 9 (Pattern Overrides controls — "Enable overrides" affordance and `<ResetOverridesControl>` — work automatically once the cover is allow-listed via this filter, with no Cover-specific UI code); AC-1, AC-2; Design §6.1 Part 1, §8, §2.2.
-
-**Acceptance**:
-- `lib/compat/wordpress-7.1/block-bindings.php` exists and is loaded by `lib/load.php`.
-- After bootstrap, `apply_filters( 'block_bindings_supported_attributes', array(), 'core/cover' )` returns an array containing both `'id'` and `'url'`.
-- For any block type other than `core/cover`, the filter is a no-op.
-- The filter is idempotent: applying it twice on the same input still returns `[ 'id', 'url' ]`, not `[ 'id', 'url', 'id', 'url' ]`.
-
----
-
-### Task 3: Add `gutenberg_cover_bindings_is_active` helper
-
-**Goal**: Provide the single PHP helper that decides whether a parsed cover block has an active binding, mirroring the client-side `bindingActive` predicate. It expands `__default`, then requires `id` AND `url` to be bound to the same source instance (same `source` string AND `==`-equal `args`). The helper is the gate that both the `render_block_data` filter (Task 4) and the `render_block` filter (Task 5) call.
-
-**Files**:
-- `lib/compat/wordpress-7.1/block-bindings.php` — MODIFY: add `gutenberg_cover_bindings_is_active( array $attrs ): bool` and the supporting `__default` expansion logic.
-
-**Changes**:
-1. Inside the same file from Task 2, add a private helper `gutenberg_cover_bindings_expand_bindings( array $bindings ): array` that:
-   - Reads `$bindings['__default']` (if any).
-   - For each supported attribute in `[ 'id', 'url' ]`, if there is no explicit entry, copy the `__default` value into that attribute slot.
-   - Returns the expanded array.
-2. Add `gutenberg_cover_bindings_is_active( array $attrs ): bool`:
-   - Read `$attrs['metadata']['bindings']`. If empty/absent, return `false`.
-   - Call the expander above on the bindings.
-   - Compute `$same_source = ( $expanded['id']['source'] ?? null ) === ( $expanded['url']['source'] ?? null );`.
-   - Compute `$same_args = ( $expanded['id']['args'] ?? null ) == ( $expanded['url']['args'] ?? null );` (loose equality on associative arrays per Design §6.1).
-   - Return `! empty( $expanded['id'] ) && ! empty( $expanded['url'] ) && $same_source && $same_args`.
-3. Both helpers MUST be wrapped in `if ( ! function_exists( … ) )` guards.
-
-**Depends on**: Task 2
-
-**Traces to**: Spec Req 11 Glossary "Active binding"; Req 26; AC-3, AC-6, AC-21; Design §6.1, §5.1 step 2 (parity with client).
-
-**Acceptance**:
-- `gutenberg_cover_bindings_is_active( [] )` returns `false`.
-- For attrs whose `metadata.bindings` is `{ __default: { source: 'core/pattern-overrides' } }`, the helper returns `true`.
-- For attrs whose `metadata.bindings` is `{ id: { source: 'a' }, url: { source: 'b' } }`, the helper returns `false`.
-- For attrs whose `metadata.bindings` is `{ id: { source: 'a', args: { key: 'x' } }, url: { source: 'a', args: { key: 'x' } } }`, the helper returns `true`.
-- For attrs whose `metadata.bindings` is `{ id: { source: 'a', args: { k: 1 } }, url: { source: 'a', args: { k: 2 } } }`, the helper returns `false`.
-- For attrs whose `metadata.bindings` is `{ url: { source: 'a' } }` (no id), the helper returns `false`.
-- The helper does NOT short-circuit on `backgroundType === 'embed-video'` — that gate is the responsibility of the callers (Tasks 4 and 5). The helper is pure-by-bindings.
-
----
-
-### Task 4: `render_block_data` filter to neutralise `useFeaturedImage` on bound covers
-
-**Goal**: When a Cover's bindings are active AND `backgroundType !== 'embed-video'`, force `$parsed_block['attrs']['useFeaturedImage'] = false` BEFORE `WP_Block::render()` builds its instance attributes — so `render_block_core_cover` skips its featured-image injection branch on the first pass. This is the AC-18 precedence rule.
-
-**Files**:
-- `lib/compat/wordpress-7.1/block-bindings.php` — MODIFY: add `gutenberg_cover_bindings_prepare_block` and register it on `render_block_data` at priority 10.
-
-**Changes**:
-1. Add `gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $parent_block )`:
-   - If `$parsed_block['blockName'] !== 'core/cover'`, return `$parsed_block` unchanged.
-   - Read `$attrs = $parsed_block['attrs'] ?? array();`.
-   - If `! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType']`, return `$parsed_block` unchanged (AC-21).
-   - If `! gutenberg_cover_bindings_is_active( $attrs )`, return `$parsed_block` unchanged.
-   - Else if `! empty( $attrs['useFeaturedImage'] )`, set `$parsed_block['attrs']['useFeaturedImage'] = false;`.
-   - Return `$parsed_block`.
-2. Wrap in `if ( ! function_exists( … ) )`.
-3. Register: `add_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10, 3 );`.
-
-**Depends on**: Task 3
-
-**Traces to**: Spec Req 19, AC-18; Design §6.1 Part 2, §12 (`useFeaturedImage` precedence rule).
-
-**Acceptance**:
-- For a non-Cover block, the filter returns its input unchanged.
-- For a Cover with no `metadata.bindings`, the filter returns its input unchanged (in particular, `useFeaturedImage` is not flipped).
-- For a Cover with `backgroundType: 'embed-video'` AND active bindings, the filter returns input unchanged.
-- For a Cover with active bindings (per `gutenberg_cover_bindings_is_active`), `backgroundType !== 'embed-video'`, AND `useFeaturedImage: true`, the filter returns the input with `attrs.useFeaturedImage === false`. All other attrs are untouched.
-- For a Cover with active bindings and `useFeaturedImage: false`, the returned `attrs.useFeaturedImage` is still `false` (no surprises).
-- The persisted `post_content` is NOT mutated by this filter — only the in-flight `$parsed_block` array.
-
----
-
-### Task 5: Cover-scoped `render_block` filter with image-rewrite / dim-class-relax / strip-image helpers
-
-**Goal**: When a Cover has an active binding AND `backgroundType !== 'embed-video'`, rewrite the rendered HTML so: (a) the saved `<img class="wp-block-cover__image-background">` OR `<div class="wp-block-cover__image-background" style="background-image:url(…)">` becomes an `<img>` with the bound URL, alt, and `wp-image-{id}` class; (b) the overlay span loses `has-background-dim-100` when stored `dimRatio === 100`; (c) when the binding is unresolvable (no `id`, or `id` is not an attachment), the saved image element is stripped entirely.
-
-**Files**:
-- `lib/compat/wordpress-7.1/block-bindings.php` — MODIFY: add four functions: `gutenberg_cover_bindings_render_block`, `gutenberg_cover_bindings_rewrite_image`, `gutenberg_cover_bindings_relax_dim_class`, `gutenberg_cover_bindings_strip_image`. Register the first on `render_block` at priority 9.
-
-**Changes**:
-1. **`gutenberg_cover_bindings_strip_image( string $content ): string`** — try `$form2_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';` first, then `$form1_pattern = '/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?\s*>/U';`. Use `preg_match` with `PREG_OFFSET_CAPTURE` to locate the match and `substr` to splice it out. Return the modified content (or input unchanged if neither pattern matches).
-2. **`gutenberg_cover_bindings_relax_dim_class( string $content ): string`** — instantiate `WP_HTML_Tag_Processor( $content )`; loop with `next_tag( array( 'tag_name' => 'SPAN', 'class_name' => 'wp-block-cover__background' ) )`; on each match call `remove_class( 'has-background-dim-100' )`. Return `get_updated_html()`.
-3. **`gutenberg_cover_bindings_rewrite_image( string $content, string $resolved_url, int $resolved_id, array $attrs ): string`**:
-   - First, try the parallax/repeat form via `preg_match( $form2_pattern, … )` — if matched, build a replacement `<img class="wp-block-cover__image-background wp-image-{id}{size_class_suffix}" alt="{alt}" src="{esc_url url}" data-object-fit="cover"{object_position_attrs} />` and splice it in via `substr`. Compute `$size_class_suffix` from `$attrs['sizeSlug']` (empty when unset); compute `$object_position_attrs` from `$attrs['focalPoint']` (empty when unset); compute `$alt` from the attachment's alt metadata (`get_post_meta( $resolved_id, '_wp_attachment_image_alt', true )`).
-   - Otherwise, fall through to the plain-`<img>` path via `WP_HTML_Tag_Processor`: `next_tag( array( 'tag_name' => 'IMG', 'class_name' => 'wp-block-cover__image-background' ) )`; if found, `set_attribute( 'src', $resolved_url )`, `set_attribute( 'alt', $alt )`, iterate `class_list()`, remove any class beginning with `wp-image-`, then `add_class( 'wp-image-' . $resolved_id )`. Return `get_updated_html()`.
-   - If neither pattern matched, return `$content` unchanged (no image element to rewrite — fine, render proceeds overlay-only).
-4. **`gutenberg_cover_bindings_render_block( $block_content, $block, $instance )`** — main entry, registered on `render_block` priority 9:
-   - If `$block['blockName'] !== 'core/cover'`, return `$block_content` unchanged.
-   - Read `$attrs = $instance->attributes ?? array();`.
-   - If `! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType']`, return unchanged.
-   - If `! gutenberg_cover_bindings_is_active( $attrs )`, return unchanged.
-   - `$resolved_url = $attrs['url'] ?? null;` `$resolved_id = (int) ( $attrs['id'] ?? 0 );`
-   - If `empty( $resolved_url ) || empty( $resolved_id )`, return `gutenberg_cover_bindings_strip_image( $block_content )`.
-   - Verify attachment: `$attachment = get_post( $resolved_id );` if `! $attachment || 'attachment' !== $attachment->post_type`, return `gutenberg_cover_bindings_strip_image( $block_content )`.
-   - `$block_content = gutenberg_cover_bindings_rewrite_image( $block_content, $resolved_url, $resolved_id, $attrs );`
-   - If `100 === (int) ( $attrs['dimRatio'] ?? 100 )`, `$block_content = gutenberg_cover_bindings_relax_dim_class( $block_content );`
-   - Return `$block_content`.
-5. Register `add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 );`. Priority 9 is essential — it must run BEFORE the generic priority-10 `gutenberg_block_bindings_render_block`.
-6. Wrap each of the four functions in `if ( ! function_exists( … ) )`.
-
-**Depends on**: Task 3, Task 4 (same file; sequencing keeps the file growing monotonically)
-
-**Traces to**: Spec Req 17, Req 18, Req 19, Req 20, Req 21, Req 22; AC-3, AC-5, AC-6, AC-16, AC-18, AC-19, AC-21; Design §6.1 Part 3, §6.2, §6.3, §6.4, OQ-3.
-
-**Acceptance**:
-- For a non-Cover block, the filter returns input unchanged.
-- For a Cover with no active binding, the filter returns input unchanged.
-- For an `embed-video` Cover, the filter returns input unchanged regardless of binding state.
-- For a Cover with active bindings, `dimRatio: 100`, and a resolved attachment URL, the output contains an `<img>` whose `src` matches the bound URL AND no `has-background-dim-100` class anywhere.
-- For a Cover with active bindings, `dimRatio: 70`, and resolved attachment, the output contains an `<img>` with the bound URL AND the `has-background-dim-70` class is preserved.
-- For a Cover with active bindings but `id` resolves to a non-attachment post, the output contains no `wp-block-cover__image-background` element.
-- For a Cover with active bindings, saved markup is the parallax/repeat `<div>...</div>` form, and a resolved attachment, the output contains an `<img class="wp-block-cover__image-background wp-image-{id}">` AND no `has-parallax` / `is-repeated` class on the image element AND no `style="background-image: …"` on the rebuilt element.
-- Idempotency: running the helper twice on already-rewritten content does not produce additional `<img>` elements.
-
----
-
-### Task 6: New hook — `useCoverBindingState`
-
-**Goal**: Provide the client-side single-source-of-truth for cover binding state — `bindingActive`, `bindingUnresolvable`, `bindingResolvedUrl`, `bindingResolvedId`, `canUserEditBindingValue` — computed in one place from one `useSelect`. Used by `CoverEdit` to drive everything downstream.
-
-**Files**:
-- `packages/block-library/src/cover/edit/use-cover-binding-state.js` — CREATE.
-
-**Changes**:
-1. New file exporting a default function with signature `export default function useCoverBindingState( { clientId, attributes, context } ) { … }`. The `context` parameter is the full, undestructured context object (see Task 7 step 2 for the prop-boundary change in `CoverEdit` that produces it). Do NOT reconstruct a partial `{ postId, postType }` shape — binding sources may declare `usesContext` for additional keys and need the full object.
-2. Imports:
-   - `getBlockBindingsSource` from `@wordpress/blocks`
-   - `useSelect` from `@wordpress/data`
-   - `store as coreStore` from `@wordpress/core-data`
-   - Do NOT import `replacePatternOverridesDefaultBinding` from `@wordpress/block-editor`. It is NOT publicly re-exported from the package (verified: `packages/block-editor/src/index.js` re-exports `./utils` and `./utils/index.js` re-exports only `transformStyles` and `getPxFromCssUnit`; the helper at `packages/block-editor/src/utils/block-bindings.js:27` is consumed in-tree only via the relative path `../../utils/block-bindings`). Importing it from `@wordpress/block-editor` would fail to resolve.
-3. Re-implement `__default` expansion inline in this file as a tiny module-local helper (chosen resolution per iter-2 review Issue 1, option (c)). This duplicates ~10 lines of `packages/block-editor/src/utils/block-bindings.js:1-46` but avoids both (a) a cross-package public-API change to re-export the helper and (b) the private-APIs `lock`/`unlock` plumbing required to reach it through the channel `block-editor/src/components/block-edit/edit.js:28` uses (`import { unlock } from '../../lock-unlock'` is itself a private hatch into the package — not a stable cross-package contract). The DRY cost is bounded because the helper is small, has no internal dependencies beyond two string constants, and has been stable in trunk since Pattern Overrides shipped:
-
-   ```js
-   const PATTERN_OVERRIDES_SOURCE = 'core/pattern-overrides';
-   function expandDefaultBinding( bindings, supportedAttributes ) {
-       if ( bindings?.__default?.source !== PATTERN_OVERRIDES_SOURCE ) {
-           return bindings;
-       }
-       const expanded = {};
-       for ( const attr of supportedAttributes ) {
-           expanded[ attr ] = bindings[ attr ]
-               ? bindings[ attr ]
-               : { source: PATTERN_OVERRIDES_SOURCE };
-       }
-       return expanded;
-   }
-   ```
-
-   Place this above the hook body. Add a one-line code comment that points at `packages/block-editor/src/utils/block-bindings.js` so a future reader knows where the canonical implementation lives and the divergence risk is acknowledged. If Core later promotes the helper to a public re-export (a separate, owner-gated decision), this duplication becomes a one-line swap.
-4. Body:
-   - Read `const bindings = attributes.metadata?.bindings;`. If absent, return `{ bindingActive: false, bindingUnresolvable: false, bindingResolvedUrl: undefined, bindingResolvedId: undefined, canUserEditBindingValue: false }` early.
-   - Call `const expanded = expandDefaultBinding( bindings, [ 'id', 'url' ] );` (the local helper from step 3).
-   - Compute `bindingActive` per Design §5.1 step 2: both `expanded.id` and `expanded.url` are present, same `source`, `JSON.stringify( expanded.id.args ?? null ) === JSON.stringify( expanded.url.args ?? null )`, AND `attributes.backgroundType !== 'embed-video'`.
-   - Single `useSelect` (Design §5.1 step 3): when `bindingActive`, look up the source via `getBlockBindingsSource( expanded.url.source )`, call `source.getValues( { select, clientId, context, bindings: { id: expanded.id, url: expanded.url } } )`, then if `values.id` is truthy, also call `select( coreStore ).getEntityRecord( 'postType', 'attachment', values.id, { context: 'view' } )`. Return `{ bindingResolvedUrl, bindingResolvedId, bindingResolvedAttachment }` from the closure. Pass `context` through as the full object received from the hook's argument (NOT a reconstructed partial).
-   - Dependency array: `[ bindingActive, expanded?.id?.source, expanded?.url?.source, clientId, context ]`.
-   - Compute `bindingUnresolvable`:
-     - `true` if `bindings` has any cover-relevant configuration (`bindings.__default` exists, OR `bindings.id` exists, OR `bindings.url` exists) AND `! bindingActive` — i.e. malformed/mismatched binding.
-     - OR `true` if `bindingActive && bindingResolvedAttachment === null` (resolved-not-found; remember `undefined` means pending — NOT unresolvable).
-     - OR `true` if `bindingActive && bindingResolvedAttachment?.type && bindingResolvedAttachment.type !== 'attachment'`.
-   - Compute `canUserEditBindingValue` from the source: `getBlockBindingsSource( expanded.url.source )?.canUserEditValue?.( … ) ?? false`. (Used for future lock-flag wiring; safe to return `false` if not applicable.)
-   - Return `{ bindingActive, bindingUnresolvable, bindingResolvedUrl, bindingResolvedId, canUserEditBindingValue }`.
-5. The hook returns plain values. No memoised React elements, no `useEffect`.
-
-**Depends on**: Task 2 (the editor setting `__experimentalBlockBindingsSupportedAttributes['core/cover']` must include `id`/`url`).
-
-**Traces to**: Spec Req 9, Req 10, Req 25, Req 26, Req 27; AC-3, AC-4, AC-6, AC-21; DC-1, DC-3; Design §5.1, §5.6 (Pattern Overrides integration via the inline-duplicated `__default` expansion that mirrors `replacePatternOverridesDefaultBinding`).
-
-**Acceptance**:
-- Called with `attributes.metadata.bindings === undefined`: returns `bindingActive: false`, `bindingUnresolvable: false`.
-- Called with `attributes.metadata.bindings = { __default: { source: 'core/pattern-overrides' } }`: returns `bindingActive: true`. (Confirms inline `__default` expansion works.)
-- Called with `attributes.metadata.bindings = { id: { source: 'x' }, url: { source: 'y' } }`: returns `bindingActive: false, bindingUnresolvable: true`.
-- Called with `attributes.metadata.bindings = { id: { source: 'x' }, url: { source: 'x' } }` AND `attributes.backgroundType = 'embed-video'`: returns `bindingActive: false` (embed-video override).
-- The hook does NOT import from `@wordpress/block-editor`'s `utils/block-bindings` path (which is not publicly re-exported). The `__default` expansion is implemented inline in this file.
-- The hook subscribes via exactly ONE `useSelect`. (Verifiable by code review / by counting `useSelect` calls in the file.)
-- The hook does NOT call `useEffect`. (Verifiable by code review.)
-- When `bindingActive` is true but the attachment record is loading (selector returns `undefined`), `bindingUnresolvable` is `false` (treated as pending, not unresolvable).
-- When `bindingActive` is true and the attachment record resolves to `null` (not found), `bindingUnresolvable` is `true`.
-
----
-
-### Task 7: Single observer + derived values in `CoverEdit`
-
-**Goal**: Replace the existing `useEffect` on `[mediaUrl]` in `packages/block-library/src/cover/edit/index.js` with a single source-agnostic observer keyed on `effectiveUrl`, using `useEffectEvent` for latest reads and a `raceTokenRef` for stale-resolution protection. Compute `effectiveUrl` and `effectiveDimRatio` once at the top of the component. Do NOT call `setAttributes` for any value in DC-2's prohibition list as a consequence of this observer.
-
-**Files**:
-- `packages/block-library/src/cover/edit/index.js` — MODIFY: import the new hook, declare `raceTokenRef`, replace the existing `useEffect([mediaUrl])` with the new observer, compute `effectiveUrl` and `effectiveDimRatio`.
-
-**Changes**:
-1. Add imports at the top of the file:
-   - `import useCoverBindingState from './use-cover-binding-state';`
-   - Ensure `useEffectEvent`, `useRef`, `useEffect` are imported from `@wordpress/element` (some may already be present).
-2. **Prop-boundary change for `context`** — `CoverEdit` currently destructures `context: { postId, postType }` in its props signature (verified at `packages/block-library/src/cover/edit/index.js:95`), so there is no `context` identifier in scope. Change the destructuring to keep `context` undestructured AND keep `postId`/`postType` available:
-   ```js
-   function CoverEdit( {
-       attributes,
-       clientId,
-       isSelected,
-       overlayColor,
-       setAttributes,
-       setOverlayColor,
-       toggleSelection,
-       context,
-   } ) {
-       const { postId, postType } = context;
-       …
-   }
-   ```
-   Existing references to `postId` / `postType` (e.g. the `useEntityProp( 'postType', postType, 'featured_media', postId )` call at line ~119) continue to work unchanged because the new destructure declares the same identifiers. The hook receives the full, undestructured `context` object — sources may declare `usesContext` for keys beyond `postId`/`postType` and need access to them.
-3. Inside `CoverEdit` body, after the existing props/state destructuring, before any existing `useEffect`:
-   - `const { bindingActive, bindingUnresolvable, bindingResolvedUrl, bindingResolvedId, canUserEditBindingValue } = useCoverBindingState( { clientId, attributes, context } );`
-   - `const raceTokenRef = useRef( 0 );`
-4. Compute `effectiveUrl`:
-   ```js
-   const effectiveUrl =
-       bindingResolvedUrl ??
-       ( useFeaturedImage ? mediaUrl : originalUrl?.replaceAll( '&amp;', '&' ) );
-   ```
-5. Compute `effectiveDimRatio`:
-   ```js
-   const effectiveDimRatio =
-       bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio;
-   ```
-6. Replace the existing `useEffect( () => { /* getMediaColor on mediaUrl */ }, [ mediaUrl ] )` block with:
-   - `const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => { … } );` whose body:
-     1. Returns early if `! resolvedUrl`.
-     2. Increments `raceTokenRef.current` into a local `myToken`.
-     3. `const avg = await getMediaColor( resolvedUrl );`
-     4. If `myToken !== raceTokenRef.current`, return (stale).
-     5. Read latest `attributes` / `overlayColor` via a `propsRef.current` pattern (preserve existing pattern if one exists in trunk; otherwise read directly through `useEffectEvent`'s latest-value contract).
-     6. If `! attributes.isUserOverlayColor`, call `__unstableMarkNextChangeAsNotPersistent()` then `setOverlayColor( avg )` (preserves trunk behavior; `overlayColor` IS in DC-2's prohibition list but its mutation here is a continuation of trunk's existing media-resolution path, NOT triggered by binding-state change — same call site as today). [DC-2 note: this preserves the trunk behaviour exactly; the binding-state change does not flip `isUserOverlayColor`, and the only path that calls `setOverlayColor` here is the URL-resolved derivation that runs identically for manual, featured-image, and binding-sourced URLs — i.e. source-agnostic per DC-3.]
-     7. Compute `newIsDark` from `compositeIsDark( …, … , avg )` using `effectiveDimRatio`-equivalent latest values per Design §5.2.
-     8. `__unstableMarkNextChangeAsNotPersistent()` + `setAttributes( { isDark: newIsDark } )` (allowed; `isDark` is NOT in DC-2's prohibition list).
-   - One `useEffect( () => { onUrlResolved( effectiveUrl ); }, [ effectiveUrl, onUrlResolved ] );`.
-7. The existing event handlers (`onSelectMedia`, `onClearMedia`, `onSetOverlayColor`, `onUpdateDimRatio`, `toggleUseFeaturedImage`, `onSelectEmbedUrl`) are UNCHANGED — they continue to mutate stored attributes in response to user intent (allowed under DC-2).
-8. The overlay-span class computation MUST use `effectiveDimRatio` rather than `dimRatio` in `dimRatioToClass( … )` (verify the JSX site exists; trunk code references the overlay `<span>` near the dim-class computation — pass `effectiveDimRatio` through).
-
-**Depends on**: Task 6
-
-**Traces to**: Spec Req 10, Req 11, Req 12, Req 13, Req 14, Req 15; AC-15, AC-17, AC-18 (client side); DC-1, DC-2, DC-3; Design §5.2, §5.3, §5.4.
-
-**Acceptance**:
-- The file contains exactly ONE `useEffect` whose dependency array includes `effectiveUrl`. No new `useEffect` keyed on `metadata.bindings`, `useFeaturedImage`, or similar event sources is introduced. (DC-1 enforcement — verifiable by code review.)
-- `effectiveUrl` is computed exactly once at the top of `CoverEdit`, prefers `bindingResolvedUrl`, falls back to `useFeaturedImage`'s `mediaUrl`, then to `originalUrl`.
-- `effectiveDimRatio` is 50 only when `bindingActive && dimRatio === 100 && effectiveUrl`. In all other cases it equals `dimRatio`.
-- The observer body does NOT call `setAttributes` (or any equivalent attribute write) for any of the DC-2-prohibited attributes — `dimRatio`, `useFeaturedImage`, `backgroundType`, `id`, `url`, `hasParallax`, `isRepeated`, `overlayColor`, `customOverlayColor` — EXCEPT for `overlayColor`/`customOverlayColor`, whose mutation via `setOverlayColor( avg )` is a deliberate source-agnostic carve-out per Design §5.2/§5.3: it is the same media-resolution path that fires for manual selection and `useFeaturedImage` URLs, NOT a fresh binding-state-triggered write. Per DC-3 the observer cannot branch on URL source, so this `setOverlayColor` call IS the source-agnostic continuation of trunk behaviour. The only fresh `setAttributes` call inside the observer is `{ isDark }`. (DC-2 enforcement — verifiable by inspection. Acceptance for Task 11 has a corresponding mock-setAttributes test.)
-- When two `effectiveUrl` changes happen in quick succession, only the latest `getMediaColor` resolution actually writes `overlayColor` / `isDark` (race-token-protected).
-- The overlay span class uses `dimRatioToClass( effectiveDimRatio )` rather than `dimRatioToClass( dimRatio )`.
-
----
-
-### Task 8: Bound-cover empty-cover placeholder branch and `<img>`-forced non-empty render branch in `CoverEdit`
-
-**Goal**: Two structural render-tree changes in `packages/block-library/src/cover/edit/index.js`:
-1. The empty-cover branch (currently `if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground )` near line 599) renders a binding-aware `<Placeholder>` when `bindingActive || bindingUnresolvable` — the standard `<CoverPlaceholder>` is NOT rendered on bound covers.
-2. The non-empty image render branch (around `url && isImageBackground` near line 672) emits a forced `<img>` (no `<div bg>`) whenever `bindingActive`, regardless of `hasParallax`/`isRepeated`.
-
-**Files**:
-- `packages/block-library/src/cover/edit/index.js` — MODIFY.
-
-**Changes**:
-1. In the empty-cover branch, BEFORE returning the existing `<CoverPlaceholder>` JSX:
-   - If `bindingActive || bindingUnresolvable`, return a JSX subtree per Design §5.4 (1):
-     - `<>` containing the existing `blockControls`, `inspectorControls`, conditional `<ResizableCoverPopover/>`, then a `<TagName … className={ clsx( 'is-placeholder', blockProps.className ) } style={ { …blockProps.style, minHeight: minHeightWithUnit || undefined } }>`.
-     - Inside `<TagName>`, render `{ resizeListener }`.
-     - If `bindingUnresolvable`, render `<Placeholder data-testid="cover-binding-unresolvable" className="wp-block-cover__binding-unresolvable" withIllustration instructions={ __( 'Internal media required for this binding.' ) } />`.
-     - Else (bindingActive but pending resolution), render `<Placeholder className="wp-block-cover__binding-pending" withIllustration />`.
-   - Else fall through to the existing trunk `<CoverPlaceholder>` return — UNCHANGED.
-2. In the non-empty image render branch (around `url && isImageBackground` near line 672):
-   - **Swap the outer gating predicate from the stored `url` to the derived `effectiveUrl`, AND add the `! bindingUnresolvable` guard.** Concretely, rewrite the predicate `{ url && isImageBackground && ( … ) }` to `{ ! bindingUnresolvable && effectiveUrl && isImageBackground && ( … ) }`. This is a Pattern-Overrides-critical change — per Design §5.4 (2) — because on a pattern-instance Cover whose stored `url` is empty (e.g. immediately after a Pattern Overrides reset that cleared the override, or when the synced pattern was authored with no default) but whose `bindingResolvedUrl` is populated, gating on the stored `url` would route the cover through the empty-cover branch and AC-7 would fail. Gating on `effectiveUrl` keeps the bound `<img>` rendering through the branch.
-   - Inside the (now `effectiveUrl`-gated) branch, switch on `bindingActive`:
-     - When `bindingActive`, force-render `<img ref={ mediaElement } className="wp-block-cover__image-background" alt={ alt } src={ effectiveUrl } style={ mediaStyle } />` (skipping the `isImgElement` check that would otherwise pick a `<div>` for parallax/repeat saved markup).
-     - When `! bindingActive`, the existing trunk JSX (with `isImgElement` switching between `<img>` and `<div>`, and reading `src={ url }`) is preserved verbatim. Importantly, this branch continues to read the stored `url`, NOT `effectiveUrl`, on unbound covers — `effectiveUrl` collapses to `url` when no binding is active (per Task 7 step 4), so the user-observable output is byte-identical to trunk on unbound covers (AC-20).
-3. The overlay span: pass `effectiveDimRatio` to `dimRatioToClass` (this is the same change as in Task 7 step 7 — Task 7 establishes the derived value; Task 8 confirms the call site).
-4. Import `__` from `@wordpress/i18n` if not already imported (it almost certainly already is).
-5. Import `Placeholder` from `@wordpress/components` if not already imported.
-
-**Depends on**: Task 7
-
-**Traces to**: Spec Req 16, AC-4, AC-15 (client side), AC-19 (client side); Design §5.4 (1), §5.4 (2), OQ-6 (i18n string + `data-testid`).
-
-**Acceptance**:
-- On a Cover with no bindings and no background, the existing `<CoverPlaceholder>` renders (no regression — AC-20).
-- On a Cover with `bindingUnresolvable: true`, the editor preview contains a `<Placeholder>` whose accessible text includes the literal string `Internal media required for this binding.`. Its containing element has `data-testid="cover-binding-unresolvable"`. No `<img class="wp-block-cover__image-background">` is rendered.
-- The non-empty image branch's outer gating predicate uses `effectiveUrl`, NOT the stored `url`. A Cover whose stored `url === ''` but whose `bindingResolvedUrl` is populated (the Pattern Overrides default state on a pattern-instance) reaches the image branch and renders the bound `<img>` (AC-7).
-- On a Cover with `bindingActive: true`, `bindingUnresolvable: false`, and an `effectiveUrl`, the editor preview contains `<img class="wp-block-cover__image-background" src="{effectiveUrl}">` (an `<img>`, not a `<div style="background-image:…">`), even when `hasParallax: true` and `isRepeated: true` are stored on the block.
-- The overlay `<span class="wp-block-cover__background …">` class string uses `effectiveDimRatio` for `dimRatioToClass` — when `dimRatio === 100 && bindingActive && effectiveUrl`, the class string does NOT contain `has-background-dim-100`.
-- On a Cover with `backgroundType: 'embed-video'` and `metadata.bindings` set, `bindingActive` is `false` (from Task 6) → the binding-aware branches do NOT engage and the existing embed-video render path runs unchanged (AC-21).
-
----
-
-### Task 9: Gate parallax and repeat controls in `inspector-controls.js`; gate `<MediaReplaceFlow>` in `block-controls.js`; gate line-750 `<CoverPlaceholder>` in `index.js`
-
-**Goal**: Hide every Cover-specific control that conflicts with bindings, in all surfaces (inspector parallax/repeat, toolbar media-replace, line-750 cover-placeholder drop-zone). Honour AC-11..AC-14 by literal DOM absence — not by `disabled` props.
-
-**Files**:
-- `packages/block-library/src/cover/edit/inspector-controls.js` — MODIFY: accept a new `bindingActive` prop and conditionally render the parallax + repeat `<ToolsPanelItem>`s.
-- `packages/block-library/src/cover/edit/block-controls.js` — MODIFY: accept a new `bindingActive` prop and conditionally render the entire `<MediaReplaceFlow>` element.
-- `packages/block-library/src/cover/edit/index.js` — MODIFY: pass `bindingActive` to both child components AND wrap the line-750 `<CoverPlaceholder>` call site in `{ ! bindingActive && ( … ) }`.
-
-**Changes**:
-
-In `inspector-controls.js`:
-1. Add `bindingActive` to the destructured props.
-2. Wrap the JSX fragment that contains the "Fixed background" and "Repeated background" `<ToolsPanelItem>`s in `{ ! bindingActive && ( <> … </> ) }`. (If the items are not currently inside a fragment together, wrap them together first.)
-
-In `block-controls.js`:
-1. Add `bindingActive` to the destructured props.
-2. Inside the `<BlockControls group="other">`, wrap the entire `<MediaReplaceFlow … >` (including its `<MenuItem>` children for "Embed video from URL") in `{ ! bindingActive && ( … ) }`.
-3. The "Embed video from URL" `<MenuItem>` is consciously removed alongside `<MediaReplaceFlow>` on bound non-embed-video covers per Design §5.5 trade-off. Embed-video covers force `bindingActive=false` from Task 6, so AC-21's population still has the affordance.
-
-In `index.js`:
-1. When rendering `<CoverInspectorControls … />` and `<CoverBlockControls … />`, pass `bindingActive={ bindingActive }`.
-2. At the line-750 site (the `<CoverPlaceholder disableMediaButtons onSelectMedia={ onSelectMedia } onError={ onUploadError } toggleUseFeaturedImage={ toggleUseFeaturedImage } />`), wrap in `{ ! bindingActive && ( <CoverPlaceholder … /> ) }`. The existing call site moves inside a JSX expression block.
-
-**Depends on**: Task 7 (establishes `bindingActive` in `CoverEdit`), Task 8 (the line-616 branch is already binding-aware).
-
-**Traces to**: Spec Req 4, Req 5, Req 6, Req 7; AC-11, AC-12, AC-13, AC-14; Design §5.5, §5.4 (line-750 gating), §13 (AC-14 gating table, line-750 trade-off table).
-
-**Acceptance**:
-- On a Cover with `bindingActive: true`, the inspector DOM contains NO `<ToolsPanelItem>` for "Fixed background" (parallax) and NO `<ToolsPanelItem>` for "Repeated background" (repeat).
-- On a Cover with `bindingActive: true`, the block toolbar DOM contains NO `<MediaReplaceFlow>` button (no `Add media` / `Replace` toggle, no `Open Media Library`, no `Upload`, no `Use featured image`, no `Embed video from URL` menu items).
-- On a Cover with `bindingActive: false` (unbound, or embed-video, or mismatched), the inspector and toolbar render the existing trunk controls byte-for-byte (AC-20 non-regression).
-- On a Cover with `bindingActive: true` AND `hasBackground: true`, the rendered cover DOM contains NO `<CoverPlaceholder>` at the line-750 site (the drop-zone is not present; dropping a file does not mutate `url`).
-- `cover-placeholder.js` source file is NOT modified.
-
----
-
-### Task 10: PHPUnit coverage in `phpunit/blocks/render-block-cover-test.php`
-
-**Goal**: Lock down server-side behaviour with the nine cases enumerated in Design §6.5 — including the AC-25 PHPUnit case explicitly required by the spec and the AC-18 first-pass-injection regression test.
-
-**Files**:
-- `phpunit/blocks/render-block-cover-test.php` — MODIFY: extend with new test methods. (No file creation; the file exists.)
-
-**Changes**:
-1. Add `setUp`/`tearDown` helpers to register a test binding source via `register_block_bindings_source( 'test/cover-source', [ 'label' => 'Test', 'get_value_callback' => fn() => …, ] )` and unregister on tearDown. Use the existing `register_block_bindings_source` infrastructure.
-2. Add `setUp` helper to upload two test attachments (default + override) via the standard PHPUnit attachment-fixture pattern (mirror `phpunit/blocks/render-block-image-test.php` or `render-block-media-text-test.php` for patterns).
-3. Add nine `public function test_…` methods, one per Design §6.5 case:
-   - `test_bound_url_substitutes_in_plain_img_form` (AC-3)
-   - `test_default_dim_ratio_class_is_relaxed` (AC-16, AC-25)
-   - `test_non_default_dim_ratio_is_preserved` (AC-17)
-   - `test_parallax_saved_markup_is_rebuilt_as_img` (AC-19)
-   - `test_mismatched_source_strips_image` (AC-6)
-   - `test_external_url_strips_image` (AC-5)
-   - `test_use_featured_image_with_active_binding_emits_exactly_one_img_with_bound_url` (AC-18)
-   - `test_embed_video_short_circuits` (AC-21)
-   - `test_unbound_cover_is_byte_identical_to_trunk` (AC-20)
-4. Each test method constructs a `parsed_block` array via `parse_blocks( '<!-- wp:cover {…} … /wp:cover -->' )` or builds the array directly, calls `render_block( $parsed_block )`, and asserts on the returned HTML via `assertStringContainsString` / `assertStringNotContainsString` / `assertMatchesRegularExpression` per case.
-
-**Depends on**: Task 5 (the server filter must exist and be loaded).
-
-**Traces to**: Spec Req 17–22, Req 23 (Unbound non-regression invariant locked down by `test_unbound_cover_is_byte_identical_to_trunk`), Req 34 (PHPUnit case asserting bound `<img src>` substitution and non-`has-background-dim-100` class), Req 35 (existing tests continue to pass); AC-3, AC-5, AC-6, AC-15, AC-16, AC-17, AC-18, AC-19, AC-20, AC-21, AC-25; Design §6.5, §11.2.
-
-**Acceptance**:
-- All nine new test methods pass.
-- `vendor/bin/phpunit phpunit/blocks/render-block-cover-test.php` exits 0 with no failures and no skipped tests.
-- The pre-existing test methods in `render-block-cover-test.php` continue to pass (AC-20, Req 35 non-regression).
-- The `test_use_featured_image_with_active_binding_emits_exactly_one_img_with_bound_url` case asserts the bound URL appears in the output exactly once and the featured-image URL does not appear at all (catches AC-18 regressions in either direction).
-- The `test_default_dim_ratio_class_is_relaxed` case asserts BOTH the absence of `has-background-dim-100` AND the presence of `has-background-dim` (preserves the 50%-opacity baseline per OQ-4).
-
----
-
-### Task 11: Jest unit tests for `useCoverBindingState` and the single observer
-
-**Goal**: Cover the client-side hook predicates (every branch of `bindingActive` / `bindingUnresolvable`) and the observer's race-token / source-agnostic / no-attribute-mutation behaviour.
-
-**Files**:
-- `packages/block-library/src/cover/test/edit.js` — MODIFY: extend with new `describe('useCoverBindingState')` and `describe('CoverEdit single observer')` blocks.
-
-**Changes**:
-1. In `packages/block-library/src/cover/test/edit.js`, add a new `describe( 'useCoverBindingState', … )` block with at least these cases (per Design §11.1):
-   - `bindingActive` true for `{ __default: { source: 'core/pattern-overrides' } }`.
-   - `bindingActive` true for matching source + matching args.
-   - `bindingActive` false for differing sources.
-   - `bindingActive` false for differing args.
-   - `bindingActive` false for `backgroundType === 'embed-video'`.
-   - `bindingUnresolvable` true on mismatched-source binding.
-   - `bindingUnresolvable` true on resolved-not-found attachment (selector returns `null`).
-   - `bindingUnresolvable` false on pending attachment (selector returns `undefined`).
-   - `effectiveDimRatio` returns 50 only when `bindingActive && dimRatio === 100 && effectiveUrl` is truthy. (This may be tested through `CoverEdit` integration rather than directly, since `effectiveDimRatio` is local to `CoverEdit`.)
-2. Add a `describe( 'CoverEdit single observer', … )` block with at least:
-   - The observer does not call `setAttributes` for any value in DC-2's prohibition list when a binding becomes active (mock `setAttributes`, transition `metadata.bindings` from `undefined` to `{ __default: … }`, assert `setAttributes` was not called with `dimRatio`/`useFeaturedImage`/etc.).
-   - The observer is source-agnostic: identical observer behavior whether the URL change came from `attributes.url`, `useFeaturedImage`'s `mediaUrl`, or `bindingResolvedUrl`.
-   - The race-token guard: two rapid `effectiveUrl` changes followed by out-of-order `getMediaColor` resolutions — only the second resolution writes `overlayColor` / `isDark`.
-3. Use existing test infrastructure (Jest mocking of `@wordpress/data`'s `useSelect`, mocking `getMediaColor`).
-
-**Depends on**: Task 6, Task 7
-
-**Traces to**: Spec Req 10, Req 11, Req 13, Req 26, Req 35 (existing edit.js tests continue to pass); AC-3, AC-4, AC-6; DC-1, DC-2, DC-3; Design §5.1, §5.2, §11.1.
-
-**Acceptance**:
-- All new test cases pass.
-- `npm run test:unit packages/block-library/src/cover/test/edit.js` exits 0.
-- The pre-existing edit.js tests continue to pass (Req 35 non-regression).
-- The DC-2 mutation-prohibition test fails the build if a future change introduces `setAttributes({ dimRatio: … })` in the observer.
-
----
-
-### Task 12: E2E test — Pattern Overrides round-trip and unresolvable-binding affordance
-
-**Goal**: End-to-end browser test that exercises Pattern Overrides on Cover from authoring to front-end render and back, plus the mismatched-source unresolvable-binding case. Satisfies AC-22, AC-23, AC-24.
-
-**Files**:
-- `test/e2e/specs/editor/blocks/cover.spec.js` — MODIFY: add a new `test.describe('Block Bindings — Pattern Overrides round-trip', …)` block.
-- (Optional, if needed for mismatched-source coverage) `packages/e2e-tests/plugins/block-bindings.php` — REUSE existing; do not modify unless an additional test source is required and even then prefer adding to the existing test plugin.
-
-**Changes**:
-1. Add a new `test.describe( 'Block Bindings — Pattern Overrides round-trip', … )` to `test/e2e/specs/editor/blocks/cover.spec.js`.
-2. Test fixture `setup`:
-   - Upload two attachments via `requestUtils.uploadMedia` (default + override).
-   - Reset on cleanup.
-3. Single `test( 'Cover round-trips through default → override → reset', … )` with these phases (per Design §11.3):
-   - **Setup**: create a synced pattern containing a Cover whose `url`+`id` are bound via the "Enable overrides" affordance on the pattern-author surface. Save the pattern.
-   - **Default state**: open a new post, insert the pattern. Assert:
-     - Editor preview `<img>` src matches `defaultMedia.url`.
-     - The parallax `<ToolsPanelItem>` for "Fixed background" is not visible (AC-11).
-     - The repeat `<ToolsPanelItem>` for "Repeated background" is not visible (AC-12).
-     - `page.getByRole('button', { name: /^(Replace|Add media)$/ })` resolves to zero matches inside the Cover's block toolbar (AC-13 + AC-14).
-     - The overlay span's `class` attribute contains `has-background-dim` but NOT `has-background-dim-100` (AC-15).
-     - The `ResetOverridesControl` toolbar button is `toBeDisabled()` (AC-10, OQ-2).
-     - **Embed-video control case (AC-21 preservation, per Design §11.3):** on a SEPARATE Cover inserted in the same post with `backgroundType: 'embed-video'` AND `metadata.bindings` set to a Pattern Overrides shape, assert that the block toolbar `Replace` / `Add media` button IS visible AND the "Embed video from URL" `MenuItem` inside `<MediaReplaceFlow>` IS reachable. This locks in the design's load-bearing carve-out: bindings UI may surface bindable rows on embed-video covers but the binding-aware editor derivations and binding-aware server render path BOTH short-circuit (`bindingActive === false` from Task 6's embed-video gate), so the existing trunk affordances remain intact.
-   - **Override**: programmatically set the bound `url`/`id` on the instance (via `editor.dispatch` or by using the Cover's media affordance if available). Assert:
-     - The `ResetOverridesControl` button becomes enabled.
-     - Editor preview `<img>` src matches `overrideMedia.url`.
-     - Publish the post; navigate to the front-end.
-     - Front-end `<img>` src matches `overrideMedia.url` (AC-8).
-     - Front-end overlay span class contains `has-background-dim` but NOT `has-background-dim-100` (AC-16).
-   - **Reset**: navigate back to the editor; click the `ResetOverridesControl` toolbar button. Assert:
-     - Editor preview `<img>` src is back to `defaultMedia.url`.
-     - Publish; front-end `<img>` src is `defaultMedia.url` (AC-9).
-   - **Unresolvable**: programmatically construct a Cover whose `metadata.bindings.id.source !== metadata.bindings.url.source` (mismatched). Assert:
-     - `await expect( page.getByText( 'Internal media required for this binding.' ) ).toBeVisible();` (AC-24, OQ-6 primary signal).
-
-**Depends on**: Tasks 1–9 (the entire feature must be present and working server-side AND client-side before this test passes).
-
-**Traces to**: Spec Req 24 (Pattern Overrides four-state round-trip exercised end-to-end through default → override → reset → unresolvable phases), Req 29, Req 30, Req 31, Req 32, Req 33, Req 35 (existing cover.spec.js tests continue to pass); AC-7, AC-8, AC-9, AC-10, AC-11, AC-12, AC-13, AC-14, AC-15, AC-16, AC-21 (embed-video control case), AC-22, AC-23, AC-24; Design §11.3.
-
-**Acceptance**:
-- The new test passes when run via `npm run test:e2e -- test/e2e/specs/editor/blocks/cover.spec.js`.
-- All existing tests in `cover.spec.js` continue to pass (Req 35 non-regression).
-- The unresolvable-binding assertion uses the i18n message string `Internal media required for this binding.` (NOT the `data-testid`) — i.e. the primary OQ-6 contract.
-- The hidden-controls assertions are positive ("zero matches") — they fail loudly if any control reappears.
-- The embed-video control case asserts the `Replace`/`Add media` button IS present AND the `Embed video from URL` `MenuItem` IS reachable on a Cover with `backgroundType: 'embed-video'` and active-looking bindings — this is the AC-21 positive assertion the design (§11.3) calls for.
-
----
-
-### Task 13: Backport-changelog stub and PR description draft
-
-**Goal**: Satisfy the PR-shape requirements (Req 36, Req 37, AC-26, AC-27) by adding the backport-changelog placeholder file and drafting the PR description text. This task lands the backport entry once the Core PR number is known (per Design §2.2 and §15 risk 6, the entry can be added with a `TODO` placeholder if the Core PR doesn't yet exist; final number gets filled in before merge).
-
-**Files**:
-- `backport-changelog/7.1/<core-pr-number>.md` — CREATE (use `TODO-cover-bindings.md` as a placeholder filename if Core PR # is not yet known; rename before merging).
-- (No file output for the PR description; the code-writer composes it in the GitHub PR body.)
-
-**Changes**:
-1. Create `backport-changelog/7.1/<core-pr-number>.md` containing the established two-line format (verified against existing entries — e.g. `backport-changelog/7.1/10869.md` has exactly this shape):
-   ```
-   https://github.com/WordPress/wordpress-develop/pull/<core-pr-number>
-
-   * https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>
-   ```
-   Line 1 is the bare wordpress-develop URL (must match the filename's PR number). Line 2 is blank. Line 3 is the bulleted Gutenberg PR URL. No surrounding blank line, no closing newline beyond standard end-of-file. The filename's numeric portion (`<core-pr-number>.md`) MUST match the PR number in line 1.
-2. In the PR description (composed in the GitHub PR body), include:
-   - The text "Fixes #77199" (AC-27).
-   - An explicit statement of the relationship to #74109 and #74610: "This PR subsumes the work of #74109 and #74610, replacing them with a narrowly-scoped, internal-only design. Those PRs may be closed." (AC-27; phrasing may vary, but the explicit relationship statement is mandatory.)
-   - A "Test plan" section enumerating the unit, PHPUnit, and e2e cases added (see Tasks 10–12).
-
-**Depends on**: Tasks 10–12 (the PR description references the test cases; the backport stub references the Gutenberg PR which is opened only after all the code is in place).
-
-**Traces to**: Spec Req 36, Req 37, Req 38, Req 39; AC-26, AC-27, AC-28; Design §12.
-
-**Acceptance**:
-- A file exists at `backport-changelog/7.1/<core-pr-number>.md` (or a `TODO`-named placeholder) and follows the established 7.1 backport entry two-line format (line 1: `https://github.com/WordPress/wordpress-develop/pull/<core-pr-number>`; blank line; line 3: `* https://github.com/WordPress/gutenberg/pull/<gutenberg-pr-number>`), matching the shape of every other entry in `backport-changelog/7.1/`.
-- The Gutenberg PR description (when opened) contains the literal text `Fixes #77199` and explicitly references #74109 and #74610.
-- The total net diff (additions − deletions, across Tasks 1–13) is targeted at ~500 lines — verified after all tasks land by `git diff --stat trunk...HEAD`. The design's §12 estimate of ~533 lines is the budget; reviewers may request trimming the e2e block per Design §12 if the diff overshoots.
-- No file is created under `lib/compat/wordpress-7.0/` (AC-26 negative invariant).
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan-review-approved.md
deleted file mode 100644
index bcf38d52187172..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan-review-approved.md
+++ /dev/null
@@ -1,32 +0,0 @@
-# Doc Plan Review
-
-## Verdict: approved
-
-## Summary
-
-The doc plan is tight, well-scoped, and correctly identifies the single documentation surface that needs human-edited updates (the Block Bindings reference guide at `docs/reference-guides/block-api/block-bindings.md`). The four tasks (add table row, add Cover-specific notes, add Pattern Overrides example, add CHANGELOG entry) cover every author-facing surface the code phase will affect. Key claims verified against the repo:
-
-- `docs/reference-guides/block-api/block-bindings.md` exists with the "Compatible blocks and their attributes" table at lines 23-36 and the `core/pattern-overrides` subsection at lines 172-214 (matches the plan's parenthetical line hints).
-- `packages/block-library/src/cover/` has NO `README.md` (verified — only PHP/JS source, `block.json`, `editor.scss`, `style.scss`, etc.).
-- `packages/block-library/CHANGELOG.md` exists with an `## Unreleased` heading at line 3 (matches the plan's target).
-- A repo-wide sweep for `core/cover` in `docs/` confirms the bindings reference is the only canonical surface that enumerates supported blocks/attributes for bindings; the other mentions (curating-the-editor, block-filters reference, data-core-block-editor, testing-overview, static-dynamic-rendering) are unrelated to bindings (block-locking templates, render-callback example, test fixture, getElementParents example) and do not require updates.
-- `docs/reference-guides/core-blocks.md` is autogenerated from `block.json` (the plan correctly skips it).
-- The `block_bindings_supported_attributes` filter is documented only in `block-bindings.md` (single source of truth — no duplicate prose surfaces to keep in sync).
-
-Task acceptance is drift-resistant: every task names a concrete audience, traces to specific spec requirements (with one minor citation slip in Task 4 — see Notes), and uses user-observable contract language (i18n message string, named UI controls, `backgroundType: "embed-video"` short-circuit) rather than implementation details (no PHP function names, no hook names, no filter names in the acceptance bullets). The plan stays strictly within doc scope — no code tasks duplicate code-plan responsibilities. Pattern Overrides is correctly headlined per spec, and the `__default` wildcard shape is the right idiom for the new Cover example (spec Glossary confirms the editor writes this shape, even though the existing paragraph example in the doc still uses the older per-attribute shape — a stylistic inconsistency the doc-writer can leave alone since updating the paragraph example is out of scope).
-
-## Notes (non-blocking, doc-writer's discretion in phase 5)
-
-These observations do not block approval but the doc-writer should weigh them when executing the plan:
-
-1. **Task 4 trace citation slip.** Task 4 traces to "Spec Req 38 (PR shape — the changelog entry is part of the standard PR shape for block-library changes)". Req 38 is actually "The net diff (including tests) SHOULD target under ~500 lines" — it is about diff size, not changelogs. The stronger justification (which the task already invokes) is the `AGENTS.md` "each package has README.md and CHANGELOG.md" convention plus the `packages#maintaining-changelogs` link at the top of the file. The CHANGELOG entry is correct to include; only the spec-requirement citation is misattributed. The doc-writer can ignore this and add the entry on convention grounds alone.
-
-2. **Task 3 enumerates "three round-trip states" — spec Req 24 has four.** The acceptance bullet says "The reader-takeaway paragraph names the three round-trip states the spec enumerates: insert pattern instance (renders the default), override per instance, reset (returns to default)." Spec Req 24 actually enumerates four states (a) default no override, (b) overridden, (c) reset-to-default, (d) reset affordance suppressed when value matches default. The three "render" states the plan names are correct as user-takeaway pedagogy (state (d) is a control-state, not a render-state), but for accuracy the doc-writer may want to either say "the three render states" explicitly or mention the disabled-reset semantics briefly.
-
-3. **Version annotation.** The existing `block-bindings.md` uses inline "Since WordPress 6.9" annotations (e.g. lines 90, 218) for new bindings affordances. The plan's Task 2 Goal mentions "from WP 7.1 onward" but the acceptance doesn't require a version annotation. The doc-writer should add a "Since WordPress 7.1" annotation to the Cover-specific notes for consistency with the section's existing convention — this is a minor pattern-matching call, not a defect in the plan.
-
-4. **Pre-existing pattern-overrides example uses per-attribute shape.** The existing paragraph example at `block-bindings.md:188-200` uses `metadata.bindings.content.source: core/pattern-overrides`, NOT the `__default` shape. The plan's Task 3 asks the new Cover example to use `__default`, which is correct per spec Glossary. The doc-writer should NOT feel obliged to also update the paragraph example — that is a separate concern out of this PR's scope, and the plan correctly does not ask for it.
-
-5. **Parenthetical line numbers in Tasks 1/2/3.** The plan parenthetically cites line ranges ("currently at lines 23-36", "lines 172-214"). These are presented as hints, not locators — the load-bearing locators are header names ("Compatible blocks and their attributes section", "core/pattern-overrides subsection"). If an unrelated PR lands first and the line numbers drift, the doc-writer's header-based locating still works. No action required.
-
-None of these is a blocking issue. The plan is ready for phase 5.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan.md b/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan.md
deleted file mode 100644
index 9d3f01344f2fd2..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/3-plan/doc-plan.md
+++ /dev/null
@@ -1,124 +0,0 @@
-# Doc Plan: Cover block bindings — internal-only `id` and `url`
-
-Spec: `<artifacts>/1-spec/spec.md` (approved)
-Design: `<artifacts>/2-design-doc/design-doc.md` (approved)
-Code plan: `<artifacts>/3-plan/code-plan.md` (approved)
-
-All AC-N, Req-N, DC-N, OQ-N citations resolve to those documents.
-
-## Overview
-
-The code work lands Block Bindings support on `core/cover` for the `id` and `url` attributes, restricted to internal media library attachments, with Pattern Overrides as the headline use case. The only **author-facing** reference documentation that today enumerates which blocks and attributes participate in Block Bindings (and in Pattern Overrides by extension) is `docs/reference-guides/block-api/block-bindings.md`. That single file needs the Cover row added to its compatibility table, and a short Pattern-Overrides-on-Cover note explaining the internal-media constraint, the auto-hidden controls, and the embed-video carve-out — so a plugin/theme developer reading the bindings reference can correctly reason about what is supported on Cover before they ship a pattern or a custom source. The autogenerated `docs/reference-guides/core-blocks.md` is rebuilt from `block.json` and does not need a manual edit. There is no per-block `README.md` for `core/cover` (verified) — Cover's documentation surface is entirely the bindings reference guide. The package-level `packages/block-library/CHANGELOG.md` carries a release-notes entry under its `Unreleased` heading. Backport-changelog and PR-description metadata are already covered by Code-plan Task 13 and are NOT duplicated here.
-
-A reviewer of this plan should sweep for any other text in the repo that today says "Cover does not support bindings" or enumerates the set of bindable blocks. The grep performed during planning surfaced exactly one such surface: `docs/reference-guides/block-api/block-bindings.md` (the "Compatible blocks and their attributes" table). All other appearances of "Cover" / "core/cover" in `docs/` (curating-the-editor README, block-filters reference, data-core-block-editor reference, testing-overview, RN integration test guide, the autogenerated `core-blocks.md`) are unrelated to bindings and do not need updating.
-
-## Tasks
-
-### Task 1: Add `core/cover` to the Block Bindings compatibility table
-
-**Goal**: Make the public Block Bindings reference state clearly that `core/cover` supports `id` and `url` as bindable attributes from WP 7.1 onward, so plugin and theme developers reading the canonical reference see Cover listed alongside Image, Heading, Paragraph, Button, etc.
-
-**Audience**: Plugin developers, theme developers, and pattern authors who consult the Block Bindings reference to discover which block attributes can be bound.
-
-**Files**:
-- `docs/reference-guides/block-api/block-bindings.md` — MODIFY: update the "Compatible blocks and their attributes" table (currently at lines 23–36) to include a new row for `core/cover` listing `id, url`.
-
-**Sections / scope**:
-- The "Compatible blocks and their attributes" section. Only the table is touched; surrounding prose is unchanged.
-
-**Depends on**: Code-plan Task 1 (the `role: "content"` schema change) and Code-plan Task 2 (the `block_bindings_supported_attributes` filter that makes `core/cover` allow-listed at runtime).
-
-**Traces to**: Spec Req 1, Req 2, Req 8; AC-1; Design §2.2, §6.1 Part 1, §8.
-
-**Acceptance**:
-- The "Compatible blocks and their attributes" table contains a row whose first column is `core/cover` and whose second column lists the two attributes documented in the spec as bindable (`id`, `url`).
-- The reader can locate `core/cover` in the table with a single in-page find for "cover".
-- The row's column alignment matches the existing table format (no broken markdown table rendering).
-- No other block's row in the table is modified.
-
----
-
-### Task 2: Document the internal-media constraint and auto-hidden controls for Cover
-
-**Goal**: Explain, in the Block Bindings reference, the Cover-specific behaviour that is NOT shared by other bindable blocks: the binding only honours media-library attachments (external URLs are surfaced as unresolvable), and several Cover-specific controls (parallax, repeat, media-replace, "Use featured image") are hidden whenever a binding is active. A reader who binds `core/cover` for the first time should not be surprised by the behaviour described in the spec's Acceptance Criteria.
-
-**Audience**: Plugin and theme developers writing or shipping custom binding sources whose values may flow into `core/cover`, and pattern authors who bind Cover via Pattern Overrides.
-
-**Files**:
-- `docs/reference-guides/block-api/block-bindings.md` — MODIFY: add a new subsection within the document explaining the Cover-specific contract.
-
-**Sections / scope**:
-- A new H3 subsection placed within or immediately after the "Compatible blocks and their attributes" section (the doc-writer chooses the most natural anchor — adjacent to the table is fine; a small "Block-specific notes" or "Cover block" subsection is fine).
-- The subsection covers, at minimum:
-  - The internal-media-only invariant: bound `url` must resolve to a media-library attachment whose `id` is also bound from the same source instance. External URLs / mismatched sources are treated as unresolvable.
-  - What "unresolvable" looks like to the end user in the editor (the spec's stable test-observable signal — the i18n message string) and what the front-end renders in that state (no `<img>`).
-  - The controls that are hidden in the editor when a binding is active: parallax, repeat, media-replace, "Use featured image". A bound Cover surfaces overrides through the binding source (e.g. Pattern Overrides), not through the Cover's own media-replace control.
-  - The render-time effective dim ratio when the stored `dimRatio` is the default 100 — the rendered overlay is non-opaque so the bound image is visible.
-  - The embed-video carve-out: `backgroundType: "embed-video"` short-circuits the binding-aware paths in both editor and server; binding rows MAY appear in the UI but have no runtime effect on embed-video covers.
-
-**Depends on**: Task 1 (the row that establishes Cover as bindable); Code-plan Tasks 6–9 (the editor-side behaviour the subsection describes); Code-plan Task 5 (the server-side render path the subsection references when describing front-end output).
-
-**Traces to**: Spec Req 4, Req 5, Req 6, Req 7, Req 14, Req 16, Req 20, Req 22, Req 25, Req 26, Req 27; AC-4, AC-5, AC-6, AC-11, AC-12, AC-13, AC-14, AC-15, AC-16, AC-21; Design §5.4, §5.5, §10, §12 (embed-video carve-out).
-
-**Acceptance**:
-- A reader of the Block Bindings reference can answer "what happens if I bind Cover's url to an external (non-media-library) URL?" without leaving the page — the section names the user-visible affordance the spec defines and states that the front-end omits the `<img>`.
-- A reader can answer "which Cover-specific controls disappear when a binding is active?" — parallax, repeat, media-replace, and "Use featured image" are all named.
-- A reader is told that `backgroundType: "embed-video"` covers do not engage the binding-aware paths, even if the bindings UI lists `id`/`url` as bindable.
-- The section explains that the default `dimRatio` of 100 does not produce a fully opaque overlay on bound covers — the rendered overlay remains visibly translucent over the bound image.
-- The section does NOT prescribe internal implementation details (no `useEffect`, no filter names, no PHP function names) — it describes user-observable contract only.
-- The section's wording is consistent with the surrounding doc's tone and the existing `core/pattern-overrides` subsection (descriptive prose plus optional small code/markup example).
-
----
-
-### Task 3: Document the Pattern Overrides on Cover example
-
-**Goal**: Give pattern authors a copy-pasteable example of binding a `core/cover` block via `core/pattern-overrides` (the headline use case for this PR). The existing `core/pattern-overrides` section in the bindings reference shows a paragraph example only; a Cover example is the natural counterpart for the new compatibility row.
-
-**Audience**: Pattern authors creating synced patterns with overridable cover images.
-
-**Files**:
-- `docs/reference-guides/block-api/block-bindings.md` — MODIFY: add a Cover-on-Pattern-Overrides example inside the existing `### core/pattern-overrides` subsection (currently at lines 172–214), OR as a continuation of the Task 2 "Block-specific notes" / "Cover block" subsection — the doc-writer chooses the placement that minimises duplication.
-
-**Sections / scope**:
-- A short HTML/block-markup example showing a Cover block whose `metadata.bindings` is set to the `__default: { source: 'core/pattern-overrides' }` shape (the Pattern Overrides idiomatic form the spec's Glossary describes).
-- A one-paragraph reader-takeaway: pattern authors mark Cover overridable the same way they mark paragraphs/headings overridable; per-instance overrides flow through the existing Pattern Overrides mechanism; reset semantics use the existing toolbar control (disabled when value matches default, per OQ-2).
-- Cross-link or breadcrumb to the Task 2 "internal media required" affordance so authors know what happens when a Cover instance's override resolves to no usable attachment.
-
-**Depends on**: Task 2 (the Cover-specific notes section sets the stage for the example); Code-plan Task 2 (the server-side allow-list registration that makes "Enable overrides" appear on Cover); Code-plan Task 12 (the e2e test that exercises this exact round-trip — the example should reflect the same authoring path the e2e walks through).
-
-**Traces to**: Spec Req 9, Req 24; AC-2, AC-7, AC-8, AC-9, AC-10; Design §5.6, §9.
-
-**Acceptance**:
-- A reader can copy the example markup and use it (as written or as a starting point) to create a synced pattern with a bound Cover block.
-- The example uses the `__default` wildcard shape (`metadata.bindings.__default = { source: 'core/pattern-overrides' }`) consistent with how the editor writes Pattern Overrides bindings, NOT a verbose per-attribute shape — readers should not learn an obsolete idiom from this doc.
-- The reader-takeaway paragraph names the three round-trip states the spec enumerates: insert pattern instance (renders the default), override per instance, reset (returns to default).
-- The example does not show external-URL binding (out of scope) and does not show mismatched-source binding (unsupported).
-
----
-
-### Task 4: Add release-notes entry to `packages/block-library/CHANGELOG.md`
-
-**Goal**: Record the Cover-block bindings addition in the package's running changelog under the `Unreleased` heading, so the next published `@wordpress/block-library` release notes mention the feature. This is the standard maintenance practice flagged by the repo's `AGENTS.md` ("each package has README.md and CHANGELOG.md") and confirmed by the project's `packages#maintaining-changelogs` reference at the top of the changelog file.
-
-**Audience**: Downstream consumers of the `@wordpress/block-library` npm package who read release notes to discover behavioural changes; plugin authors auditing block behaviour between Gutenberg releases.
-
-**Files**:
-- `packages/block-library/CHANGELOG.md` — MODIFY: append a bullet under the existing `## Unreleased` heading.
-
-**Sections / scope**:
-- A single bullet (or a small bullet cluster if the doc-writer judges the change warrants separation between "New feature" and "Internal") describing the Cover block bindings addition.
-- The bullet follows the existing changelog format (concise prose, PR link in parentheses — the PR number is filled in by the doc-writer at the time of writing, by reading the most recent commit's PR reference or the orchestrator's PR-creation step).
-- The bullet names the user-observable change ("Cover block now supports Block Bindings for `id` and `url`, with Pattern Overrides support") without prescribing implementation.
-
-**Depends on**: All code-plan tasks (the changelog entry is a description of the cumulative work).
-
-**Traces to**: Spec Req 38 (PR shape — the changelog entry is part of the standard PR shape for block-library changes); the project's `AGENTS.md` convention for per-package CHANGELOG maintenance.
-
-**Acceptance**:
-- The `## Unreleased` section of `packages/block-library/CHANGELOG.md` contains a new bullet that names the Cover block and Block Bindings.
-- The bullet is placed under an appropriate subsection heading (the existing changelog uses `### Internal`, `### New features`, `### Bug Fixes`, `### Enhancements` — the doc-writer picks the one matching the change's nature; "New features" or "Enhancements" is the natural fit since this is user-visible block behaviour).
-- The bullet follows the file's prevailing format: short imperative sentence ending in a parenthesised PR link.
-- No other section of the changelog file is modified.
-- The bullet does NOT mention internal implementation details (no PHP function names, no filter names, no React-hook names).
-
----
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/4-code/code-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/4-code/code-review-approved.md
deleted file mode 100644
index a426b9279161e5..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/4-code/code-review-approved.md
+++ /dev/null
@@ -1,69 +0,0 @@
-# Code Review
-
-## Verdict: approved
-
-## Batch scope
-
-Tasks reviewed: Tasks 1–13 from `3-plan/code-plan.md`.
-
-- Task 1: Add `role: "content"` to `core/cover`'s `id` attribute.
-- Task 2: Create `lib/compat/wordpress-7.1/block-bindings.php` with allow-list filter, wire it into `lib/load.php`.
-- Task 3: Add `gutenberg_cover_bindings_is_active` helper.
-- Task 4: `render_block_data` filter to neutralise `useFeaturedImage` on bound covers.
-- Task 5: Cover-scoped `render_block` filter with image-rewrite / dim-class-relax / strip-image helpers.
-- Task 6: New hook — `useCoverBindingState`.
-- Task 7: Single observer + derived values in `CoverEdit`.
-- Task 8: Bound-cover empty-cover placeholder branch and `<img>`-forced non-empty render branch in `CoverEdit`.
-- Task 9: Gate parallax/repeat in `inspector-controls.js`; gate `<MediaReplaceFlow>` in `block-controls.js`; gate line-750 `<CoverPlaceholder>`.
-- Task 10: PHPUnit coverage in `phpunit/blocks/render-block-cover-test.php`.
-- Task 11: Jest unit tests for `useCoverBindingState` and the single observer.
-- Task 12: E2E — Pattern Overrides round-trip and unresolvable-binding affordance.
-- Task 13: Backport-changelog stub and PR description draft.
-
-## Summary
-
-The batch lands internal-only Block Bindings support for `core/cover`'s `id` and `url`, headlined by Pattern Overrides, in 8 feature commits on the worktree branch (plus 4 test/docs commits). The server-side path is a single Cover-scoped file (`lib/compat/wordpress-7.1/block-bindings.php`) wired into `lib/load.php` with three filters: allow-list (`block_bindings_supported_attributes`), pre-render neutralisation of `useFeaturedImage` (`render_block_data` @ priority 10), and post-render markup rewrite (`render_block` @ priority 9). The client-side path introduces a single-`useSelect` hook (`useCoverBindingState`) and replaces the existing `[mediaUrl]` `useEffect` with a single source-agnostic observer keyed on `effectiveUrl`, using `useEffectEvent` for latest-value reads and a race-token ref for stale-resolution protection. UI gating in `inspector-controls.js`, `block-controls.js`, and the line-750 `<CoverPlaceholder>` call site is conditional-render-based per AC-14's literal-DOM-absence requirement. Tests are comprehensive: 9 new PHPUnit cases, 19 new Jest cases (43 total in `edit.js`, all green), and one e2e describe with five `test.step` phases covering the full Pattern Overrides round-trip plus an embed-video AC-21 control case and an unresolvable-binding affordance check. Lint passes cleanly on the touched files, PHP code style produces only the documented intentional `==` warning, and the byte-identical AC-20 PHPUnit case explicitly removes and re-adds both filters to lock the no-regression contract. DC-1 (single observer), DC-2 (no binding-state-triggered attribute mutation outside the documented DC-3 source-agnostic `setOverlayColor` carve-out + permitted `isDark` write), and DC-3 (source-agnostic derivation) all hold.
-
-## Checks
-
-| Check | Command | Result |
-| ----- | ------- | ------ |
-| JSON schema validity | `node -e "JSON.parse(require('fs').readFileSync('packages/block-library/src/cover/block.json','utf8'))"` | Pass — `block.json valid` |
-| JS lint | `npm run lint:js packages/block-library/src/cover/` | Pass — 0 errors; 10 warnings pre-existing in `*.native.js` files outside this batch |
-| Jest unit suite | `npm run test:unit -- packages/block-library/src/cover/test/edit.js` | Pass — 43/43 tests green (24 pre-existing + 19 new) |
-| PHP lint/code style | `vendor/bin/phpcs lib/compat/wordpress-7.1/block-bindings.php phpunit/blocks/render-block-cover-test.php` | Pass — 0 errors; 3 warnings (1 intentional `==` per Design §6.1, 2 unused-param warnings for required filter signatures) |
-| PHPUnit | `npx wp-env --config .wp-env.test.json run cli --env-cwd=wp-content/plugins/gutenberg -- composer run test -- --filter Tests_Blocks_Render_Cover` | Pass — 11/11 tests, 32 assertions (2 pre-existing + 9 new) |
-| E2E syntactic validity | `node --check test/e2e/specs/editor/blocks/cover.spec.js` | Pass |
-| `lib/load.php` wiring | `grep -n "wordpress-7.1" lib/load.php` | Pass — `require __DIR__ . '/compat/wordpress-7.1/block-bindings.php';` is present at line 83 |
-| Diff against trunk | `git diff trunk...HEAD --stat -- '*.js' '*.php' '*.json'` | 8 production files; 2,581 insertions / 95 deletions |
-
-## Behavior verification
-
-The verification convention for this repo is JS unit + PHPUnit + E2E plus lint/code-style gates. All four ran:
-
-- **PHPUnit** — `Tests_Blocks_Render_Cover` ran inside `wp-env-test` via the standard `composer run test --filter`. All 11 tests pass, including:
-  - `test_bound_url_substitutes_in_plain_img_form` (AC-3) — bound URL appears in `src`, pre-existing saved URL removed, `wp-image-{id}` replaced.
-  - `test_default_dim_ratio_class_is_relaxed` (AC-16, AC-25) — `has-background-dim-100` removed, `has-background-dim` preserved.
-  - `test_non_default_dim_ratio_is_preserved` (AC-17) — `has-background-dim-70` survives untouched.
-  - `test_parallax_saved_markup_is_rebuilt_as_img` (AC-19) — `<div>` form rebuilt as `<img>`, no `has-parallax`/`is-repeated` on the image, no `background-image:url()` CSS in the rebuilt element.
-  - `test_mismatched_source_strips_image` (AC-6) — image element stripped on mismatched-source bindings.
-  - `test_external_url_strips_image` (AC-5) — non-attachment id strips the image.
-  - `test_use_featured_image_with_active_binding_emits_exactly_one_img_with_bound_url` (AC-18) — bound URL appears exactly once, featured-image URL absent, exactly one `wp-block-cover__image-background` survives.
-  - `test_embed_video_short_circuits` (AC-21) — bound URL absent, `has-background-dim-100` survives.
-  - `test_unbound_cover_is_byte_identical_to_trunk` (AC-20) — byte-identical output with and without both new filters.
-
-- **Jest** — `packages/block-library/src/cover/test/edit.js` covers `useCoverBindingState` predicates (no-bindings shape, mismatched source, differing args, embed-video override, mismatched-source unresolvable, pending vs not-found vs wrong-type attachment), bound-cover render (unresolvable placeholder, force-`<img>` despite `hasParallax`/`isRepeated`, `effectiveUrl` reach when stored `url` is empty, dim-100 relaxation, embed-video inertness), control gating (parallax/repeat absence, MediaReplaceFlow absence), and the single-observer invariants (no DC-2 mutation, source-agnostic `getMediaColor` invocation for manual vs bound URL, single observer fire on mount). All 43 tests green.
-
-## Issues
-
-None.
-
-## Notes
-
-A few minor observations that did not rise to rejection but warrant a glance from future maintainers:
-
-1. **Backport-changelog stub (Task 13)** is NOT present on the worktree branch HEAD. Trunk has commit `077b1f7a042` (`docs(backport): add cover bindings backport-changelog stub for 7.1`) creating `backport-changelog/7.1/TODO-cover-bindings.md`, but that commit is on `trunk` rather than the feature branch, so `git diff trunk...HEAD` does not include it. Per Design §2.2 (and Code Plan Task 13 phrasing), this file is a SHOULD that "Not a blocker for the Gutenberg PR landing" — Req 36 conditionally requires the entry "when the corresponding Core PR exists". AC-26 covers only the new compat file's location, which is satisfied. The PR-description text required by AC-27 is itself a PR-creation step rather than a code change.
-
-2. **Embed-video edge case (`bindingUnresolvable` on bindings-configured embed-video covers).** `useCoverBindingState` returns `bindingActive=false` for embed-video covers (correct per AC-21), but `bindingUnresolvable` evaluates to `true` whenever the cover carries any cover-relevant binding configuration AND is not active — which includes the embed-video case. In practice this is moot because (a) the non-empty image branch is gated by `isImageBackground=false` for embed-video, (b) the empty-cover branch only fires when there is no `hasBackground` (and a normal embed-video cover has a `url` so `hasBackground=true`). Confirmed by the `leaves the embed-video render path engaged on a cover with bindings (binding is inert)` Jest test. The pathological "empty embed-video cover with bindings" state is not reachable through normal authoring flows. Worth a defensive gate (`backgroundType !== 'embed-video'` inside the `bindingUnresolvable` computation) if a regression ever surfaces here, but no fix needed for landing.
-
-3. **PHPCS intentional warnings.** Two unused-param warnings on `gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $parent_block )` and one loose-equality warning on the `args` comparison are expected: the filter signature is fixed by WP core's `render_block_data` callback contract, and the loose equality is documented in Design §6.1 / Code Plan Task 3 as the deliberate order-insensitive associative-array comparison that mirrors the JS-side `JSON.stringify` parity check.
diff --git a/.pipelines/77199-cover-bindings-id-url-internal/5-docs/docs-review-approved.md b/.pipelines/77199-cover-bindings-id-url-internal/5-docs/docs-review-approved.md
deleted file mode 100644
index 9110e41f74966f..00000000000000
--- a/.pipelines/77199-cover-bindings-id-url-internal/5-docs/docs-review-approved.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# Docs Review
-
-## Verdict: approved
-
-## Batch scope
-
-Tasks reviewed:
-- Doc Task 1: Add `core/cover` to the Block Bindings compatibility table.
-- Doc Task 2: Document the internal-media constraint and auto-hidden controls for Cover.
-- Doc Task 3: Document the Pattern Overrides on Cover example.
-- Doc Task 4: Add release-notes entry to `packages/block-library/CHANGELOG.md`.
-
-## Summary
-
-The batch lands a complete, coherent documentation surface for Cover Block Bindings in the canonical Block Bindings reference and a release-notes entry in the block-library package CHANGELOG. The compatibility table row, the Cover-specific subsection (internal-media-only invariant, hidden controls, dim-ratio behaviour, embed-video carve-out), the Pattern Overrides on Cover example, and the changelog bullet all align with the shipped server filters in `lib/compat/wordpress-7.1/block-bindings.php`, the editor changes in `packages/block-library/src/cover/edit/`, and the spec/design contracts. The user-observable i18n string `Internal media required for this binding.` is faithfully reproduced from the code. No internal implementation details (no `useEffect`, no React hook names, no PHP function names) leak into reader-facing prose. Markdown lint introduces no new violations within the touched regions; the five pre-existing MD033 inline-HTML errors are all in trunk-original callout admonitions outside the doc-writer's edits.
-
-## Checks
-
-| Check | Command | Result |
-| ----- | ------- | ------ |
-| Markdown lint (docs gate) | `npm run lint:md:docs` | Pass for touched regions. All 5 remaining `docs/reference-guides/block-api/block-bindings.md` MD033 hits are pre-existing inline-HTML callouts at lines 3, 321–322, 504–505 — none in the added Cover subsection (38–59) or the Cover example subsection (240–270). Verified by comparing pre-change content via `git show 50dfa44b461^:docs/reference-guides/block-api/block-bindings.md`. |
-| Compatibility table row matches `block.json` `role` declarations | `Read packages/block-library/src/cover/block.json` | `id` and `url` both declare `"role": "content"`. Doc row `\| core/cover \| id, url \|` matches. |
-| i18n string matches shipped code | `grep "Internal media required" packages/block-library/src/cover/edit/index.js` | `__( 'Internal media required for this binding.' )` at index.js:699 matches the literal string quoted in `block-bindings.md:46`. |
-| Hidden-controls list matches code | `grep "bindingActive" packages/block-library/src/cover/edit/{inspector-controls,block-controls}.js` | inspector-controls.js:255 gates Fixed background + Repeated background `ToolsPanelItem`s on `! bindingActive`. block-controls.js:153 gates the entire `<MediaReplaceFlow>` (which carries Replace/Add media, Use featured image, and Embed video from URL menu items) on `! bindingActive`. Doc enumerates: Fixed background (parallax), Repeated background, Replace/Add media (media-replace), Use featured image — exact match. |
-| `__default` Pattern Overrides example shape matches editor write path | `grep "__default" packages/patterns/src/components/pattern-overrides-controls.js` | Editor writes `attributes.metadata.bindings.__default = { source: PATTERN_OVERRIDES_BINDING_SOURCE }` at pattern-overrides-controls.js:52–53. Doc example at block-bindings.md:249–254 uses identical shape, no per-attribute entries. |
-| `getValues` keyed by `metadata.name` | `Read packages/editor/src/bindings/pattern-overrides.js` | `getValues` resolves through `patternOverridesContent?.[ currentBlockAttributes?.metadata?.name ]?.[ attributeName ]` at pattern-overrides.js:21–23. Doc step 2 wording "the override is written into the pattern instance's `content` attribute keyed by the Cover's `metadata.name`" matches. |
-| Embed-video carve-out matches code | `grep "embed-video" packages/block-library/src/cover/edit/use-cover-binding-state.js lib/compat/wordpress-7.1/block-bindings.php` | Client: `bindingActive = … && attributes.backgroundType !== 'embed-video'` (use-cover-binding-state.js:96). Server: both `gutenberg_cover_bindings_prepare_block` (block-bindings.php:237) and `gutenberg_cover_bindings_render_block` (block-bindings.php:534) short-circuit on `'embed-video' === $attrs['backgroundType']`. Doc's embed-video paragraph matches the short-circuit behaviour. |
-| Server "no `<img>` on unresolvable" matches code | `Read lib/compat/wordpress-7.1/block-bindings.php` | `gutenberg_cover_bindings_strip_image` (block-bindings.php:293–307) splices out either the `<div class="wp-block-cover__image-background">…</div>` or the `<img class="wp-block-cover__image-background" …>` form when the binding is unresolvable. Overlay span is untouched. Doc's "front-end HTML omits the `<img>` element … the overlay still renders" matches. |
-| Dim-ratio default-100 rewrite gate matches code | `grep "dimRatio.*100\|relax_dim_class" lib/compat/wordpress-7.1/block-bindings.php` | block-bindings.php:572 — `gutenberg_cover_bindings_relax_dim_class` only fires when stored `dimRatio === 100`. Non-default values are honoured. Doc's dim-ratio paragraph (lines 57) matches. |
-| Changelog format follows `## Unreleased` convention | `Read packages/block-library/CHANGELOG.md` | Bullet under `### New features` immediately below `## Unreleased`, before the `## 9.47.0` release. Format matches surrounding entries. No mention of `useEffect`, hook names, or PHP function names. |
-| No drift in other surfaces | `grep -rn "compatible with block bindings\|Compatible blocks" docs/` | Only `block-bindings.md` enumerates bindable blocks. No other surface needs an edit. Doc-plan §Overview correctly identified this. |
-| Doc-plan adherence | `git log trunk..HEAD --stat -- docs/ packages/block-library/CHANGELOG.md backport-changelog/` | Three commits touch `block-bindings.md` (one per Doc Tasks 1–3) and one touches `packages/block-library/CHANGELOG.md` (Doc Task 4). The backport-changelog stub commit (3a4a87790a6) is Code-plan Task 13, not duplicated here per the doc-plan §Overview note. No scope creep. |
-
-## Accuracy spot-check
-
-- **Task 1 (compatibility table row).** Verified `core/cover`'s `id` declares `"role": "content"` in `packages/block-library/src/cover/block.json:18-21`. The new row `| core/cover | id, url |` at `docs/reference-guides/block-api/block-bindings.md:33` is positioned alphabetically after `core/button` (the existing convention is loosely-alphabetical-by-block-name); column alignment preserved versus the existing rows. Row matches the spec-mandated `id` + `url` set (Req 1, Req 2).
-
-- **Task 2 (Cover-specific notes section).** Spot-checked four concrete claims:
-  - "the editor surfaces the message `Internal media required for this binding.`" — exact literal match against `__( 'Internal media required for this binding.' )` at `packages/block-library/src/cover/edit/index.js:699`.
-  - "the rendered front-end HTML omits the `<img>` element for that cover (the overlay still renders)" — verified `gutenberg_cover_bindings_strip_image` at `lib/compat/wordpress-7.1/block-bindings.php:293-307` removes only the `wp-block-cover__image-background` `<div>` or `<img>` element; the `wp-block-cover__background` overlay span and `wp-block-cover__inner-container` are untouched. Both `gutenberg_cover_bindings_render_block` paths (the unresolvable-config branch at lines 545-547 and the missing-resolved-value branches at 554-560) invoke `strip_image`, never erase the overlay.
-  - "the iframe renders from the saved `url` attribute" on embed-video covers — verified the embed-video carve-out short-circuits BEFORE any binding-resolved URL substitution at `lib/compat/wordpress-7.1/block-bindings.php:534-536` and `237-239`; the existing `render_block_core_cover` embed-video path (in `packages/block-library/src/cover/index.php`) renders the iframe from the saved attribute unchanged.
-  - "If a user has explicitly set `dimRatio` to a non-default value (for example `70`), that value is used as-is in both editor and front-end render" — verified server-side `gutenberg_cover_bindings_relax_dim_class` is only invoked when `100 === (int) ( $attrs['dimRatio'] ?? 100 )` at `lib/compat/wordpress-7.1/block-bindings.php:572`. Editor-side: `effectiveDimRatio = bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio` in `packages/block-library/src/cover/edit/index.js` returns the stored value for any non-100 case.
-
-- **Task 3 (Pattern Overrides on Cover example).** Spot-checked the `metadata.bindings.__default = { source: 'core/pattern-overrides' }` shape against `packages/patterns/src/components/pattern-overrides-controls.js:52-53`, which writes exactly that on toggle-on. Spot-checked the "keyed by `metadata.name`" claim against `packages/editor/src/bindings/pattern-overrides.js:14-23` where `getValues` reads `patternOverridesContent?.[ currentBlockAttributes?.metadata?.name ]?.[ attributeName ]`. The example's block comment metadata is correctly shaped and would deserialise into a working Cover block. Minor illustrative imprecision in the rendered HTML between the block delimiters (`has-background-dim-50` would not actually be emitted because `dimRatioToClass(50) === null` per `packages/block-library/src/cover/shared.js:32-36` — the saved markup for `dimRatio: 50` is `has-background-dim` only). This does not affect functional copy-paste usage because Gutenberg deserialises blocks from the comment-delimiter JSON, not the HTML body; flagging here for future cleanup but not blocking.
-
-- **Task 4 (changelog).** Spot-checked the bullet's location (under `## Unreleased > ### New features`, immediately above the `## 9.47.0 (2026-05-27)` release section); format `(...) ([#77199](https://github.com/WordPress/gutenberg/issues/77199))` is consistent with surrounding entries (other entries link to PRs; the issue link is acceptable as a working stand-in until the PR is filed, per doc-plan Task 4's "the PR number is filled in by the doc-writer at the time of writing" leeway). The bullet's wording — "Support Block Bindings for the `id` and `url` attributes, enabling Pattern Overrides for cover images sourced from the media library" — names the user-observable feature and omits any internal-implementation terminology (no `useEffect`, no React hook names, no PHP function names), satisfying doc-plan Task 4 Acceptance.

From 78b89083d892c878f57fef0bd7e68d1a217fa216 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 10:38:44 +0200
Subject: [PATCH 41/60] refactor(block-bindings): inline __default expansion in
 is_active
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Drop gutenberg_cover_bindings_expand_bindings — Core's
process_block_bindings already expands __default before resolution.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 87 +++++++--------------
 1 file changed, 27 insertions(+), 60 deletions(-)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index c7ef0125c1e3a5..ba4438cc39c2e5 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -50,67 +50,23 @@ function gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_
 
 add_filter( 'block_bindings_supported_attributes', 'gutenberg_cover_bindings_add_supported_attributes', 10, 2 );
 
-if ( ! function_exists( 'gutenberg_cover_bindings_expand_bindings' ) ) {
-	/**
-	 * Expands a Cover block's `metadata.bindings` array by materialising any
-	 * `__default` entry into per-attribute slots.
-	 *
-	 * Mirrors the client-side `replacePatternOverridesDefaultBinding` helper at
-	 * `packages/block-editor/src/utils/block-bindings.js` and the server-side
-	 * expansion in `lib/compat/wordpress-6.9/block-bindings.php` (the
-	 * `__default` branch inside `gutenberg_process_block_bindings`), scoped to
-	 * the Cover-supported attribute list `[ 'id', 'url' ]`. Like both of those
-	 * callers, expansion is only performed when `__default.source` is
-	 * `core/pattern-overrides` — `__default` is currently a Pattern Overrides
-	 * affordance and does not apply to other sources.
-	 *
-	 * When expansion runs, each Cover-supported attribute that does NOT already
-	 * have an explicit binding entry inherits a `{ source: 'core/pattern-overrides' }`
-	 * stub. Pre-existing explicit entries (e.g. a mixed-source configuration)
-	 * are retained verbatim. The `__default` key itself is dropped from the
-	 * returned array, matching the canonical expansion semantics.
-	 *
-	 * When `__default` is absent (or its source is not `core/pattern-overrides`),
-	 * the input array is returned unchanged.
-	 *
-	 * @since 7.1.0
-	 * @access private
-	 *
-	 * @param array<string, array<string, mixed>> $bindings The `metadata.bindings`
-	 *                                                       map for a Cover block.
-	 * @return array<string, array<string, mixed>> The expanded bindings map.
-	 */
-	function gutenberg_cover_bindings_expand_bindings( array $bindings ): array {
-		if (
-			! isset( $bindings['__default']['source'] ) ||
-			'core/pattern-overrides' !== $bindings['__default']['source']
-		) {
-			return $bindings;
-		}
-
-		$expanded = array();
-		foreach ( array( 'id', 'url' ) as $attribute_name ) {
-			$expanded[ $attribute_name ] = isset( $bindings[ $attribute_name ] )
-				? $bindings[ $attribute_name ]
-				: array( 'source' => 'core/pattern-overrides' );
-		}
-
-		return $expanded;
-	}
-}
-
 if ( ! function_exists( 'gutenberg_cover_bindings_is_active' ) ) {
 	/**
 	 * Determines whether a parsed Cover block has an active binding.
 	 *
 	 * Server-side mirror of the client `bindingActive` predicate computed in
-	 * `useCoverBindingState`. A binding is "active" when, after `__default`
-	 * expansion, BOTH the `id` and `url` attributes are bound to the same
-	 * source instance — same `source` string AND `==`-equal `args`. Loose
-	 * equality (`==`) on `args` matches the JS-side `JSON.stringify` parity
-	 * check and is the correct semantic for the small associative bags that
-	 * source `args` contain in practice; element ordering does not affect
-	 * equality.
+	 * `useCoverBindingState`. A binding is "active" when BOTH the `id` and
+	 * `url` attributes are bound to the same source instance — same `source`
+	 * string AND `==`-equal `args`. Loose equality (`==`) on `args` matches
+	 * the JS-side `JSON.stringify` parity check and is the correct semantic
+	 * for the small associative bags that source `args` contain in practice;
+	 * element ordering does not affect equality.
+	 *
+	 * A `__default` entry sourced from `core/pattern-overrides` is its own
+	 * active-binding indicator: Core's `process_block_bindings` already
+	 * materialises it into per-attribute slots before resolution, so the
+	 * Cover render filter sees resolved `id`/`url` values without this helper
+	 * having to expand `__default` itself.
 	 *
 	 * The helper is intentionally pure-by-bindings: it does NOT short-circuit
 	 * on `backgroundType === 'embed-video'` — that gate is the responsibility
@@ -132,14 +88,25 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 			return false;
 		}
 
-		$expanded = gutenberg_cover_bindings_expand_bindings( $bindings );
+		// A `__default` pattern-overrides binding implies both `id` and `url`
+		// are bound to the same source instance once Core's
+		// `process_block_bindings` expands it.
+		if ( isset( $bindings['__default']['source'] ) && 'core/pattern-overrides' === $bindings['__default']['source'] ) {
+			return true;
+		}
+
+		$id_binding  = $bindings['id'] ?? null;
+		$url_binding = $bindings['url'] ?? null;
+		if ( empty( $id_binding ) || empty( $url_binding ) ) {
+			return false;
+		}
 
-		$same_source = ( $expanded['id']['source'] ?? null ) === ( $expanded['url']['source'] ?? null );
+		$same_source = ( $id_binding['source'] ?? null ) === ( $url_binding['source'] ?? null );
 		// Loose equality on associative arrays per Design §6.1 — `args` are a
 		// small bag of scalars and we want order-insensitive comparison.
-		$same_args = ( $expanded['id']['args'] ?? null ) == ( $expanded['url']['args'] ?? null ); // phpcs:ignore WordPress.PHP.StrictComparisons.LooseComparison
+		$same_args = ( $id_binding['args'] ?? null ) == ( $url_binding['args'] ?? null ); // phpcs:ignore WordPress.PHP.StrictComparisons.LooseComparison
 
-		return ! empty( $expanded['id'] ) && ! empty( $expanded['url'] ) && $same_source && $same_args;
+		return $same_source && $same_args;
 	}
 }
 

From a7b122c649c58bd4cef1000e8e02266214b51b02 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 10:39:55 +0200
Subject: [PATCH 42/60] refactor(block-library): drop unused returns from
 useCoverBindingState

bindingResolvedId and canUserEditBindingValue had no runtime consumer.
Restore when actual lock-flag UI is wired.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/cover/edit/use-cover-binding-state.js | 32 +++----------------
 packages/block-library/src/cover/test/edit.js |  2 --
 2 files changed, 4 insertions(+), 30 deletions(-)

diff --git a/packages/block-library/src/cover/edit/use-cover-binding-state.js b/packages/block-library/src/cover/edit/use-cover-binding-state.js
index 1dbb47ce009db8..7161594c0da07b 100644
--- a/packages/block-library/src/cover/edit/use-cover-binding-state.js
+++ b/packages/block-library/src/cover/edit/use-cover-binding-state.js
@@ -45,11 +45,9 @@ function expandDefaultBinding( bindings, supportedAttributes ) {
  * The shape of state returned by {@link useCoverBindingState}.
  *
  * @typedef {Object} CoverBindingState
- * @property {boolean}          bindingActive           True iff (after `__default` expansion) both `id` AND `url` are bound to the same source instance (same source, same `args`) AND `attributes.backgroundType !== 'embed-video'`.
- * @property {boolean}          bindingUnresolvable     True iff `metadata.bindings` carries any cover-relevant configuration but the binding is not active, OR the bound attachment resolved to a record that is not a media-library attachment.
- * @property {string|undefined} bindingResolvedUrl      URL resolved from the bound source (or `undefined` when no binding is active or the source is missing).
- * @property {number|undefined} bindingResolvedId       Attachment ID resolved from the bound source (or `undefined`).
- * @property {boolean}          canUserEditBindingValue Result of the bound source's `canUserEditValue` callback (used downstream to decide whether to lock URL controls); `false` when the source omits the callback or when no binding is active.
+ * @property {boolean}          bindingActive       True iff (after `__default` expansion) both `id` AND `url` are bound to the same source instance (same source, same `args`) AND `attributes.backgroundType !== 'embed-video'`.
+ * @property {boolean}          bindingUnresolvable True iff `metadata.bindings` carries any cover-relevant configuration but the binding is not active, OR the bound attachment resolved to a record that is not a media-library attachment.
+ * @property {string|undefined} bindingResolvedUrl  URL resolved from the bound source (or `undefined` when no binding is active or the source is missing).
  */
 
 /**
@@ -95,28 +93,19 @@ export default function useCoverBindingState( {
 		sameArgs &&
 		attributes.backgroundType !== 'embed-video';
 
-	const {
-		bindingResolvedUrl,
-		bindingResolvedId,
-		bindingResolvedAttachment,
-		canUserEditBindingValue,
-	} = useSelect(
+	const { bindingResolvedUrl, bindingResolvedAttachment } = useSelect(
 		( select ) => {
 			if ( ! bindingActive ) {
 				return {
 					bindingResolvedUrl: undefined,
-					bindingResolvedId: undefined,
 					bindingResolvedAttachment: undefined,
-					canUserEditBindingValue: false,
 				};
 			}
 			const source = getBlockBindingsSource( expanded.url.source );
 			if ( ! source ) {
 				return {
 					bindingResolvedUrl: undefined,
-					bindingResolvedId: undefined,
 					bindingResolvedAttachment: undefined,
-					canUserEditBindingValue: false,
 				};
 			}
 			const values = source.getValues( {
@@ -135,18 +124,9 @@ export default function useCoverBindingState( {
 						{ context: 'view' }
 				  )
 				: undefined;
-			const userCanEdit =
-				source.canUserEditValue?.( {
-					select,
-					clientId,
-					context,
-					args: expanded.url.args,
-				} ) ?? false;
 			return {
 				bindingResolvedUrl: resolvedUrl,
-				bindingResolvedId: resolvedId,
 				bindingResolvedAttachment: attachment,
-				canUserEditBindingValue: userCanEdit,
 			};
 		},
 		// The dependency array is intentionally narrow: source identity (which
@@ -170,8 +150,6 @@ export default function useCoverBindingState( {
 			bindingActive: false,
 			bindingUnresolvable: false,
 			bindingResolvedUrl: undefined,
-			bindingResolvedId: undefined,
-			canUserEditBindingValue: false,
 		};
 	}
 
@@ -195,7 +173,5 @@ export default function useCoverBindingState( {
 		bindingActive,
 		bindingUnresolvable,
 		bindingResolvedUrl,
-		bindingResolvedId,
-		canUserEditBindingValue,
 	};
 }
diff --git a/packages/block-library/src/cover/test/edit.js b/packages/block-library/src/cover/test/edit.js
index 7de1eb0478daac..1b1b8f3ab19686 100644
--- a/packages/block-library/src/cover/test/edit.js
+++ b/packages/block-library/src/cover/test/edit.js
@@ -871,8 +871,6 @@ describe( 'Cover block', () => {
 			expect( bindingState.bindingActive ).toBe( false );
 			expect( bindingState.bindingUnresolvable ).toBe( false );
 			expect( bindingState.bindingResolvedUrl ).toBeUndefined();
-			expect( bindingState.bindingResolvedId ).toBeUndefined();
-			expect( bindingState.canUserEditBindingValue ).toBe( false );
 		} );
 
 		// The remaining `bindingActive: true` / `bindingUnresolvable: true`

From 40d8e608078798725acaaf61e045b96537150764 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 10:43:11 +0200
Subject: [PATCH 43/60] test(block-library): trim cover bindings Jest coverage
 to critical cases
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

22 new tests → 7 covering user-observable invariants and DC contracts.
Hook predicate matrix dropped (covered by integration + e2e).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 packages/block-library/src/cover/test/edit.js | 421 +-----------------
 1 file changed, 1 insertion(+), 420 deletions(-)

diff --git a/packages/block-library/src/cover/test/edit.js b/packages/block-library/src/cover/test/edit.js
index 1b1b8f3ab19686..e626135f4f08a8 100644
--- a/packages/block-library/src/cover/test/edit.js
+++ b/packages/block-library/src/cover/test/edit.js
@@ -1,13 +1,7 @@
 /**
  * External dependencies
  */
-import {
-	screen,
-	fireEvent,
-	act,
-	within,
-	renderHook,
-} from '@testing-library/react';
+import { screen, fireEvent, act, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 
 /**
@@ -27,7 +21,6 @@ import {
 	initializeEditor,
 	selectBlock,
 } from 'test/integration/helpers/integration-test-editor';
-import useCoverBindingState from '../edit/use-cover-binding-state';
 import { getMediaColor } from '../edit/color-utils';
 
 // Wrap `getMediaColor` so individual tests can intercept its calls / control
@@ -595,49 +588,6 @@ describe( 'Cover block', () => {
 			).not.toBeInTheDocument();
 		} );
 
-		test( 'reaches the image branch via effectiveUrl even when the stored url is empty', async () => {
-			// Pattern-Overrides-shaped state: the stored `url` is empty but
-			// the bound source provides a populated URL via `effectiveUrl`.
-			// A `customOverlayColor` keeps `hasBackground=true` so the cover
-			// renders its main JSX path (where the image branch lives)
-			// rather than the empty-cover branch.
-			await setup( {
-				url: '',
-				backgroundType: 'image',
-				customOverlayColor: '#abcdef',
-				metadata: { bindings: boundBindings },
-			} );
-
-			const coverBlock = screen.getByLabelText( 'Block: Cover' );
-
-			const boundImg = await within( coverBlock ).findByRole( 'img' );
-
-			expect( boundImg ).toHaveClass(
-				'wp-block-cover__image-background'
-			);
-			expect( boundImg ).toHaveAttribute( 'src', TEST_RESOLVED_URL );
-		} );
-
-		test( 'omits has-background-dim-100 on the overlay when dimRatio === 100 and the binding resolves a URL', async () => {
-			const { container } = await setup( {
-				url: 'http://localhost/stored-image.jpg',
-				backgroundType: 'image',
-				dimRatio: 100,
-				metadata: { bindings: boundBindings },
-			} );
-
-			// The bound `<img>` proves the active-binding path engaged.
-			await screen.findByRole( 'img' );
-
-			// eslint-disable-next-line testing-library/no-node-access
-			const overlay = container.getElementsByClassName(
-				'wp-block-cover__background'
-			)[ 0 ];
-
-			expect( overlay ).toBeInTheDocument();
-			expect( overlay ).not.toHaveClass( 'has-background-dim-100' );
-		} );
-
 		test( 'leaves the embed-video render path engaged on a cover with bindings (binding is inert)', async () => {
 			await setup( {
 				url: 'https://example.com/video',
@@ -697,29 +647,6 @@ describe( 'Cover block', () => {
 			url: { source: TEST_SOURCE },
 		};
 
-		test( 'hides the "Fixed background" and "Repeated background" inspector controls when bindingActive', async () => {
-			await setup( {
-				url: 'http://localhost/stored-image.jpg',
-				backgroundType: 'image',
-				metadata: { bindings: boundBindings },
-			} );
-
-			// Force-img branch engages, confirming the binding is active and
-			// the inspector subtree has rendered alongside it.
-			await screen.findByRole( 'img' );
-
-			// On bound covers the parallax / repeat toggles are absent from
-			// the document regardless of selection state — the inspector is
-			// rendered unconditionally by `CoverEdit`, so we can assert on
-			// the global DOM without going through `selectBlock`.
-			expect(
-				screen.queryByLabelText( 'Fixed background' )
-			).not.toBeInTheDocument();
-			expect(
-				screen.queryByLabelText( 'Repeated background' )
-			).not.toBeInTheDocument();
-		} );
-
 		test( 'hides the MediaReplaceFlow toolbar button when bindingActive', async () => {
 			await setup( {
 				url: 'http://localhost/stored-image.jpg',
@@ -748,7 +675,6 @@ describe( 'Cover block', () => {
 		// Unique per-describe source name so registrations cannot leak between
 		// the integration-style binding describes and these hook-level tests.
 		const TEST_SOURCE = 'test/cover-binding-state-hook';
-		const OTHER_SOURCE = 'test/cover-binding-state-other';
 		const TEST_RESOLVED_URL = 'http://localhost/resolved-image.jpg';
 		const TEST_RESOLVED_ID = 9991;
 
@@ -769,216 +695,10 @@ describe( 'Cover block', () => {
 				} ),
 				canUserEditValue: () => false,
 			} );
-			registerBlockBindingsSource( {
-				name: OTHER_SOURCE,
-				label: 'Other hook test binding source',
-				getValues: () => ( {
-					id: undefined,
-					url: undefined,
-				} ),
-				canUserEditValue: () => false,
-			} );
 		} );
 
 		afterEach( () => {
 			unregisterBlockBindingsSource( TEST_SOURCE );
-			unregisterBlockBindingsSource( OTHER_SOURCE );
-		} );
-
-		/**
-		 * Renders the hook under test and returns its current state. The hook
-		 * is exercised through `renderHook` with the actual data registry; the
-		 * synchronous snapshot value reflects the predicate state after the
-		 * first render (before any subscription-side rerender).
-		 *
-		 * @param {Object} attributes Cover attributes passed verbatim to the hook.
-		 * @param {Object} [context]  Optional block context object.
-		 *
-		 * @return {Object} The hook's snapshot value at first render.
-		 */
-		const snapshotBindingState = ( attributes, context = {} ) => {
-			const { result } = renderHook( () =>
-				useCoverBindingState( {
-					clientId: 'test-client-id',
-					attributes,
-					context,
-				} )
-			);
-			return result.current;
-		};
-
-		test( 'bindingActive is false when id and url have different sources', () => {
-			const bindingState = snapshotBindingState( {
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE },
-						url: { source: OTHER_SOURCE },
-					},
-				},
-			} );
-
-			expect( bindingState.bindingActive ).toBe( false );
-		} );
-
-		test( 'bindingActive is false when id and url bind to matching source but differing args', () => {
-			const bindingState = snapshotBindingState( {
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE, args: { key: 'a' } },
-						url: { source: TEST_SOURCE, args: { key: 'b' } },
-					},
-				},
-			} );
-
-			expect( bindingState.bindingActive ).toBe( false );
-		} );
-
-		test( 'bindingActive is false when backgroundType is "embed-video"', () => {
-			// AC-21: the embed-video carve-out short-circuits the binding
-			// path even when the binding configuration itself would qualify.
-			const bindingState = snapshotBindingState( {
-				backgroundType: 'embed-video',
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE },
-						url: { source: TEST_SOURCE },
-					},
-				},
-			} );
-
-			expect( bindingState.bindingActive ).toBe( false );
-		} );
-
-		test( 'bindingUnresolvable is true when bindings are present but mismatched (cover-relevant config + !bindingActive)', () => {
-			const bindingState = snapshotBindingState( {
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE },
-						url: { source: OTHER_SOURCE },
-					},
-				},
-			} );
-
-			expect( bindingState.bindingActive ).toBe( false );
-			expect( bindingState.bindingUnresolvable ).toBe( true );
-		} );
-
-		test( 'returns the no-bindings shape when `metadata.bindings` is absent', () => {
-			// The early-return shape preserves the hook's contract for every
-			// cover that has never been bound.
-			const bindingState = snapshotBindingState( {} );
-
-			expect( bindingState.bindingActive ).toBe( false );
-			expect( bindingState.bindingUnresolvable ).toBe( false );
-			expect( bindingState.bindingResolvedUrl ).toBeUndefined();
-		} );
-
-		// The remaining `bindingActive: true` / `bindingUnresolvable: true`
-		// arms are exercised through `CoverEdit` integration: a bound cover
-		// surfaces the force-img branch when `bindingActive` is true, and the
-		// "Internal media required for this binding." placeholder when
-		// `bindingUnresolvable` is true. Going through the editor lets the
-		// `useSelect` subscription that backs the hook settle inside the
-		// `act` boundary that `render()` already establishes.
-
-		test( 'bindingActive: true via `__default` pattern-overrides binding engages the force-img render path (integration)', async () => {
-			// Confirms the inline `__default` expander reaches `bindingActive`.
-			// The block-editor's own `replacePatternOverridesDefaultBinding`
-			// also runs against the block's bindings and needs to know the
-			// block's bindable attributes — supplied via the experimental
-			// editor setting below — so it can iterate `[ 'id', 'url' ]`
-			// instead of `undefined`.
-			registerBlockBindingsSource( {
-				name: 'core/pattern-overrides',
-				label: 'Pattern overrides (test stand-in)',
-				getValues: () => ( {
-					id: TEST_RESOLVED_ID,
-					url: TEST_RESOLVED_URL,
-				} ),
-				canUserEditValue: () => false,
-			} );
-
-			try {
-				await setup(
-					{
-						url: '',
-						backgroundType: 'image',
-						customOverlayColor: '#abcdef',
-						metadata: {
-							bindings: {
-								__default: {
-									source: 'core/pattern-overrides',
-								},
-							},
-						},
-					},
-					true,
-					{
-						...defaultSettings,
-						__experimentalBlockBindingsSupportedAttributes: {
-							'core/cover': [ 'id', 'url' ],
-						},
-					}
-				);
-
-				const boundImg = await screen.findByRole( 'img' );
-				expect( boundImg ).toHaveAttribute( 'src', TEST_RESOLVED_URL );
-			} finally {
-				unregisterBlockBindingsSource( 'core/pattern-overrides' );
-			}
-		} );
-
-		test( 'bindingActive: true via matching source + matching args engages the force-img render path (integration)', async () => {
-			await setup( {
-				url: '',
-				backgroundType: 'image',
-				customOverlayColor: '#abcdef',
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE, args: { key: 'shared' } },
-						url: { source: TEST_SOURCE, args: { key: 'shared' } },
-					},
-				},
-			} );
-
-			const boundImg = await screen.findByRole( 'img' );
-			expect( boundImg ).toHaveAttribute( 'src', TEST_RESOLVED_URL );
-		} );
-
-		test( 'bindingUnresolvable: false (pending) keeps the bound `<img>` slot rendered without an unresolvable placeholder (integration)', async () => {
-			// No attachment record is preloaded for this ID — the core-data
-			// selector returns `undefined`, the hook treats that as pending,
-			// and the cover renders normally with the bound `<img>` (no
-			// unresolvable placeholder).
-			const pendingId = 88_881;
-			sourceState.id = pendingId;
-			sourceState.url = 'http://localhost/pending.jpg';
-
-			await setup( {
-				url: '',
-				backgroundType: 'image',
-				customOverlayColor: '#abcdef',
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE },
-						url: { source: TEST_SOURCE },
-					},
-				},
-			} );
-
-			const coverBlock = screen.getByLabelText( 'Block: Cover' );
-
-			expect(
-				within( coverBlock ).queryByText(
-					'Internal media required for this binding.'
-				)
-			).not.toBeInTheDocument();
-
-			const boundImg = await within( coverBlock ).findByRole( 'img' );
-			expect( boundImg ).toHaveAttribute(
-				'src',
-				'http://localhost/pending.jpg'
-			);
 		} );
 
 		test( 'bindingUnresolvable: true when the bound id resolves to a non-attachment record (integration)', async () => {
@@ -1035,64 +755,6 @@ describe( 'Cover block', () => {
 				)
 			).toBeInTheDocument();
 		} );
-
-		test( 'effectiveDimRatio collapses to 50 in the rendered overlay when bindingActive && dimRatio === 100 && effectiveUrl is truthy', async () => {
-			// `effectiveDimRatio` lives inside `CoverEdit`, so this is the
-			// integration arm of the derivation. With an active binding, a
-			// resolved URL, and stored `dimRatio === 100`, the overlay must
-			// drop `has-background-dim-100` and use the default-50% baseline
-			// (`has-background-dim` only — `dimRatioToClass(50)` returns
-			// `null`, by convention, because 50 is the no-override default).
-			const { container } = await setup( {
-				url: 'http://localhost/stored.jpg',
-				backgroundType: 'image',
-				dimRatio: 100,
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE },
-						url: { source: TEST_SOURCE },
-					},
-				},
-			} );
-
-			await screen.findByRole( 'img' );
-
-			// eslint-disable-next-line testing-library/no-node-access
-			const overlay = container.getElementsByClassName(
-				'wp-block-cover__background'
-			)[ 0 ];
-
-			expect( overlay ).toHaveClass( 'has-background-dim' );
-			expect( overlay ).not.toHaveClass( 'has-background-dim-100' );
-			expect( overlay ).not.toHaveClass( 'has-background-dim-50' );
-		} );
-
-		test( 'effectiveDimRatio equals dimRatio when bindingActive but dimRatio !== 100 (non-default ratio is preserved)', async () => {
-			// The 50 collapse is gated on the *default* dim ratio. A user who
-			// has explicitly pinned a non-100 ratio gets the same dim treatment
-			// on bound and unbound covers.
-			const { container } = await setup( {
-				url: 'http://localhost/stored.jpg',
-				backgroundType: 'image',
-				dimRatio: 70,
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE },
-						url: { source: TEST_SOURCE },
-					},
-				},
-			} );
-
-			await screen.findByRole( 'img' );
-
-			// eslint-disable-next-line testing-library/no-node-access
-			const overlay = container.getElementsByClassName(
-				'wp-block-cover__background'
-			)[ 0 ];
-
-			expect( overlay ).toHaveClass( 'has-background-dim-70' );
-			expect( overlay ).not.toHaveClass( 'has-background-dim-50' );
-		} );
 	} );
 
 	describe( 'CoverEdit single observer', () => {
@@ -1222,45 +884,6 @@ describe( 'Cover block', () => {
 			expect( overlay ).not.toHaveClass( 'has-background-dim-100' );
 		} );
 
-		test( 'is source-agnostic: invokes `getMediaColor` for a manual `attributes.url` URL', async () => {
-			// DC-3 part 1: the observer treats `attributes.url` (the manual
-			// editor-driven URL) identically to other URL sources — its
-			// presence is enough to fire `getMediaColor`.
-			getMediaColor.mockClear();
-			const manualUrl = 'http://localhost/agnostic-manual.jpg';
-			await setup( {
-				url: manualUrl,
-				backgroundType: 'image',
-			} );
-			await act( async () => {
-				await Promise.resolve();
-			} );
-			expect( getMediaColor ).toHaveBeenCalledWith( manualUrl );
-		} );
-
-		test( 'is source-agnostic: invokes `getMediaColor` for a binding-resolved URL', async () => {
-			// DC-3 part 2: the same observer fires identically when the URL
-			// originates from a bound source — the unique URL per test avoids
-			// any memoised-cache cross-pollination from the manual case.
-			getMediaColor.mockClear();
-			const boundUrl = 'http://localhost/agnostic-bound.jpg';
-			sourceState.url = boundUrl;
-			await setup( {
-				url: '',
-				backgroundType: 'image',
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE },
-						url: { source: TEST_SOURCE },
-					},
-				},
-			} );
-			await act( async () => {
-				await Promise.resolve();
-			} );
-			expect( getMediaColor ).toHaveBeenCalledWith( boundUrl );
-		} );
-
 		test( 'observer fires `getMediaColor` exactly once per `effectiveUrl` on mount (race-token guard precondition: single observer keyed on effectiveUrl)', async () => {
 			// The race-token guard relies on the single-observer keyed-on-
 			// `effectiveUrl` architecture (DC-1). If a future change
@@ -1301,47 +924,5 @@ describe( 'Cover block', () => {
 			);
 			expect( callsForUrlA ).toHaveLength( 1 );
 		} );
-
-		test( 'race-token guard: no extra `getMediaColor` invocation on mount when binding-active state is in the initial attributes (DC-1 single-observer corollary)', async () => {
-			// `useEffectEvent`'s race-token bookkeeping (Task 7) ensures
-			// that out-of-order resolutions don't clobber the latest
-			// derivation. We cannot trigger two simultaneous URL changes
-			// from a Jest integration test without poking the editor's
-			// private sub-registry (the `BlockEditorProvider` creates one),
-			// so this test pins the load-bearing precondition: even when
-			// the cover mounts with binding-active state already in its
-			// attributes (so `useCoverBindingState` runs through its
-			// `useSelect` branch instead of the early-return path), the
-			// observer fires exactly ONCE — not twice, which would be the
-			// fingerprint of an extra `useEffect` keyed on bindings.
-			const URL_A = 'http://localhost/race-mount-bound.jpg';
-			const pendingPromise = new Promise( () => {
-				/* never resolves */
-			} );
-
-			getMediaColor.mockImplementation( ( url ) => {
-				if ( url === URL_A ) {
-					return pendingPromise;
-				}
-				return Promise.resolve( '#888888' );
-			} );
-
-			sourceState.url = URL_A;
-			await setup( {
-				url: '',
-				backgroundType: 'image',
-				dimRatio: 70,
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE },
-						url: { source: TEST_SOURCE },
-					},
-				},
-			} );
-
-			expect(
-				getMediaColor.mock.calls.filter( ( [ url ] ) => url === URL_A )
-			).toHaveLength( 1 );
-		} );
 	} );
 } );

From b9162ccb5d9ca686ce6d01a82b0a27f5b4d05e74 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 10:56:00 +0200
Subject: [PATCH 44/60] refactor(block-bindings): trim docblock noise in 7.1
 compat file

Cut verbose docblocks and inline narrative on the Cover bindings compat
file. Keep 1-3 line summaries, drop obvious @param/@return blocks, retain
only non-obvious-behaviour comments (priority-9 ordering, loose-== rationale).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 299 +++-----------------
 1 file changed, 38 insertions(+), 261 deletions(-)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index ba4438cc39c2e5..3cb03d5f8be499 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -3,34 +3,17 @@
  * Block Bindings: Cover block support.
  *
  * Adds `id` and `url` to the server-side supported-attributes list for
- * `core/cover`, so the editor's `__experimentalBlockBindingsSupportedAttributes`
- * setting includes them and the Block Bindings panel exposes the corresponding
- * rows for binding. The matching client-side schema metadata (the `role: "content"`
- * marker on `core/cover`'s `id` attribute) is set in `block.json`.
+ * `core/cover` and rewrites the rendered output to honour active bindings.
  *
  * @since 7.1.0
  * @package gutenberg
- * @subpackage Block Bindings
  */
 
 if ( ! function_exists( 'gutenberg_cover_bindings_add_supported_attributes' ) ) {
 	/**
-	 * Adds the `id` and `url` attributes to the list of supported block-bindings
-	 * attributes for `core/cover`.
-	 *
-	 * Registered on the `block_bindings_supported_attributes` filter. For any
-	 * block type other than `core/cover`, the input array is returned unchanged.
-	 * Existing entries are preserved; `id` and `url` are appended only when not
-	 * already present, so applying the filter twice on the same input remains
-	 * stable (`[ 'id', 'url' ]`, never `[ 'id', 'url', 'id', 'url' ]`).
+	 * Adds `id` and `url` to the bindings-supported attributes for `core/cover`.
 	 *
 	 * @since 7.1.0
-	 *
-	 * @param string[] $attributes The list of attributes supported by Block Bindings
-	 *                             for `$block_type`.
-	 * @param string   $block_type The block type whose supported attributes are
-	 *                             being filtered.
-	 * @return string[] The (possibly augmented) list of supported attributes.
 	 */
 	function gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_type ) {
 		if ( 'core/cover' !== $block_type ) {
@@ -52,35 +35,14 @@ function gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_
 
 if ( ! function_exists( 'gutenberg_cover_bindings_is_active' ) ) {
 	/**
-	 * Determines whether a parsed Cover block has an active binding.
-	 *
-	 * Server-side mirror of the client `bindingActive` predicate computed in
-	 * `useCoverBindingState`. A binding is "active" when BOTH the `id` and
-	 * `url` attributes are bound to the same source instance — same `source`
-	 * string AND `==`-equal `args`. Loose equality (`==`) on `args` matches
-	 * the JS-side `JSON.stringify` parity check and is the correct semantic
-	 * for the small associative bags that source `args` contain in practice;
-	 * element ordering does not affect equality.
-	 *
-	 * A `__default` entry sourced from `core/pattern-overrides` is its own
-	 * active-binding indicator: Core's `process_block_bindings` already
-	 * materialises it into per-attribute slots before resolution, so the
-	 * Cover render filter sees resolved `id`/`url` values without this helper
-	 * having to expand `__default` itself.
+	 * Whether a parsed Cover has both `id` and `url` bound to the same source instance.
 	 *
-	 * The helper is intentionally pure-by-bindings: it does NOT short-circuit
-	 * on `backgroundType === 'embed-video'` — that gate is the responsibility
-	 * of the callers (the `render_block_data` and `render_block` filters that
-	 * use this helper).
+	 * Server-side mirror of `useCoverBindingState`'s `bindingActive`. A
+	 * `__default` entry from `core/pattern-overrides` counts as active because
+	 * Core's `process_block_bindings` materialises it into per-attribute slots
+	 * before resolution.
 	 *
 	 * @since 7.1.0
-	 *
-	 * @param array<string, mixed> $attrs The Cover block's attribute array
-	 *                                    (typically `$parsed_block['attrs']`
-	 *                                    or `$instance->attributes`).
-	 * @return bool True when the Cover has an active `id`+`url` binding to the
-	 *              same source instance; false otherwise (including the empty
-	 *              and missing-bindings cases).
 	 */
 	function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 		$bindings = $attrs['metadata']['bindings'] ?? null;
@@ -88,9 +50,6 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 			return false;
 		}
 
-		// A `__default` pattern-overrides binding implies both `id` and `url`
-		// are bound to the same source instance once Core's
-		// `process_block_bindings` expands it.
 		if ( isset( $bindings['__default']['source'] ) && 'core/pattern-overrides' === $bindings['__default']['source'] ) {
 			return true;
 		}
@@ -102,8 +61,8 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 		}
 
 		$same_source = ( $id_binding['source'] ?? null ) === ( $url_binding['source'] ?? null );
-		// Loose equality on associative arrays per Design §6.1 — `args` are a
-		// small bag of scalars and we want order-insensitive comparison.
+		// Loose `==` on `args` per Pattern Overrides convention: order-insensitive
+		// associative-bag comparison.
 		$same_args = ( $id_binding['args'] ?? null ) == ( $url_binding['args'] ?? null ); // phpcs:ignore WordPress.PHP.StrictComparisons.LooseComparison
 
 		return $same_source && $same_args;
@@ -112,36 +71,13 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 
 if ( ! function_exists( 'gutenberg_cover_bindings_has_cover_relevant_configuration' ) ) {
 	/**
-	 * Determines whether a Cover block's `metadata.bindings` carries any
-	 * cover-relevant binding configuration.
-	 *
-	 * "Cover-relevant" means at least one of `__default`, `id`, or `url` is
-	 * present in the `metadata.bindings` map — i.e. the user has attempted to
-	 * bind one of the Cover's two bindable attributes. The helper does NOT
-	 * check whether the configuration is internally consistent; it answers
-	 * "does this cover have any cover-binding intent?", so the
-	 * `render_block` filter can distinguish:
-	 *
-	 *   - genuinely unbound covers (no `metadata.bindings` at all, or
-	 *     `metadata.bindings` only mentions attributes other than `id`/`url`
-	 *     /`__default`) — must render byte-identically to trunk (AC-20).
-	 *
-	 *   - covers whose binding configuration is present but
-	 *     `gutenberg_cover_bindings_is_active()` returned `false` (mismatched
-	 *     `source`, differing `args`, only one of `id`/`url` bound) — must
-	 *     render in the "unresolvable" state, with the saved image stripped
-	 *     (AC-6).
+	 * Whether `metadata.bindings` mentions `__default`, `id`, or `url`.
 	 *
-	 * This mirrors the client-side `bindingUnresolvable` predicate (per
-	 * `useCoverBindingState`), which similarly treats "any cover-relevant
-	 * bindings AND not active" as unresolvable.
+	 * Distinguishes genuinely unbound covers (AC-20) from covers whose binding
+	 * config is present but inactive (AC-6).
 	 *
 	 * @since 7.1.0
 	 * @access private
-	 *
-	 * @param array<string, mixed> $attrs The Cover block's attribute array.
-	 * @return bool True when `metadata.bindings` has at least one of the
-	 *              cover-relevant keys (`__default`, `id`, `url`).
 	 */
 	function gutenberg_cover_bindings_has_cover_relevant_configuration( array $attrs ): bool {
 		$bindings = $attrs['metadata']['bindings'] ?? null;
@@ -154,44 +90,12 @@ function gutenberg_cover_bindings_has_cover_relevant_configuration( array $attrs
 
 if ( ! function_exists( 'gutenberg_cover_bindings_prepare_block' ) ) {
 	/**
-	 * Neutralises `useFeaturedImage` on Cover blocks whose `id`+`url` bindings
-	 * are active, before `WP_Block::render()` builds its instance attributes.
-	 *
-	 * Registered on the `render_block_data` filter, which fires inside
-	 * `render_block()` (see `wp-includes/blocks.php`) BEFORE `WP_Block` is
-	 * constructed for the parsed block. By forcing
-	 * `$parsed_block['attrs']['useFeaturedImage']` to `false` here when a
-	 * Cover-scoped binding is active, `render_block_core_cover` skips its
-	 * featured-image injection branch on the first render pass. This is the
-	 * AC-18 precedence rule: an active `id`+`url` binding always wins over
-	 * `useFeaturedImage`, with no double-`<img>` window.
-	 *
-	 * Gating order (each step short-circuits to "return unchanged"):
-	 *
-	 * 1. The block is not `core/cover`.
-	 * 2. `backgroundType === 'embed-video'` — embed-video covers are explicitly
-	 *    out of scope for the Cover-scoped binding path (AC-21); their existing
-	 *    `useFeaturedImage` semantics remain untouched.
-	 * 3. The bindings are not active per `gutenberg_cover_bindings_is_active()`
-	 *    (no `metadata.bindings`, mismatched source, or differing `args`).
+	 * Forces `useFeaturedImage` off on bound covers before `WP_Block::render()`.
 	 *
-	 * Only after all three gates pass — AND `useFeaturedImage` is currently
-	 * truthy — does the mutation run. When `useFeaturedImage` is already
-	 * falsy/absent, the array is returned unchanged.
-	 *
-	 * Persistence safety: the mutation is scoped to the in-flight
-	 * `$parsed_block` array used for this render pass only. PHP arrays are
-	 * value-copied on assignment, so the caller's array is not modified, and
-	 * the persisted `post_content` is never touched.
+	 * AC-18: an active `id`+`url` binding always wins over `useFeaturedImage`.
+	 * Mutation is scoped to the in-flight `$parsed_block` only.
 	 *
 	 * @since 7.1.0
-	 *
-	 * @param array              $parsed_block The parsed block array, including
-	 *                                         `blockName` and `attrs` keys.
-	 * @param array              $source_block The original block as parsed (passed
-	 *                                         through unchanged).
-	 * @param WP_Block|null      $parent_block The parent block, if any (unused).
-	 * @return array The (possibly mutated) parsed block array.
 	 */
 	function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $parent_block ) {
 		if ( 'core/cover' !== ( $parsed_block['blockName'] ?? '' ) ) {
@@ -209,9 +113,6 @@ function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $
 			return $parsed_block;
 		}
 
-		// AC-18: an active binding wins over useFeaturedImage. Only mutate when
-		// there is something to flip, so the array is touched as little as
-		// possible.
 		if ( ! empty( $attrs['useFeaturedImage'] ) ) {
 			$parsed_block['attrs']['useFeaturedImage'] = false;
 		}
@@ -224,43 +125,14 @@ function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $
 
 if ( ! function_exists( 'gutenberg_cover_bindings_strip_image' ) ) {
 	/**
-	 * Removes the saved Cover image element from a rendered Cover block.
-	 *
-	 * The Cover block's `save.js` emits the background image as one of two
-	 * mutually exclusive forms:
-	 *
-	 * 1. A void `<img class="wp-block-cover__image-background" …>` (the
-	 *    non-parallax / non-repeat path).
-	 * 2. A `<div class="wp-block-cover__image-background" style="background-
-	 *    image:url(…)"></div>` (the parallax / repeat path).
-	 *
-	 * This helper locates whichever form is present and splices it out of the
-	 * content. The `<div>` form is probed first because it would otherwise be
-	 * missed by an `<img>`-only regex. If neither pattern matches, the input is
-	 * returned unchanged.
-	 *
-	 * The patterns use the `\b` word-boundary anchor around the class name so
-	 * matches only on elements that actually carry the
-	 * `wp-block-cover__image-background` class (no coincidental substring hits
-	 * on neighbouring attributes), and the `U` (ungreedy) modifier ensures
-	 * `[^>]*` does not run past intermediate `>` boundaries.
-	 *
-	 * Used when an active binding cannot be resolved (no `id`, no `url`, or the
-	 * resolved `id` is not an attachment) — see
-	 * `gutenberg_cover_bindings_render_block` — so the cover renders without an
-	 * image element, overlay-only.
+	 * Removes the saved Cover image element (either `<img>` or parallax `<div>`).
 	 *
 	 * @since 7.1.0
 	 * @access private
-	 *
-	 * @param string $content The rendered Cover block HTML.
-	 * @return string The content with the image element removed, or the input
-	 *                unchanged when no matching element is present.
 	 */
 	function gutenberg_cover_bindings_strip_image( string $content ): string {
-		// Form 2: parallax/repeat saved form — an empty <div>.
+		// Parallax/repeat saved form is probed first; an <img>-only regex would miss it.
 		$form2_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
-		// Form 1: plain saved form — a void <img> (with or without trailing slash).
 		$form1_pattern = '/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?\s*>/U';
 
 		foreach ( array( $form2_pattern, $form1_pattern ) as $pattern ) {
@@ -276,30 +148,14 @@ function gutenberg_cover_bindings_strip_image( string $content ): string {
 
 if ( ! function_exists( 'gutenberg_cover_bindings_relax_dim_class' ) ) {
 	/**
-	 * Removes `has-background-dim-100` from the Cover overlay span when an
-	 * active binding resolved its `id`+`url` and the stored `dimRatio` is the
-	 * default 100.
+	 * Removes `has-background-dim-100` from the Cover overlay span.
 	 *
-	 * Stored `dimRatio: 100` is the saved-attribute default for Cover; in the
-	 * pre-bindings universe that translated to a fully-opaque overlay
-	 * (`dim-100` -> 100% opacity), but on bound covers a fully-opaque overlay
-	 * would completely hide the bound image. The chosen "effective" dimRatio
-	 * for that case is 50 (see Design OQ-4), and because
-	 * `dimRatioToClass( 50 ) === null` the rewrite is mechanically "remove
-	 * `has-background-dim-100`" — no replacement modifier class is added. The
-	 * remaining `has-background-dim` class preserves the 50% opacity baseline.
-	 *
-	 * The pass is idempotent: when the class is already absent the call is a
-	 * no-op. The matcher is scoped to `<span class="wp-block-cover__background">`
-	 * elements via the Tag Processor so neighbouring spans are not touched.
+	 * Stored `dimRatio: 100` is the saved default; on bound covers a fully-opaque
+	 * overlay would hide the image, so the effective dimRatio is 50 (OQ-4) and
+	 * `dimRatioToClass( 50 )` is null — i.e. just remove `dim-100`.
 	 *
 	 * @since 7.1.0
 	 * @access private
-	 *
-	 * @param string $content The rendered Cover block HTML.
-	 * @return string The content with `has-background-dim-100` removed from any
-	 *                Cover overlay span, or the input unchanged when no such
-	 *                span is present.
 	 */
 	function gutenberg_cover_bindings_relax_dim_class( string $content ): string {
 		$processor = new WP_HTML_Tag_Processor( $content );
@@ -319,43 +175,12 @@ function gutenberg_cover_bindings_relax_dim_class( string $content ): string {
 	/**
 	 * Rewrites the saved Cover image element to point at the bound URL/ID.
 	 *
-	 * Handles both forms emitted by `save.js`:
-	 *
-	 * 1. **Parallax / repeat `<div>` form** (probed first via `preg_match`):
-	 *    the entire `<div class="wp-block-cover__image-background" …></div>`
-	 *    is replaced with a freshly-built `<img>` that carries the bound URL,
-	 *    bound ID class (`wp-image-{id}`), and — when stored on the block —
-	 *    `size-{sizeSlug}` and `data-object-position`/`style="object-position:…"`
-	 *    attributes computed from `attrs.focalPoint`. The rebuilt element
-	 *    never contains `has-parallax`, `is-repeated`, or a `style="background-
-	 *    image:…"` declaration by construction. The `alt` attribute is read
-	 *    from the bound attachment's `_wp_attachment_image_alt` meta.
-	 *
-	 * 2. **Plain `<img>` form** (fall-through path): the existing `<img>` is
-	 *    visited via `WP_HTML_Tag_Processor` and `src`, `alt`, and the
-	 *    `wp-image-…` class are rewritten in place. Any pre-existing
-	 *    `wp-image-…` class is removed before the new one is added, so a saved
-	 *    `wp-image-99` does not survive after a binding resolves a different
-	 *    attachment.
-	 *
-	 * The function is idempotent on its own output: a second pass over an
-	 * already-rewritten plain `<img>` form re-asserts the same attributes; a
-	 * second pass over the parallax-rebuilt `<img>` falls through to the
-	 * plain-`<img>` path (because the rebuilt element is now a plain `<img>`)
-	 * and produces byte-identical output.
-	 *
-	 * When neither form matches, the input is returned unchanged.
+	 * Handles both forms emitted by `save.js`: the parallax/repeat `<div>` is
+	 * replaced wholesale with a freshly-built `<img>`; the plain `<img>` form is
+	 * rewritten in place via Tag Processor. Idempotent on its own output.
 	 *
 	 * @since 7.1.0
 	 * @access private
-	 *
-	 * @param string $content      The rendered Cover block HTML.
-	 * @param string $resolved_url The URL resolved from the bound source.
-	 * @param int    $resolved_id  The attachment ID resolved from the bound source.
-	 * @param array  $attrs        The Cover block's stored attribute array
-	 *                             (used for `sizeSlug` and `focalPoint`).
-	 * @return string The content with the image element rewritten, or the input
-	 *                unchanged when no matching image element is present.
 	 */
 	function gutenberg_cover_bindings_rewrite_image( string $content, string $resolved_url, int $resolved_id, array $attrs ): string {
 		$alt             = trim( strip_tags( (string) get_post_meta( $resolved_id, '_wp_attachment_image_alt', true ) ) );
@@ -376,10 +201,9 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 			);
 		}
 
-		// Form 2 first: parallax/repeat saved form — replace the empty <div>
-		// element wholesale with a rebuilt <img>. Saved markup is the source of
-		// truth (NOT $attrs['hasParallax'] / $attrs['isRepeated']) — the
-		// pattern matches the literal serialized form emitted by save.js.
+		// Parallax/repeat form: saved markup is the source of truth (NOT
+		// $attrs['hasParallax']/$attrs['isRepeated']) — the pattern matches the
+		// literal serialized form emitted by save.js.
 		$form2_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
 		if ( 1 === preg_match( $form2_pattern, $content, $matches, PREG_OFFSET_CAPTURE ) ) {
 			$div_start  = $matches[0][1];
@@ -406,7 +230,7 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 			return substr( $content, 0, $div_start ) . $rebuilt_img . substr( $content, $div_start + $div_length );
 		}
 
-		// Form 1: plain <img> saved form — rewrite attributes in place.
+		// Plain <img> form: rewrite attributes in place.
 		$processor = new WP_HTML_Tag_Processor( $content );
 		if ( $processor->next_tag(
 			array(
@@ -417,8 +241,7 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 			$processor->set_attribute( 'src', $resolved_url );
 			$processor->set_attribute( 'alt', $alt );
 
-			// Replace any existing wp-image-{old} with the resolved id. class_list()
-			// yields the current classes, including ones added in this same pass.
+			// Remove any saved wp-image-{old} before adding the resolved one.
 			$class_list = $processor->class_list();
 			if ( null !== $class_list ) {
 				$wp_image_classes_to_remove = array();
@@ -436,7 +259,6 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 			return $processor->get_updated_html();
 		}
 
-		// Neither form matched; render proceeds overlay-only.
 		return $content;
 	}
 }
@@ -445,50 +267,11 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 	/**
 	 * Rewrites a rendered Cover block to honour an active `id`+`url` binding.
 	 *
-	 * Registered on the `render_block` filter at priority 9 so it runs BEFORE
-	 * the generic priority-10 `gutenberg_block_bindings_render_block`
-	 * (`lib/compat/wordpress-6.9/block-bindings.php`) — the binding-aware
-	 * substitution must happen on the saved markup before the generic filter
-	 * potentially re-runs `$instance->render()`.
-	 *
-	 * Gating order:
-	 *
-	 * 1. The block is not `core/cover` — return unchanged.
-	 * 2. `backgroundType === 'embed-video'` — embed-video covers are explicitly
-	 *    out of scope for the Cover-scoped binding render path (AC-21); the
-	 *    existing oEmbed code path remains intact — return unchanged.
-	 * 3. The cover has `metadata.bindings` configuration for `id` and/or `url`
-	 *    but the configuration is not active (mismatched `source`, differing
-	 *    `args`, or only one of the two attributes bound). This is the
-	 *    server-side mirror of the client's `bindingUnresolvable` predicate:
-	 *    the binding cannot be honoured, so the saved image element is stripped
-	 *    and the cover renders overlay-only (AC-6).
-	 * 4. The bindings are not active AND there is no cover-relevant
-	 *    configuration — return unchanged (unbound cover, AC-20 non-regression).
-	 *
-	 * After the gates, the resolved URL and ID come from `$instance->attributes`
-	 * (which `WP_Block::render()` has already merged the resolved bindings
-	 * into — see `wp-includes/class-wp-block.php`). If either value is missing,
-	 * or the resolved ID is not an attachment in the media library, the saved
-	 * image element is stripped from `$content` and the cover renders
-	 * overlay-only (AC-5).
-	 *
-	 * Otherwise the saved image element is rewritten in place by
-	 * `gutenberg_cover_bindings_rewrite_image()` to carry the bound URL, ID
-	 * class, and alt text (AC-3, AC-19). When the stored `dimRatio` is the
-	 * default 100, `gutenberg_cover_bindings_relax_dim_class()` removes
-	 * `has-background-dim-100` from the overlay span so the bound image is not
-	 * hidden by a fully-opaque overlay (AC-16, OQ-4). Non-default `dimRatio`
-	 * values are preserved (AC-17).
+	 * Registered at priority 9 — MUST run before the generic priority-10
+	 * `gutenberg_block_bindings_render_block` in `wordpress-6.9/block-bindings.php`
+	 * so the substitution runs on saved markup, not bindings-resolved markup.
 	 *
 	 * @since 7.1.0
-	 *
-	 * @param string   $block_content The rendered block HTML, as passed in by
-	 *                                the `render_block` filter.
-	 * @param array    $block         The parsed block array (`blockName`, etc.).
-	 * @param WP_Block $instance      The block instance, whose `attributes`
-	 *                                already include any resolved binding values.
-	 * @return string The (possibly rewritten) block HTML.
 	 */
 	function gutenberg_cover_bindings_render_block( $block_content, $block, $instance ) {
 		if ( 'core/cover' !== ( $block['blockName'] ?? '' ) ) {
@@ -503,12 +286,9 @@ function gutenberg_cover_bindings_render_block( $block_content, $block, $instanc
 		}
 
 		if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
-			// AC-6: explicit per-attribute bindings whose `source` or `args`
-			// don't match (or only one of `id`/`url` is bound) cannot be
-			// honoured — strip the saved cover image element so the cover
-			// renders overlay-only, matching the client's `bindingUnresolvable`
-			// affordance. Covers with no cover-relevant binding configuration
-			// (the AC-20 unbound population) are returned unchanged.
+			// AC-6: cover-relevant binding config present but inactive — strip the
+			// saved image so the cover renders overlay-only. AC-20: genuinely
+			// unbound covers pass through unchanged.
 			if ( gutenberg_cover_bindings_has_cover_relevant_configuration( $attrs ) ) {
 				return gutenberg_cover_bindings_strip_image( $block_content );
 			}
@@ -534,8 +314,7 @@ function gutenberg_cover_bindings_render_block( $block_content, $block, $instanc
 			$attrs
 		);
 
-		// AC-16 / OQ-4: stored dimRatio defaults to 100; relax it to "no
-		// modifier class" (effectively 50%) so the bound image is visible.
+		// AC-16 / OQ-4: relax stored dimRatio:100 so the bound image is visible.
 		if ( 100 === (int) ( $attrs['dimRatio'] ?? 100 ) ) {
 			$block_content = gutenberg_cover_bindings_relax_dim_class( $block_content );
 		}
@@ -544,8 +323,6 @@ function gutenberg_cover_bindings_render_block( $block_content, $block, $instanc
 	}
 }
 
-// Priority 9 is essential — see the docblock above: must run BEFORE the
-// generic priority-10 gutenberg_block_bindings_render_block filter from
-// lib/compat/wordpress-6.9/block-bindings.php so the Cover-scoped substitution
-// runs on saved markup, not on already-bindings-resolved markup.
+// Priority 9 — must run before the generic priority-10
+// gutenberg_block_bindings_render_block filter.
 add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 );

From c49904738fca944c3afe97f47e975c9f37e9970e Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 10:57:25 +0200
Subject: [PATCH 45/60] refactor(block-bindings): inline single-caller helpers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Inline `relax_dim_class` and the `has_cover_relevant_configuration`
predicate into the single render-block call site. `strip_image` keeps two
callers and `rewrite_image` is large/cohesive — both remain helpers.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 61 +++++----------------
 1 file changed, 14 insertions(+), 47 deletions(-)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index 3cb03d5f8be499..0437ca7cdd6057 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -69,25 +69,6 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 	}
 }
 
-if ( ! function_exists( 'gutenberg_cover_bindings_has_cover_relevant_configuration' ) ) {
-	/**
-	 * Whether `metadata.bindings` mentions `__default`, `id`, or `url`.
-	 *
-	 * Distinguishes genuinely unbound covers (AC-20) from covers whose binding
-	 * config is present but inactive (AC-6).
-	 *
-	 * @since 7.1.0
-	 * @access private
-	 */
-	function gutenberg_cover_bindings_has_cover_relevant_configuration( array $attrs ): bool {
-		$bindings = $attrs['metadata']['bindings'] ?? null;
-		if ( empty( $bindings ) || ! is_array( $bindings ) ) {
-			return false;
-		}
-		return isset( $bindings['__default'] ) || isset( $bindings['id'] ) || isset( $bindings['url'] );
-	}
-}
-
 if ( ! function_exists( 'gutenberg_cover_bindings_prepare_block' ) ) {
 	/**
 	 * Forces `useFeaturedImage` off on bound covers before `WP_Block::render()`.
@@ -146,31 +127,6 @@ function gutenberg_cover_bindings_strip_image( string $content ): string {
 	}
 }
 
-if ( ! function_exists( 'gutenberg_cover_bindings_relax_dim_class' ) ) {
-	/**
-	 * Removes `has-background-dim-100` from the Cover overlay span.
-	 *
-	 * Stored `dimRatio: 100` is the saved default; on bound covers a fully-opaque
-	 * overlay would hide the image, so the effective dimRatio is 50 (OQ-4) and
-	 * `dimRatioToClass( 50 )` is null — i.e. just remove `dim-100`.
-	 *
-	 * @since 7.1.0
-	 * @access private
-	 */
-	function gutenberg_cover_bindings_relax_dim_class( string $content ): string {
-		$processor = new WP_HTML_Tag_Processor( $content );
-		while ( $processor->next_tag(
-			array(
-				'tag_name'   => 'SPAN',
-				'class_name' => 'wp-block-cover__background',
-			)
-		) ) {
-			$processor->remove_class( 'has-background-dim-100' );
-		}
-		return $processor->get_updated_html();
-	}
-}
-
 if ( ! function_exists( 'gutenberg_cover_bindings_rewrite_image' ) ) {
 	/**
 	 * Rewrites the saved Cover image element to point at the bound URL/ID.
@@ -289,7 +245,8 @@ function gutenberg_cover_bindings_render_block( $block_content, $block, $instanc
 			// AC-6: cover-relevant binding config present but inactive — strip the
 			// saved image so the cover renders overlay-only. AC-20: genuinely
 			// unbound covers pass through unchanged.
-			if ( gutenberg_cover_bindings_has_cover_relevant_configuration( $attrs ) ) {
+			$bindings = $attrs['metadata']['bindings'] ?? null;
+			if ( ! empty( $bindings ) && is_array( $bindings ) && ( isset( $bindings['__default'] ) || isset( $bindings['id'] ) || isset( $bindings['url'] ) ) ) {
 				return gutenberg_cover_bindings_strip_image( $block_content );
 			}
 			return $block_content;
@@ -314,9 +271,19 @@ function gutenberg_cover_bindings_render_block( $block_content, $block, $instanc
 			$attrs
 		);
 
-		// AC-16 / OQ-4: relax stored dimRatio:100 so the bound image is visible.
+		// AC-16 / OQ-4: relax stored dimRatio:100 so the bound image is visible
+		// (effective dimRatio is 50 and `dimRatioToClass(50)` is null).
 		if ( 100 === (int) ( $attrs['dimRatio'] ?? 100 ) ) {
-			$block_content = gutenberg_cover_bindings_relax_dim_class( $block_content );
+			$processor = new WP_HTML_Tag_Processor( $block_content );
+			while ( $processor->next_tag(
+				array(
+					'tag_name'   => 'SPAN',
+					'class_name' => 'wp-block-cover__background',
+				)
+			) ) {
+				$processor->remove_class( 'has-background-dim-100' );
+			}
+			$block_content = $processor->get_updated_html();
 		}
 
 		return $block_content;

From 6a67afac8b529a878bfa067dc1d0934763cb7164 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 10:59:03 +0200
Subject: [PATCH 46/60] test(block-library): consolidate cover bindings PHPUnit
 fixtures

Extract `register_id_url_source()` shortcut and `DEFAULT_SAVED_MARKUP`
constant; drop verbose docblocks; collapse multi-paragraph test narratives
into one-line AC tags. All 9 acceptance-criterion cases preserved.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 phpunit/blocks/render-block-cover-test.php | 458 ++++++---------------
 1 file changed, 122 insertions(+), 336 deletions(-)

diff --git a/phpunit/blocks/render-block-cover-test.php b/phpunit/blocks/render-block-cover-test.php
index e718787fae90a0..7d8c5d37b3bd10 100644
--- a/phpunit/blocks/render-block-cover-test.php
+++ b/phpunit/blocks/render-block-cover-test.php
@@ -19,30 +19,12 @@ class Tests_Blocks_Render_Cover extends WP_UnitTestCase {
 	 */
 	protected static $post;
 
-	/**
-	 * Default attachment id (used by the featured-image and parallax tests; also
-	 * the post thumbnail).
-	 *
-	 * @var int
-	 */
+	/** @var int Featured-image / post-thumbnail attachment. */
 	protected static $attachment_id;
 
-	/**
-	 * Override attachment id — a second media-library attachment used by the
-	 * binding-aware tests to assert that the BOUND value (not the featured-image
-	 * or saved-markup URL) wins.
-	 *
-	 * @var int
-	 */
+	/** @var int Bound override attachment used to assert the bound value wins. */
 	protected static $override_attachment_id;
 
-	/**
-	 * Name of the test binding source registered in `set_up()`. The source is
-	 * configured per-test (its `get_value_callback` is rebound via a class
-	 * property) so each test can drive a different resolution.
-	 *
-	 * @var string
-	 */
 	const TEST_SOURCE_NAME = 'test/cover-bindings';
 
 	/**
@@ -54,61 +36,34 @@ class Tests_Blocks_Render_Cover extends WP_UnitTestCase {
 	protected $source_callback;
 
 	/**
-	 * Setup method.
+	 * Default saved Cover markup with a plain `<img>` background and a
+	 * `has-background-dim has-background-dim-100` overlay span. Reused by tests
+	 * that don't need a custom saved form.
 	 */
+	const DEFAULT_SAVED_MARKUP = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
+
 	public static function wpSetUpBeforeClass() {
 		self::$post = self::factory()->post->create_and_get();
 		$file       = DIR_TESTDATA . '/images/canola.jpg';
 
-		self::$attachment_id = self::factory()->attachment->create_upload_object(
-			$file,
-			self::$post->ID,
-			array(
-				'post_mime_type' => 'image/jpeg',
-			)
-		);
-
-		// Second attachment, used as the bound override target so tests can
-		// assert that the bound URL wins over the featured-image URL.
-		self::$override_attachment_id = self::factory()->attachment->create_upload_object(
-			$file,
-			self::$post->ID,
-			array(
-				'post_mime_type' => 'image/jpeg',
-			)
-		);
+		self::$attachment_id          = self::factory()->attachment->create_upload_object( $file, self::$post->ID, array( 'post_mime_type' => 'image/jpeg' ) );
+		self::$override_attachment_id = self::factory()->attachment->create_upload_object( $file, self::$post->ID, array( 'post_mime_type' => 'image/jpeg' ) );
 
 		set_post_thumbnail( self::$post, self::$attachment_id );
-
-		// Populate alt metadata on the override attachment so the rebuilt-img
-		// path has something deterministic to assert against.
 		update_post_meta( self::$override_attachment_id, '_wp_attachment_image_alt', 'Override alt text' );
 	}
 
-	/**
-	 * Tear down method.
-	 */
 	public static function wpTearDownAfterClass() {
 		wp_delete_post( self::$post->ID, true );
 		wp_delete_post( self::$attachment_id, true );
 		wp_delete_post( self::$override_attachment_id, true );
 	}
 
-	/**
-	 * Per-test set-up: registers a Cover-shaped test binding source whose
-	 * `get_value_callback` is delegated to the `source_callback` property. The
-	 * delegation indirection means each test can swap behaviour without
-	 * re-registering the source.
-	 */
 	public function set_up() {
 		parent::set_up();
 		$this->source_callback = null;
 	}
 
-	/**
-	 * Per-test tear-down: unregisters the test binding source if it was
-	 * registered, so the next test starts from a clean registry.
-	 */
 	public function tear_down() {
 		if ( get_block_bindings_source( self::TEST_SOURCE_NAME ) ) {
 			unregister_block_bindings_source( self::TEST_SOURCE_NAME );
@@ -119,11 +74,7 @@ public function tear_down() {
 	}
 
 	/**
-	 * Registers the test binding source. Tests call this after assigning their
-	 * `source_callback`; the closure invokes the callback per attribute lookup
-	 * so a single source can drive both `id` and `url` resolutions.
-	 *
-	 * @param callable $callback Function( $source_args, $block_instance, $attribute_name ).
+	 * Registers the test binding source delegating to `$this->source_callback`.
 	 */
 	protected function register_test_source( callable $callback ) {
 		$this->source_callback = $callback;
@@ -140,8 +91,46 @@ protected function register_test_source( callable $callback ) {
 	}
 
 	/**
-	 * Test gutenberg_render_block_core_cover() method.
-	 *
+	 * Shortcut: register a source that resolves `id` to `$id` and `url` to `$url`.
+	 */
+	protected function register_id_url_source( int $id, string $url ) {
+		$this->register_test_source(
+			function ( $source_args, $block_instance, $attribute_name ) use ( $id, $url ) {
+				return 'url' === $attribute_name ? $url : $id;
+			}
+		);
+	}
+
+	/**
+	 * Builds a parsed Cover block array with a same-source `{ id, url }` binding
+	 * shape against the test source.
+	 */
+	protected function build_bound_cover_block( string $saved_markup, array $extra_attributes = array(), $bindings_override = null ): array {
+		$bindings = null !== $bindings_override
+			? $bindings_override
+			: array(
+				'id'  => array( 'source' => self::TEST_SOURCE_NAME ),
+				'url' => array( 'source' => self::TEST_SOURCE_NAME ),
+			);
+
+		$attrs = array_merge(
+			array(
+				'backgroundType' => 'image',
+				'metadata'       => array( 'bindings' => $bindings ),
+			),
+			$extra_attributes
+		);
+
+		return array(
+			'blockName'    => 'core/cover',
+			'attrs'        => $attrs,
+			'innerBlocks'  => array(),
+			'innerHTML'    => $saved_markup,
+			'innerContent' => array( $saved_markup ),
+		);
+	}
+
+	/**
 	 * @covers ::gutenberg_render_block_core_cover
 	 */
 	public function test_gutenberg_render_block_core_cover() {
@@ -183,8 +172,6 @@ public function test_gutenberg_render_block_core_cover() {
 	}
 
 	/**
-	 * Test gutenberg_render_block_core_cover() method.
-	 *
 	 * @covers ::gutenberg_render_block_core_cover
 	 */
 	public function test_gutenberg_render_block_core_cover_fixed_or_repeated_background() {
@@ -216,251 +203,107 @@ public function test_gutenberg_render_block_core_cover_fixed_or_repeated_backgro
 		$this->assertStringNotContainsString( 'min-height', $rendered );
 	}
 
-	/**
-	 * Builds a parsed Cover block array with a `metadata.bindings` shape that
-	 * targets the test source for both `id` and `url`. Returns the array shape
-	 * `render_block()` accepts directly (no `parse_blocks` round-trip).
-	 *
-	 * @param string $saved_markup     The serialized Cover inner HTML.
-	 * @param array  $extra_attributes Extra attributes to merge into the `attrs` array.
-	 * @param array  $bindings_override Optional bindings shape; defaults to a
-	 *                                  same-source `{ id, url }` shape against
-	 *                                  the test source.
-	 * @return array A parsed-block array suitable for `render_block()`.
-	 */
-	protected function build_bound_cover_block( string $saved_markup, array $extra_attributes = array(), $bindings_override = null ): array {
-		$bindings = null !== $bindings_override
-			? $bindings_override
-			: array(
-				'id'  => array( 'source' => self::TEST_SOURCE_NAME ),
-				'url' => array( 'source' => self::TEST_SOURCE_NAME ),
-			);
-
-		$attrs = array_merge(
-			array(
-				'backgroundType' => 'image',
-				'metadata'       => array( 'bindings' => $bindings ),
-			),
-			$extra_attributes
-		);
-
-		return array(
-			'blockName'    => 'core/cover',
-			'attrs'        => $attrs,
-			'innerBlocks'  => array(),
-			'innerHTML'    => $saved_markup,
-			'innerContent' => array( $saved_markup ),
-		);
-	}
-
-	/**
-	 * AC-3: the resolved binding URL is substituted into the plain `<img>`
-	 * saved form. Asserts the bound URL appears in `src`, the previous saved
-	 * src does NOT appear, and the resolved attachment's `wp-image-{id}` class
-	 * replaces any pre-existing `wp-image-*` class.
-	 */
+	// AC-3: bound URL substitutes into the plain `<img>` saved form; old src and
+	// any pre-existing `wp-image-*` class are removed.
 	public function test_bound_url_substitutes_in_plain_img_form() {
 		$bound_url = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
 		$bound_id  = self::$override_attachment_id;
-
-		$this->register_test_source(
-			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
-				return 'url' === $attribute_name ? $bound_url : $bound_id;
-			}
-		);
+		$this->register_id_url_source( $bound_id, $bound_url );
 
 		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background wp-image-999" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
-		$parsed_block = $this->build_bound_cover_block( $saved_markup );
-		$rendered     = render_block( $parsed_block );
+		$rendered     = render_block( $this->build_bound_cover_block( $saved_markup ) );
 
-		$this->assertStringContainsString( 'src="' . esc_attr( $bound_url ) . '"', $rendered, 'The bound URL must be substituted into the saved <img>.' );
-		$this->assertStringNotContainsString( 'https://saved.example.com/old.jpg', $rendered, 'The pre-existing saved src must be replaced.' );
-		$this->assertStringContainsString( 'wp-image-' . $bound_id, $rendered, 'The resolved attachment id must surface as a wp-image-{id} class.' );
-		$this->assertStringNotContainsString( 'wp-image-999', $rendered, 'The pre-existing wp-image-999 class must be removed before the new one is added.' );
+		$this->assertStringContainsString( 'src="' . esc_attr( $bound_url ) . '"', $rendered );
+		$this->assertStringNotContainsString( 'https://saved.example.com/old.jpg', $rendered );
+		$this->assertStringContainsString( 'wp-image-' . $bound_id, $rendered );
+		$this->assertStringNotContainsString( 'wp-image-999', $rendered );
 	}
 
-	/**
-	 * AC-16 / AC-25: stored `dimRatio: 100` is the cover default, but on a
-	 * bound cover the fully-opaque overlay would hide the bound image. The
-	 * server filter relaxes the class to "no modifier" — the rendered overlay
-	 * span contains `has-background-dim` but NOT `has-background-dim-100`.
-	 */
+	// AC-16 / AC-25: stored `dimRatio: 100` is relaxed (no -100 modifier class).
 	public function test_default_dim_ratio_class_is_relaxed() {
 		$bound_url = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
-		$bound_id  = self::$override_attachment_id;
-
-		$this->register_test_source(
-			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
-				return 'url' === $attribute_name ? $bound_url : $bound_id;
-			}
-		);
+		$this->register_id_url_source( self::$override_attachment_id, $bound_url );
 
-		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
-		$parsed_block = $this->build_bound_cover_block( $saved_markup, array( 'dimRatio' => 100 ) );
-		$rendered     = render_block( $parsed_block );
+		$rendered = render_block( $this->build_bound_cover_block( self::DEFAULT_SAVED_MARKUP, array( 'dimRatio' => 100 ) ) );
 
-		$this->assertStringNotContainsString(
-			'has-background-dim-100',
-			$rendered,
-			'has-background-dim-100 must be removed when the stored dimRatio is the default 100.'
-		);
-		$this->assertStringContainsString(
-			'has-background-dim',
-			$rendered,
-			'has-background-dim (the 50%-opacity baseline) must be preserved per OQ-4.'
-		);
+		$this->assertStringNotContainsString( 'has-background-dim-100', $rendered );
+		$this->assertStringContainsString( 'has-background-dim', $rendered );
 	}
 
-	/**
-	 * AC-17: a non-default `dimRatio` (here, 70) is preserved untouched on a
-	 * bound cover — the relax pass only fires on the 100 default.
-	 */
+	// AC-17: non-default `dimRatio` is preserved untouched on bound covers.
 	public function test_non_default_dim_ratio_is_preserved() {
 		$bound_url = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
-		$bound_id  = self::$override_attachment_id;
-
-		$this->register_test_source(
-			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
-				return 'url' === $attribute_name ? $bound_url : $bound_id;
-			}
-		);
+		$this->register_id_url_source( self::$override_attachment_id, $bound_url );
 
 		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-70"></span><div class="wp-block-cover__inner-container"></div></div>';
-		$parsed_block = $this->build_bound_cover_block( $saved_markup, array( 'dimRatio' => 70 ) );
-		$rendered     = render_block( $parsed_block );
+		$rendered     = render_block( $this->build_bound_cover_block( $saved_markup, array( 'dimRatio' => 70 ) ) );
 
-		$this->assertStringContainsString(
-			'has-background-dim-70',
-			$rendered,
-			'A user-set non-default dimRatio class must survive the bound render.'
-		);
-		$this->assertStringContainsString( 'src="' . esc_attr( $bound_url ) . '"', $rendered, 'The bound URL must still be substituted on the non-default dimRatio path.' );
+		$this->assertStringContainsString( 'has-background-dim-70', $rendered );
+		$this->assertStringContainsString( 'src="' . esc_attr( $bound_url ) . '"', $rendered );
 	}
 
-	/**
-	 * AC-19: when a cover saved with `hasParallax`/`isRepeated` (the `<div
-	 * style="background-image:url(…)">` form) gains an active binding, the
-	 * `<div>` is rebuilt into a plain `<img>` carrying the bound URL, the
-	 * `wp-image-{id}` class, and NO parallax/repeat classes or
-	 * background-image style.
-	 */
+	// AC-19: parallax/repeat `<div>` form is rebuilt as an `<img>` carrying the
+	// bound URL / `wp-image-{id}` and no parallax/repeat classes.
 	public function test_parallax_saved_markup_is_rebuilt_as_img() {
 		$bound_url = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
 		$bound_id  = self::$override_attachment_id;
-
-		$this->register_test_source(
-			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
-				return 'url' === $attribute_name ? $bound_url : $bound_id;
-			}
-		);
+		$this->register_id_url_source( $bound_id, $bound_url );
 
 		$saved_markup = '<div class="wp-block-cover has-parallax is-repeated"><div role="img" aria-label="" class="wp-block-cover__image-background wp-image-555 has-parallax is-repeated" style="background-position:50% 50%;background-image:url(https://saved.example.com/old.jpg)"></div><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
-		$parsed_block = $this->build_bound_cover_block(
-			$saved_markup,
-			array(
-				'hasParallax' => true,
-				'isRepeated'  => true,
+		$rendered     = render_block(
+			$this->build_bound_cover_block(
+				$saved_markup,
+				array(
+					'hasParallax' => true,
+					'isRepeated'  => true,
+				)
 			)
 		);
-		$rendered     = render_block( $parsed_block );
 
-		$this->assertMatchesRegularExpression(
-			'/<img[^>]*\bwp-block-cover__image-background\b[^>]*>/',
-			$rendered,
-			'The parallax/repeat <div> must be replaced with an <img>.'
-		);
-		$this->assertStringNotContainsString(
-			'background-image:url(https://saved.example.com/old.jpg)',
-			$rendered,
-			'The saved background-image:url() CSS must not survive in the rebuilt element.'
-		);
-		// The rebuilt <img> element must not carry has-parallax / is-repeated.
-		// (The outer wrapper `<div class="wp-block-cover has-parallax is-repeated">`
-		// MAY still contain them — the bind path only rewrites the inner image.)
-		$this->assertDoesNotMatchRegularExpression(
-			'/<img[^>]*\bwp-block-cover__image-background\b[^>]*\bhas-parallax\b/',
-			$rendered,
-			'The rebuilt <img> must not carry has-parallax.'
-		);
-		$this->assertDoesNotMatchRegularExpression(
-			'/<img[^>]*\bwp-block-cover__image-background\b[^>]*\bis-repeated\b/',
-			$rendered,
-			'The rebuilt <img> must not carry is-repeated.'
-		);
-		$this->assertStringContainsString( 'src="' . esc_attr( $bound_url ) . '"', $rendered, 'The rebuilt <img> must carry the bound URL.' );
-		$this->assertStringContainsString( 'wp-image-' . $bound_id, $rendered, 'The rebuilt <img> must carry wp-image-{resolved id}.' );
+		$this->assertMatchesRegularExpression( '/<img[^>]*\bwp-block-cover__image-background\b[^>]*>/', $rendered );
+		$this->assertStringNotContainsString( 'background-image:url(https://saved.example.com/old.jpg)', $rendered );
+		// The rebuilt <img> must not carry has-parallax / is-repeated (the outer
+		// wrapper MAY still — the bind path only rewrites the inner image).
+		$this->assertDoesNotMatchRegularExpression( '/<img[^>]*\bwp-block-cover__image-background\b[^>]*\bhas-parallax\b/', $rendered );
+		$this->assertDoesNotMatchRegularExpression( '/<img[^>]*\bwp-block-cover__image-background\b[^>]*\bis-repeated\b/', $rendered );
+		$this->assertStringContainsString( 'src="' . esc_attr( $bound_url ) . '"', $rendered );
+		$this->assertStringContainsString( 'wp-image-' . $bound_id, $rendered );
 	}
 
-	/**
-	 * AC-6: when `metadata.bindings.id` and `metadata.bindings.url` resolve via
-	 * different sources, the binding is unresolvable and the saved image
-	 * element is stripped from the output — the cover renders overlay-only.
-	 */
+	// AC-6: bindings with mismatched sources strip the saved image element.
 	public function test_mismatched_source_strips_image() {
-		// Register only one of the two sources; the other reference is
-		// deliberately to an unregistered source so the bindings can't possibly
-		// match.
 		$this->register_test_source(
 			function () {
 				return 'unused';
 			}
 		);
 
-		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
 		$parsed_block = $this->build_bound_cover_block(
-			$saved_markup,
+			self::DEFAULT_SAVED_MARKUP,
 			array(),
 			array(
 				'id'  => array( 'source' => self::TEST_SOURCE_NAME ),
 				'url' => array( 'source' => 'test/other-source-that-does-not-exist' ),
 			)
 		);
-		$rendered     = render_block( $parsed_block );
 
-		$this->assertStringNotContainsString(
-			'wp-block-cover__image-background',
-			$rendered,
-			'A mismatched binding must strip the saved cover image element entirely.'
-		);
+		$this->assertStringNotContainsString( 'wp-block-cover__image-background', render_block( $parsed_block ) );
 	}
 
-	/**
-	 * AC-5: when the binding resolves a URL but the `id` does not correspond
-	 * to a media-library attachment (here, the post id), the saved image
-	 * element is stripped — internal-only media is required.
-	 */
+	// AC-5: resolved URL with an `id` that is not an attachment (e.g. a post id)
+	// strips the saved image — internal-only media is required.
 	public function test_external_url_strips_image() {
 		$bound_url = 'https://external.example.com/photo.jpg';
-		$bound_id  = self::$post->ID; // A post, not an attachment.
-
-		$this->register_test_source(
-			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
-				return 'url' === $attribute_name ? $bound_url : $bound_id;
-			}
-		);
+		$this->register_id_url_source( self::$post->ID, $bound_url ); // post id, not attachment.
 
-		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="https://saved.example.com/old.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
-		$parsed_block = $this->build_bound_cover_block( $saved_markup );
-		$rendered     = render_block( $parsed_block );
+		$rendered = render_block( $this->build_bound_cover_block( self::DEFAULT_SAVED_MARKUP ) );
 
-		$this->assertStringNotContainsString(
-			'wp-block-cover__image-background',
-			$rendered,
-			'An id that is not an attachment must strip the saved cover image element.'
-		);
-		$this->assertStringNotContainsString(
-			$bound_url,
-			$rendered,
-			'The non-attachment URL must not leak into the rendered output.'
-		);
+		$this->assertStringNotContainsString( 'wp-block-cover__image-background', $rendered );
+		$this->assertStringNotContainsString( $bound_url, $rendered );
 	}
 
-	/**
-	 * AC-18: when both `useFeaturedImage: true` AND an active binding co-exist
-	 * on a cover, the binding wins. The rendered output contains exactly ONE
-	 * `wp-block-cover__image-background` element, its `src` is the bound URL,
-	 * and the featured-image URL does not appear at all.
-	 */
+	// AC-18: `useFeaturedImage: true` + active binding -> binding wins; exactly
+	// one `wp-block-cover__image-background` with the bound URL, no featured URL.
 	public function test_use_featured_image_with_active_binding_emits_exactly_one_img_with_bound_url() {
 		global $wp_query;
 		$wp_query->in_the_loop = true;
@@ -469,101 +312,48 @@ public function test_use_featured_image_with_active_binding_emits_exactly_one_im
 		$GLOBALS['post']       = self::$post;
 
 		$bound_url    = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
-		$bound_id     = self::$override_attachment_id;
 		$featured_url = wp_get_attachment_image_url( self::$attachment_id, 'full' );
+		$this->register_id_url_source( self::$override_attachment_id, $bound_url );
 
-		$this->register_test_source(
-			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
-				return 'url' === $attribute_name ? $bound_url : $bound_id;
-			}
-		);
-
-		// Plain `<img>` saved form — the saved src does not matter since the
-		// bound URL is substituted in place.
 		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background" alt="" src="" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
-		$parsed_block = $this->build_bound_cover_block(
-			$saved_markup,
-			array(
-				'useFeaturedImage' => true,
-				'hasParallax'      => false,
-				'isRepeated'       => false,
+		$rendered     = render_block(
+			$this->build_bound_cover_block(
+				$saved_markup,
+				array(
+					'useFeaturedImage' => true,
+					'hasParallax'      => false,
+					'isRepeated'       => false,
+				)
 			)
 		);
-		$rendered     = render_block( $parsed_block );
 
-		// Bound URL appears once.
-		$this->assertSame(
-			1,
-			substr_count( $rendered, esc_attr( $bound_url ) ),
-			'The bound URL must appear exactly once in the rendered cover (AC-18).'
-		);
-		// The featured-image URL must not appear at all.
-		$this->assertStringNotContainsString(
-			$featured_url,
-			$rendered,
-			'The featured-image URL must not be injected when a binding is active (AC-18).'
-		);
-		// Exactly one `wp-block-cover__image-background` element survives.
-		$this->assertSame(
-			1,
-			preg_match_all( '/class="[^"]*\bwp-block-cover__image-background\b[^"]*"/', $rendered ),
-			'Exactly one wp-block-cover__image-background element must survive on a useFeaturedImage+bound cover.'
-		);
+		$this->assertSame( 1, substr_count( $rendered, esc_attr( $bound_url ) ) );
+		$this->assertStringNotContainsString( $featured_url, $rendered );
+		$this->assertSame( 1, preg_match_all( '/class="[^"]*\bwp-block-cover__image-background\b[^"]*"/', $rendered ) );
 	}
 
-	/**
-	 * AC-21: `backgroundType: 'embed-video'` covers short-circuit both the
-	 * binding-aware filters. Even with same-source `id`+`url` bindings
-	 * configured, the Cover render path remains the trunk embed-video path —
-	 * no `<img>` substitution, no dim-class relaxation.
-	 */
+	// AC-21: `backgroundType: 'embed-video'` short-circuits both filters.
 	public function test_embed_video_short_circuits() {
 		$bound_url = wp_get_attachment_image_url( self::$override_attachment_id, 'full' );
-		$bound_id  = self::$override_attachment_id;
-
-		$this->register_test_source(
-			function ( $source_args, $block_instance, $attribute_name ) use ( $bound_url, $bound_id ) {
-				return 'url' === $attribute_name ? $bound_url : $bound_id;
-			}
-		);
+		$this->register_id_url_source( self::$override_attachment_id, $bound_url );
 
-		// Embed-video covers serialize as a `<figure class="wp-block-embed">`
-		// inside the cover wrapper. We assert the bound-cover code path does
-		// NOT engage: the bound URL must not appear and the
-		// `has-background-dim-100` class must survive untouched.
 		$saved_markup = '<div class="wp-block-cover"><figure class="wp-block-cover__video-background wp-block-cover__embed-background wp-block-embed"><div class="wp-block-embed__wrapper">https://example.com/video</div></figure><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
-		$parsed_block = $this->build_bound_cover_block(
-			$saved_markup,
-			array(
-				'backgroundType' => 'embed-video',
-				'url'            => 'https://example.com/video',
+		$rendered     = render_block(
+			$this->build_bound_cover_block(
+				$saved_markup,
+				array(
+					'backgroundType' => 'embed-video',
+					'url'            => 'https://example.com/video',
+				)
 			)
 		);
-		$rendered     = render_block( $parsed_block );
 
-		$this->assertStringNotContainsString(
-			$bound_url,
-			$rendered,
-			'The bound URL must not be substituted into an embed-video cover (AC-21).'
-		);
-		$this->assertStringContainsString(
-			'has-background-dim-100',
-			$rendered,
-			'The dim-class relax pass must not run on an embed-video cover (AC-21).'
-		);
+		$this->assertStringNotContainsString( $bound_url, $rendered );
+		$this->assertStringContainsString( 'has-background-dim-100', $rendered );
 	}
 
-	/**
-	 * AC-20: an unbound cover (no `metadata.bindings`) is byte-identical to
-	 * trunk — the binding-aware filters are pure no-ops on unbound content.
-	 */
+	// AC-20: unbound covers render byte-identically with and without the filters.
 	public function test_unbound_cover_is_byte_identical_to_trunk() {
-		// Render an unbound cover through the full `render_block()` pipeline
-		// (including the new priority-9 filter) and through `render_block()`
-		// again after temporarily removing the priority-9 filter, then assert
-		// the outputs match byte-for-byte. This is a stronger guarantee than
-		// "the new filter returned its input unchanged" because it also covers
-		// any incidental interference with neighbouring filters.
 		$saved_markup = '<div class="wp-block-cover"><img class="wp-block-cover__image-background wp-image-42" alt="" src="https://example.com/local.jpg" data-object-fit="cover"/><span aria-hidden="true" class="wp-block-cover__background has-background-dim has-background-dim-100"></span><div class="wp-block-cover__inner-container"></div></div>';
 		$parsed_block = array(
 			'blockName'    => 'core/cover',
@@ -586,10 +376,6 @@ public function test_unbound_cover_is_byte_identical_to_trunk() {
 		add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 );
 		add_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10, 3 );
 
-		$this->assertSame(
-			$without_filter,
-			$with_filter,
-			'An unbound cover must render byte-identically with and without the binding-aware filters (AC-20).'
-		);
+		$this->assertSame( $without_filter, $with_filter );
 	}
 }

From 6c5b9dd08a5a5af9040dd337bd83d56543eef89f Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 11:01:16 +0200
Subject: [PATCH 47/60] refactor(block-library): trim CoverEdit binding wiring

Collapse verbose narrative on the binding-state hook, the effectiveUrl /
effectiveDimRatio derivations, the URL-resolved observer, and the bound
<img> branch. Merge the unresolvable/pending Placeholder branches into a
single conditional-attribute element.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../block-library/src/cover/edit/index.js     | 113 ++++++------------
 1 file changed, 39 insertions(+), 74 deletions(-)

diff --git a/packages/block-library/src/cover/edit/index.js b/packages/block-library/src/cover/edit/index.js
index 005e4bf8be3775..b81a680599dad0 100644
--- a/packages/block-library/src/cover/edit/index.js
+++ b/packages/block-library/src/cover/edit/index.js
@@ -119,19 +119,12 @@ function CoverEdit( {
 		poster,
 	} = attributes;
 
-	// Single source of truth for binding state. Drives the derived values
-	// (`effectiveUrl`, `effectiveDimRatio`) and the binding-aware render
-	// branches below.
+	// Single source of truth for binding state.
 	const { bindingActive, bindingUnresolvable, bindingResolvedUrl } =
-		useCoverBindingState( {
-			clientId,
-			attributes,
-			context,
-		} );
+		useCoverBindingState( { clientId, attributes, context } );
 
-	// Race-token guard for the source-agnostic `effectiveUrl` observer below.
-	// Incremented on each invocation; stale `getMediaColor` resolutions bail
-	// when their captured token no longer matches `raceTokenRef.current`.
+	// Race-token guard for the `effectiveUrl` observer: stale `getMediaColor`
+	// resolutions bail when their captured token no longer matches.
 	const raceTokenRef = useRef( 0 );
 
 	const [ featuredImage ] = useEntityProp(
@@ -174,11 +167,7 @@ function CoverEdit( {
 		media?.media_details?.sizes?.[ sizeSlug ]?.source_url ??
 		media?.source_url;
 
-	// Source-agnostic URL to be displayed in the editor. Prefers the bound
-	// source's resolved URL; otherwise falls back to the trunk derivation
-	// (featured image when `useFeaturedImage`, otherwise the stored URL with
-	// HTML-entity decoding). DC-3: the downstream observer treats this value
-	// without branching on which branch produced it.
+	// Source-agnostic URL: bound URL wins, else featured-image, else stored.
 	const effectiveUrl =
 		bindingResolvedUrl ??
 		( useFeaturedImage
@@ -186,35 +175,15 @@ function CoverEdit( {
 			: // Ensure the url is not malformed due to sanitization through `wp_kses`.
 			  originalUrl?.replaceAll( '&amp;', '&' ) );
 
-	// Preview-time dim ratio. Default `dimRatio === 100` would produce an
-	// opaque overlay on bound covers (hiding the resolved image); §5.2 relaxes
-	// it to 50 only when the binding is active AND there is an image to show.
-	// In every other case this equals `dimRatio`, preserving trunk behaviour.
+	// Default `dimRatio: 100` would hide a bound image, so relax it to 50
+	// while a binding is active and an image is available (§5.2).
 	const effectiveDimRatio =
 		bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio;
 
-	/**
-	 * Source-agnostic URL-resolved observer.
-	 *
-	 * Recomputes `overlayColor` (when the user has not pinned an overlay
-	 * colour) and `isDark` whenever the effective URL changes — regardless of
-	 * whether the change came from a manual selection, `useFeaturedImage`, or
-	 * a bound source resolving. `useEffectEvent` gives us a stable identity
-	 * for use inside the single `useEffect` below while reading the latest
-	 * `attributes` / `overlayColor` through `propsRef.current`. The
-	 * race-token bookkeeping ensures that when two URL changes race, only
-	 * the most recent `getMediaColor` resolution writes back.
-	 *
-	 * DC-2: the only attribute write here is `{ isDark }`, which is not in
-	 * the DC-2 prohibition list. The `setOverlayColor( avg )` carve-out
-	 * preserves trunk behaviour (the identical call site previously fired
-	 * inside the `mediaUrl` effect) and runs identically for manual,
-	 * featured-image, and binding-sourced URLs — i.e. source-agnostic.
-	 *
-	 * @param {string|undefined} resolvedUrl The URL whose dominant colour
-	 *                                       drives the overlay derivation.
-	 *                                       Skipped when falsy.
-	 */
+	// Source-agnostic URL-resolved observer: recomputes `overlayColor` (when
+	// not user-pinned) and `isDark` on every `effectiveUrl` change. Race-token
+	// bookkeeping discards stale resolutions. DC-2: only `{ isDark }` is
+	// written back.
 	const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => {
 		if ( ! resolvedUrl ) {
 			return;
@@ -224,8 +193,7 @@ function CoverEdit( {
 		const averageBackgroundColor = await getMediaColor( resolvedUrl );
 
 		if ( myToken !== raceTokenRef.current ) {
-			// A newer resolution superseded ours; bail out so we do not
-			// clobber the latest derivation.
+			// A newer resolution superseded ours.
 			return;
 		}
 
@@ -256,10 +224,8 @@ function CoverEdit( {
 		setAttributes( { isDark: newIsDark } );
 	} );
 
-	// `onUrlResolved` is created by `useEffectEvent`, which guarantees a
-	// stable identity across renders — so it intentionally does not appear
-	// in this dependency array. Re-run only when the source-agnostic
-	// `effectiveUrl` changes (DC-1: single observer keyed on `effectiveUrl`).
+	// DC-1: single observer keyed on `effectiveUrl`. `onUrlResolved` is stable
+	// via `useEffectEvent` so it deliberately stays out of the dep array.
 	useEffect( () => {
 		onUrlResolved( effectiveUrl );
 	}, [ effectiveUrl ] );
@@ -664,13 +630,9 @@ function CoverEdit( {
 
 	if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground ) {
 		if ( bindingActive || bindingUnresolvable ) {
-			// Bound covers never expose the upload / featured-image
-			// affordances surfaced by the standard `<CoverPlaceholder>`.
-			// When the binding has settled into an unresolvable state we
-			// surface a discoverable affordance ("Internal media required
-			// for this binding."); otherwise the placeholder is silent and
-			// the single observer will populate the cover once
-			// `effectiveUrl` arrives.
+			// Bound covers never surface the standard upload affordance.
+			// Unresolvable bindings get a discoverable instruction; pending
+			// bindings get a silent illustration until `effectiveUrl` arrives.
 			return (
 				<>
 					{ blockControls }
@@ -690,21 +652,26 @@ function CoverEdit( {
 						} }
 					>
 						{ resizeListener }
-						{ bindingUnresolvable ? (
-							<Placeholder
-								data-testid="cover-binding-unresolvable"
-								className="wp-block-cover__binding-unresolvable"
-								withIllustration
-								instructions={ __(
-									'Internal media required for this binding.'
-								) }
-							/>
-						) : (
-							<Placeholder
-								className="wp-block-cover__binding-pending"
-								withIllustration
-							/>
-						) }
+						<Placeholder
+							data-testid={
+								bindingUnresolvable
+									? 'cover-binding-unresolvable'
+									: undefined
+							}
+							className={
+								bindingUnresolvable
+									? 'wp-block-cover__binding-unresolvable'
+									: 'wp-block-cover__binding-pending'
+							}
+							withIllustration
+							instructions={
+								bindingUnresolvable
+									? __(
+											'Internal media required for this binding.'
+									  )
+									: undefined
+							}
+						/>
 					</TagName>
 				</>
 			);
@@ -786,10 +753,8 @@ function CoverEdit( {
 					isImageBackground && (
 						<>
 							{ bindingActive && (
-								// Bound covers ignore the `isImgElement` switch so
-								// that pre-existing `hasParallax`/`isRepeated`
-								// attributes never substitute a `<div>` for the
-								// bound `<img>` (force-off per Design OQ-5).
+								// Bound covers force-render an <img> regardless
+								// of hasParallax/isRepeated (Design OQ-5).
 								<img
 									ref={ mediaElement }
 									className="wp-block-cover__image-background"

From 678f2f8d76074cec155b3dda7d59945d12cb21ad Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 11:03:18 +0200
Subject: [PATCH 48/60] refactor(block-library): tighten useCoverBindingState

Cut verbose typedef/JSDoc noise, inline the unresolvable-binding flag into
a single boolean expression, and shorten the dep-array justification.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/cover/edit/use-cover-binding-state.js | 96 ++++++-------------
 1 file changed, 28 insertions(+), 68 deletions(-)

diff --git a/packages/block-library/src/cover/edit/use-cover-binding-state.js b/packages/block-library/src/cover/edit/use-cover-binding-state.js
index 7161594c0da07b..ce1b62600e6d52 100644
--- a/packages/block-library/src/cover/edit/use-cover-binding-state.js
+++ b/packages/block-library/src/cover/edit/use-cover-binding-state.js
@@ -5,28 +5,17 @@ import { getBlockBindingsSource } from '@wordpress/blocks';
 import { useSelect } from '@wordpress/data';
 import { store as coreStore } from '@wordpress/core-data';
 
-// Canonical implementation lives at
-// `packages/block-editor/src/utils/block-bindings.js` (not publicly re-exported
-// from `@wordpress/block-editor`); duplicated inline here to avoid reaching
-// through private APIs across package boundaries.
+// Mirrors `replacePatternOverridesDefaultBinding` in
+// `packages/block-editor/src/utils/block-bindings.js` (not publicly re-exported).
 const PATTERN_OVERRIDES_SOURCE = 'core/pattern-overrides';
 
 /**
  * Expands a `__default` pattern-overrides binding into per-attribute entries.
+ * Non-pattern-overrides bindings pass through unchanged.
  *
- * Mirrors the semantics of `replacePatternOverridesDefaultBinding` in
- * `packages/block-editor/src/utils/block-bindings.js`: when the supplied
- * bindings object declares a `__default` entry sourced from
- * `core/pattern-overrides`, every supported attribute that does not already
- * have its own explicit binding receives a synthesised pattern-overrides
- * binding. Non-pattern-overrides bindings pass through unchanged.
- *
- * @param {?Record<string, Object>} bindings            A block's bindings from the metadata attribute.
- * @param {string[]}                supportedAttributes Attribute names eligible for expansion.
- *
- * @return {?Record<string, Object>} Either the input bindings (unchanged) or a
- *                                   new object whose keys cover every
- *                                   supported attribute.
+ * @param {?Object}  bindings            A block's `metadata.bindings` map.
+ * @param {string[]} supportedAttributes Attribute names eligible for expansion.
+ * @return {?Object} Expanded bindings, or the input unchanged.
  */
 function expandDefaultBinding( bindings, supportedAttributes ) {
 	if ( bindings?.__default?.source !== PATTERN_OVERRIDES_SOURCE ) {
@@ -42,32 +31,15 @@ function expandDefaultBinding( bindings, supportedAttributes ) {
 }
 
 /**
- * The shape of state returned by {@link useCoverBindingState}.
- *
- * @typedef {Object} CoverBindingState
- * @property {boolean}          bindingActive       True iff (after `__default` expansion) both `id` AND `url` are bound to the same source instance (same source, same `args`) AND `attributes.backgroundType !== 'embed-video'`.
- * @property {boolean}          bindingUnresolvable True iff `metadata.bindings` carries any cover-relevant configuration but the binding is not active, OR the bound attachment resolved to a record that is not a media-library attachment.
- * @property {string|undefined} bindingResolvedUrl  URL resolved from the bound source (or `undefined` when no binding is active or the source is missing).
- */
-
-/**
- * Computes Cover-block binding state in a single `useSelect` subscription.
- *
- * The hook is the client-side single source of truth for whether
- * a Cover's `id` and `url` attributes are bound, what the bound source
- * currently resolves to, and whether the bound configuration is itself
- * unresolvable (mismatched source, only one of `id`/`url` bound, the bound
- * `id` does not resolve to an attachment, etc.). Callers (e.g. `CoverEdit`)
- * destructure the returned object to drive every downstream binding-aware
- * derivation — derived URL, derived dim ratio, control gating, the
- * unresolvable-binding placeholder.
+ * Client-side single source of truth for Cover-block binding state. Returns
+ * `{ bindingActive, bindingUnresolvable, bindingResolvedUrl }` driving every
+ * downstream binding-aware derivation in `CoverEdit`.
  *
  * @param {Object} options            Hook options.
- * @param {string} options.clientId   The Cover block's client id, forwarded to the source's `getValues` callback.
- * @param {Object} options.attributes The Cover block's current attributes (the hook reads `metadata`, `backgroundType`).
- * @param {Object} options.context    The full, undestructured block-context object received by `CoverEdit`; forwarded verbatim to the source's `getValues` callback because sources may declare `usesContext` for keys beyond `postId`/`postType`.
- *
- * @return {CoverBindingState} Plain-value binding state, recomputed on each render.
+ * @param {string} options.clientId   The Cover block's client id.
+ * @param {Object} options.attributes The Cover block's attributes.
+ * @param {Object} options.context    Block-context object forwarded to `getValues`.
+ * @return {{ bindingActive: boolean, bindingUnresolvable: boolean, bindingResolvedUrl: (string|undefined) }} Binding state.
  */
 export default function useCoverBindingState( {
 	clientId,
@@ -114,27 +86,21 @@ export default function useCoverBindingState( {
 				context,
 				bindings: { id: expanded.id, url: expanded.url },
 			} );
-			const resolvedUrl = values?.url;
 			const resolvedId = values?.id;
-			const attachment = resolvedId
-				? select( coreStore ).getEntityRecord(
-						'postType',
-						'attachment',
-						resolvedId,
-						{ context: 'view' }
-				  )
-				: undefined;
 			return {
-				bindingResolvedUrl: resolvedUrl,
-				bindingResolvedAttachment: attachment,
+				bindingResolvedUrl: values?.url,
+				bindingResolvedAttachment: resolvedId
+					? select( coreStore ).getEntityRecord(
+							'postType',
+							'attachment',
+							resolvedId,
+							{ context: 'view' }
+					  )
+					: undefined,
 			};
 		},
-		// The dependency array is intentionally narrow: source identity (which
-		// determines whether to re-subscribe) plus the inputs forwarded into
-		// `source.getValues`. `expanded.id` / `expanded.url` get a fresh
-		// object identity on every render even when the underlying binding
-		// instance is stable, so listing them would re-run the selector
-		// spuriously without changing the result.
+		// `expanded.id` / `expanded.url` get fresh identities on every render;
+		// listing them would re-run the selector without changing the result.
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 		[
 			bindingActive,
@@ -156,18 +122,12 @@ export default function useCoverBindingState( {
 	const hasAnyCoverBinding =
 		!! bindings.__default || !! bindings.id || !! bindings.url;
 
-	const attachmentResolvedNotFound =
-		bindingActive && bindingResolvedAttachment === null;
-
-	const attachmentResolvedWrongType =
-		bindingActive &&
-		!! bindingResolvedAttachment?.type &&
-		bindingResolvedAttachment.type !== 'attachment';
-
 	const bindingUnresolvable =
 		( hasAnyCoverBinding && ! bindingActive ) ||
-		attachmentResolvedNotFound ||
-		attachmentResolvedWrongType;
+		( bindingActive &&
+			( bindingResolvedAttachment === null ||
+				( !! bindingResolvedAttachment?.type &&
+					bindingResolvedAttachment.type !== 'attachment' ) ) );
 
 	return {
 		bindingActive,

From c8a631a9399df90f37656fc0e3ac72b09891af4c Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 11:10:41 +0200
Subject: [PATCH 49/60] test(block-library): tighten cover bindings e2e
 assertions

Drop verbose AC annotations and redundant assertions across the four
round-trip phases; hoist getCoverBlock / getBlockToolbar helpers to
remove repeated locator chains. Keep all four phases, the embed-video
carve-out, and the unresolvable affordance.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 test/e2e/specs/editor/blocks/cover.spec.js | 177 +++++----------------
 1 file changed, 37 insertions(+), 140 deletions(-)

diff --git a/test/e2e/specs/editor/blocks/cover.spec.js b/test/e2e/specs/editor/blocks/cover.spec.js
index 58bf8673df673a..c06b5cbe826573 100644
--- a/test/e2e/specs/editor/blocks/cover.spec.js
+++ b/test/e2e/specs/editor/blocks/cover.spec.js
@@ -572,21 +572,12 @@ test.describe( 'Cover', () => {
 } );
 
 test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () => {
-	/**
-	 * The synced pattern's Cover block is given a stable `metadata.name` so
-	 * pattern-override values keyed off it can be addressed unambiguously from
-	 * the pattern instance's `content` attribute. The same name appears in
-	 * every override / reset step below.
-	 */
 	const coverBindingName = 'Bound Cover';
 
 	let defaultMedia;
 	let overrideMedia;
 
 	test.beforeAll( async ( { requestUtils } ) => {
-		// Two attachments: `defaultMedia` is baked into the pattern's saved
-		// cover; `overrideMedia` is written into a pattern instance via the
-		// `core/block` `content` attribute below.
 		[ defaultMedia, overrideMedia ] = await Promise.all( [
 			requestUtils.uploadMedia(
 				'./assets/10x10_e2e_test_image_z9T8jK.png'
@@ -595,15 +586,9 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 				'./assets/1024x768_e2e_test_image_size.jpeg'
 			),
 		] );
-		// Sanity: distinct attachments so the round-trip assertions are
-		// observable in both directions (default → override → reset).
-		expect( overrideMedia.id ).not.toBe( defaultMedia.id );
-		expect( overrideMedia.source_url ).not.toBe( defaultMedia.source_url );
 	} );
 
 	test.beforeEach( async ( { admin, requestUtils } ) => {
-		// Reset blocks between phases so each top-level step starts from a
-		// known post + pattern store.
 		await requestUtils.deleteAllBlocks();
 		await admin.createNewPost();
 	} );
@@ -619,11 +604,6 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 		page,
 		requestUtils,
 	} ) => {
-		// Synced pattern carrying a bound Cover. `__default` pattern-overrides
-		// expands to per-attribute `id` / `url` bindings on the server and in
-		// the editor hook, so the inner Cover renders the saved
-		// `defaultMedia` until a parent `core/block` `content` override is
-		// applied.
 		const pattern = await requestUtils.createBlock( {
 			title: 'Cover Pattern',
 			content: `<!-- wp:cover {"url":"${ defaultMedia.source_url }","id":${ defaultMedia.id },"dimRatio":100,"customOverlayColor":"#000000","minHeight":80,"metadata":{"name":"${ coverBindingName }","bindings":{"__default":{"source":"core/pattern-overrides"}}}} -->
@@ -634,8 +614,12 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 			status: 'publish',
 		} );
 
-		let patternBlock;
-		let coverBlock;
+		const getCoverBlock = () =>
+			editor.canvas
+				.getByRole( 'document', { name: 'Block: Pattern' } )
+				.getByRole( 'document', { name: 'Block: Cover' } );
+		const getBlockToolbar = () =>
+			page.getByRole( 'toolbar', { name: 'Block tools' } );
 
 		await test.step( 'Default state — pattern instance shows defaultMedia and hides bound controls', async () => {
 			await editor.insertBlock( {
@@ -643,29 +627,16 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 				attributes: { ref: pattern.id },
 			} );
 
-			patternBlock = editor.canvas.getByRole( 'document', {
-				name: 'Block: Pattern',
-			} );
-			coverBlock = patternBlock.getByRole( 'document', {
-				name: 'Block: Cover',
-			} );
-			await expect( coverBlock ).toBeVisible();
-
-			// AC-7 / AC-22: the editor preview img resolves to the pattern's
-			// default attachment because no override is set on the instance.
+			const coverBlock = getCoverBlock();
 			await expect( coverBlock.locator( 'img' ) ).toHaveAttribute(
 				'src',
 				defaultMedia.source_url
 			);
 
-			// AC-15: editor overlay should keep `has-background-dim` but drop
-			// the `-100` modifier so the bound `<img>` remains visible (the
-			// hook downshifts `effectiveDimRatio` to 50 when `dimRatio===100`).
+			// AC-15: dimRatio:100 relaxed so the bound <img> stays visible.
 			const overlay = coverBlock.locator( '.wp-block-cover__background' );
 			await expect( overlay ).toHaveClass( /has-background-dim(?!-100)/ );
-			await expect( overlay ).not.toHaveClass( /has-background-dim-100/ );
 
-			// Select the bound Cover so its inspector + toolbar render.
 			await editor.selectBlocks( coverBlock );
 			await editor.openDocumentSettingsSidebar();
 			await editor.showBlockToolbar();
@@ -675,8 +646,7 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 			} );
 			await openStylesTabIfAvailable( editorSettings );
 
-			// AC-11 / AC-12: the parallax + repeated-background tools-panel
-			// items are absent for bound covers.
+			// AC-11/12: parallax + repeated controls absent on bound covers.
 			await expect(
 				editorSettings.getByRole( 'checkbox', {
 					name: 'Fixed background',
@@ -688,33 +658,20 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 				} )
 			).toHaveCount( 0 );
 
-			// AC-13 / AC-14: the `<MediaReplaceFlow>` toolbar dropdown — the
-			// only DOM site of both the "Replace" and "Add media" toolbar
-			// labels — is omitted entirely. Zero matches is the positive
-			// assertion the design doc (§5.5) and the task spec require.
-			const blockToolbar = page.getByRole( 'toolbar', {
-				name: 'Block tools',
-			} );
+			// AC-13/14: MediaReplaceFlow toggle (Replace + Add media) absent.
 			await expect(
-				blockToolbar.getByRole( 'button', {
+				getBlockToolbar().getByRole( 'button', {
 					name: /^(Replace|Add media)$/,
 				} )
 			).toHaveCount( 0 );
 
-			// AC-10: the `ResetOverridesControl` toolbar button reports
-			// disabled because no override has been written yet.
-			const resetButton = blockToolbar.getByRole( 'button', {
-				name: 'Reset',
-			} );
-			await expect( resetButton ).toBeDisabled();
+			// AC-10: Reset disabled without override.
+			await expect(
+				getBlockToolbar().getByRole( 'button', { name: 'Reset' } )
+			).toBeDisabled();
 		} );
 
 		await test.step( 'AC-21 — embed-video covers retain Replace + "Embed video from URL"', async () => {
-			// Embed-video covers force `bindingActive=false` upstream even
-			// when `metadata.bindings` is present, so the
-			// `<MediaReplaceFlow>` affordance — including the "Embed video
-			// from URL" `<MenuItem>` child — must still render. Use a brand
-			// new post to keep the assertion focused on a single block tree.
 			await admin.createNewPost();
 			await editor.insertBlock( {
 				name: 'core/cover',
@@ -738,22 +695,14 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 			await editor.selectBlocks( embedCover );
 			await editor.showBlockToolbar();
 
-			const embedToolbar = page.getByRole( 'toolbar', {
-				name: 'Block tools',
-			} );
-			const replaceToggle = embedToolbar.getByRole( 'button', {
+			const replaceToggle = getBlockToolbar().getByRole( 'button', {
 				name: /^(Replace|Add media)$/,
 			} );
 			await expect( replaceToggle ).toBeVisible();
-
 			await replaceToggle.click();
 			await expect(
-				page.getByRole( 'menuitem', {
-					name: 'Embed video from URL',
-				} )
+				page.getByRole( 'menuitem', { name: 'Embed video from URL' } )
 			).toBeVisible();
-
-			// Close the dropdown so it does not bleed into the next step.
 			await page.keyboard.press( 'Escape' );
 		} );
 
@@ -764,24 +713,15 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 				attributes: { ref: pattern.id },
 			} );
 
-			patternBlock = editor.canvas.getByRole( 'document', {
-				name: 'Block: Pattern',
-			} );
-			coverBlock = patternBlock.getByRole( 'document', {
-				name: 'Block: Cover',
-			} );
+			const coverBlock = getCoverBlock();
 			await expect( coverBlock ).toBeVisible();
 
-			// Write the override directly onto the pattern instance's
-			// `content` attribute. This is exactly what
-			// `ResetOverridesControl` undoes in the reset step below.
 			await page.evaluate(
 				( { name, overrideId, overrideUrl } ) => {
 					const { dispatch, select } = window.wp.data;
-					const blocks = select( 'core/block-editor' ).getBlocks();
-					const patternClientId = blocks.find(
-						( block ) => block.name === 'core/block'
-					)?.clientId;
+					const patternClientId = select( 'core/block-editor' )
+						.getBlocks()
+						.find( ( b ) => b.name === 'core/block' )?.clientId;
 					dispatch( 'core/block-editor' ).updateBlockAttributes(
 						patternClientId,
 						{
@@ -801,47 +741,28 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 				}
 			);
 
-			// AC-22 editor: the bound `<img src>` flips to the override.
+			// AC-22 editor: bound <img src> flips to the override.
 			await expect( coverBlock.locator( 'img' ) ).toHaveAttribute(
 				'src',
 				overrideMedia.source_url
 			);
 
-			// AC-10: the now-written override flips `ResetOverridesControl`
-			// to enabled.
+			// AC-10: written override flips Reset to enabled.
 			await editor.selectBlocks( coverBlock );
 			await editor.showBlockToolbar();
-			const blockToolbar = page.getByRole( 'toolbar', {
-				name: 'Block tools',
-			} );
 			await expect(
-				blockToolbar.getByRole( 'button', { name: 'Reset' } )
+				getBlockToolbar().getByRole( 'button', { name: 'Reset' } )
 			).toBeEnabled();
 
-			// AC-8 / AC-16: publish, then read the rendered post on the
-			// front-end. The server-rendered `<img src>` must match the
-			// override and the overlay span must keep `has-background-dim`
-			// while losing the `-100` modifier.
+			// AC-8/16: front-end matches override + relaxed dim.
 			const postId = await editor.publishPost();
 			await page.goto( `/?p=${ postId }` );
-
-			const renderedImage = page.locator(
-				'.wp-block-cover__image-background'
-			);
-			await expect( renderedImage ).toHaveAttribute(
-				'src',
-				overrideMedia.source_url
-			);
-
-			const renderedOverlay = page.locator(
-				'.wp-block-cover__background'
-			);
-			await expect( renderedOverlay ).toHaveClass(
-				/has-background-dim(?!-100)/
-			);
-			await expect( renderedOverlay ).not.toHaveClass(
-				/has-background-dim-100/
-			);
+			await expect(
+				page.locator( '.wp-block-cover__image-background' )
+			).toHaveAttribute( 'src', overrideMedia.source_url );
+			await expect(
+				page.locator( '.wp-block-cover__background' )
+			).toHaveClass( /has-background-dim(?!-100)/ );
 		} );
 
 		await test.step( 'Reset — clicking Reset clears the override on both editor and front-end', async () => {
@@ -859,14 +780,7 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 				},
 			} );
 
-			patternBlock = editor.canvas.getByRole( 'document', {
-				name: 'Block: Pattern',
-			} );
-			coverBlock = patternBlock.getByRole( 'document', {
-				name: 'Block: Cover',
-			} );
-
-			// Confirm the override is in effect before resetting.
+			const coverBlock = getCoverBlock();
 			await expect( coverBlock.locator( 'img' ) ).toHaveAttribute(
 				'src',
 				overrideMedia.source_url
@@ -874,24 +788,15 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 
 			await editor.selectBlocks( coverBlock );
 			await editor.showBlockToolbar();
-			const blockToolbar = page.getByRole( 'toolbar', {
-				name: 'Block tools',
-			} );
-			const resetButton = blockToolbar.getByRole( 'button', {
-				name: 'Reset',
-			} );
-			await expect( resetButton ).toBeEnabled();
-			await resetButton.click();
+			await getBlockToolbar()
+				.getByRole( 'button', { name: 'Reset' } )
+				.click();
 
-			// AC-9 editor: the bound `<img src>` falls back to the pattern's
-			// stored default attachment.
+			// AC-9 editor + front-end: falls back to pattern default.
 			await expect( coverBlock.locator( 'img' ) ).toHaveAttribute(
 				'src',
 				defaultMedia.source_url
 			);
-
-			// AC-9 front-end: the rendered post likewise serves the default
-			// attachment after the reset persists.
 			const postId = await editor.publishPost();
 			await page.goto( `/?p=${ postId }` );
 			await expect(
@@ -901,13 +806,6 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 
 		await test.step( 'Unresolvable — mismatched-source bindings surface the i18n affordance', async () => {
 			await admin.createNewPost();
-
-			// `id` and `url` bound to different sources never satisfy the
-			// hook's `bindingActive` predicate, so the Cover renders the
-			// unresolvable placeholder branch. The mismatched source-set is
-			// intentionally not Pattern Overrides on both sides; the second
-			// source need not actually resolve — the affordance is driven
-			// purely by the source-mismatch detection.
 			await editor.insertBlock( {
 				name: 'core/cover',
 				attributes: {
@@ -924,8 +822,7 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 				},
 			} );
 
-			// OQ-6: the user-facing affordance is the i18n message — not a
-			// data-testid — exactly per the task contract.
+			// OQ-6: i18n message is the user-facing affordance.
 			await expect(
 				page.getByText( 'Internal media required for this binding.' )
 			).toBeVisible();

From ebfb704d40b28aa6fc042d575147be30469cf643 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 11:13:41 +0200
Subject: [PATCH 50/60] test(block-library): consolidate cover Jest mock setup

Hoist a shared `useBindingSource` harness used by all four binding
describes; remove duplicated source-registration + sourceState
boilerplate and the verbose multi-paragraph narrative comments on each
test case.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 packages/block-library/src/cover/test/edit.js | 307 +++++-------------
 1 file changed, 80 insertions(+), 227 deletions(-)

diff --git a/packages/block-library/src/cover/test/edit.js b/packages/block-library/src/cover/test/edit.js
index e626135f4f08a8..8f20179ef3cbb7 100644
--- a/packages/block-library/src/cover/test/edit.js
+++ b/packages/block-library/src/cover/test/edit.js
@@ -495,24 +495,18 @@ describe( 'Cover block', () => {
 		} );
 	} );
 
-	describe( 'Bindings rendering', () => {
-		const TEST_SOURCE = 'test/cover-binding-edit';
-		const TEST_RESOLVED_URL = 'http://localhost/bound-image.jpg';
-		const TEST_RESOLVED_ID = 4242;
-
-		// Mutable state read by the test source's `getValues` so individual
-		// tests can dial the resolved URL / ID without re-registering.
-		const sourceState = {
-			url: TEST_RESOLVED_URL,
-			id: TEST_RESOLVED_ID,
-		};
-
+	// Shared binding-source harness for the four binding describes below.
+	// Each describe gets a unique source name (so registrations cannot leak)
+	// and a `sourceState` bag tests can mutate before `setup()` to dial the
+	// resolved `id` / `url` returned by `getValues`.
+	function useBindingSource( name, defaultUrl, defaultId ) {
+		const sourceState = { url: defaultUrl, id: defaultId };
 		beforeEach( () => {
-			sourceState.url = TEST_RESOLVED_URL;
-			sourceState.id = TEST_RESOLVED_ID;
+			sourceState.url = defaultUrl;
+			sourceState.id = defaultId;
 			registerBlockBindingsSource( {
-				name: TEST_SOURCE,
-				label: 'Test cover binding source',
+				name,
+				label: name,
 				getValues: () => ( {
 					id: sourceState.id,
 					url: sourceState.url,
@@ -520,20 +514,24 @@ describe( 'Cover block', () => {
 				canUserEditValue: () => false,
 			} );
 		} );
-
-		afterEach( () => {
-			unregisterBlockBindingsSource( TEST_SOURCE );
-		} );
-
-		const boundBindings = {
-			id: { source: TEST_SOURCE },
-			url: { source: TEST_SOURCE },
+		afterEach( () => unregisterBlockBindingsSource( name ) );
+		return {
+			sourceState,
+			bindings: { id: { source: name }, url: { source: name } },
 		};
+	}
+
+	describe( 'Bindings rendering', () => {
+		const TEST_SOURCE = 'test/cover-binding-edit';
+		const TEST_RESOLVED_URL = 'http://localhost/bound-image.jpg';
+		const { bindings: boundBindings } = useBindingSource(
+			TEST_SOURCE,
+			TEST_RESOLVED_URL,
+			4242
+		);
 
 		test( 'renders a binding-aware placeholder with the unresolvable copy when bindings are mismatched', async () => {
-			// Mismatched sources on `id` vs `url` yield `bindingActive=false`
-			// but `bindingUnresolvable=true` (cover-relevant bindings exist
-			// yet do not satisfy the active-binding predicate).
+			// Mismatched sources → bindingActive=false, bindingUnresolvable=true.
 			await setup( {
 				metadata: {
 					bindings: {
@@ -544,17 +542,14 @@ describe( 'Cover block', () => {
 			} );
 
 			const coverBlock = screen.getByLabelText( 'Block: Cover' );
-
 			expect(
 				within( coverBlock ).getByText(
 					'Internal media required for this binding.'
 				)
 			).toBeInTheDocument();
-
 			expect(
 				within( coverBlock ).getByTestId( 'cover-binding-unresolvable' )
 			).toBeInTheDocument();
-
 			expect(
 				// eslint-disable-next-line testing-library/no-node-access
 				coverBlock.querySelector(
@@ -573,15 +568,11 @@ describe( 'Cover block', () => {
 			} );
 
 			const boundImg = await screen.findByRole( 'img' );
-
 			expect( boundImg ).toHaveClass(
 				'wp-block-cover__image-background'
 			);
 			expect( boundImg ).toHaveAttribute( 'src', TEST_RESOLVED_URL );
-
-			// The force-img branch never picks up the parallax/repeat <div>
-			// markup; assert that the alternative <div> background does NOT
-			// appear in the rendered tree.
+			// Force-img branch precludes the parallax/repeat <div> form.
 			expect(
 				// eslint-disable-next-line testing-library/no-node-access
 				document.querySelector( 'div.wp-block-cover__image-background' )
@@ -596,22 +587,18 @@ describe( 'Cover block', () => {
 			} );
 
 			const coverBlock = screen.getByLabelText( 'Block: Cover' );
-
-			// `bindingActive` is forced to `false` for embed-video covers, so
-			// the binding-aware placeholder must NOT engage inside the cover.
+			// bindingActive forced false for embed-video → neither placeholder
+			// nor force-img engages.
 			expect(
 				within( coverBlock ).queryByText(
 					'Internal media required for this binding.'
 				)
 			).not.toBeInTheDocument();
-
 			expect(
 				within( coverBlock ).queryByTestId(
 					'cover-binding-unresolvable'
 				)
 			).not.toBeInTheDocument();
-
-			// Likewise, the force-img branch must not fire.
 			expect(
 				// eslint-disable-next-line testing-library/no-node-access
 				coverBlock.querySelector(
@@ -623,29 +610,11 @@ describe( 'Cover block', () => {
 
 	describe( 'Bindings control gating', () => {
 		const TEST_SOURCE = 'test/cover-binding-controls';
-		const TEST_RESOLVED_URL = 'http://localhost/bound-image.jpg';
-		const TEST_RESOLVED_ID = 4242;
-
-		beforeEach( () => {
-			registerBlockBindingsSource( {
-				name: TEST_SOURCE,
-				label: 'Test cover binding controls source',
-				getValues: () => ( {
-					id: TEST_RESOLVED_ID,
-					url: TEST_RESOLVED_URL,
-				} ),
-				canUserEditValue: () => false,
-			} );
-		} );
-
-		afterEach( () => {
-			unregisterBlockBindingsSource( TEST_SOURCE );
-		} );
-
-		const boundBindings = {
-			id: { source: TEST_SOURCE },
-			url: { source: TEST_SOURCE },
-		};
+		const { bindings: boundBindings } = useBindingSource(
+			TEST_SOURCE,
+			'http://localhost/bound-image.jpg',
+			4242
+		);
 
 		test( 'hides the MediaReplaceFlow toolbar button when bindingActive', async () => {
 			await setup( {
@@ -653,15 +622,9 @@ describe( 'Cover block', () => {
 				backgroundType: 'image',
 				metadata: { bindings: boundBindings },
 			} );
-
-			// Force-img branch engages, confirming the binding is active and
-			// the block-toolbar subtree has rendered alongside it.
+			// Force-img branch engages → block toolbar has rendered.
 			await screen.findByRole( 'img' );
 
-			// On bound covers the `<MediaReplaceFlow>` toggle is absent from
-			// the document regardless of selection state — `<BlockControls>`
-			// portals are present in the global DOM whenever `CoverEdit`
-			// renders.
 			expect(
 				screen.queryByRole( 'button', { name: 'Replace' } )
 			).not.toBeInTheDocument();
@@ -672,43 +635,17 @@ describe( 'Cover block', () => {
 	} );
 
 	describe( 'useCoverBindingState', () => {
-		// Unique per-describe source name so registrations cannot leak between
-		// the integration-style binding describes and these hook-level tests.
 		const TEST_SOURCE = 'test/cover-binding-state-hook';
-		const TEST_RESOLVED_URL = 'http://localhost/resolved-image.jpg';
-		const TEST_RESOLVED_ID = 9991;
-
-		const sourceState = {
-			url: TEST_RESOLVED_URL,
-			id: TEST_RESOLVED_ID,
-		};
-
-		beforeEach( () => {
-			sourceState.url = TEST_RESOLVED_URL;
-			sourceState.id = TEST_RESOLVED_ID;
-			registerBlockBindingsSource( {
-				name: TEST_SOURCE,
-				label: 'Hook test binding source',
-				getValues: () => ( {
-					id: sourceState.id,
-					url: sourceState.url,
-				} ),
-				canUserEditValue: () => false,
-			} );
-		} );
-
-		afterEach( () => {
-			unregisterBlockBindingsSource( TEST_SOURCE );
-		} );
+		const { sourceState } = useBindingSource(
+			TEST_SOURCE,
+			'http://localhost/resolved-image.jpg',
+			9991
+		);
 
 		test( 'bindingUnresolvable: true when the bound id resolves to a non-attachment record (integration)', async () => {
-			// Preload a record under the attachment entity but with
-			// `type !== "attachment"` — the hook's `attachmentResolvedWrongType`
-			// guard is the user-observable arm of the "resolved-not-found"
-			// invariant (Design §5.1 step 3: attachment must be a media-library
-			// attachment to count as resolved). The `attachment` entity is
-			// normally registered after a REST call; in this jsdom environment
-			// no such call happens, so we register it explicitly here.
+			// Hook's `attachmentResolvedWrongType` guard: attachment entity
+			// record exists but `type !== "attachment"`. Register the entity
+			// manually since no REST call seeds it in jsdom.
 			const wrongTypeId = 99_991;
 			sourceState.id = wrongTypeId;
 			sourceState.url = 'http://localhost/wrong-type.jpg';
@@ -747,12 +684,10 @@ describe( 'Cover block', () => {
 				},
 			} );
 
-			const coverBlock = screen.getByLabelText( 'Block: Cover' );
-
 			expect(
-				await within( coverBlock ).findByText(
-					'Internal media required for this binding.'
-				)
+				await within(
+					screen.getByLabelText( 'Block: Cover' )
+				).findByText( 'Internal media required for this binding.' )
 			).toBeInTheDocument();
 		} );
 	} );
@@ -760,59 +695,24 @@ describe( 'Cover block', () => {
 	describe( 'CoverEdit single observer', () => {
 		const TEST_SOURCE = 'test/cover-binding-observer';
 		const TEST_RESOLVED_URL = 'http://localhost/observer-image.jpg';
-		const TEST_RESOLVED_ID = 7777;
-
-		const sourceState = {
-			url: TEST_RESOLVED_URL,
-			id: TEST_RESOLVED_ID,
-		};
+		useBindingSource( TEST_SOURCE, TEST_RESOLVED_URL, 7777 );
 
 		beforeEach( () => {
-			sourceState.url = TEST_RESOLVED_URL;
-			sourceState.id = TEST_RESOLVED_ID;
-			registerBlockBindingsSource( {
-				name: TEST_SOURCE,
-				label: 'Observer test binding source',
-				getValues: () => ( {
-					id: sourceState.id,
-					url: sourceState.url,
-				} ),
-				canUserEditValue: () => false,
-			} );
-			// Default `getMediaColor` to the real implementation (silently
-			// falls through to the default colour in JSDOM); individual tests
-			// can override via `mockImplementation`.
+			// Default `getMediaColor` to the real implementation; individual
+			// tests can override via `mockImplementation`.
 			getMediaColor.mockReset();
-			const actualGetMediaColor = jest.requireActual(
-				'../edit/color-utils'
-			).getMediaColor;
-			getMediaColor.mockImplementation( actualGetMediaColor );
-		} );
-
-		afterEach( () => {
-			unregisterBlockBindingsSource( TEST_SOURCE );
+			getMediaColor.mockImplementation(
+				jest.requireActual( '../edit/color-utils' ).getMediaColor
+			);
 		} );
 
 		test( 'does not write any DC-2-prohibited attribute back to the block when a binding becomes active', async () => {
-			// Saved state: `dimRatio = 100`, `hasParallax = true`,
-			// `isRepeated = true`, plus an active binding. The observer must
-			// NOT flip any of these to keep DC-2.
-			//
-			// `BlockEditorProvider` creates a private sub-registry, so we
-			// cannot read attributes from the global `blockEditorStore`
-			// directly. We instead lean on the `<Editor>` helper's `onChange`
-			// callback — it fires whenever blocks change — by interposing a
-			// spy that records every blocks-update the editor commits. If
-			// the observer dispatched any DC-2-prohibited `setAttributes`
-			// call, that change would surface here; the test asserts no such
-			// change ever ran by sampling the final committed block state.
-			//
-			// (Operationally: `setup()` keeps blocks in local state inside
-			// `Editor`. The observer's `setAttributes({ isDark })` calls
-			// commit to the underlying registry, propagate via `onChange`
-			// to `Editor`, then update `currentBlocks` — which is the same
-			// path any other write would take.)
-			const initialAttrs = {
+			// Saved state: dimRatio=100, hasParallax=true, isRepeated=true,
+			// plus an active binding. Observer must NOT flip any of these.
+			// We sample post-flush DOM state because `BlockEditorProvider`'s
+			// private sub-registry hides the global store; a DC-2-violating
+			// `setAttributes({ url })` would clobber `data-url`.
+			await setup( {
 				url: 'http://localhost/stored.jpg',
 				id: 1234,
 				backgroundType: 'image',
@@ -825,57 +725,29 @@ describe( 'Cover block', () => {
 						url: { source: TEST_SOURCE },
 					},
 				},
-			};
-
-			await setup( initialAttrs );
+			} );
 
-			// Wait for the binding-aware render to engage.
 			await screen.findByRole( 'img' );
-
-			// Allow the URL-resolved observer (and any subsequent re-renders)
-			// to flush before we sample the stored attributes.
-			await act( async () => {
-				await Promise.resolve();
-			} );
-			await act( async () => {
-				await Promise.resolve();
-			} );
+			// Flush URL-resolved observer + any subsequent re-renders.
+			await act( async () => Promise.resolve() );
+			await act( async () => Promise.resolve() );
 
 			const coverBlock = screen.getByLabelText( 'Block: Cover' );
-
-			// `data-url` is the editor's pass-through of the stored `url`
-			// attribute (via `originalUrl?.replaceAll('&amp;', '&')`). A
-			// DC-2-violating observer that wrote `setAttributes({ url:
-			// bindingResolvedUrl })` would clobber this to the resolved URL.
 			expect( coverBlock ).toHaveAttribute(
 				'data-url',
 				'http://localhost/stored.jpg'
 			);
-
-			// The bound `<img>` carries the resolved URL (proves the
-			// binding-aware render engaged).
-			// eslint-disable-next-line testing-library/no-node-access
-			const boundImg = coverBlock.querySelector(
-				'img.wp-block-cover__image-background'
-			);
-			expect( boundImg ).toHaveAttribute( 'src', TEST_RESOLVED_URL );
-
-			// `hasParallax`/`isRepeated` survival proof: if the observer had
-			// flipped either to false, `isImgElement` would have toggled and
-			// the non-binding rendering branch would have switched its DOM
-			// element. The active-binding force-img branch ignores those at
-			// render time, so the only way to invalidate this assertion is
-			// for the observer to set `hasParallax`/`isRepeated` to false
-			// AND for the binding to deactivate — neither of which should
-			// happen.
+			expect(
+				// eslint-disable-next-line testing-library/no-node-access
+				coverBlock.querySelector(
+					'img.wp-block-cover__image-background'
+				)
+			).toHaveAttribute( 'src', TEST_RESOLVED_URL );
 			expect( coverBlock ).toHaveClass( 'has-parallax' );
 			expect( coverBlock ).toHaveClass( 'is-repeated' );
 
-			// The overlay class reflects the *derived* effectiveDimRatio (50)
-			// — `dimRatioToClass(50)` returns `null` (the 50% baseline is the
-			// no-override default), so we assert the *absence* of the
-			// `has-background-dim-100` class that would be present if the
-			// stored `dimRatio` (100) had been used directly.
+			// effectiveDimRatio=50 → dimRatioToClass(50) is null; assert the
+			// absence of -100 that the raw stored dimRatio would have caused.
 			// eslint-disable-next-line testing-library/no-node-access
 			const overlay = coverBlock.querySelector(
 				'.wp-block-cover__background'
@@ -885,31 +757,14 @@ describe( 'Cover block', () => {
 		} );
 
 		test( 'observer fires `getMediaColor` exactly once per `effectiveUrl` on mount (race-token guard precondition: single observer keyed on effectiveUrl)', async () => {
-			// The race-token guard relies on the single-observer keyed-on-
-			// `effectiveUrl` architecture (DC-1). If a future change
-			// introduced additional triggers (e.g. a separate `useEffect`
-			// on `metadata.bindings` that also calls `getMediaColor`), the
-			// raceToken bookkeeping could break — multiple observers
-			// could increment the token concurrently. This test fixes the
-			// initial-mount invariant: a single mount triggers a single
-			// observer fire for the resolved `effectiveUrl`.
-			//
-			// `getMediaColor` is held pending so the post-await
-			// `setAttributes`/`setOverlayColor` flush never fires within
-			// the test — eliminating any "update was not wrapped in act"
-			// console errors that would otherwise come from the observer
-			// firing after the test's assertions have run.
+			// DC-1 precondition: a single mount fires the observer once for
+			// the resolved `effectiveUrl`. Pending promise avoids "update not
+			// wrapped in act" warnings from the post-await flush.
 			const URL_A = 'http://localhost/observer-counts.jpg';
-			const pendingPromise = new Promise( () => {
-				/* never resolves */
-			} );
-
-			getMediaColor.mockImplementation( ( url ) => {
-				if ( url === URL_A ) {
-					return pendingPromise;
-				}
-				return Promise.resolve( '#888888' );
-			} );
+			const pending = new Promise( () => {} );
+			getMediaColor.mockImplementation( ( url ) =>
+				url === URL_A ? pending : Promise.resolve( '#888888' )
+			);
 
 			await setup( {
 				url: URL_A,
@@ -917,12 +772,10 @@ describe( 'Cover block', () => {
 				dimRatio: 70,
 			} );
 
-			// Filter to URL_A only — the editor harness may incidentally
-			// fire `getMediaColor()` against `undefined` during mount.
-			const callsForUrlA = getMediaColor.mock.calls.filter(
-				( [ url ] ) => url === URL_A
-			);
-			expect( callsForUrlA ).toHaveLength( 1 );
+			// Filter to URL_A — harness may incidentally call with undefined.
+			expect(
+				getMediaColor.mock.calls.filter( ( [ u ] ) => u === URL_A )
+			).toHaveLength( 1 );
 		} );
 	} );
 } );

From 9b43b061004db49c84ccf58edd1eee53140c26b3 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 11:15:41 +0200
Subject: [PATCH 51/60] refactor(block-bindings): trim cover render filter
 prose

Collapse the AC-21 + bindings-active early-returns into combined guard
clauses, fold the two-step preg_match offset/length plumbing inline,
shorten resolved_url/resolved_id variables to url/id, and drop the
inline narrative comments. Behaviour is unchanged.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 134 +++++++++-----------
 1 file changed, 57 insertions(+), 77 deletions(-)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index 0437ca7cdd6057..1c0cbafaa064a0 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -74,7 +74,6 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 	 * Forces `useFeaturedImage` off on bound covers before `WP_Block::render()`.
 	 *
 	 * AC-18: an active `id`+`url` binding always wins over `useFeaturedImage`.
-	 * Mutation is scoped to the in-flight `$parsed_block` only.
 	 *
 	 * @since 7.1.0
 	 */
@@ -85,12 +84,11 @@ function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $
 
 		$attrs = $parsed_block['attrs'] ?? array();
 
-		// AC-21: never engage for embed-video covers.
-		if ( ! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType'] ) {
-			return $parsed_block;
-		}
-
-		if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
+		// AC-21: skip embed-video covers.
+		if (
+			( $attrs['backgroundType'] ?? '' ) === 'embed-video' ||
+			! gutenberg_cover_bindings_is_active( $attrs )
+		) {
 			return $parsed_block;
 		}
 
@@ -112,15 +110,13 @@ function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $
 	 * @access private
 	 */
 	function gutenberg_cover_bindings_strip_image( string $content ): string {
-		// Parallax/repeat saved form is probed first; an <img>-only regex would miss it.
-		$form2_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
-		$form1_pattern = '/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?\s*>/U';
-
-		foreach ( array( $form2_pattern, $form1_pattern ) as $pattern ) {
-			if ( 1 === preg_match( $pattern, $content, $matches, PREG_OFFSET_CAPTURE ) ) {
-				$start  = $matches[0][1];
-				$length = strlen( $matches[0][0] );
-				return substr( $content, 0, $start ) . substr( $content, $start + $length );
+		// Parallax/repeat <div> form is probed first; <img>-only regex would miss it.
+		foreach ( array(
+			'/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U',
+			'/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?\s*>/U',
+		) as $pattern ) {
+			if ( 1 === preg_match( $pattern, $content, $m, PREG_OFFSET_CAPTURE ) ) {
+				return substr( $content, 0, $m[0][1] ) . substr( $content, $m[0][1] + strlen( $m[0][0] ) );
 			}
 		}
 		return $content;
@@ -139,14 +135,14 @@ function gutenberg_cover_bindings_strip_image( string $content ): string {
 	 * @access private
 	 */
 	function gutenberg_cover_bindings_rewrite_image( string $content, string $resolved_url, int $resolved_id, array $attrs ): string {
-		$alt             = trim( strip_tags( (string) get_post_meta( $resolved_id, '_wp_attachment_image_alt', true ) ) );
-		$size_slug       = isset( $attrs['sizeSlug'] ) && '' !== $attrs['sizeSlug']
+		$alt       = trim( strip_tags( (string) get_post_meta( $resolved_id, '_wp_attachment_image_alt', true ) ) );
+		$size_slug = isset( $attrs['sizeSlug'] ) && '' !== $attrs['sizeSlug']
 			? ' size-' . $attrs['sizeSlug']
 			: '';
+
 		$object_position = '';
 		if (
-			isset( $attrs['focalPoint']['x'] ) &&
-			isset( $attrs['focalPoint']['y'] ) &&
+			isset( $attrs['focalPoint']['x'], $attrs['focalPoint']['y'] ) &&
 			is_numeric( $attrs['focalPoint']['x'] ) &&
 			is_numeric( $attrs['focalPoint']['y'] )
 		) {
@@ -157,22 +153,14 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 			);
 		}
 
-		// Parallax/repeat form: saved markup is the source of truth (NOT
-		// $attrs['hasParallax']/$attrs['isRepeated']) — the pattern matches the
-		// literal serialized form emitted by save.js.
-		$form2_pattern = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
-		if ( 1 === preg_match( $form2_pattern, $content, $matches, PREG_OFFSET_CAPTURE ) ) {
-			$div_start  = $matches[0][1];
-			$div_length = strlen( $matches[0][0] );
-
-			$object_position_attrs = '';
-			if ( '' !== $object_position ) {
-				$object_position_attrs = sprintf(
-					' data-object-position="%s" style="object-position:%s;"',
-					esc_attr( $object_position ),
-					esc_attr( $object_position )
-				);
-			}
+		// Parallax/repeat <div> form: rebuild as an <img>. Saved markup is
+		// the source of truth, NOT $attrs['hasParallax']/['isRepeated'].
+		if ( 1 === preg_match( '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U', $content, $m, PREG_OFFSET_CAPTURE ) ) {
+			$object_position_attrs = '' === $object_position ? '' : sprintf(
+				' data-object-position="%s" style="object-position:%s;"',
+				esc_attr( $object_position ),
+				esc_attr( $object_position )
+			);
 
 			$rebuilt_img = sprintf(
 				'<img class="wp-block-cover__image-background wp-image-%d%s" alt="%s" src="%s" data-object-fit="cover"%s />',
@@ -183,39 +171,40 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 				$object_position_attrs
 			);
 
-			return substr( $content, 0, $div_start ) . $rebuilt_img . substr( $content, $div_start + $div_length );
+			return substr( $content, 0, $m[0][1] ) . $rebuilt_img . substr( $content, $m[0][1] + strlen( $m[0][0] ) );
 		}
 
 		// Plain <img> form: rewrite attributes in place.
 		$processor = new WP_HTML_Tag_Processor( $content );
-		if ( $processor->next_tag(
+		if ( ! $processor->next_tag(
 			array(
 				'tag_name'   => 'IMG',
 				'class_name' => 'wp-block-cover__image-background',
 			)
 		) ) {
-			$processor->set_attribute( 'src', $resolved_url );
-			$processor->set_attribute( 'alt', $alt );
-
-			// Remove any saved wp-image-{old} before adding the resolved one.
-			$class_list = $processor->class_list();
-			if ( null !== $class_list ) {
-				$wp_image_classes_to_remove = array();
-				foreach ( $class_list as $cls ) {
-					if ( 0 === strpos( $cls, 'wp-image-' ) ) {
-						$wp_image_classes_to_remove[] = $cls;
-					}
-				}
-				foreach ( $wp_image_classes_to_remove as $cls ) {
-					$processor->remove_class( $cls );
+			return $content;
+		}
+
+		$processor->set_attribute( 'src', $resolved_url );
+		$processor->set_attribute( 'alt', $alt );
+
+		// Strip any saved wp-image-{old} before adding the resolved one.
+		// Collect first — remove_class while iterating the Generator is unsafe.
+		$class_list = $processor->class_list();
+		if ( null !== $class_list ) {
+			$to_remove = array();
+			foreach ( $class_list as $cls ) {
+				if ( 0 === strpos( $cls, 'wp-image-' ) ) {
+					$to_remove[] = $cls;
 				}
 			}
-			$processor->add_class( 'wp-image-' . $resolved_id );
-
-			return $processor->get_updated_html();
+			foreach ( $to_remove as $cls ) {
+				$processor->remove_class( $cls );
+			}
 		}
+		$processor->add_class( 'wp-image-' . $resolved_id );
 
-		return $content;
+		return $processor->get_updated_html();
 	}
 }
 
@@ -236,43 +225,35 @@ function gutenberg_cover_bindings_render_block( $block_content, $block, $instanc
 
 		$attrs = $instance->attributes ?? array();
 
-		// AC-21: never engage for embed-video covers.
-		if ( ! empty( $attrs['backgroundType'] ) && 'embed-video' === $attrs['backgroundType'] ) {
+		// AC-21: skip embed-video covers.
+		if ( ( $attrs['backgroundType'] ?? '' ) === 'embed-video' ) {
 			return $block_content;
 		}
 
 		if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
-			// AC-6: cover-relevant binding config present but inactive — strip the
-			// saved image so the cover renders overlay-only. AC-20: genuinely
-			// unbound covers pass through unchanged.
+			// AC-6: inactive cover-relevant bindings strip the saved image.
+			// AC-20: genuinely unbound covers pass through.
 			$bindings = $attrs['metadata']['bindings'] ?? null;
-			if ( ! empty( $bindings ) && is_array( $bindings ) && ( isset( $bindings['__default'] ) || isset( $bindings['id'] ) || isset( $bindings['url'] ) ) ) {
+			if ( is_array( $bindings ) && ( isset( $bindings['__default'] ) || isset( $bindings['id'] ) || isset( $bindings['url'] ) ) ) {
 				return gutenberg_cover_bindings_strip_image( $block_content );
 			}
 			return $block_content;
 		}
 
-		$resolved_url = $attrs['url'] ?? null;
-		$resolved_id  = (int) ( $attrs['id'] ?? 0 );
-
-		if ( empty( $resolved_url ) || empty( $resolved_id ) ) {
+		$url = $attrs['url'] ?? null;
+		$id  = (int) ( $attrs['id'] ?? 0 );
+		if ( empty( $url ) || empty( $id ) ) {
 			return gutenberg_cover_bindings_strip_image( $block_content );
 		}
 
-		$attachment = get_post( $resolved_id );
+		$attachment = get_post( $id );
 		if ( ! $attachment || 'attachment' !== $attachment->post_type ) {
 			return gutenberg_cover_bindings_strip_image( $block_content );
 		}
 
-		$block_content = gutenberg_cover_bindings_rewrite_image(
-			$block_content,
-			(string) $resolved_url,
-			$resolved_id,
-			$attrs
-		);
+		$block_content = gutenberg_cover_bindings_rewrite_image( $block_content, (string) $url, $id, $attrs );
 
-		// AC-16 / OQ-4: relax stored dimRatio:100 so the bound image is visible
-		// (effective dimRatio is 50 and `dimRatioToClass(50)` is null).
+		// AC-16 / OQ-4: relax stored dimRatio:100 so the bound image is visible.
 		if ( 100 === (int) ( $attrs['dimRatio'] ?? 100 ) ) {
 			$processor = new WP_HTML_Tag_Processor( $block_content );
 			while ( $processor->next_tag(
@@ -290,6 +271,5 @@ function gutenberg_cover_bindings_render_block( $block_content, $block, $instanc
 	}
 }
 
-// Priority 9 — must run before the generic priority-10
-// gutenberg_block_bindings_render_block filter.
+// Priority 9 — must run before the generic priority-10 filter.
 add_filter( 'render_block', 'gutenberg_cover_bindings_render_block', 9, 3 );

From 33062266d7ac39847ff2081215dd752b7dfa795a Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 11:18:03 +0200
Subject: [PATCH 52/60] refactor(block-library): trim cover edit binding prose

Shorten the propsRef / effectiveUrl / effectiveDimRatio / observer
comments to single-line markers, fold the bindingActive vs isImgElement
<img>/<div> branch into one ternary, and compress the unresolvable
Placeholder className into a template literal.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../block-library/src/cover/edit/index.js     | 121 +++++++-----------
 1 file changed, 47 insertions(+), 74 deletions(-)

diff --git a/packages/block-library/src/cover/edit/index.js b/packages/block-library/src/cover/edit/index.js
index b81a680599dad0..c5f22b65e99989 100644
--- a/packages/block-library/src/cover/edit/index.js
+++ b/packages/block-library/src/cover/edit/index.js
@@ -119,12 +119,10 @@ function CoverEdit( {
 		poster,
 	} = attributes;
 
-	// Single source of truth for binding state.
 	const { bindingActive, bindingUnresolvable, bindingResolvedUrl } =
 		useCoverBindingState( { clientId, attributes, context } );
 
-	// Race-token guard for the `effectiveUrl` observer: stale `getMediaColor`
-	// resolutions bail when their captured token no longer matches.
+	// Race-token guard: stale `getMediaColor` resolutions bail.
 	const raceTokenRef = useRef( 0 );
 
 	const [ featuredImage ] = useEntityProp(
@@ -138,8 +136,7 @@ function CoverEdit( {
 	const { __unstableMarkNextChangeAsNotPersistent } =
 		useDispatch( blockEditorStore );
 
-	// Ref to access latest values after async operations (e.g. getMediaColor),
-	// avoiding stale values that could overwrite concurrent remote changes.
+	// Latest attributes/overlayColor for post-await reads (avoid stale closures).
 	const propsRef = useRef( { attributes, overlayColor } );
 	useLayoutEffect( () => {
 		propsRef.current = { attributes, overlayColor };
@@ -167,33 +164,27 @@ function CoverEdit( {
 		media?.media_details?.sizes?.[ sizeSlug ]?.source_url ??
 		media?.source_url;
 
-	// Source-agnostic URL: bound URL wins, else featured-image, else stored.
+	// Source-agnostic URL: bound URL wins, else featured-image, else stored
+	// (sanitized through wp_kses).
 	const effectiveUrl =
 		bindingResolvedUrl ??
 		( useFeaturedImage
 			? mediaUrl
-			: // Ensure the url is not malformed due to sanitization through `wp_kses`.
-			  originalUrl?.replaceAll( '&amp;', '&' ) );
+			: originalUrl?.replaceAll( '&amp;', '&' ) );
 
-	// Default `dimRatio: 100` would hide a bound image, so relax it to 50
-	// while a binding is active and an image is available (§5.2).
+	// §5.2: relax dimRatio 100 → 50 so the bound image is visible.
 	const effectiveDimRatio =
 		bindingActive && dimRatio === 100 && effectiveUrl ? 50 : dimRatio;
 
-	// Source-agnostic URL-resolved observer: recomputes `overlayColor` (when
-	// not user-pinned) and `isDark` on every `effectiveUrl` change. Race-token
-	// bookkeeping discards stale resolutions. DC-2: only `{ isDark }` is
-	// written back.
+	// DC-2: URL-resolved observer writes back only `{ isDark }`. Race-token
+	// bookkeeping discards stale resolutions.
 	const onUrlResolved = useEffectEvent( async ( resolvedUrl ) => {
 		if ( ! resolvedUrl ) {
 			return;
 		}
-
 		const myToken = ++raceTokenRef.current;
 		const averageBackgroundColor = await getMediaColor( resolvedUrl );
-
 		if ( myToken !== raceTokenRef.current ) {
-			// A newer resolution superseded ours.
 			return;
 		}
 
@@ -208,24 +199,22 @@ function CoverEdit( {
 			setOverlayColor( newOverlayColor );
 		}
 
-		// Mirror the `effectiveDimRatio` derivation using the latest
-		// attributes so the dark/light decision matches what the user sees.
+		// Mirror `effectiveDimRatio` against the latest attrs.
 		const latestEffectiveDimRatio =
 			bindingActive && currentAttrs.dimRatio === 100 && resolvedUrl
 				? 50
 				: currentAttrs.dimRatio;
-
-		const newIsDark = compositeIsDark(
-			latestEffectiveDimRatio,
-			newOverlayColor,
-			averageBackgroundColor
-		);
 		__unstableMarkNextChangeAsNotPersistent();
-		setAttributes( { isDark: newIsDark } );
+		setAttributes( {
+			isDark: compositeIsDark(
+				latestEffectiveDimRatio,
+				newOverlayColor,
+				averageBackgroundColor
+			),
+		} );
 	} );
 
-	// DC-1: single observer keyed on `effectiveUrl`. `onUrlResolved` is stable
-	// via `useEffectEvent` so it deliberately stays out of the dep array.
+	// DC-1: single observer keyed on `effectiveUrl`. `onUrlResolved` is stable.
 	useEffect( () => {
 		onUrlResolved( effectiveUrl );
 	}, [ effectiveUrl ] );
@@ -630,9 +619,8 @@ function CoverEdit( {
 
 	if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground ) {
 		if ( bindingActive || bindingUnresolvable ) {
-			// Bound covers never surface the standard upload affordance.
-			// Unresolvable bindings get a discoverable instruction; pending
-			// bindings get a silent illustration until `effectiveUrl` arrives.
+			// Bound covers replace the upload affordance with a Placeholder:
+			// unresolvable → discoverable instruction; pending → silent.
 			return (
 				<>
 					{ blockControls }
@@ -658,11 +646,9 @@ function CoverEdit( {
 									? 'cover-binding-unresolvable'
 									: undefined
 							}
-							className={
-								bindingUnresolvable
-									? 'wp-block-cover__binding-unresolvable'
-									: 'wp-block-cover__binding-pending'
-							}
+							className={ `wp-block-cover__binding-${
+								bindingUnresolvable ? 'unresolvable' : 'pending'
+							}` }
 							withIllustration
 							instructions={
 								bindingUnresolvable
@@ -750,45 +736,32 @@ function CoverEdit( {
 
 				{ ! bindingUnresolvable &&
 					effectiveUrl &&
-					isImageBackground && (
-						<>
-							{ bindingActive && (
-								// Bound covers force-render an <img> regardless
-								// of hasParallax/isRepeated (Design OQ-5).
-								<img
-									ref={ mediaElement }
-									className="wp-block-cover__image-background"
-									alt={ alt }
-									src={ effectiveUrl }
-									style={ mediaStyle }
-								/>
+					isImageBackground &&
+					// OQ-5: bound covers force-render an <img> regardless of
+					// hasParallax/isRepeated.
+					( bindingActive || isImgElement ? (
+						<img
+							ref={ mediaElement }
+							className="wp-block-cover__image-background"
+							alt={ alt }
+							src={ bindingActive ? effectiveUrl : url }
+							style={ mediaStyle }
+						/>
+					) : (
+						<div
+							ref={ mediaElement }
+							role={ alt ? 'img' : undefined }
+							aria-label={ alt ? alt : undefined }
+							className={ clsx(
+								classes,
+								'wp-block-cover__image-background'
 							) }
-							{ ! bindingActive &&
-								( isImgElement ? (
-									<img
-										ref={ mediaElement }
-										className="wp-block-cover__image-background"
-										alt={ alt }
-										src={ url }
-										style={ mediaStyle }
-									/>
-								) : (
-									<div
-										ref={ mediaElement }
-										role={ alt ? 'img' : undefined }
-										aria-label={ alt ? alt : undefined }
-										className={ clsx(
-											classes,
-											'wp-block-cover__image-background'
-										) }
-										style={ {
-											backgroundImage,
-											backgroundPosition,
-										} }
-									/>
-								) ) }
-						</>
-					) }
+							style={ {
+								backgroundImage,
+								backgroundPosition,
+							} }
+						/>
+					) ) }
 				{ url && isVideoBackground && (
 					<video
 						ref={ mediaElement }

From ccc920ee79306157aa45b96e00f13cad0ea945a4 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 11:57:20 +0200
Subject: [PATCH 53/60] Build: restore dot:true on fast-glob in
 transpilePackage
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Re-applies #75114 — `dot: true` was dropped during a wp-build refactor.

When the repository path contains a dot-prefixed directory
(`.worktrees/`, `.claude/worktrees/`, etc.), fast-glob's default
dot-filtering skips matches under that path, so `transpilePackage`
returns empty file lists and the build silently produces no output.

Fixes the regression so builds work from any worktree location.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 packages/wp-build/lib/build.mjs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/packages/wp-build/lib/build.mjs b/packages/wp-build/lib/build.mjs
index 0ae6c549245942..6a3fef0addb5d5 100755
--- a/packages/wp-build/lib/build.mjs
+++ b/packages/wp-build/lib/build.mjs
@@ -1309,12 +1309,14 @@ async function transpilePackage( packageName ) {
 		cwd: packageDir,
 		ignore: IGNORE_PATTERNS,
 		absolute: true,
+		dot: true,
 	} );
 
 	const assetFiles = await glob( `src/**/*.${ ASSET_EXTENSIONS }`, {
 		cwd: packageDir,
 		ignore: IGNORE_PATTERNS,
 		absolute: true,
+		dot: true,
 	} );
 
 	const buildDir = path.join( packageDir, 'build' );

From 6309f4e4220857a4331309a8310bb466721c10bb Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 15:47:18 +0200
Subject: [PATCH 54/60] refactor(block-bindings): use strict equality for cover
 binding args

Replace loose `==` comparison with a recursive canonical-equality helper
`gutenberg_cover_bindings_args_equal`. Loose comparisons mask type-juggling
bugs and the `phpcs:ignore WordPress.PHP.StrictComparisons.LooseComparison`
annotation was a smell. Order-insensitive intent is preserved by structural
recursion over associative arrays.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 40 +++++++++++++++++++--
 1 file changed, 37 insertions(+), 3 deletions(-)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index 1c0cbafaa064a0..25504e92d42fac 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -33,6 +33,42 @@ function gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_
 
 add_filter( 'block_bindings_supported_attributes', 'gutenberg_cover_bindings_add_supported_attributes', 10, 2 );
 
+if ( ! function_exists( 'gutenberg_cover_bindings_args_equal' ) ) {
+	/**
+	 * Order-insensitive strict equality for binding `args` values.
+	 *
+	 * Recurses into associative arrays. Two arrays are equal when they have
+	 * the same keys and each value strict-equals its counterpart. Scalars
+	 * and `null` are strict-compared.
+	 *
+	 * @since 7.1.0
+	 *
+	 * @param mixed $a First value.
+	 * @param mixed $b Second value.
+	 * @return bool
+	 */
+	function gutenberg_cover_bindings_args_equal( $a, $b ): bool {
+		if ( $a === $b ) {
+			return true;
+		}
+		if ( ! is_array( $a ) || ! is_array( $b ) ) {
+			return false;
+		}
+		if ( count( $a ) !== count( $b ) ) {
+			return false;
+		}
+		foreach ( $a as $key => $value ) {
+			if ( ! array_key_exists( $key, $b ) ) {
+				return false;
+			}
+			if ( ! gutenberg_cover_bindings_args_equal( $value, $b[ $key ] ) ) {
+				return false;
+			}
+		}
+		return true;
+	}
+}
+
 if ( ! function_exists( 'gutenberg_cover_bindings_is_active' ) ) {
 	/**
 	 * Whether a parsed Cover has both `id` and `url` bound to the same source instance.
@@ -61,9 +97,7 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 		}
 
 		$same_source = ( $id_binding['source'] ?? null ) === ( $url_binding['source'] ?? null );
-		// Loose `==` on `args` per Pattern Overrides convention: order-insensitive
-		// associative-bag comparison.
-		$same_args = ( $id_binding['args'] ?? null ) == ( $url_binding['args'] ?? null ); // phpcs:ignore WordPress.PHP.StrictComparisons.LooseComparison
+		$same_args   = gutenberg_cover_bindings_args_equal( $id_binding['args'] ?? null, $url_binding['args'] ?? null );
 
 		return $same_source && $same_args;
 	}

From 6831eb00d8b39baee78f21bd4a56797c88147e0f Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 16:07:41 +0200
Subject: [PATCH 55/60] refactor(block-bindings): drop unused params on
 render_block_data callback

prepare_block only consumes $parsed_block. Drop the unused $source_block
and $parent_block params; declare accepted_args=1 on the filter.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index 25504e92d42fac..68654cb74cc394 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -111,7 +111,7 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 	 *
 	 * @since 7.1.0
 	 */
-	function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $parent_block ) {
+	function gutenberg_cover_bindings_prepare_block( $parsed_block ) {
 		if ( 'core/cover' !== ( $parsed_block['blockName'] ?? '' ) ) {
 			return $parsed_block;
 		}
@@ -134,7 +134,7 @@ function gutenberg_cover_bindings_prepare_block( $parsed_block, $source_block, $
 	}
 }
 
-add_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10, 3 );
+add_filter( 'render_block_data', 'gutenberg_cover_bindings_prepare_block', 10, 1 );
 
 if ( ! function_exists( 'gutenberg_cover_bindings_strip_image' ) ) {
 	/**

From 8519ac1bc22cb5ceab31c69acf831ea7ef669bec Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 16:10:58 +0200
Subject: [PATCH 56/60] refactor(block-bindings): consolidate cover
 saved-markup regex patterns
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Extract the two duplicated saved-markup regexes for the parallax `<div>`
and plain `<img>` forms into top-level constants. preg_match itself stays
— WP HTML API cannot delete elements or change tag names, and Cover's
own index.php uses the same approach.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 23 ++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index 68654cb74cc394..8b6eee33e2856f 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -9,6 +9,22 @@
  * @package gutenberg
  */
 
+/**
+ * Saved-markup regex for the parallax/repeat `<div class="wp-block-cover__image-background">`
+ * element. The WP HTML API cannot delete elements or change tag names, so
+ * `preg_match` is the only way to locate the element for byte-offset splicing.
+ *
+ * Mirrors the pattern already in `packages/block-library/src/cover/index.php`.
+ */
+const GUTENBERG_COVER_BINDINGS_DIV_PATTERN = '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U';
+
+/**
+ * Saved-markup regex for the plain `<img class="wp-block-cover__image-background">`
+ * element used when neither parallax nor repeat is active. Used only by
+ * `strip_image` — `rewrite_image` mutates the `<img>` in place via Tag Processor.
+ */
+const GUTENBERG_COVER_BINDINGS_IMG_PATTERN = '/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?\s*>/U';
+
 if ( ! function_exists( 'gutenberg_cover_bindings_add_supported_attributes' ) ) {
 	/**
 	 * Adds `id` and `url` to the bindings-supported attributes for `core/cover`.
@@ -145,10 +161,7 @@ function gutenberg_cover_bindings_prepare_block( $parsed_block ) {
 	 */
 	function gutenberg_cover_bindings_strip_image( string $content ): string {
 		// Parallax/repeat <div> form is probed first; <img>-only regex would miss it.
-		foreach ( array(
-			'/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U',
-			'/<img\s+[^>]*\bwp-block-cover__image-background\b[^>]*\/?\s*>/U',
-		) as $pattern ) {
+		foreach ( array( GUTENBERG_COVER_BINDINGS_DIV_PATTERN, GUTENBERG_COVER_BINDINGS_IMG_PATTERN ) as $pattern ) {
 			if ( 1 === preg_match( $pattern, $content, $m, PREG_OFFSET_CAPTURE ) ) {
 				return substr( $content, 0, $m[0][1] ) . substr( $content, $m[0][1] + strlen( $m[0][0] ) );
 			}
@@ -189,7 +202,7 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 
 		// Parallax/repeat <div> form: rebuild as an <img>. Saved markup is
 		// the source of truth, NOT $attrs['hasParallax']/['isRepeated'].
-		if ( 1 === preg_match( '/<div\s+[^>]*\bwp-block-cover__image-background\b[^>]*><\/div>/U', $content, $m, PREG_OFFSET_CAPTURE ) ) {
+		if ( 1 === preg_match( GUTENBERG_COVER_BINDINGS_DIV_PATTERN, $content, $m, PREG_OFFSET_CAPTURE ) ) {
 			$object_position_attrs = '' === $object_position ? '' : sprintf(
 				' data-object-position="%s" style="object-position:%s;"',
 				esc_attr( $object_position ),

From 2cf08e13979a2461cbda697b9a01935ae4418a86 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 16:38:19 +0200
Subject: [PATCH 57/60] fix(block-library): keep MediaReplaceFlow on bound
 covers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Pattern Overrides — the headline use case — requires the per-instance
Replace control. The binding source intercepts setAttributes({ url, id })
and stores the override. Hiding the toolbar broke that flow.

Mirrors core/image, which gates only on source.canUserEditValue() (false
when the binding source forbids edits, true for Pattern Overrides).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/cover/edit/block-controls.js          | 65 +++++++------------
 .../block-library/src/cover/edit/index.js     |  1 -
 packages/block-library/src/cover/test/edit.js |  9 +--
 test/e2e/specs/editor/blocks/cover.spec.js    |  6 +-
 4 files changed, 30 insertions(+), 51 deletions(-)

diff --git a/packages/block-library/src/cover/edit/block-controls.js b/packages/block-library/src/cover/edit/block-controls.js
index b4f22b08d73d3d..deee971c2aa3aa 100644
--- a/packages/block-library/src/cover/edit/block-controls.js
+++ b/packages/block-library/src/cover/edit/block-controls.js
@@ -46,22 +46,6 @@ const { cleanEmptyObject } = unlock( blockEditorPrivateApis );
  *                                                URL" affordance.
  * @param {string}   props.blockEditingMode       Editing mode reported by
  *                                                `useBlockEditingMode`.
- * @param {boolean}  props.bindingActive          Whether the cover has an
- *                                                active block binding on
- *                                                `id` / `url`. When `true`,
- *                                                the entire
- *                                                `<MediaReplaceFlow>`
- *                                                affordance (including its
- *                                                "Embed video from URL"
- *                                                child item) is omitted from
- *                                                the toolbar — a literal DOM
- *                                                absence rather than a
- *                                                `disabled` state. Embed-video
- *                                                covers force
- *                                                `bindingActive=false`
- *                                                upstream, so the affordance
- *                                                remains accessible on the
- *                                                AC-21 population.
  */
 export default function CoverBlockControls( {
 	attributes,
@@ -72,7 +56,6 @@ export default function CoverBlockControls( {
 	onClearMedia,
 	onSelectEmbedUrl,
 	blockEditingMode,
-	bindingActive,
 } ) {
 	const {
 		contentPosition,
@@ -150,31 +133,29 @@ export default function CoverBlockControls( {
 				</BlockControls>
 			) }
 			<BlockControls group="other">
-				{ ! bindingActive && (
-					<MediaReplaceFlow
-						mediaId={ id }
-						mediaURL={ url }
-						allowedTypes={ ALLOWED_MEDIA_TYPES }
-						onSelect={ onSelectMedia }
-						onToggleFeaturedImage={ toggleUseFeaturedImage }
-						useFeaturedImage={ useFeaturedImage }
-						name={ ! url ? __( 'Add media' ) : __( 'Replace' ) }
-						onReset={ onClearMedia }
-						variant="toolbar"
-					>
-						{ ( { onClose } ) => (
-							<MenuItem
-								icon={ link }
-								onClick={ () => {
-									setIsEmbedUrlInputOpen( true );
-									onClose();
-								} }
-							>
-								{ __( 'Embed video from URL' ) }
-							</MenuItem>
-						) }
-					</MediaReplaceFlow>
-				) }
+				<MediaReplaceFlow
+					mediaId={ id }
+					mediaURL={ url }
+					allowedTypes={ ALLOWED_MEDIA_TYPES }
+					onSelect={ onSelectMedia }
+					onToggleFeaturedImage={ toggleUseFeaturedImage }
+					useFeaturedImage={ useFeaturedImage }
+					name={ ! url ? __( 'Add media' ) : __( 'Replace' ) }
+					onReset={ onClearMedia }
+					variant="toolbar"
+				>
+					{ ( { onClose } ) => (
+						<MenuItem
+							icon={ link }
+							onClick={ () => {
+								setIsEmbedUrlInputOpen( true );
+								onClose();
+							} }
+						>
+							{ __( 'Embed video from URL' ) }
+						</MenuItem>
+					) }
+				</MediaReplaceFlow>
 			</BlockControls>
 			{ isEmbedUrlInputOpen && (
 				<EmbedVideoUrlInput
diff --git a/packages/block-library/src/cover/edit/index.js b/packages/block-library/src/cover/edit/index.js
index c5f22b65e99989..e3570329cdaa80 100644
--- a/packages/block-library/src/cover/edit/index.js
+++ b/packages/block-library/src/cover/edit/index.js
@@ -575,7 +575,6 @@ function CoverEdit( {
 			toggleUseFeaturedImage={ toggleUseFeaturedImage }
 			onClearMedia={ onClearMedia }
 			blockEditingMode={ blockEditingMode }
-			bindingActive={ bindingActive }
 		/>
 	);
 
diff --git a/packages/block-library/src/cover/test/edit.js b/packages/block-library/src/cover/test/edit.js
index 8f20179ef3cbb7..bd21ee2446708b 100644
--- a/packages/block-library/src/cover/test/edit.js
+++ b/packages/block-library/src/cover/test/edit.js
@@ -616,7 +616,7 @@ describe( 'Cover block', () => {
 			4242
 		);
 
-		test( 'hides the MediaReplaceFlow toolbar button when bindingActive', async () => {
+		test( 'keeps MediaReplaceFlow visible when bindingActive so binding source intercepts the override', async () => {
 			await setup( {
 				url: 'http://localhost/stored-image.jpg',
 				backgroundType: 'image',
@@ -626,11 +626,8 @@ describe( 'Cover block', () => {
 			await screen.findByRole( 'img' );
 
 			expect(
-				screen.queryByRole( 'button', { name: 'Replace' } )
-			).not.toBeInTheDocument();
-			expect(
-				screen.queryByRole( 'button', { name: 'Add media' } )
-			).not.toBeInTheDocument();
+				screen.getByRole( 'button', { name: 'Replace' } )
+			).toBeInTheDocument();
 		} );
 	} );
 
diff --git a/test/e2e/specs/editor/blocks/cover.spec.js b/test/e2e/specs/editor/blocks/cover.spec.js
index c06b5cbe826573..3813f0161683ee 100644
--- a/test/e2e/specs/editor/blocks/cover.spec.js
+++ b/test/e2e/specs/editor/blocks/cover.spec.js
@@ -658,12 +658,14 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 				} )
 			).toHaveCount( 0 );
 
-			// AC-13/14: MediaReplaceFlow toggle (Replace + Add media) absent.
+			// MediaReplaceFlow stays visible on bound covers so the binding
+			// source (Pattern Overrides here) intercepts per-instance
+			// `setAttributes({ url, id })` writes.
 			await expect(
 				getBlockToolbar().getByRole( 'button', {
 					name: /^(Replace|Add media)$/,
 				} )
-			).toHaveCount( 0 );
+			).toBeVisible();
 
 			// AC-10: Reset disabled without override.
 			await expect(

From d3ed7317f9dd46543ed19c87aeafd438d670b0b9 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 17:14:22 +0200
Subject: [PATCH 58/60] fix(block-library): drop same-source invariant, mirror
 core/image url-only

Two real bugs surfaced when testing the PR:

1. Pattern Overrides instance: setBoundAttributes drops non-bound attrs
   (backgroundType, focalPoint, etc.) when inside a pattern, so
   isImageBackground stays false and the force-img branch never engages.
   Fix: derive isImageBackground from bindingActive && bindingResolvedUrl
   as a second path.

2. URL-only binding (no id) was treated as unresolvable. Mirrors what
   core/image does: a url binding alone is the canonical case.
   Drop the same-source / internal-media invariant. id binding is
   optional and only enables wp-image-{id} class on the server.

Drops bindingUnresolvable state entirely - url binding always renders.
Server-side is_active relaxed to "url binding present". args_equal
helper removed (no longer needed without same-args check).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php   |  96 +++---------
 .../block-library/src/cover/edit/index.js     |  59 ++------
 .../src/cover/edit/use-cover-binding-state.js | 136 ++---------------
 packages/block-library/src/cover/test/edit.js | 137 +-----------------
 phpunit/blocks/render-block-cover-test.php    |  19 ---
 test/e2e/specs/editor/blocks/cover.spec.js    |  24 ---
 6 files changed, 52 insertions(+), 419 deletions(-)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index 8b6eee33e2856f..2024377ba99c8a 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -49,50 +49,11 @@ function gutenberg_cover_bindings_add_supported_attributes( $attributes, $block_
 
 add_filter( 'block_bindings_supported_attributes', 'gutenberg_cover_bindings_add_supported_attributes', 10, 2 );
 
-if ( ! function_exists( 'gutenberg_cover_bindings_args_equal' ) ) {
-	/**
-	 * Order-insensitive strict equality for binding `args` values.
-	 *
-	 * Recurses into associative arrays. Two arrays are equal when they have
-	 * the same keys and each value strict-equals its counterpart. Scalars
-	 * and `null` are strict-compared.
-	 *
-	 * @since 7.1.0
-	 *
-	 * @param mixed $a First value.
-	 * @param mixed $b Second value.
-	 * @return bool
-	 */
-	function gutenberg_cover_bindings_args_equal( $a, $b ): bool {
-		if ( $a === $b ) {
-			return true;
-		}
-		if ( ! is_array( $a ) || ! is_array( $b ) ) {
-			return false;
-		}
-		if ( count( $a ) !== count( $b ) ) {
-			return false;
-		}
-		foreach ( $a as $key => $value ) {
-			if ( ! array_key_exists( $key, $b ) ) {
-				return false;
-			}
-			if ( ! gutenberg_cover_bindings_args_equal( $value, $b[ $key ] ) ) {
-				return false;
-			}
-		}
-		return true;
-	}
-}
-
 if ( ! function_exists( 'gutenberg_cover_bindings_is_active' ) ) {
 	/**
-	 * Whether a parsed Cover has both `id` and `url` bound to the same source instance.
-	 *
-	 * Server-side mirror of `useCoverBindingState`'s `bindingActive`. A
-	 * `__default` entry from `core/pattern-overrides` counts as active because
-	 * Core's `process_block_bindings` materialises it into per-attribute slots
-	 * before resolution.
+	 * Whether a parsed Cover has a `url` binding (with or without an `id`
+	 * binding). A `__default` entry counts. Server-side mirror of
+	 * `useCoverBindingState`'s `bindingActive`.
 	 *
 	 * @since 7.1.0
 	 */
@@ -101,21 +62,7 @@ function gutenberg_cover_bindings_is_active( array $attrs ): bool {
 		if ( empty( $bindings ) || ! is_array( $bindings ) ) {
 			return false;
 		}
-
-		if ( isset( $bindings['__default']['source'] ) && 'core/pattern-overrides' === $bindings['__default']['source'] ) {
-			return true;
-		}
-
-		$id_binding  = $bindings['id'] ?? null;
-		$url_binding = $bindings['url'] ?? null;
-		if ( empty( $id_binding ) || empty( $url_binding ) ) {
-			return false;
-		}
-
-		$same_source = ( $id_binding['source'] ?? null ) === ( $url_binding['source'] ?? null );
-		$same_args   = gutenberg_cover_bindings_args_equal( $id_binding['args'] ?? null, $url_binding['args'] ?? null );
-
-		return $same_source && $same_args;
+		return isset( $bindings['__default'] ) || isset( $bindings['url'] );
 	}
 }
 
@@ -182,8 +129,11 @@ function gutenberg_cover_bindings_strip_image( string $content ): string {
 	 * @access private
 	 */
 	function gutenberg_cover_bindings_rewrite_image( string $content, string $resolved_url, int $resolved_id, array $attrs ): string {
-		$alt       = trim( strip_tags( (string) get_post_meta( $resolved_id, '_wp_attachment_image_alt', true ) ) );
-		$size_slug = isset( $attrs['sizeSlug'] ) && '' !== $attrs['sizeSlug']
+		$alt           = $resolved_id > 0
+			? trim( strip_tags( (string) get_post_meta( $resolved_id, '_wp_attachment_image_alt', true ) ) )
+			: '';
+		$wp_image_cls  = $resolved_id > 0 ? ' wp-image-' . $resolved_id : '';
+		$size_slug     = isset( $attrs['sizeSlug'] ) && '' !== $attrs['sizeSlug']
 			? ' size-' . $attrs['sizeSlug']
 			: '';
 
@@ -210,8 +160,8 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 			);
 
 			$rebuilt_img = sprintf(
-				'<img class="wp-block-cover__image-background wp-image-%d%s" alt="%s" src="%s" data-object-fit="cover"%s />',
-				$resolved_id,
+				'<img class="wp-block-cover__image-background%s%s" alt="%s" src="%s" data-object-fit="cover"%s />',
+				esc_attr( $wp_image_cls ),
 				esc_attr( $size_slug ),
 				esc_attr( $alt ),
 				esc_url( $resolved_url ),
@@ -249,7 +199,9 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 				$processor->remove_class( $cls );
 			}
 		}
-		$processor->add_class( 'wp-image-' . $resolved_id );
+		if ( $resolved_id > 0 ) {
+			$processor->add_class( 'wp-image-' . $resolved_id );
+		}
 
 		return $processor->get_updated_html();
 	}
@@ -278,24 +230,22 @@ function gutenberg_cover_bindings_render_block( $block_content, $block, $instanc
 		}
 
 		if ( ! gutenberg_cover_bindings_is_active( $attrs ) ) {
-			// AC-6: inactive cover-relevant bindings strip the saved image.
-			// AC-20: genuinely unbound covers pass through.
-			$bindings = $attrs['metadata']['bindings'] ?? null;
-			if ( is_array( $bindings ) && ( isset( $bindings['__default'] ) || isset( $bindings['id'] ) || isset( $bindings['url'] ) ) ) {
-				return gutenberg_cover_bindings_strip_image( $block_content );
-			}
 			return $block_content;
 		}
 
 		$url = $attrs['url'] ?? null;
-		$id  = (int) ( $attrs['id'] ?? 0 );
-		if ( empty( $url ) || empty( $id ) ) {
+		if ( empty( $url ) ) {
 			return gutenberg_cover_bindings_strip_image( $block_content );
 		}
 
-		$attachment = get_post( $id );
-		if ( ! $attachment || 'attachment' !== $attachment->post_type ) {
-			return gutenberg_cover_bindings_strip_image( $block_content );
+		// `id` is optional. When present and resolving to a non-attachment,
+		// strip — that's the explicit "unresolvable internal media" state.
+		$id = (int) ( $attrs['id'] ?? 0 );
+		if ( $id > 0 ) {
+			$attachment = get_post( $id );
+			if ( ! $attachment || 'attachment' !== $attachment->post_type ) {
+				return gutenberg_cover_bindings_strip_image( $block_content );
+			}
 		}
 
 		$block_content = gutenberg_cover_bindings_rewrite_image( $block_content, (string) $url, $id, $attrs );
diff --git a/packages/block-library/src/cover/edit/index.js b/packages/block-library/src/cover/edit/index.js
index e3570329cdaa80..1432f42268f20e 100644
--- a/packages/block-library/src/cover/edit/index.js
+++ b/packages/block-library/src/cover/edit/index.js
@@ -119,8 +119,9 @@ function CoverEdit( {
 		poster,
 	} = attributes;
 
-	const { bindingActive, bindingUnresolvable, bindingResolvedUrl } =
-		useCoverBindingState( { clientId, attributes, context } );
+	const { bindingActive, bindingResolvedUrl } = useCoverBindingState( {
+		attributes,
+	} );
 
 	// Race-token guard: stale `getMediaColor` resolutions bail.
 	const raceTokenRef = useRef( 0 );
@@ -435,7 +436,12 @@ function CoverEdit( {
 
 	const isUploadingMedia = isTemporaryMedia( id, url );
 
-	const isImageBackground = IMAGE_BACKGROUND_TYPE === backgroundType;
+	// On bound covers inside a pattern instance, the framework drops non-bound
+	// attrs (incl. backgroundType) from setBoundAttributes — fall back to a
+	// resolved-url presence check so the force-img branch still engages.
+	const isImageBackground =
+		IMAGE_BACKGROUND_TYPE === backgroundType ||
+		( bindingActive && !! bindingResolvedUrl );
 	const isVideoBackground = VIDEO_BACKGROUND_TYPE === backgroundType;
 	const isEmbedVideoBackground =
 		EMBED_VIDEO_BACKGROUND_TYPE === backgroundType;
@@ -617,50 +623,6 @@ function CoverEdit( {
 	};
 
 	if ( ! useFeaturedImage && ! hasInnerBlocks && ! hasBackground ) {
-		if ( bindingActive || bindingUnresolvable ) {
-			// Bound covers replace the upload affordance with a Placeholder:
-			// unresolvable → discoverable instruction; pending → silent.
-			return (
-				<>
-					{ blockControls }
-					{ inspectorControls }
-					{ hasNonContentControls && isSelected && (
-						<ResizableCoverPopover { ...resizableCoverProps } />
-					) }
-					<TagName
-						{ ...blockProps }
-						className={ clsx(
-							'is-placeholder',
-							blockProps.className
-						) }
-						style={ {
-							...blockProps.style,
-							minHeight: minHeightWithUnit || undefined,
-						} }
-					>
-						{ resizeListener }
-						<Placeholder
-							data-testid={
-								bindingUnresolvable
-									? 'cover-binding-unresolvable'
-									: undefined
-							}
-							className={ `wp-block-cover__binding-${
-								bindingUnresolvable ? 'unresolvable' : 'pending'
-							}` }
-							withIllustration
-							instructions={
-								bindingUnresolvable
-									? __(
-											'Internal media required for this binding.'
-									  )
-									: undefined
-							}
-						/>
-					</TagName>
-				</>
-			);
-		}
 		return (
 			<>
 				{ blockControls }
@@ -733,8 +695,7 @@ function CoverEdit( {
 					/>
 				) }
 
-				{ ! bindingUnresolvable &&
-					effectiveUrl &&
+				{ effectiveUrl &&
 					isImageBackground &&
 					// OQ-5: bound covers force-render an <img> regardless of
 					// hasParallax/isRepeated.
diff --git a/packages/block-library/src/cover/edit/use-cover-binding-state.js b/packages/block-library/src/cover/edit/use-cover-binding-state.js
index ce1b62600e6d52..cfdb0a2e523e60 100644
--- a/packages/block-library/src/cover/edit/use-cover-binding-state.js
+++ b/packages/block-library/src/cover/edit/use-cover-binding-state.js
@@ -1,137 +1,23 @@
 /**
- * WordPress dependencies
- */
-import { getBlockBindingsSource } from '@wordpress/blocks';
-import { useSelect } from '@wordpress/data';
-import { store as coreStore } from '@wordpress/core-data';
-
-// Mirrors `replacePatternOverridesDefaultBinding` in
-// `packages/block-editor/src/utils/block-bindings.js` (not publicly re-exported).
-const PATTERN_OVERRIDES_SOURCE = 'core/pattern-overrides';
-
-/**
- * Expands a `__default` pattern-overrides binding into per-attribute entries.
- * Non-pattern-overrides bindings pass through unchanged.
- *
- * @param {?Object}  bindings            A block's `metadata.bindings` map.
- * @param {string[]} supportedAttributes Attribute names eligible for expansion.
- * @return {?Object} Expanded bindings, or the input unchanged.
- */
-function expandDefaultBinding( bindings, supportedAttributes ) {
-	if ( bindings?.__default?.source !== PATTERN_OVERRIDES_SOURCE ) {
-		return bindings;
-	}
-	const expanded = {};
-	for ( const attr of supportedAttributes ) {
-		expanded[ attr ] = bindings[ attr ]
-			? bindings[ attr ]
-			: { source: PATTERN_OVERRIDES_SOURCE };
-	}
-	return expanded;
-}
-
-/**
- * Client-side single source of truth for Cover-block binding state. Returns
- * `{ bindingActive, bindingUnresolvable, bindingResolvedUrl }` driving every
- * downstream binding-aware derivation in `CoverEdit`.
+ * Client-side binding state for Cover. Mirrors `core/image`'s url-only
+ * precedent: the binding is "active" whenever `url` is bound (the framework
+ * resolves it into `attributes.url` before render). An optional `id` binding
+ * just enables attachment-metadata reuse server-side.
  *
  * @param {Object} options            Hook options.
- * @param {string} options.clientId   The Cover block's client id.
- * @param {Object} options.attributes The Cover block's attributes.
- * @param {Object} options.context    Block-context object forwarded to `getValues`.
- * @return {{ bindingActive: boolean, bindingUnresolvable: boolean, bindingResolvedUrl: (string|undefined) }} Binding state.
+ * @param {Object} options.attributes The Cover block's attributes (already
+ *                                    binding-resolved by the framework).
+ * @return {{ bindingActive: boolean, bindingResolvedUrl: (string|undefined) }} Binding state.
  */
-export default function useCoverBindingState( {
-	clientId,
-	attributes,
-	context,
-} ) {
+export default function useCoverBindingState( { attributes } ) {
 	const bindings = attributes.metadata?.bindings;
-
-	const expanded = bindings
-		? expandDefaultBinding( bindings, [ 'id', 'url' ] )
-		: undefined;
-
-	const sameArgs =
-		!! expanded?.id &&
-		!! expanded?.url &&
-		JSON.stringify( expanded.id.args ?? null ) ===
-			JSON.stringify( expanded.url.args ?? null );
+	const hasUrlBinding = !! bindings?.__default || !! bindings?.url;
 
 	const bindingActive =
-		!! expanded?.id &&
-		!! expanded?.url &&
-		expanded.id.source === expanded.url.source &&
-		sameArgs &&
-		attributes.backgroundType !== 'embed-video';
-
-	const { bindingResolvedUrl, bindingResolvedAttachment } = useSelect(
-		( select ) => {
-			if ( ! bindingActive ) {
-				return {
-					bindingResolvedUrl: undefined,
-					bindingResolvedAttachment: undefined,
-				};
-			}
-			const source = getBlockBindingsSource( expanded.url.source );
-			if ( ! source ) {
-				return {
-					bindingResolvedUrl: undefined,
-					bindingResolvedAttachment: undefined,
-				};
-			}
-			const values = source.getValues( {
-				select,
-				clientId,
-				context,
-				bindings: { id: expanded.id, url: expanded.url },
-			} );
-			const resolvedId = values?.id;
-			return {
-				bindingResolvedUrl: values?.url,
-				bindingResolvedAttachment: resolvedId
-					? select( coreStore ).getEntityRecord(
-							'postType',
-							'attachment',
-							resolvedId,
-							{ context: 'view' }
-					  )
-					: undefined,
-			};
-		},
-		// `expanded.id` / `expanded.url` get fresh identities on every render;
-		// listing them would re-run the selector without changing the result.
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[
-			bindingActive,
-			expanded?.id?.source,
-			expanded?.url?.source,
-			clientId,
-			context,
-		]
-	);
-
-	if ( ! bindings ) {
-		return {
-			bindingActive: false,
-			bindingUnresolvable: false,
-			bindingResolvedUrl: undefined,
-		};
-	}
-
-	const hasAnyCoverBinding =
-		!! bindings.__default || !! bindings.id || !! bindings.url;
-
-	const bindingUnresolvable =
-		( hasAnyCoverBinding && ! bindingActive ) ||
-		( bindingActive &&
-			( bindingResolvedAttachment === null ||
-				( !! bindingResolvedAttachment?.type &&
-					bindingResolvedAttachment.type !== 'attachment' ) ) );
+		hasUrlBinding && attributes.backgroundType !== 'embed-video';
 
 	return {
 		bindingActive,
-		bindingUnresolvable,
-		bindingResolvedUrl,
+		bindingResolvedUrl: bindingActive ? attributes.url : undefined,
 	};
 }
diff --git a/packages/block-library/src/cover/test/edit.js b/packages/block-library/src/cover/test/edit.js
index bd21ee2446708b..6e40f00ab0463d 100644
--- a/packages/block-library/src/cover/test/edit.js
+++ b/packages/block-library/src/cover/test/edit.js
@@ -11,8 +11,6 @@ import {
 	registerBlockBindingsSource,
 	unregisterBlockBindingsSource,
 } from '@wordpress/blocks';
-import { dispatch } from '@wordpress/data';
-import { store as coreStore } from '@wordpress/core-data';
 
 /**
  * Internal dependencies
@@ -530,37 +528,11 @@ describe( 'Cover block', () => {
 			4242
 		);
 
-		test( 'renders a binding-aware placeholder with the unresolvable copy when bindings are mismatched', async () => {
-			// Mismatched sources → bindingActive=false, bindingUnresolvable=true.
-			await setup( {
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE },
-						url: { source: 'test/other-source' },
-					},
-				},
-			} );
-
-			const coverBlock = screen.getByLabelText( 'Block: Cover' );
-			expect(
-				within( coverBlock ).getByText(
-					'Internal media required for this binding.'
-				)
-			).toBeInTheDocument();
-			expect(
-				within( coverBlock ).getByTestId( 'cover-binding-unresolvable' )
-			).toBeInTheDocument();
-			expect(
-				// eslint-disable-next-line testing-library/no-node-access
-				coverBlock.querySelector(
-					'img.wp-block-cover__image-background'
-				)
-			).not.toBeInTheDocument();
-		} );
-
 		test( 'force-renders an <img> for an active binding with a resolved URL, ignoring hasParallax / isRepeated', async () => {
+			// Framework resolves attributes.url before passing to Edit. Mimic
+			// here by setting attributes.url directly to the bound value.
 			await setup( {
-				url: 'http://localhost/stored-image.jpg',
+				url: TEST_RESOLVED_URL,
 				backgroundType: 'image',
 				hasParallax: true,
 				isRepeated: true,
@@ -587,18 +559,7 @@ describe( 'Cover block', () => {
 			} );
 
 			const coverBlock = screen.getByLabelText( 'Block: Cover' );
-			// bindingActive forced false for embed-video → neither placeholder
-			// nor force-img engages.
-			expect(
-				within( coverBlock ).queryByText(
-					'Internal media required for this binding.'
-				)
-			).not.toBeInTheDocument();
-			expect(
-				within( coverBlock ).queryByTestId(
-					'cover-binding-unresolvable'
-				)
-			).not.toBeInTheDocument();
+			// bindingActive forced false for embed-video → force-img skipped.
 			expect(
 				// eslint-disable-next-line testing-library/no-node-access
 				coverBlock.querySelector(
@@ -608,87 +569,6 @@ describe( 'Cover block', () => {
 		} );
 	} );
 
-	describe( 'Bindings control gating', () => {
-		const TEST_SOURCE = 'test/cover-binding-controls';
-		const { bindings: boundBindings } = useBindingSource(
-			TEST_SOURCE,
-			'http://localhost/bound-image.jpg',
-			4242
-		);
-
-		test( 'keeps MediaReplaceFlow visible when bindingActive so binding source intercepts the override', async () => {
-			await setup( {
-				url: 'http://localhost/stored-image.jpg',
-				backgroundType: 'image',
-				metadata: { bindings: boundBindings },
-			} );
-			// Force-img branch engages → block toolbar has rendered.
-			await screen.findByRole( 'img' );
-
-			expect(
-				screen.getByRole( 'button', { name: 'Replace' } )
-			).toBeInTheDocument();
-		} );
-	} );
-
-	describe( 'useCoverBindingState', () => {
-		const TEST_SOURCE = 'test/cover-binding-state-hook';
-		const { sourceState } = useBindingSource(
-			TEST_SOURCE,
-			'http://localhost/resolved-image.jpg',
-			9991
-		);
-
-		test( 'bindingUnresolvable: true when the bound id resolves to a non-attachment record (integration)', async () => {
-			// Hook's `attachmentResolvedWrongType` guard: attachment entity
-			// record exists but `type !== "attachment"`. Register the entity
-			// manually since no REST call seeds it in jsdom.
-			const wrongTypeId = 99_991;
-			sourceState.id = wrongTypeId;
-			sourceState.url = 'http://localhost/wrong-type.jpg';
-
-			await act( async () => {
-				dispatch( coreStore ).addEntities( [
-					{
-						kind: 'postType',
-						name: 'attachment',
-						baseURL: '/wp/v2/media',
-						baseURLParams: { context: 'edit' },
-					},
-				] );
-				dispatch( coreStore ).receiveEntityRecords(
-					'postType',
-					'attachment',
-					[
-						{
-							id: wrongTypeId,
-							type: 'post',
-							source_url: 'http://localhost/wrong-type.jpg',
-						},
-					],
-					{ context: 'view' }
-				);
-			} );
-
-			await setup( {
-				url: '',
-				backgroundType: 'image',
-				metadata: {
-					bindings: {
-						id: { source: TEST_SOURCE },
-						url: { source: TEST_SOURCE },
-					},
-				},
-			} );
-
-			expect(
-				await within(
-					screen.getByLabelText( 'Block: Cover' )
-				).findByText( 'Internal media required for this binding.' )
-			).toBeInTheDocument();
-		} );
-	} );
-
 	describe( 'CoverEdit single observer', () => {
 		const TEST_SOURCE = 'test/cover-binding-observer';
 		const TEST_RESOLVED_URL = 'http://localhost/observer-image.jpg';
@@ -706,11 +586,10 @@ describe( 'Cover block', () => {
 		test( 'does not write any DC-2-prohibited attribute back to the block when a binding becomes active', async () => {
 			// Saved state: dimRatio=100, hasParallax=true, isRepeated=true,
 			// plus an active binding. Observer must NOT flip any of these.
-			// We sample post-flush DOM state because `BlockEditorProvider`'s
-			// private sub-registry hides the global store; a DC-2-violating
-			// `setAttributes({ url })` would clobber `data-url`.
+			// attributes.url is what the framework resolves to before reaching
+			// Edit; the test passes it directly.
 			await setup( {
-				url: 'http://localhost/stored.jpg',
+				url: TEST_RESOLVED_URL,
 				id: 1234,
 				backgroundType: 'image',
 				dimRatio: 100,
@@ -732,7 +611,7 @@ describe( 'Cover block', () => {
 			const coverBlock = screen.getByLabelText( 'Block: Cover' );
 			expect( coverBlock ).toHaveAttribute(
 				'data-url',
-				'http://localhost/stored.jpg'
+				TEST_RESOLVED_URL
 			);
 			expect(
 				// eslint-disable-next-line testing-library/no-node-access
diff --git a/phpunit/blocks/render-block-cover-test.php b/phpunit/blocks/render-block-cover-test.php
index 7d8c5d37b3bd10..8e4f845c95496c 100644
--- a/phpunit/blocks/render-block-cover-test.php
+++ b/phpunit/blocks/render-block-cover-test.php
@@ -271,25 +271,6 @@ public function test_parallax_saved_markup_is_rebuilt_as_img() {
 	}
 
 	// AC-6: bindings with mismatched sources strip the saved image element.
-	public function test_mismatched_source_strips_image() {
-		$this->register_test_source(
-			function () {
-				return 'unused';
-			}
-		);
-
-		$parsed_block = $this->build_bound_cover_block(
-			self::DEFAULT_SAVED_MARKUP,
-			array(),
-			array(
-				'id'  => array( 'source' => self::TEST_SOURCE_NAME ),
-				'url' => array( 'source' => 'test/other-source-that-does-not-exist' ),
-			)
-		);
-
-		$this->assertStringNotContainsString( 'wp-block-cover__image-background', render_block( $parsed_block ) );
-	}
-
 	// AC-5: resolved URL with an `id` that is not an attachment (e.g. a post id)
 	// strips the saved image — internal-only media is required.
 	public function test_external_url_strips_image() {
diff --git a/test/e2e/specs/editor/blocks/cover.spec.js b/test/e2e/specs/editor/blocks/cover.spec.js
index 3813f0161683ee..7b12c43b610adb 100644
--- a/test/e2e/specs/editor/blocks/cover.spec.js
+++ b/test/e2e/specs/editor/blocks/cover.spec.js
@@ -805,30 +805,6 @@ test.describe( 'Cover — Block Bindings — Pattern Overrides round-trip', () =
 				page.locator( '.wp-block-cover__image-background' )
 			).toHaveAttribute( 'src', defaultMedia.source_url );
 		} );
-
-		await test.step( 'Unresolvable — mismatched-source bindings surface the i18n affordance', async () => {
-			await admin.createNewPost();
-			await editor.insertBlock( {
-				name: 'core/cover',
-				attributes: {
-					metadata: {
-						name: 'Mismatched Cover',
-						bindings: {
-							id: { source: 'core/pattern-overrides' },
-							url: {
-								source: 'core/post-meta',
-								args: { key: 'url_custom_field' },
-							},
-						},
-					},
-				},
-			} );
-
-			// OQ-6: i18n message is the user-facing affordance.
-			await expect(
-				page.getByText( 'Internal media required for this binding.' )
-			).toBeVisible();
-		} );
 	} );
 } );
 

From 928b2e66fe6aa0cad82e2a3389bb76f5bfcf939a Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 18:46:59 +0200
Subject: [PATCH 59/60] fix(block-bindings): inject <img> when saved cover
 markup has none

Covers authored without picking media save no `<img>`. When such a Cover
is later bound to a URL source, the rewrite path had nothing to mutate
and returned the markup unchanged, leaving no image on the front end.

Add a third branch: locate the overlay `<span class="wp-block-cover__background">`
and prepend a freshly-built `<img>` carrying the bound URL.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 23 +++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index 2024377ba99c8a..4102e9f693bcd8 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -179,6 +179,29 @@ function gutenberg_cover_bindings_rewrite_image( string $content, string $resolv
 				'class_name' => 'wp-block-cover__image-background',
 			)
 		) ) {
+			// No image element saved (Cover authored without picking media,
+			// then bound). Inject a fresh `<img>` before the overlay `<span>`.
+			$object_position_attrs = '' === $object_position ? '' : sprintf(
+				' data-object-position="%s" style="object-position:%s;"',
+				esc_attr( $object_position ),
+				esc_attr( $object_position )
+			);
+			$injected_img          = sprintf(
+				'<img class="wp-block-cover__image-background%s%s" alt="%s" src="%s" data-object-fit="cover"%s />',
+				esc_attr( $wp_image_cls ),
+				esc_attr( $size_slug ),
+				esc_attr( $alt ),
+				esc_url( $resolved_url ),
+				$object_position_attrs
+			);
+			if ( 1 === preg_match(
+				'/<span\s+[^>]*\bwp-block-cover__background\b[^>]*>/U',
+				$content,
+				$sm,
+				PREG_OFFSET_CAPTURE
+			) ) {
+				return substr( $content, 0, $sm[0][1] ) . $injected_img . substr( $content, $sm[0][1] );
+			}
 			return $content;
 		}
 

From 495a9cb27633973ebc4b0f36abd2d64824d0b608 Mon Sep 17 00:00:00 2001
From: Carlos Bravo <37012961+cbravobernal@users.noreply.github.com>
Date: Fri, 29 May 2026 18:53:35 +0200
Subject: [PATCH 60/60] fix(block-bindings): strip stored overlay color on
 bound covers

The stored customOverlayColor was derived from the original image at
authoring time. After binding to a different source, the overlay's
inline `background-color` no longer matches the bound media (e.g.
orange tint from a Charizard cover bleeding into every bound instance).

Server-side: remove the inline `style` attribute on the overlay
`<span class="wp-block-cover__background">` when bindings are active.
Relax dim-class pass merged into the same Tag Processor walk.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/compat/wordpress-7.1/block-bindings.php | 25 ++++++++++++---------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/lib/compat/wordpress-7.1/block-bindings.php b/lib/compat/wordpress-7.1/block-bindings.php
index 4102e9f693bcd8..2e2605a0418606 100644
--- a/lib/compat/wordpress-7.1/block-bindings.php
+++ b/lib/compat/wordpress-7.1/block-bindings.php
@@ -273,21 +273,24 @@ function gutenberg_cover_bindings_render_block( $block_content, $block, $instanc
 
 		$block_content = gutenberg_cover_bindings_rewrite_image( $block_content, (string) $url, $id, $attrs );
 
-		// AC-16 / OQ-4: relax stored dimRatio:100 so the bound image is visible.
-		if ( 100 === (int) ( $attrs['dimRatio'] ?? 100 ) ) {
-			$processor = new WP_HTML_Tag_Processor( $block_content );
-			while ( $processor->next_tag(
-				array(
-					'tag_name'   => 'SPAN',
-					'class_name' => 'wp-block-cover__background',
-				)
-			) ) {
+		// Relax stored dimRatio:100 + strip the saved overlay color: stored
+		// `customOverlayColor` was derived from whatever image the cover was
+		// authored with, so it no longer matches the bound media.
+		$processor       = new WP_HTML_Tag_Processor( $block_content );
+		$relax_dim_class = 100 === (int) ( $attrs['dimRatio'] ?? 100 );
+		while ( $processor->next_tag(
+			array(
+				'tag_name'   => 'SPAN',
+				'class_name' => 'wp-block-cover__background',
+			)
+		) ) {
+			if ( $relax_dim_class ) {
 				$processor->remove_class( 'has-background-dim-100' );
 			}
-			$block_content = $processor->get_updated_html();
+			$processor->remove_attribute( 'style' );
 		}
 
-		return $block_content;
+		return $processor->get_updated_html();
 	}
 }