Merge remote-tracking branch 'origin/suggest/inline-wiring' into fix/f27-summary-context

# Conflicts:
#	packages/editor/src/components/suggestion-mode/suggestion-summary.js
#	packages/editor/src/components/suggestion-mode/test/suggestion-summary.js

Author: adamsilverstein

docs/explanations/architecture/suggestions.md

@@ -273,7 +273,7 @@ The current implementation (`provider.js`) uses comment meta. A future Yjs-backe
 
 In the notes sidebar, a suggestion thread renders:
 
-- **`SuggestionSummary`** — a Docs-style "Add: …", "Delete: …", "Format: …" summary derived from the operations. It is the sidebar's sole suggestion renderer; its `wordDiff` engine lives in `word-diff.js`, capped by `MAX_DIFF_LENGTH`/`MAX_DIFF_TOKENS` so a large payload can't freeze the sidebar.
+- **`SuggestionSummary`** — a Docs-style "Add: …", "Delete: …", "Change: …" summary derived from the operations. Inline formatting reads "Formatting: bold" and block attributes read "Change: heading level", so the two families of suggestion stay tellable apart in a mixed list. It is the sidebar's sole suggestion renderer; its `wordDiff` engine lives in `word-diff.js`, capped by `MAX_DIFF_LENGTH`/`MAX_DIFF_TOKENS` so a large payload can't freeze the sidebar.
 - **Accept / Reject icon buttons** — checkmark and close icons that trigger the provider's apply/reject flows.
 
 ## Yjs v2 Migration Path

packages/editor/CHANGELOG.md

