@wordpress/editor 14.45.2-next.v.202605131032.0 → 14.47.0

package/src/components/collab-sidebar/test/utils.js

@@ -1,12 +1,321 @@
 /**
  * Internal dependencies
  */
-import { calculateNotePositions } from '../utils';
+import {
+	getNoteIdsFromMetadata,
+	addNoteIdToMetadata,
+	removeNoteIdFromMetadata,
+	calculateNotePositions,
+	pickPrimaryNote,
+} from '../utils';
 
 function makeRect( top ) {
 	return { top };
 }
 
+describe( 'getNoteIdsFromMetadata', () => {
+	it( 'returns empty array for null metadata', () => {
+		expect( getNoteIdsFromMetadata( null ) ).toEqual( [] );
+	} );
+
+	it( 'returns empty array for undefined metadata', () => {
+		expect( getNoteIdsFromMetadata( undefined ) ).toEqual( [] );
+	} );
+
+	it( 'returns empty array for metadata without noteId', () => {
+		expect( getNoteIdsFromMetadata( {} ) ).toEqual( [] );
+		expect( getNoteIdsFromMetadata( { name: 'test' } ) ).toEqual( [] );
+	} );
+
+	it( 'returns empty array for noteId of 0', () => {
+		expect( getNoteIdsFromMetadata( { noteId: 0 } ) ).toEqual( [] );
+	} );
+
+	it( 'returns empty array for noteId of empty string', () => {
+		expect( getNoteIdsFromMetadata( { noteId: '' } ) ).toEqual( [] );
+	} );
+
+	it( 'returns empty array for noteId of false', () => {
+		expect( getNoteIdsFromMetadata( { noteId: false } ) ).toEqual( [] );
+	} );
+
+	it( 'returns array from scalar noteId (legacy format)', () => {
+		expect( getNoteIdsFromMetadata( { noteId: 42 } ) ).toEqual( [ 42 ] );
+	} );
+
+	it( 'coerces a string-typed legacy noteId to a number', () => {
+		expect( getNoteIdsFromMetadata( { noteId: '42' } ) ).toEqual( [ 42 ] );
+	} );
+
+	it( 'drops non-numeric and non-positive ids', () => {
+		expect(
+			getNoteIdsFromMetadata( { noteId: [ 1, 'abc', -3, 2 ] } )
+		).toEqual( [ 1, 2 ] );
+	} );
+
+	it( 'returns array from array noteId', () => {
+		expect( getNoteIdsFromMetadata( { noteId: [ 1, 2, 3 ] } ) ).toEqual( [
+			1, 2, 3,
+		] );
+	} );
+
+	it( 'filters out falsy values from array', () => {
+		expect(
+			getNoteIdsFromMetadata( { noteId: [ 1, null, 2, undefined, 3 ] } )
+		).toEqual( [ 1, 2, 3 ] );
+	} );
+
+	it( 'filters out zero and empty string from array', () => {
+		expect(
+			getNoteIdsFromMetadata( { noteId: [ 0, '', 1, false, 2 ] } )
+		).toEqual( [ 1, 2 ] );
+	} );
+
+	it( 'returns empty array when all array values are falsy', () => {
+		expect(
+			getNoteIdsFromMetadata( { noteId: [ null, undefined, 0, '' ] } )
+		).toEqual( [] );
+	} );
+
+	it( 'deduplicates repeated ids while preserving first occurrence order', () => {
+		expect( getNoteIdsFromMetadata( { noteId: [ 1, 1, 1 ] } ) ).toEqual( [
+			1,
+		] );
+		expect(
+			getNoteIdsFromMetadata( { noteId: [ 1, 2, 1, 3, 2 ] } )
+		).toEqual( [ 1, 2, 3 ] );
+	} );
+
+	it( 'deduplicates across numeric and string-typed duplicates', () => {
+		expect(
+			getNoteIdsFromMetadata( { noteId: [ 1, '1', 2, '2' ] } )
+		).toEqual( [ 1, 2 ] );
+	} );
+} );
+
+describe( 'addNoteIdToMetadata', () => {
+	it( 'creates array for first note on empty metadata', () => {
+		const result = addNoteIdToMetadata( {}, 42 );
+		expect( result.noteId ).toEqual( [ 42 ] );
+	} );
+
+	it( 'creates array for first note on null metadata', () => {
+		const result = addNoteIdToMetadata( null, 42 );
+		expect( result.noteId ).toEqual( [ 42 ] );
+	} );
+
+	it( 'creates array for first note on undefined metadata', () => {
+		const result = addNoteIdToMetadata( undefined, 42 );
+		expect( result.noteId ).toEqual( [ 42 ] );
+	} );
+
+	it( 'converts scalar noteId to array and appends new id', () => {
+		const result = addNoteIdToMetadata( { noteId: 1 }, 2 );
+		expect( result.noteId ).toEqual( [ 1, 2 ] );
+	} );
+
+	it( 'appends to existing array', () => {
+		const result = addNoteIdToMetadata( { noteId: [ 1, 2 ] }, 3 );
+		expect( result.noteId ).toEqual( [ 1, 2, 3 ] );
+	} );
+
+	it( 'prevents duplicates', () => {
+		const result = addNoteIdToMetadata( { noteId: [ 1, 2 ] }, 1 );
+		expect( result ).toEqual( { noteId: [ 1, 2 ] } );
+	} );
+
+	it( 'preserves other metadata properties', () => {
+		const result = addNoteIdToMetadata( { noteId: 1, name: 'test' }, 2 );
+		expect( result ).toEqual( { noteId: [ 1, 2 ], name: 'test' } );
+	} );
+
+	it( 'returns original metadata object when duplicate is added', () => {
+		const metadata = { noteId: [ 1, 2 ] };
+		const result = addNoteIdToMetadata( metadata, 1 );
+		expect( result ).toBe( metadata );
+	} );
+
+	it( 'handles adding to metadata with other properties but no noteId', () => {
+		const result = addNoteIdToMetadata( { name: 'test' }, 5 );
+		expect( result ).toEqual( { name: 'test', noteId: [ 5 ] } );
+	} );
+
+	it( 'dedupes a numeric id against a string-typed legacy id', () => {
+		const metadata = { noteId: '5' };
+		const result = addNoteIdToMetadata( metadata, 5 );
+		expect( result ).toBe( metadata );
+	} );
+
+	it( 'dedupes a string id against a numeric id already in the array', () => {
+		const result = addNoteIdToMetadata( { noteId: [ 1, 2 ] }, '2' );
+		expect( result ).toEqual( { noteId: [ 1, 2 ] } );
+	} );
+} );
+
+describe( 'removeNoteIdFromMetadata', () => {
+	it( 'removes noteId from array', () => {
+		const result = removeNoteIdFromMetadata( { noteId: [ 1, 2, 3 ] }, 2 );
+		expect( result.noteId ).toEqual( [ 1, 3 ] );
+	} );
+
+	it( 'returns undefined noteId when array becomes empty', () => {
+		const result = removeNoteIdFromMetadata( { noteId: [ 1 ] }, 1 );
+		expect( result.noteId ).toBeUndefined();
+	} );
+
+	it( 'handles removing from scalar noteId (legacy format)', () => {
+		const result = removeNoteIdFromMetadata( { noteId: 42 }, 42 );
+		expect( result.noteId ).toBeUndefined();
+	} );
+
+	it( 'handles removing non-existent id', () => {
+		const result = removeNoteIdFromMetadata( { noteId: [ 1, 2 ] }, 99 );
+		expect( result.noteId ).toEqual( [ 1, 2 ] );
+	} );
+
+	it( 'handles empty metadata', () => {
+		const result = removeNoteIdFromMetadata( {}, 1 );
+		expect( result.noteId ).toBeUndefined();
+	} );
+
+	it( 'preserves other metadata properties', () => {
+		const result = removeNoteIdFromMetadata(
+			{ noteId: [ 1, 2 ], name: 'test' },
+			1
+		);
+		expect( result ).toEqual( { noteId: [ 2 ], name: 'test' } );
+	} );
+
+	it( 'handles null metadata', () => {
+		const result = removeNoteIdFromMetadata( null, 1 );
+		expect( result.noteId ).toBeUndefined();
+	} );
+
+	it( 'handles undefined metadata', () => {
+		const result = removeNoteIdFromMetadata( undefined, 1 );
+		expect( result.noteId ).toBeUndefined();
+	} );
+
+	it( 'removes last note and cleans up noteId to undefined', () => {
+		const result = removeNoteIdFromMetadata(
+			{ noteId: [ 42 ], name: 'test' },
+			42
+		);
+		expect( result ).toEqual( { name: 'test', noteId: undefined } );
+	} );
+
+	it( 'removes a numeric id when stored as a string-typed legacy scalar', () => {
+		const result = removeNoteIdFromMetadata( { noteId: '42' }, 42 );
+		expect( result.noteId ).toBeUndefined();
+	} );
+
+	it( 'removes a string id when stored as a number in the array', () => {
+		const result = removeNoteIdFromMetadata( { noteId: [ 1, 2, 3 ] }, '2' );
+		expect( result.noteId ).toEqual( [ 1, 3 ] );
+	} );
+} );
+
+describe( 'note id order preservation', () => {
+	// The collab sidebar relies on insertion order: the first id in the
+	// metadata array is treated as the first (block-aligned) note, with
+	// subsequent notes stacking below. These tests pin that contract.
+	// See https://github.com/WordPress/gutenberg/issues/75145#issuecomment-4361104794
+
+	it( 'preserves insertion order across multiple sequential adds', () => {
+		let metadata = {};
+		metadata = addNoteIdToMetadata( metadata, 5 );
+		metadata = addNoteIdToMetadata( metadata, 3 );
+		metadata = addNoteIdToMetadata( metadata, 7 );
+		metadata = addNoteIdToMetadata( metadata, 1 );
+		expect( metadata.noteId ).toEqual( [ 5, 3, 7, 1 ] );
+	} );
+
+	it( 'does not sort or reorder ids when adding', () => {
+		// A naive implementation might sort numerically; this confirms it
+		// preserves the order the user added notes in.
+		const result = addNoteIdToMetadata( { noteId: [ 10, 2, 30 ] }, 4 );
+		expect( result.noteId ).toEqual( [ 10, 2, 30, 4 ] );
+	} );
+
+	it( 'keeps the first id first after appending more notes', () => {
+		let metadata = addNoteIdToMetadata( {}, 42 );
+		metadata = addNoteIdToMetadata( metadata, 99 );
+		metadata = addNoteIdToMetadata( metadata, 7 );
+		const ids = getNoteIdsFromMetadata( metadata );
+		expect( ids[ 0 ] ).toBe( 42 );
+	} );
+
+	it( 'preserves order of remaining ids after removing one from the middle', () => {
+		const result = removeNoteIdFromMetadata(
+			{ noteId: [ 1, 2, 3, 4, 5 ] },
+			3
+		);
+		expect( result.noteId ).toEqual( [ 1, 2, 4, 5 ] );
+	} );
+
+	it( 'preserves remaining ids in order after removing the first id', () => {
+		const result = removeNoteIdFromMetadata(
+			{ noteId: [ 1, 2, 3, 4 ] },
+			1
+		);
+		expect( result.noteId ).toEqual( [ 2, 3, 4 ] );
+	} );
+
+	it( 'preserves remaining ids in order after removing the last id', () => {
+		const result = removeNoteIdFromMetadata(
+			{ noteId: [ 1, 2, 3, 4 ] },
+			4
+		);
+		expect( result.noteId ).toEqual( [ 1, 2, 3 ] );
+	} );
+
+	it( 'preserves order across an interleaved sequence of adds and removes', () => {
+		let metadata = {};
+		metadata = addNoteIdToMetadata( metadata, 10 );
+		metadata = addNoteIdToMetadata( metadata, 20 );
+		metadata = addNoteIdToMetadata( metadata, 30 );
+		metadata = removeNoteIdFromMetadata( metadata, 20 );
+		metadata = addNoteIdToMetadata( metadata, 40 );
+		expect( metadata.noteId ).toEqual( [ 10, 30, 40 ] );
+	} );
+
+	it( 'preserves array order through a getNoteIdsFromMetadata round-trip', () => {
+		const ids = [ 9, 4, 7, 2, 11 ];
+		expect( getNoteIdsFromMetadata( { noteId: ids } ) ).toEqual( ids );
+	} );
+
+	it( 'keeps the legacy scalar id as the first id when migrating to an array', () => {
+		// When a legacy single-note post gains a second note, the original
+		// note must remain the block-aligned (first) note.
+		const result = addNoteIdToMetadata( { noteId: 42 }, 99 );
+		expect( result.noteId ).toEqual( [ 42, 99 ] );
+		expect( result.noteId[ 0 ] ).toBe( 42 );
+	} );
+} );
+
+describe( 'pickPrimaryNote', () => {
+	it( 'returns null for an empty list', () => {
+		expect( pickPrimaryNote( [] ) ).toBeNull();
+	} );
+
+	it( 'returns the first unresolved thread when one exists', () => {
+		const threads = [
+			{ id: 1, status: 'approved' },
+			{ id: 2, status: 'hold' },
+			{ id: 3, status: 'hold' },
+		];
+		expect( pickPrimaryNote( threads ) ).toBe( threads[ 1 ] );
+	} );
+
+	it( 'falls back to the first thread when none are unresolved', () => {
+		const threads = [
+			{ id: 1, status: 'approved' },
+			{ id: 2, status: 'approved' },
+		];
+		expect( pickPrimaryNote( threads ) ).toBe( threads[ 0 ] );
+	} );
+} );
+
 describe( 'calculateNotePositions', () => {
 	it( 'returns empty positions when the anchor thread has no blockRect', () => {
 		const { positions } = calculateNotePositions( {
@@ -152,4 +461,69 @@ describe( 'calculateNotePositions', () => {
 		// 2: 300 + 500 - 16 = 784
 		expect( positions ).toEqual( { 1: 584, 2: 784 } );
 	} );
+
+	it( 'stacks two threads that share a block with the first as anchor', () => {
+		const threads = [ { id: 1 }, { id: 2 } ];
+		const blockRects = {
+			1: makeRect( 200 ),
+			2: makeRect( 200 ),
+		};
+		const heights = { 1: 50, 2: 50 };
+
+		const { positions } = calculateNotePositions( {
+			threads,
+			selectedNoteId: 1,
+			blockRects,
+			heights,
+			scrollTop: 0,
+		} );
+
+		// 1 (anchor):    200 - 16 = 184
+		// 2 (downward):  (184 + 50) - 200 + 20 = 54 → 200 + 54 = 254
+		expect( positions ).toEqual( { 1: 184, 2: 254 } );
+	} );
+
+	it( 'stacks two threads that share a block with the second as anchor', () => {
+		const threads = [ { id: 1 }, { id: 2 } ];
+		const blockRects = {
+			1: makeRect( 200 ),
+			2: makeRect( 200 ),
+		};
+		const heights = { 1: 50, 2: 50 };
+
+		const { positions } = calculateNotePositions( {
+			threads,
+			selectedNoteId: 2,
+			blockRects,
+			heights,
+			scrollTop: 0,
+		} );
+
+		// 2 (anchor):  200 - 16 = 184
+		// 1 (upward):  184 - 200 - 50 - 20 = -86 → 200 + (-86) = 114
+		expect( positions ).toEqual( { 1: 114, 2: 184 } );
+	} );
+
+	it( 'stacks three threads sharing a block with middle as anchor', () => {
+		const threads = [ { id: 1 }, { id: 2 }, { id: 3 } ];
+		const blockRects = {
+			1: makeRect( 200 ),
+			2: makeRect( 200 ),
+			3: makeRect( 200 ),
+		};
+		const heights = { 1: 50, 2: 50, 3: 50 };
+
+		const { positions } = calculateNotePositions( {
+			threads,
+			selectedNoteId: 2,
+			blockRects,
+			heights,
+			scrollTop: 0,
+		} );
+
+		// 2 (anchor):    200 - 16 = 184
+		// 3 (downward):  (184 + 50) - 200 + 20 = 54 → 254
+		// 1 (upward):    184 - 200 - 50 - 20 = -86 → 114
+		expect( positions ).toEqual( { 1: 114, 2: 184, 3: 254 } );
+	} );
 } );

package/src/components/collab-sidebar/utils.js

@@ -23,7 +23,7 @@ const OVERLAP_MARGIN = 20;
  */
 const AVATAR_BORDER_COLORS = [
 	'#C36EFF', // Purple
-	'#FF51A8', // Pink
+	'#D94145', // Red
 	'#E4780A', // Orange
 	'#FF35EE', // Magenta
 	'#879F11', // Olive
@@ -90,6 +90,75 @@ export function getNoteExcerpt( text, excerptLength = 10 ) {
 	return isTrimmed ? trimmedExcerpt + '…' : trimmedExcerpt;
 }
 
+/**
+ * Normalizes noteId metadata to always return an array of unique numeric ids,
+ * preserving insertion order. Handles both scalar (legacy, possibly
+ * string-typed) and array (new) values.
+ *
+ * @param {Object} metadata Block metadata object
+ * @return {number[]} Array of note IDs (may be empty)
+ */
+export function getNoteIdsFromMetadata( metadata ) {
+	const noteId = metadata?.noteId;
+	const raw = Array.isArray( noteId ) ? noteId : [ noteId ];
+	const ids = new Set();
+	for ( const value of raw ) {
+		const id = Number( value );
+		if ( Number.isFinite( id ) && id > 0 ) {
+			ids.add( id );
+		}
+	}
+	return [ ...ids ];
+}
+
+/**
+ * Adds a note ID to the metadata.
+ * Converts scalar to array if needed, otherwise appends.
+ *
+ * @param {Object} metadata Existing block metadata
+ * @param {number} noteId   Note ID to add
+ * @return {Object} Updated metadata object
+ */
+export function addNoteIdToMetadata( metadata, noteId ) {
+	const ids = new Set( getNoteIdsFromMetadata( metadata ) );
+	const id = Number( noteId );
+	if ( ids.has( id ) ) {
+		return metadata;
+	}
+	ids.add( id );
+	return { ...metadata, noteId: [ ...ids ] };
+}
+
+/**
+ * Picks the most relevant thread from a list: first unresolved, else first.
+ *
+ * @param {Array} threads Ordered list of thread objects.
+ * @return {Object|null} Selected thread or null when the list is empty.
+ */
+export function pickPrimaryNote( threads ) {
+	return (
+		threads.find( ( thread ) => thread.status === 'hold' ) ??
+		threads[ 0 ] ??
+		null
+	);
+}
+
+/**
+ * Removes a note ID from the metadata.
+ *
+ * @param {Object} metadata Existing block metadata
+ * @param {number} noteId   Note ID to remove
+ * @return {Object} Updated metadata object
+ */
+export function removeNoteIdFromMetadata( metadata, noteId ) {
+	const ids = new Set( getNoteIdsFromMetadata( metadata ) );
+	ids.delete( Number( noteId ) );
+	return {
+		...metadata,
+		noteId: ids.size > 0 ? [ ...ids ] : undefined,
+	};
+}
+
 /**
  * Calculate final top positions for all floating note threads in the
  * editor's content coordinate space. Adjusts positions to prevent overlapping

package/src/components/collaborators-overlay/compute-selection.ts

@@ -1,6 +1,10 @@
-import { SelectionDirection, SelectionType } from '@wordpress/core-data';
-import type { ResolvedSelection } from '@wordpress/core-data';
+import { privateApis as coreDataPrivateApis } from '@wordpress/core-data';
+import type {
+	CoreDataPrivateApis,
+	ResolvedSelection,
+} from '@wordpress/core-data';
 
+import { unlock } from '../../lock-unlock';
 import {
 	getCursorPosition,
 	getSelectionRects,
@@ -10,6 +14,10 @@ import {
 } from './cursor-dom-utils';
 import type { CursorCoords, SelectionRect } from './cursor-dom-utils';
 
+const { SelectionDirection, SelectionType } = unlock(
+	coreDataPrivateApis
+) as Pick< CoreDataPrivateApis, 'SelectionDirection' | 'SelectionType' >;
+
 /** Common parameters passed to cursor/selection computation helpers. */
 interface OverlayContext {
 	editorDocument: Document;
@@ -36,6 +44,44 @@ export interface SelectionVisual {
 	selectionRects?: SelectionRect[];
 }
 
+/**
+ * Resolve the most specific editor element the selection refers to.
+ *
+ * When the sender carries an `attributeKey`, narrow to the RichText element
+ * matching `data-wp-block-attribute-key` inside the block. This is what makes
+ * cursor placement work for blocks with multiple RichText fields (e.g.
+ * `core/table` cells: `body.0.cells.0.content`, etc.). Falls back to the
+ * block element when `attributeKey` is missing (WholeBlock selections,
+ * older senders, or DOM lookup miss).
+ *
+ * @param editorDocument    - The editor document.
+ * @param resolvedSelection - The resolved selection.
+ * @return The target element (RichText editable or block), or null.
+ */
+function resolveTargetElement(
+	editorDocument: Document,
+	resolvedSelection: ResolvedSelection
+): HTMLElement | null {
+	if ( ! resolvedSelection.localClientId ) {
+		return null;
+	}
+
+	const blockElement = editorDocument.querySelector< HTMLElement >(
+		`[data-block="${ resolvedSelection.localClientId }"]`
+	);
+
+	if ( ! blockElement || ! resolvedSelection.attributeKey ) {
+		return blockElement;
+	}
+
+	const attrKey = CSS.escape( resolvedSelection.attributeKey );
+	return (
+		blockElement.querySelector< HTMLElement >(
+			`[data-wp-block-attribute-key="${ attrKey }"]`
+		) ?? blockElement
+	);
+}
+
 /**
  * Compute cursor coords and optional selection rects for a single user's selection.
  *
@@ -83,14 +129,14 @@ function computeCursorOnly(
 	if ( ! start.localClientId ) {
 		return {};
 	}
-	const blockElement =
-		overlayContext.editorDocument.querySelector< HTMLElement >(
-			`[data-block="${ start.localClientId }"]`
-		);
+	const targetElement = resolveTargetElement(
+		overlayContext.editorDocument,
+		start
+	);
 	return {
 		coords: getCursorPosition(
 			start.richTextOffset,
-			blockElement,
+			targetElement,
 			overlayContext.editorDocument,
 			overlayContext.overlayRect
 		),
@@ -157,10 +203,10 @@ function computeTextSelection(
 	}
 
 	// Fallback: cursor at start position only.
-	const startBlock =
-		overlayContext.editorDocument.querySelector< HTMLElement >(
-			`[data-block="${ start.localClientId }"]`
-		);
+	const startBlock = resolveTargetElement(
+		overlayContext.editorDocument,
+		start
+	);
 
 	return {
 		coords: getCursorPosition(
@@ -185,10 +231,10 @@ function computeSingleBlockRects(
 	end: ResolvedSelection,
 	overlayContext: OverlayContext
 ): SingleBlockResult {
-	const blockElement =
-		overlayContext.editorDocument.querySelector< HTMLElement >(
-			`[data-block="${ start.localClientId }"]`
-		);
+	const blockElement = resolveTargetElement(
+		overlayContext.editorDocument,
+		start
+	);
 	if (
 		! blockElement ||
 		start.richTextOffset === null ||
@@ -227,11 +273,13 @@ function computeMultiBlockRects(
 ): MultiBlockResult {
 	let docFirst = start;
 	let docLast = end;
-	let firstBlock = overlayContext.editorDocument.querySelector< HTMLElement >(
-		`[data-block="${ docFirst.localClientId }"]`
+	let firstBlock = resolveTargetElement(
+		overlayContext.editorDocument,
+		docFirst
 	);
-	let lastBlock = overlayContext.editorDocument.querySelector< HTMLElement >(
-		`[data-block="${ docLast.localClientId }"]`
+	let lastBlock = resolveTargetElement(
+		overlayContext.editorDocument,
+		docLast
 	);
 
 	// Swap to document order if needed.

package/src/components/collaborators-overlay/use-block-highlighting.ts

@@ -1,11 +1,14 @@
 /**
  * WordPress dependencies
  */
+// @ts-expect-error No exported types
+import { store as blockEditorStore } from '@wordpress/block-editor';
 import {
 	privateApis as coreDataPrivateApis,
-	SelectionType,
+	type CoreDataPrivateApis,
 	type PostEditorAwarenessState as ActiveCollaborator,
 } from '@wordpress/core-data';
+import { useSelect } from '@wordpress/data';
 import { useEffect, useRef, useState } from '@wordpress/element';
 
 /**
@@ -18,6 +21,10 @@ import { useDebouncedRecompute } from './use-debounced-recompute';
 
 const { useActiveCollaborators, useResolvedSelection } =
 	unlock( coreDataPrivateApis );
+const { SelectionType } = unlock( coreDataPrivateApis ) as Pick<
+	CoreDataPrivateApis,
+	'SelectionType'
+>;
 
 export interface BlockHighlightData {
 	blockId: string;
@@ -67,6 +74,11 @@ export function useBlockHighlighting(
 	const [ recomputeToken, rerenderHighlightsAfterDelay ] =
 		useDebouncedRecompute( delayMs );
 
+	const blockClientIds = useSelect(
+		( select ) => select( blockEditorStore ).getClientIdsWithDescendants(),
+		[]
+	);
+
 	// All DOM mutations and position computations live inside useEffect.
 	useEffect( () => {
 		if ( ! blockEditorDocument ) {
@@ -203,6 +215,7 @@ export function useBlockHighlighting(
 		overlayElement,
 		recomputeToken,
 		resolveSelection,
+		blockClientIds,
 	] );
 
 	return { highlights, rerenderHighlightsAfterDelay };

package/src/components/collaborators-overlay/use-render-cursors.ts

@@ -1,8 +1,8 @@
-import {
-	privateApis as coreDataPrivateApis,
-	SelectionType,
-} from '@wordpress/core-data';
+// @ts-expect-error No exported types
+import { store as blockEditorStore } from '@wordpress/block-editor';
+import { privateApis as coreDataPrivateApis } from '@wordpress/core-data';
 import type {
+	CoreDataPrivateApis,
 	ResolvedSelection,
 	PostEditorAwarenessState as ActiveCollaborator,
 } from '@wordpress/core-data';
@@ -19,6 +19,10 @@ import type { SelectionRect } from './cursor-dom-utils';
 
 const { useActiveCollaborators, useResolvedSelection } =
 	unlock( coreDataPrivateApis );
+const { SelectionType } = unlock( coreDataPrivateApis ) as Pick<
+	CoreDataPrivateApis,
+	'SelectionType'
+>;
 
 export type { SelectionRect };
 
@@ -66,6 +70,11 @@ export function useRenderCursors(
 		[]
 	);
 
+	const blockClientIds = useSelect(
+		( select ) => select( blockEditorStore ).getClientIdsWithDescendants(),
+		[]
+	);
+
 	const [ cursorPositions, setCursorPositions ] = useState< CursorData[] >(
 		[]
 	);
@@ -106,6 +115,7 @@ export function useRenderCursors(
 			let start: ResolvedSelection = {
 				richTextOffset: null,
 				localClientId: null,
+				attributeKey: null,
 			};
 			let end: ResolvedSelection | undefined;
 
@@ -176,6 +186,7 @@ export function useRenderCursors(
 		sortedUsers,
 		showOwnCursor,
 		recomputeToken,
+		blockClientIds,
 	] );
 
 	return { cursors: cursorPositions, rerenderCursorsAfterDelay };