@@ -12,6 +12,7 @@
 -   Suggest mode: keep a pasted run's bold, italics and links when it becomes a suggestion. A rich-text paste was diffed as plain text, so the marker held the words and none of their formatting and accepting the suggestion destroyed a pasted link. The pasted run is now carried into the marker as rich text, whether it opens a new addition or grows the author's own pending one, with the marker stamped as the outermost format so the proposal stays a single `<mark>` ([#81672](https://github.com/WordPress/gutenberg/pull/81672)).
 -   Suggest mode: keep the code editor closed while the Suggest intent is active and while the post still carries unresolved inline suggestion markers, and identify a marker by its element rather than by a substring of the document ([#81662](https://github.com/WordPress/gutenberg/pull/81662)).
 -   Suggest mode: Announce inline suggestion markers to screen readers. A marker's state was carried entirely by color and text decoration, so a run proposed for deletion was read aloud as ordinary prose. Each marker is now bracketed by an announcement naming the kind of change and the person who proposed it, and add and delete markers carry `role="insertion"` and `role="deletion"`; a formatting suggestion no longer claims to be a deletion. Suggestions over overlapping runs nest, and each is announced and attributed to the person who made it ([#81663](https://github.com/WordPress/gutenberg/pull/81663), [#81957](https://github.com/WordPress/gutenberg/pull/81957)).
+-   Suggest mode: keep a review decision and its note together through undo. Accepting or rejecting a suggestion changes block content and resolves the note, but only the content half is in the undo stack, so undo put the marker back on a note that stayed resolved - a marked-up run with no Accept/Reject on it and no way to clear it. Undoing a decision made in this session now reopens its note along with the marker ([#81669](https://github.com/WordPress/gutenberg/pull/81669)).
 -   Suggest mode: extend a format suggestion on a second toggle instead of opening a second one. Toggling a further format over a run that already carries the suggester's own pending `format` marker recorded a suggestion whose before and after were both empty - unreviewable and unapplyable - and made every marker in the block disappear. The existing suggestion is now revised in place, a toggle that restores the original run retracts it rather than storing a note that proposes nothing, and a note that has replies is revised rather than withdrawn ([#81665](https://github.com/WordPress/gutenberg/pull/81665)).
 -   Suggest mode: refuse post status changes while suggesting. `editPost` drops the `status` field in the `suggest` intent, the status control and the summary panel show the status without offering to change it, and the publish button is disabled there rather than dropping the status edit and saving the post anyway. A status edit that travels with a companion field - the `password` that visibility changes carry, the `date` that scheduling carries - is refused whole rather than half-applied, a status repeated at the value it already holds is not announced as a refusal, and a status staged before the intent changed is discarded on the way in. The refusal is announced and shown in a snackbar ([#81664](https://github.com/WordPress/gutenberg/pull/81664)).
 -   Register the editor and block editor keyboard shortcuts from the editor provider, so shortcuts work for consumers that mount the editor without rendering `EditorKeyboardShortcutsRegister` themselves ([#81580](https://github.com/WordPress/gutenberg/pull/81580)).

packages/editor/src/components/suggestion-mode/provider.js

@@ -426,10 +426,56 @@ function withDecisionInFlight( decide ) {
 			return await decide( args );
 		} finally {
 			decisionsInFlight.delete( key );
+			resolvedThisSession.add( key );
 		}
 	};
 }
 
+/*
+ * Suggestions this session has applied or rejected.
+ *
+ * A decision has two halves: the block change, which the undo stack holds, and
+ * the comment's lifecycle status, which lives on the server and no keystroke
+ * here can walk back. Undo therefore puts a marker back while its note stays
+ * resolved, leaving a marked-up run with no Accept/Reject on it and no way to
+ * clear it through the UI (issue #73411, F-18). The note collector watches this
+ * set and reopens a note whose marker reappears, so the two halves travel
+ * together again.
+ *
+ * Deliberately scoped to decisions made HERE rather than to every resolved note
+ * that has a live marker: a peer's decision arriving through sync before this
+ * session's content catches up looks identical from the outside, and reopening
+ * that would undo their review.
+ */
+const resolvedThisSession = new Set();
+
+/**
+ * Comment ids this session applied or rejected and has not yet reopened.
+ *
+ * @return {Set<string>} Comment id keys.
+ */
+export function getSuggestionsResolvedThisSession() {
+	return resolvedThisSession;
+}
+
+/**
+ * Forget a decision, once its note has been reopened or is past reopening.
+ *
+ * @param {number|string} commentId Comment id.
+ */
+export function forgetResolvedSuggestion( commentId ) {
+	resolvedThisSession.delete( String( commentId ) );
+}
+
+/**
+ * Record a decision again, so a failed reopen is retried on a later pass.
+ *
+ * @param {number|string} commentId Comment id.
+ */
+export function rememberResolvedSuggestion( commentId ) {
+	resolvedThisSession.add( String( commentId ) );
+}
+
 /**
  * Comment-meta backed suggestions provider. The provider shape is stable so
  * a future Yjs-backed provider can swap in without touching the UI.

packages/editor/src/components/suggestion-mode/suggestion-note-gc.js

@@ -36,8 +36,11 @@ import { useSuggestionOverlay } from './overlay-context';
 import {
 	findInlineOp,
 	findStructuralOp,
+	forgetResolvedSuggestion,
+	getSuggestionsResolvedThisSession,
 	isSuggestionDecisionInFlight,
 	parseSuggestionPayload,
+	rememberResolvedSuggestion,
 } from './provider';
 import { findSuggestionRange } from '../inline-suggestions';
 import { getNoteIdsFromMetadata } from '../collab-sidebar/utils';
@@ -156,13 +159,25 @@ export default function SuggestionNoteGC() {
 	// Pending suggestion root notes only; replies and resolved notes have no
 	// anchor contract.
 	const suggestionNotes = [];
+	/*
+	 * Notes this session applied or rejected. Their marker should be gone; if
+	 * it is back, an undo walked the block half of the decision back while the
+	 * note stayed resolved, and the note has to follow (#73411, F-18).
+	 */
+	const resolvedNotes = [];
+	const resolvedIds = getSuggestionsResolvedThisSession();
 	for ( const note of notes ?? [] ) {
-		if ( note.parent !== 0 || note.status !== 'hold' ) {
+		if ( note.parent !== 0 ) {
 			continue;
 		}
 		const anchor = describeAnchor( note );
-		if ( anchor ) {
+		if ( ! anchor ) {
+			continue;
+		}
+		if ( note.status === 'hold' ) {
 			suggestionNotes.push( { note, anchor } );
+		} else if ( resolvedIds.has( String( note.id ) ) ) {
+			resolvedNotes.push( { note, anchor } );
 		}
 	}
 
@@ -174,6 +189,8 @@ export default function SuggestionNoteGC() {
 
 	const entriesRef = useRef( entries );
 	entriesRef.current = entries;
+	const resolvedNotesRef = useRef( resolvedNotes );
+	resolvedNotesRef.current = resolvedNotes;
 	const clearOverlayRef = useRef( clearOverlay );
 	clearOverlayRef.current = clearOverlay;
 
@@ -210,6 +227,15 @@ export default function SuggestionNoteGC() {
 					}`
 				);
 			}
+			for ( const { note, anchor } of resolvedNotes ) {
+				parts.push(
+					`r${ note.id }:${
+						isAnchorPresent( note, anchor, blockEditor, entries )
+							? 1
+							: 0
+					}`
+				);
+			}
 			return parts.join( '|' );
 		},
 		// eslint-disable-next-line react-hooks/exhaustive-deps
@@ -338,6 +364,42 @@ export default function SuggestionNoteGC() {
 				trashedRef.current.set( idKey, info );
 			} );
 		}
+		/*
+		 * Undo: a decision this session made has had its marker put back. The
+		 * comment's status is the half undo cannot reach, so reopen it here -
+		 * otherwise the run stays marked with no Accept/Reject on it and no way
+		 * to clear it through the UI (#73411, F-18). The in-flight guard keeps
+		 * this off the decision's own window, where the status can land before
+		 * the tree has been mutated.
+		 */
+		for ( const { note, anchor } of resolvedNotesRef.current ) {
+			if (
+				isSuggestionDecisionInFlight( note.id ) ||
+				! isAnchorPresent(
+					note,
+					anchor,
+					blockEditor,
+					entriesRef.current
+				)
+			) {
+				continue;
+			}
+			forgetResolvedSuggestion( note.id );
+			saveEntityRecord(
+				'root',
+				'comment',
+				{
+					id: note.id,
+					status: 'hold',
+					meta: { _wp_suggestion_status: '' },
+				},
+				{ throwOnError: true }
+			).catch( () => {
+				// Reopen failed; leave it recorded so a later pass retries.
+				rememberResolvedSuggestion( note.id );
+			} );
+		}
+
 		// `presenceSignature` fully determines the work; the other values are
 		// read through refs or stable.
 		// eslint-disable-next-line react-hooks/exhaustive-deps

packages/editor/src/components/suggestion-mode/suggestion-summary.js

@@ -15,11 +15,14 @@
  *                        halves are one change, so they are reported on one
  *                        line ("old" → "new") rather than as an unrelated
  *                        delete plus add.
- *   - **Format: …**    — non-text attribute changes. Uses
- *                        `FORMAT_ATTRIBUTE_LABELS` to surface friendly names
- *                        (e.g. `level` → "heading level") with a fallback to
- *                        the raw attribute name so a brand-new attribute
- *                        isn't silently swallowed.
+ *   - **Change: …**    — non-text attribute changes. Uses
+ *                        `ATTRIBUTE_LABELS` to surface friendly names
+ *                        (e.g. `level` → "heading level") and humanizes any
+ *                        attribute not in that map so a brand-new attribute
+ *                        isn't silently swallowed or shown as `camelCase`.
+ *   - **Rename block:** — the one attribute change worth its own line: a
+ *                        block renamed through `metadata.name`, reported
+ *                        with the name being proposed.
  *   - **Add formatting: / Remove formatting:**
  *                      — pure inline-format changes (bold, italic, links).
  *                        Detected by tag-level diff of the serialized HTML
@@ -36,6 +39,10 @@
  * kind and count ("3 spaces") rather than quoted into invisibility, and
  * structural lines name the parent block when there is one.
  *
+ * "Change:" and the two "… formatting:" labels name different families of
+ * suggestion, so they have to be readable as different things in a mixed list.
+ * The attribute family was once "Format:", one word from "Formatting:".
+ *
  * Quoted lines report what a reviewer would read on screen: the diff behind
  * them runs on visible text, never on the raw content attribute, so no markup
  * reaches the sidebar. Changed words keep the spaces that separated them, and
@@ -63,11 +70,14 @@ const SUMMARY_MAX_CHARS = 120;
 const REPLACE_SIDE_MAX_CHARS = 60;
 
 /**
- * Friendlier labels for common block attributes so `Format:` lines read like
- * human categories rather than internal names. Anything not in this map
- * falls through to the raw attribute name.
+ * Friendlier labels for common block attributes so `Change:` lines read like
+ * human categories rather than internal names. Anything not in this map is
+ * humanized by `humanizeAttributeName`.
+ *
+ * The names here match what the editor's own controls call these settings, so
+ * a reviewer reading "additional CSS class" can go and find the field.
  */
-const FORMAT_ATTRIBUTE_LABELS = {
+const ATTRIBUTE_LABELS = {
 	level: __( 'heading level' ),
 	align: __( 'alignment' ),
 	textAlign: __( 'text alignment' ),
@@ -77,8 +87,46 @@ const FORMAT_ATTRIBUTE_LABELS = {
 	href: __( 'link' ),
 	backgroundColor: __( 'background color' ),
 	textColor: __( 'text color' ),
+	className: __( 'additional CSS class' ),
+	anchor: __( 'HTML anchor' ),
+	content: __( 'text' ),
+	metadata: __( 'block settings' ),
 };
 
+/**
+ * Turn an attribute key the summary has no friendly label for into something
+ * readable: `fontFamily` becomes "font family", `layout_type` becomes "layout
+ * type". Better than surfacing the raw key, which used to be lowercased whole
+ * and rendered `className` as the non-word "classname".
+ *
+ * @param {string} key Attribute key.
+ * @return {string} Humanized name.
+ */
+function humanizeAttributeName( key ) {
+	if ( typeof key !== 'string' || key === '' ) {
+		return __( 'setting' );
+	}
+	return key
+		.replace( /([a-z0-9])([A-Z])/g, '$1 $2' )
+		.replace( /[_-]+/g, ' ' )
+		.replace( /\s+/g, ' ' )
+		.trim()
+		.toLowerCase();
+}
+
+/**
+ * Read the custom block name out of a `metadata` attribute value, which is
+ * where the "Rename" command stores it. Returns null for anything that isn't
+ * a usable name so the caller can fall back to the generic label.
+ *
+ * @param {*} metadata Attribute value.
+ * @return {?string} The block name, or null.
+ */
+function readBlockName( metadata ) {
+	const name = metadata?.name;
+	return typeof name === 'string' && name.trim() !== '' ? name.trim() : null;
+}
+
 /**
  * Convert a block name like `core/paragraph` to a friendlier label used in
  * structural-suggestion summaries ("Remove block: paragraph"). Strips the
@@ -343,6 +391,19 @@ function joinLabels( labels ) {
 	return unique.join( ', ' );
 }
 
+/**
+ * Join attribute labels without touching their case. Unlike `joinLabels`,
+ * which lowercases the inline-format names it is given, these labels already
+ * read as the editor writes them and carry acronyms - "HTML anchor",
+ * "additional CSS class" - that lowercasing would turn into noise.
+ *
+ * @param {string[]} labels Attribute labels.
+ * @return {string} Comma-joined list.
+ */
+function joinAttributeLabels( labels ) {
+	return Array.from( new Set( labels.filter( Boolean ) ) ).join( ', ' );
+}
+
 function ellipsize( text, max = SUMMARY_MAX_CHARS ) {
 	const trimmed = text.replace( /\s+/g, ' ' ).trim();
 	if ( trimmed.length <= max ) {
@@ -473,8 +534,8 @@ function isTextLike( value ) {
 /**
  * Build a list of `{ label, value }` lines summarizing a suggestion. The
  * content attribute is reported with `Add:` / `Delete:` quotes; other
- * attribute changes are collapsed into a single `Format:` line listing the
- * touched attributes.
+ * attribute changes are collapsed into a single `Change:` line listing the
+ * touched settings.
  *
  * @param {import('./provider').SuggestionOperation[]} operations Operations.
  * @return {Array<{label: string, value: string}>} Rendered lines.
@@ -564,11 +625,41 @@ export function summarizeOperations( operations ) {
 			continue;
 		}
 
+		/*
+		 * A rename is stored as a `metadata` attribute change, so it would
+		 * otherwise arrive in the sidebar as the word "metadata" - a reviewer
+		 * can't tell whether a block was renamed, bound to a field, or turned
+		 * into a pattern override. Report the proposed name instead, and only
+		 * when the name is what actually changed.
+		 */
+		if ( op.attribute === 'metadata' ) {
+			const beforeName = readBlockName( op.before );
+			const afterName = readBlockName( op.after );
+			if ( afterName && afterName !== beforeName ) {
+				lines.push( {
+					label: __( 'Rename block:' ),
+					value: `“${ ellipsize( afterName ) }”`,
+				} );
+				continue;
+			}
+			if ( beforeName && ! afterName ) {
+				lines.push( {
+					label: __( 'Rename block:' ),
+					value: sprintf(
+						/* translators: %s: the block's current custom name. */
+						__( 'reset “%s” to the default name' ),
+						ellipsize( beforeName )
+					),
+				} );
+				continue;
+			}
+		}
+
 		const isContent = op.attribute === 'content';
 		/*
 		 * The word diff below is O(m*n); cap the input length so a payload
 		 * approaching the 64KB limit can't freeze the sidebar. Oversized
-		 * content changes fall back to the attribute-level "Format: content"
+		 * content changes fall back to the attribute-level "Change: text"
 		 * line. This character cap composes with `wordDiff`'s own
 		 * MAX_DIFF_TOKENS guard, which bounds the LCS table itself for any
 		 * input that passes here but tokenizes pathologically.
@@ -670,18 +761,26 @@ export function summarizeOperations( operations ) {
 	}
 
 	if ( attributeLabels.length > 0 ) {
+		/*
+		 * Attribute changes and inline formatting are different families of
+		 * suggestion, so their labels have to be tellable apart at a glance in
+		 * a mixed list. "Format:" next to "Formatting:" was not.
+		 */
 		const labels = attributeLabels.map(
-			( key ) => FORMAT_ATTRIBUTE_LABELS[ key ] ?? key
+			( key ) => ATTRIBUTE_LABELS[ key ] ?? humanizeAttributeName( key )
 		);
-		lines.push( { label: __( 'Format:' ), value: joinLabels( labels ) } );
+		lines.push( {
+			label: __( 'Change:' ),
+			value: joinAttributeLabels( labels ),
+		} );
 	}
 
 	return lines;
 }
 
 /**
  * Compact sidebar summary of a suggestion — "Add: …", "Delete: …",
- * "Format: …". Designed to mirror a Google Docs-style review note.
+ * "Change: …". Designed to mirror a Google Docs-style review note.
  *
  * @param {Object}                                     props
  * @param {import('./provider').SuggestionOperation[]} props.operations