superdoc 2.0.0-next.27 → 2.0.0-next.29

package/dist/chunks/{create-super-doc-ui-pYMthdDn.cjs → create-super-doc-ui-BXehf3i3.cjs}

@@ -21,7 +21,8 @@ function getV2TrackedChangeMutationImpact(event) {
 	if (upsertIds.size === 0 && removedIds.size === 0) return null;
 	return {
 		upsertIds,
-		removedIds
+		removedIds,
+		reconcileMode: event.origin === "history" ? "authoritative" : "targeted"
 	};
 }
 var normalizeIds = (values) => new Set(Array.from(values ?? []).filter((value) => typeof value === "string" && value.length > 0));
@@ -31,7 +32,7 @@ var itemId = (item) => {
 	if (typeof item?.address?.entityId === "string" && item.address.entityId.length > 0) return item.address.entityId;
 	return null;
 };
-var contextMatches = (left, right) => left?.adapter === right?.adapter && left?.documentId === right?.documentId && left?.editor === right?.editor;
+var contextMatches = (left, right) => left?.adapter === right?.adapter && left?.documentId === right?.documentId && left?.editor === right?.editor && left?.reconcileToken === right?.reconcileToken;
 function createV2ReviewMutationReconciler({ getContext, reconcile, hydrate, onReconciled }) {
 	const pendingUpserts = /* @__PURE__ */ new Map();
 	let sequence = 0;
@@ -48,43 +49,78 @@ function createV2ReviewMutationReconciler({ getContext, reconcile, hydrate, onRe
 		}
 		return clearedIds;
 	};
-	const readySnapshot = () => new Map([...pendingUpserts].filter(([, entry]) => entry.ready === true));
+	const readySnapshot = (reconcileMode) => new Map([...pendingUpserts].filter(([, entry]) => entry.ready === true && entry.reconcileMode === reconcileMode));
 	const markRenderGatedReady = () => {
-		for (const entry of pendingUpserts.values()) if (entry.gate === "render") entry.ready = true;
+		let changed = false;
+		for (const entry of pendingUpserts.values()) {
+			if (entry.gate !== "render" || entry.ready) continue;
+			entry.ready = true;
+			changed = true;
+		}
+		return changed;
+	};
+	const markEntriesReadyThrough = (maxVersion) => {
+		let changed = false;
+		for (const entry of pendingUpserts.values()) {
+			if (entry.version > maxVersion || entry.ready) continue;
+			entry.ready = true;
+			changed = true;
+		}
+		return changed;
 	};
-	const notifyReconciled = async (context, ids, result) => {
-		if (ids.size === 0 || typeof onReconciled !== "function") return;
+	const notifyReconciled = async (context, ids, result, allowEmpty = false) => {
+		if (!allowEmpty && ids.size === 0 || typeof onReconciled !== "function") return;
 		try {
 			await onReconciled(context, ids, result);
 		} catch {}
 	};
 	const idsFromResult = (result) => normalizeIds(result?.resolvedIds ?? (result?.items ?? []).map(itemId).filter(Boolean));
+	const reconcileTargetedSnapshot = async (context, snapshot, capturedGeneration) => {
+		const result = await reconcile(context, {
+			upsertIds: new Set(snapshot.keys()),
+			removedIds: /* @__PURE__ */ new Set(),
+			reconcileMode: "targeted"
+		});
+		if (!isCurrent(capturedGeneration, context)) return;
+		await notifyReconciled(context, clearResolved(idsFromResult(result), snapshot), result);
+		if (new Set([...snapshot].filter(([id, version]) => pendingUpserts.get(id) === version).map(([id]) => id)).size === 0) return;
+		const fallback = await hydrate(context, {
+			trackedChangesListMode: "interaction-prime",
+			refreshReason: "mutation-render-reconcile",
+			blocking: false
+		});
+		if (!isCurrent(capturedGeneration, context)) return;
+		await notifyReconciled(context, clearResolved(idsFromResult(fallback), snapshot), fallback);
+	};
+	const reconcileAuthoritativeSnapshot = async (context, snapshot, capturedGeneration) => {
+		const result = await hydrate(context, {
+			trackedChangesListMode: "all",
+			refreshReason: "mutation-history-render-reconcile",
+			blocking: true
+		});
+		if (!isCurrent(capturedGeneration, context)) return;
+		if (![...snapshot].some(([id, entry]) => pendingUpserts.get(id) === entry)) return;
+		const transportSucceeded = result?.ok === true;
+		const catalogIsAuthoritative = transportSucceeded && result?.complete === true && result?.sourceCoverageComplete === true;
+		const returnedIds = transportSucceeded ? idsFromResult(result) : /* @__PURE__ */ new Set();
+		const clearedIds = catalogIsAuthoritative ? clearResolved(new Set(snapshot.keys()), snapshot) : /* @__PURE__ */ new Set();
+		await notifyReconciled(context, catalogIsAuthoritative ? clearedIds : returnedIds, {
+			...result,
+			reconcileMode: "authoritative"
+		}, true);
+	};
 	const flush = () => {
-		if (flushInFlight) {
-			flushRequested = true;
-			return flushInFlight;
-		}
-		const snapshot = readySnapshot();
-		if (snapshot.size === 0) return null;
+		if (flushInFlight) return flushInFlight;
+		const targetedSnapshot = readySnapshot("targeted");
+		const authoritativeSnapshot = readySnapshot("authoritative");
+		if (targetedSnapshot.size === 0 && authoritativeSnapshot.size === 0) return null;
 		const context = getContext();
 		if (!context?.adapter) return null;
 		flushRequested = false;
 		const capturedGeneration = generation;
-		const upsertIds = new Set(snapshot.keys());
-		flushInFlight = Promise.resolve().then(() => reconcile(context, {
-			upsertIds,
-			removedIds: /* @__PURE__ */ new Set()
-		})).then(async (result) => {
-			if (!isCurrent(capturedGeneration, context)) return;
-			await notifyReconciled(context, clearResolved(idsFromResult(result), snapshot), result);
-			if (new Set([...snapshot].filter(([id, version]) => pendingUpserts.get(id) === version).map(([id]) => id)).size === 0) return;
-			const fallback = await hydrate(context, {
-				trackedChangesListMode: "interaction-prime",
-				refreshReason: "mutation-render-reconcile",
-				blocking: false
-			});
-			if (!isCurrent(capturedGeneration, context)) return;
-			await notifyReconciled(context, clearResolved(idsFromResult(fallback), snapshot), fallback);
+		flushInFlight = Promise.resolve().then(async () => {
+			if (authoritativeSnapshot.size > 0) await reconcileAuthoritativeSnapshot(context, authoritativeSnapshot, capturedGeneration).catch(() => void 0);
+			if (targetedSnapshot.size > 0) await reconcileTargetedSnapshot(context, targetedSnapshot, capturedGeneration).catch(() => void 0);
 		}).catch(() => {}).finally(() => {
 			flushInFlight = null;
 			if (flushRequested) flush();
@@ -93,8 +129,18 @@ function createV2ReviewMutationReconciler({ getContext, reconcile, hydrate, onRe
 	};
 	const enqueueWithGate = (impact, gate) => {
 		if (!impact) return;
+		const reconcileMode = impact.reconcileMode === "authoritative" ? "authoritative" : "targeted";
 		const removedIds = normalizeIds(impact.removedIds);
-		for (const id of removedIds) pendingUpserts.delete(id);
+		for (const id of removedIds) {
+			const existing = pendingUpserts.get(id);
+			if (existing?.reconcileMode === "authoritative") pendingUpserts.set(id, {
+				...existing,
+				version: ++sequence,
+				gate,
+				ready: false
+			});
+			else pendingUpserts.delete(id);
+		}
 		const context = getContext();
 		if (removedIds.size > 0 && context?.adapter) try {
 			Promise.resolve(reconcile(context, {
@@ -102,16 +148,20 @@ function createV2ReviewMutationReconciler({ getContext, reconcile, hydrate, onRe
 				removedIds
 			})).catch(() => void 0);
 		} catch {}
-		for (const id of normalizeIds(impact.upsertIds)) if (!removedIds.has(id)) pendingUpserts.set(id, {
-			version: ++sequence,
-			gate,
-			ready: false
-		});
+		for (const id of normalizeIds(impact.upsertIds)) if (!removedIds.has(id)) {
+			const existing = pendingUpserts.get(id);
+			pendingUpserts.set(id, {
+				version: ++sequence,
+				gate,
+				ready: false,
+				reconcileMode: reconcileMode === "authoritative" || existing?.reconcileMode === "authoritative" ? "authoritative" : "targeted"
+			});
+		}
 	};
 	const enqueue = (impact) => enqueueWithGate(impact, "render");
-	const onRender = () => {
-		markRenderGatedReady();
-		flushRequested = true;
+	const onRender = (supersedesInFlight = false) => {
+		const madeReady = markRenderGatedReady();
+		if (flushInFlight && (madeReady || supersedesInFlight)) flushRequested = true;
 		flush();
 	};
 	return {
@@ -125,18 +175,22 @@ function createV2ReviewMutationReconciler({ getContext, reconcile, hydrate, onRe
 			const context = getContext();
 			if (!context?.adapter) return;
 			const capturedGeneration = generation;
-			const capturedEntries = new Map([...normalizeIds(impact.upsertIds)].flatMap((id) => {
+			const capturedSequence = sequence;
+			const impactedIds = new Set([...normalizeIds(impact.upsertIds), ...normalizeIds(impact.removedIds)]);
+			const capturedEntries = new Map([...impactedIds].flatMap((id) => {
 				const entry = pendingUpserts.get(id);
 				return entry ? [[id, entry]] : [];
 			}));
 			Promise.resolve().then(() => waitForPaint()).then(() => {
 				if (!isCurrent(capturedGeneration, context)) return;
-				markRenderGatedReady();
+				let madeReady = markRenderGatedReady();
+				if (markEntriesReadyThrough(capturedSequence)) madeReady = true;
 				for (const [id, entry] of capturedEntries) {
 					if (pendingUpserts.get(id) !== entry) continue;
+					if (!entry.ready) madeReady = true;
 					entry.ready = true;
 				}
-				flushRequested = true;
+				if (flushInFlight && (madeReady || capturedSequence > 0)) flushRequested = true;
 				flush();
 			}).catch(() => {
 				if (!isCurrent(capturedGeneration, context)) return;
@@ -311,7 +365,8 @@ const SUPERDOC_UI_REASONS = {
 	historyEmpty: "history-empty",
 	searchUnavailable: "search-unavailable",
 	searchInvalidPattern: "search-invalid-pattern",
-	replaceUnsupported: "replace-unsupported"
+	replaceUnsupported: "replace-unsupported",
+	contentControlLocked: "content-control-locked"
 };
 const BUILT_IN_COMMAND_IDS = {
 	bold: "bold",
@@ -2275,7 +2330,13 @@ function buildTableCommandInput(action, context) {
 function createSuperDocUI(options) {
 	const superdoc = options.superdoc;
 	const optimisticInlineValues = /* @__PURE__ */ new Map();
+	const optimisticInlineToggles = /* @__PURE__ */ new Map();
+	const pendingInlineToggleMutations = [];
 	let lastOptimisticInlineSelectionSignature = null;
+	let optimisticInlineToggleGeneration = 0;
+	let inlineToggleMutationActive = false;
+	let inlineToggleMutationIdle = Promise.resolve();
+	let resolveInlineToggleMutationIdle = null;
 	let painter = {
 		mode: "idle",
 		snapshot: null,
@@ -2451,6 +2512,31 @@ function createSuperDocUI(options) {
 	let explicitActiveChange = null;
 	let explicitActiveChangeRevision = 0;
 	let queuedTrackChangeNavigationInvalidation = 0;
+	const mirrorTrackedChangeFocusToHost = (next) => {
+		const host = getHost();
+		if (typeof host?.getHandles !== "function") return;
+		const handles = safeCall(() => host.getHandles(), null);
+		const review = handles?.review;
+		if (!review) return;
+		if (next) {
+			if (typeof review.setActiveReviewTarget !== "function") return;
+			const layout = handles?.layout;
+			safeCall(() => review.setActiveReviewTarget({
+				entityType: "trackedChange",
+				entityId: next.id,
+				...next.paintedEntityId ? { paintedEntityId: next.paintedEntityId } : {},
+				origin: "panel",
+				layoutEpoch: typeof layout?.generation === "number" ? layout.generation : 0,
+				story: next.story ?? {
+					kind: "story",
+					storyType: "body"
+				}
+			}), null);
+			return;
+		}
+		if (typeof review.getActiveReviewTarget !== "function" || typeof review.clearActiveReviewTarget !== "function") return;
+		if (safeCall(() => review.getActiveReviewTarget(), null)?.entityType === "trackedChange") safeCall(() => review.clearActiveReviewTarget(), void 0);
+	};
 	const setExplicitActiveChange = (next, options$1) => {
 		explicitActiveChange = next;
 		explicitActiveChangeRevision += 1;
@@ -2464,6 +2550,8 @@ function createSuperDocUI(options) {
 	let lastEffectiveInlineReadKey = null;
 	let pendingEffectiveInlineRead = null;
 	let asyncRefreshScheduled = false;
+	let asyncReadFailureRetryTimer = null;
+	let asyncReadFailureRetryAtMs = 0;
 	let foregroundAsyncRetryTimer = null;
 	let pendingSelectionSeedValidationToken = null;
 	let typingContentInvalidationTimer = null;
@@ -2478,6 +2566,19 @@ function createSuperDocUI(options) {
 		if (typeof queueMicrotask === "function") queueMicrotask(run);
 		else Promise.resolve().then(run);
 	};
+	const ASYNC_READ_FAILURE_RETRY_BASE_MS = 250;
+	const ASYNC_READ_FAILURE_RETRY_MAX_MS = 5e3;
+	const scheduleAsyncReadFailureRetry = (retryAtMs) => {
+		if (disposed) return;
+		if (asyncReadFailureRetryTimer && asyncReadFailureRetryAtMs <= retryAtMs) return;
+		if (asyncReadFailureRetryTimer) clearTimeout(asyncReadFailureRetryTimer);
+		asyncReadFailureRetryAtMs = retryAtMs;
+		asyncReadFailureRetryTimer = setTimeout(() => {
+			asyncReadFailureRetryTimer = null;
+			asyncReadFailureRetryAtMs = 0;
+			if (!disposed) recompute();
+		}, Math.max(0, retryAtMs - Date.now()));
+	};
 	const editorIdentityIds = /* @__PURE__ */ new WeakMap();
 	let editorIdentityCounter = 0;
 	const editorIdentityId = (editor) => {
@@ -2490,6 +2591,16 @@ function createSuperDocUI(options) {
 		return `e${id}`;
 	};
 	let documentMutationRevision = 0;
+	let reviewMutationToken = {};
+	let authoritativeTrackChangesPendingToken = null;
+	let authoritativeTrackChangesRetryTimer = null;
+	let authoritativeTrackChangesFailureCount = 0;
+	const clearAuthoritativeTrackChangesRetry = () => {
+		if (authoritativeTrackChangesRetryTimer) clearTimeout(authoritativeTrackChangesRetryTimer);
+		authoritativeTrackChangesRetryTimer = null;
+		authoritativeTrackChangesFailureCount = 0;
+	};
+	let scheduleAuthoritativeTrackChangesRetry = (_reconcileToken) => void 0;
 	let postDecisionTrackChangesToken = null;
 	let postDecisionTrackChangesReconcileToken = null;
 	let postDecisionTrackChangeIds = /* @__PURE__ */ new Set();
@@ -2535,28 +2646,92 @@ function createSuperDocUI(options) {
 			run();
 		}, POST_DECISION_TRACKED_CHANGES_RECONCILE_DELAY_MS);
 	};
-	const markPostDecisionTrackChanges = (ids) => {
+	const notifyPostDecisionTrackChanges = (receipt) => {
+		const notify = () => {
+			if (disposed) return;
+			for (const listener of [...listeners]) listener(state);
+		};
+		const record = isLooseObject(receipt) ? receipt : null;
+		const readiness = getEditor()?.documentMutationReadiness;
+		const waitForPostPaintTask = () => {
+			const requestFrame = globalThis.requestAnimationFrame;
+			if (typeof requestFrame !== "function") return Promise.resolve();
+			return new Promise((resolve) => {
+				let settled = false;
+				const finish = () => {
+					if (settled) return;
+					settled = true;
+					clearTimeout(fallback);
+					resolve();
+				};
+				const fallback = setTimeout(finish, 250);
+				requestFrame(() => requestFrame(() => setTimeout(finish, 0)));
+			});
+		};
+		if (record?.success === true && typeof record.txId === "string" && record.txId.length > 0 && typeof readiness?.whenPainted === "function") try {
+			Promise.resolve(readiness.whenPainted.call(readiness, record)).then(waitForPostPaintTask, () => void 0).then(notify, notify);
+			return;
+		} catch {}
+		notify();
+	};
+	const publishPostDecisionTrackChanges = (ids, receipt) => {
+		const previous = state.trackChanges;
+		const items = previous.items.filter((item) => {
+			const id = readEntityId(item);
+			return !id || !ids.has(id);
+		});
+		if (items.length === previous.items.length) return;
+		if (explicitActiveChange && ids.has(explicitActiveChange.id)) setExplicitActiveChange(null);
+		const authors = /* @__PURE__ */ new Set();
+		for (const item of items) {
+			const change = trackChangesItemPayload(item);
+			const row = item;
+			const author = change.author ?? change.authorEmail ?? row.author ?? row.authorEmail;
+			if (typeof author === "string") authors.add(author);
+		}
+		const removedCount = previous.items.length - items.length;
+		state = {
+			...state,
+			trackChanges: {
+				...previous,
+				items,
+				total: Math.max(items.length, previous.total - removedCount),
+				activeId: previous.activeId && ids.has(previous.activeId) ? null : previous.activeId,
+				authors: [...authors]
+			}
+		};
+		notifyPostDecisionTrackChanges(receipt);
+	};
+	const markPostDecisionTrackChanges = (ids, receipt) => {
 		if (ids.size === 0) return;
-		postDecisionTrackChangesToken = contentToken();
-		postDecisionTrackChangeIds = new Set(ids);
+		const token = contentToken();
+		const alreadyRemoved = postDecisionTrackChangesToken === token ? postDecisionTrackChangeIds : /* @__PURE__ */ new Set();
+		const newlyRemoved = new Set([...ids].filter((id) => !alreadyRemoved.has(id)));
+		if (newlyRemoved.size === 0) return;
+		postDecisionTrackChangesToken = token;
+		postDecisionTrackChangeIds = new Set([...alreadyRemoved, ...newlyRemoved]);
 		applyPostDecisionTrackChangesToCache(postDecisionTrackChangeIds);
 		schedulePostDecisionTrackChangesReconcile();
-		recompute();
+		publishPostDecisionTrackChanges(newlyRemoved, receipt);
 	};
 	const postDecisionTrackChangeIdsForToken = (token) => postDecisionTrackChangesToken === token && postDecisionTrackChangeIds.size > 0 ? postDecisionTrackChangeIds : null;
-	const mergeTrackedChangeItemsIntoCache = (items) => {
+	const mergeTrackedChangeItemsIntoCache = (items, orderedItems = []) => {
 		const projected = items.map(projectTrackChangesItem).filter((item) => item != null && readEntityId(item) != null);
 		if (projected.length === 0) return;
+		const orderedIds = orderedItems.map(projectTrackChangesItem).map((item) => item == null ? null : readEntityId(item)).filter((id) => id != null);
 		for (const key of ["trackChanges", "trackChanges:all"]) {
 			const entry = asyncReads.get(key);
 			const nextValue = entry?.hasSettled && Array.isArray(entry.value) ? [...entry.value] : [];
+			const insertedIds = /* @__PURE__ */ new Set();
 			let changed = false;
 			for (const fresh of projected) {
 				const id = readEntityId(fresh);
 				if (!id) continue;
 				const index = nextValue.findIndex((candidate) => readEntityId(candidate) === id);
-				if (index < 0) nextValue.push(fresh);
-				else {
+				if (index < 0) {
+					nextValue.push(fresh);
+					insertedIds.add(id);
+				} else {
 					const previous = nextValue[index];
 					nextValue[index] = isLooseObject(previous) ? {
 						...previous,
@@ -2565,6 +2740,24 @@ function createSuperDocUI(options) {
 				}
 				changed = true;
 			}
+			if (key === "trackChanges" && insertedIds.size > 0 && orderedIds.length > 0) {
+				const placeableIds = new Set(orderedIds.filter((id) => insertedIds.has(id)));
+				const insertedRows = new Map(nextValue.filter((item) => placeableIds.has(readEntityId(item) ?? "")).map((item) => [readEntityId(item), item]));
+				const placedValue = nextValue.filter((item) => !placeableIds.has(readEntityId(item) ?? ""));
+				for (const [orderIndex, id] of orderedIds.entries()) {
+					if (!placeableIds.has(id)) continue;
+					const item = insertedRows.get(id);
+					if (!item) continue;
+					const followingAnchor = orderedIds.slice(orderIndex + 1).map((candidateId) => placedValue.findIndex((candidate) => readEntityId(candidate) === candidateId)).find((index) => index >= 0);
+					if (followingAnchor != null) {
+						placedValue.splice(followingAnchor, 0, item);
+						continue;
+					}
+					const precedingAnchor = orderedIds.slice(0, orderIndex).reverse().map((candidateId) => placedValue.findIndex((candidate) => readEntityId(candidate) === candidateId)).find((index) => index >= 0);
+					placedValue.splice(precedingAnchor == null ? placedValue.length : precedingAnchor + 1, 0, item);
+				}
+				nextValue.splice(0, nextValue.length, ...placedValue);
+			}
 			if (!changed) continue;
 			asyncReads.set(key, {
 				token: entry?.token ?? null,
@@ -2574,6 +2767,57 @@ function createSuperDocUI(options) {
 			});
 		}
 	};
+	const replaceTrackedChangeItemsInCache = (items) => {
+		const token = contentToken();
+		const suppressedIds = postDecisionTrackChangeIdsForToken(token);
+		const projected = items.map(projectTrackChangesItem).filter((item) => {
+			if (item == null) return false;
+			const id = readEntityId(item);
+			return id != null && !suppressedIds?.has(id);
+		});
+		for (const key of ["trackChanges", "trackChanges:all"]) asyncReads.set(key, {
+			token,
+			value: [...projected],
+			hasSettled: true,
+			inflightToken: null
+		});
+	};
+	const hydrateTrackedChanges = async (context, options$1) => {
+		try {
+			const listTrackedChanges = context.v2TrackedChanges?.listTrackedChanges;
+			if (typeof listTrackedChanges === "function") {
+				const result$1 = await Promise.resolve(listTrackedChanges.call(context.v2TrackedChanges, {
+					mode: options$1.trackedChangesListMode,
+					refreshReason: options$1.refreshReason,
+					blocking: options$1.blocking,
+					...options$1.targetIds?.length ? { targetIds: options$1.targetIds } : {}
+				}));
+				const ok = options$1.trackedChangesListMode === "all" && options$1.refreshReason === "mutation-history-render-reconcile" ? result$1?.ok === true : result$1?.ok !== false;
+				return {
+					ok,
+					items: ok && Array.isArray(result$1?.items) ? result$1.items : [],
+					...typeof result$1?.complete === "boolean" ? { complete: result$1.complete } : {},
+					...typeof result$1?.sourceCoverageComplete === "boolean" ? { sourceCoverageComplete: result$1.sourceCoverageComplete } : {}
+				};
+			}
+			const list = context.docTrackChanges?.list;
+			if (typeof list !== "function") return {
+				ok: false,
+				items: []
+			};
+			const result = await Promise.resolve(list.call(context.docTrackChanges));
+			return {
+				ok: true,
+				items: Array.isArray(result?.items) ? result.items : []
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				items: [],
+				failures: [error]
+			};
+		}
+	};
 	const reviewMutationReconciler = createV2ReviewMutationReconciler({
 		getContext: () => {
 			const editor = getEditor();
@@ -2587,6 +2831,7 @@ function createSuperDocUI(options) {
 				editor,
 				adapter,
 				documentId: rawDocumentId == null ? null : String(rawDocumentId),
+				reconcileToken: reviewMutationToken,
 				v2TrackedChanges,
 				docTrackChanges
 			};
@@ -2600,6 +2845,9 @@ function createSuperDocUI(options) {
 				resolvedIds: [],
 				unresolvedIds: []
 			};
+			const settledTrackChanges = asyncReads.get("trackChanges");
+			const cachedIds = new Set(settledTrackChanges?.hasSettled && Array.isArray(settledTrackChanges.value) ? settledTrackChanges.value.map(readEntityId).filter((id) => id != null) : []);
+			const idsNeedingPlacement = new Set(requestedIds.filter((id) => !cachedIds.has(id)));
 			const getTrackedChange = context.v2TrackedChanges?.getTrackedChange;
 			const getRawTrackedChange = context.docTrackChanges?.get;
 			if (typeof getTrackedChange !== "function" && typeof getRawTrackedChange !== "function") return {
@@ -2648,55 +2896,59 @@ function createSuperDocUI(options) {
 					resolvedIds.push(read.id);
 				} else unresolvedIds.push(read.id);
 			}
+			let orderedItems;
+			const placementIds = resolvedIds.filter((id) => idsNeedingPlacement.has(id));
+			if (placementIds.length > 0) {
+				const orderResult = await hydrateTrackedChanges(context, {
+					trackedChangesListMode: "interaction-prime",
+					refreshReason: "mutation-render-reconcile",
+					blocking: false,
+					targetIds: placementIds
+				});
+				if (orderResult.ok) orderedItems = orderResult.items;
+			}
 			return {
 				ok: unresolvedIds.length === 0,
 				items,
+				orderedItems,
 				resolvedIds,
 				unresolvedIds,
 				failures: reads.filter((read) => !read.ok).map((read) => read.result)
 			};
 		},
-		hydrate: async (context, options$1) => {
-			try {
-				const listTrackedChanges = context.v2TrackedChanges?.listTrackedChanges;
-				if (typeof listTrackedChanges === "function") {
-					const result$1 = await Promise.resolve(listTrackedChanges.call(context.v2TrackedChanges, {
-						mode: options$1.trackedChangesListMode,
-						refreshReason: options$1.refreshReason,
-						blocking: options$1.blocking
-					}));
-					return {
-						ok: result$1?.ok !== false,
-						items: result$1?.ok !== false && Array.isArray(result$1?.items) ? result$1.items : []
-					};
-				}
-				const list = context.docTrackChanges?.list;
-				if (typeof list !== "function") return {
-					ok: false,
-					items: []
-				};
-				const result = await Promise.resolve(list.call(context.docTrackChanges));
-				return {
-					ok: true,
-					items: Array.isArray(result?.items) ? result.items : []
-				};
-			} catch (error) {
-				return {
-					ok: false,
-					items: [],
-					failures: [error]
-				};
+		hydrate: hydrateTrackedChanges,
+		onReconciled: (context, ids, result) => {
+			if (result?.reconcileMode === "authoritative") {
+				if (context.reconcileToken !== reviewMutationToken) return;
+				if (result.ok === true && result.complete === true && result.sourceCoverageComplete === true) {
+					clearAuthoritativeTrackChangesRetry();
+					replaceTrackedChangeItemsInCache(result.items ?? []);
+					authoritativeTrackChangesPendingToken = null;
+				} else if (result.ok === true) {
+					clearAuthoritativeTrackChangesRetry();
+					mergeTrackedChangeItemsIntoCache(result.items ?? []);
+				} else scheduleAuthoritativeTrackChangesRetry(context.reconcileToken);
+				recompute();
+				return;
 			}
-		},
-		onReconciled: (_context, ids, result) => {
 			mergeTrackedChangeItemsIntoCache((result?.items ?? []).filter((item) => {
 				const projected = projectTrackChangesItem(item);
 				const id = projected == null ? null : readEntityId(projected);
 				return id != null && ids.has(id);
-			}));
+			}), result?.orderedItems ?? result?.items ?? []);
 			recompute();
 		}
 	});
+	scheduleAuthoritativeTrackChangesRetry = (reconcileToken) => {
+		if (disposed || authoritativeTrackChangesRetryTimer) return;
+		const delayMs = Math.min(ASYNC_READ_FAILURE_RETRY_BASE_MS * 2 ** authoritativeTrackChangesFailureCount, ASYNC_READ_FAILURE_RETRY_MAX_MS);
+		authoritativeTrackChangesFailureCount += 1;
+		authoritativeTrackChangesRetryTimer = setTimeout(() => {
+			authoritativeTrackChangesRetryTimer = null;
+			if (disposed || authoritativeTrackChangesPendingToken === null || reconcileToken !== reviewMutationToken) return;
+			reviewMutationReconciler.onRender(true);
+		}, delayMs);
+	};
 	const selectionReadToken = () => `${contentToken()}|m${readDocumentMode()}|s${selectionEpoch}`;
 	const selectionSignature = (selection$1) => JSON.stringify({
 		t: selection$1.target ?? null,
@@ -2714,7 +2966,7 @@ function createSuperDocUI(options) {
 		const read = host?.getDocumentLoadingSnapshot;
 		if (typeof read !== "function") return "unknown";
 		const stage = safeCall(() => read.call(host), null)?.sourceStage;
-		if (stage === "source-loading") return "loading";
+		if (stage === "opening" || stage === "ready-window" || stage === "source-loading") return "loading";
 		if (stage === "source-complete" || stage === "source-failed" || stage === "source-cancelled") return "complete";
 		return "unknown";
 	};
@@ -2880,17 +3132,24 @@ function createSuperDocUI(options) {
 				token,
 				value: normalize(raw),
 				hasSettled: true,
-				inflightToken: null
+				inflightToken: null,
+				failedToken: null,
+				failureCount: 0,
+				retryAtMs: 0
 			};
 			asyncReads.set(key, settled);
 			return settled;
 		}
 		const prev = asyncReads.get(key);
+		const retryingSameToken = prev?.failedToken === token;
 		asyncReads.set(key, {
 			token: prev?.token ?? null,
 			value: prev?.value ?? null,
 			hasSettled: prev?.hasSettled ?? false,
-			inflightToken: token
+			inflightToken: token,
+			failedToken: retryingSameToken ? token : null,
+			failureCount: retryingSameToken ? prev.failureCount ?? 0 : 0,
+			retryAtMs: 0
 		});
 		Promise.resolve(raw).then((resolved) => {
 			const entry = asyncReads.get(key);
@@ -2899,17 +3158,26 @@ function createSuperDocUI(options) {
 				token,
 				value: normalize(resolved),
 				hasSettled: true,
-				inflightToken: null
+				inflightToken: null,
+				failedToken: null,
+				failureCount: 0,
+				retryAtMs: 0
 			});
 			scheduleAsyncRefresh();
 		}, () => {
 			const entry = asyncReads.get(key);
 			if (!entry || entry.inflightToken !== token) return;
+			const failureCount = entry.failedToken === token ? (entry.failureCount ?? 0) + 1 : 1;
+			const retryDelayMs = Math.min(ASYNC_READ_FAILURE_RETRY_MAX_MS, ASYNC_READ_FAILURE_RETRY_BASE_MS * 2 ** Math.min(failureCount - 1, 8));
+			const retryAtMs = Date.now() + retryDelayMs;
 			asyncReads.set(key, {
 				...entry,
-				inflightToken: null
+				inflightToken: null,
+				failedToken: token,
+				failureCount,
+				retryAtMs
 			});
-			scheduleAsyncRefresh();
+			scheduleAsyncReadFailureRetry(retryAtMs);
 		});
 		return null;
 	};
@@ -2970,6 +3238,17 @@ function createSuperDocUI(options) {
 				status: "pending"
 			};
 		}
+		if (entry?.failedToken === token && entry.inflightToken == null && (entry.retryAtMs ?? 0) > Date.now()) {
+			scheduleAsyncReadFailureRetry(entry.retryAtMs);
+			if (entry.hasSettled) return {
+				value: entry.value,
+				status: "stale"
+			};
+			return {
+				value: null,
+				status: "pending"
+			};
+		}
 		if (!entry && key.startsWith("effInline:") && shouldDeferEffectiveInlineRead(key)) return {
 			value: null,
 			status: "pending"
@@ -3019,8 +3298,14 @@ function createSuperDocUI(options) {
 		const editor = getEditor();
 		if (editor === lastCoordinatorEditor) return;
 		reviewMutationReconciler.reset();
+		reviewMutationToken = {};
 		lastCoordinatorEditor = editor;
 		asyncReads.clear();
+		authoritativeTrackChangesPendingToken = null;
+		clearAuthoritativeTrackChangesRetry();
+		if (asyncReadFailureRetryTimer) clearTimeout(asyncReadFailureRetryTimer);
+		asyncReadFailureRetryTimer = null;
+		asyncReadFailureRetryAtMs = 0;
 		if (pendingEffectiveInlineRead?.timer) clearTimeout(pendingEffectiveInlineRead.timer);
 		pendingEffectiveInlineRead = null;
 		lastEffectiveInlineReadKey = null;
@@ -3036,7 +3321,9 @@ function createSuperDocUI(options) {
 		clearPostDecisionTrackChanges();
 	};
 	const invalidateDocumentContent = (options$1) => {
+		const carryAuthoritativeTrackChangesHold = authoritativeTrackChangesPendingToken !== null;
 		documentMutationRevision += 1;
+		if (carryAuthoritativeTrackChangesHold) authoritativeTrackChangesPendingToken = contentToken();
 		if (!options$1?.preservePostDecisionTrackChanges) clearPostDecisionTrackChanges();
 	};
 	const insertText = (text) => {
@@ -3227,7 +3514,12 @@ function createSuperDocUI(options) {
 	};
 	const readAllStoryTrackChanges = () => {
 		const tcApi = getDoc()?.trackChanges;
-		const { value, status } = readAsync("trackChanges:all", contentToken(), () => tcApi?.list ? tcApi.list({ in: "all" }) : void 0, (raw) => {
+		const token = contentToken();
+		const heldEntry = asyncReads.get("trackChanges:all");
+		const { value, status } = authoritativeTrackChangesPendingToken === token ? {
+			value: heldEntry?.hasSettled ? heldEntry.value : null,
+			status: heldEntry?.hasSettled ? "stale" : "pending"
+		} : readAsync("trackChanges:all", token, () => tcApi?.list ? tcApi.list({ in: "all" }) : void 0, (raw) => {
 			return (raw && Array.isArray(raw.items) ? raw.items : []).map(projectTrackChangesItem).filter((item) => item != null);
 		});
 		return status === "ready" ? value : null;
@@ -3238,7 +3530,11 @@ function createSuperDocUI(options) {
 		const listTrackedChanges = typeof v2TrackedChanges?.listTrackedChanges === "function" ? v2TrackedChanges.listTrackedChanges : null;
 		const token = contentToken();
 		const postDecisionIds = postDecisionTrackChangeIdsForToken(token);
-		const { value, status: listStatus } = readAsync("trackChanges", token, () => {
+		const heldEntry = asyncReads.get("trackChanges");
+		const { value, status: listStatus } = authoritativeTrackChangesPendingToken === token ? {
+			value: heldEntry?.hasSettled ? heldEntry.value : null,
+			status: heldEntry?.hasSettled ? "stale" : "pending"
+		} : readAsync("trackChanges", token, () => {
 			if (listTrackedChanges) return postDecisionTrackChangesToken === token ? listTrackedChanges.call(v2TrackedChanges, POST_DECISION_TRACKED_CHANGES_LIST_OPTIONS) : listTrackedChanges.call(v2TrackedChanges);
 			return tcApi?.list ? tcApi.list() : void 0;
 		}, (raw) => raw && Array.isArray(raw.items) ? raw.items : []);
@@ -3284,22 +3580,29 @@ function createSuperDocUI(options) {
 			activeIds
 		};
 	};
-	const computeActiveContentControlIds = (ccApi, selection$1) => {
+	const computeActiveContentControlLockModes = (ccApi, selection$1) => {
 		if (!ccApi || typeof ccApi.listInRange !== "function") return {
-			ids: [],
+			lockModesById: /* @__PURE__ */ new Map(),
 			status: "ready"
 		};
 		const range = selectionBlockRange(selection$1);
 		if (!range) return {
-			ids: [],
+			lockModesById: /* @__PURE__ */ new Map(),
 			status: "ready"
 		};
 		const { value, status } = readAsync(`contentControls:inRange:${selectionSignature(selection$1)}`, contentToken(), () => ccApi.listInRange(range), (raw) => raw && Array.isArray(raw.items) ? raw.items : []);
 		const rows = value ?? [];
-		const ids = [];
-		for (const row of rows) if (typeof row?.id === "string") ids.push(row.id);
+		const lockModesById = /* @__PURE__ */ new Map();
+		for (const row of rows) if (typeof row?.id === "string") lockModesById.set(row.id, typeof row.lockMode === "string" ? row.lockMode : "unlocked");
+		return {
+			lockModesById,
+			status
+		};
+	};
+	const computeActiveContentControlIds = (ccApi, selection$1) => {
+		const { lockModesById, status } = computeActiveContentControlLockModes(ccApi, selection$1);
 		return {
-			ids,
+			ids: [...lockModesById.keys()],
 			status
 		};
 	};
@@ -3615,14 +3918,20 @@ function createSuperDocUI(options) {
 			frozenProjectedValues = projectedInlineValues;
 			frozenProjectedValuesKey = `${selectionKey(selection$1)}:${contentToken()}`;
 		}
+		const ccApi = doc?.contentControls;
+		const { lockModesById } = computeActiveContentControlLockModes(ccApi, selection$1);
 		const states = {};
-		for (const id of allCommandIds()) states[id] = computeCommandState(id, doc, selection$1, projectedInlineValues);
+		for (const id of allCommandIds()) states[id] = computeCommandState(id, doc, selection$1, projectedInlineValues, lockModesById);
 		return states;
 	};
 	const unavailableRouteReason = (doc) => {
 		if (doc) return SUPERDOC_UI_REASONS.operationUnavailable;
 		return getEditor() ? SUPERDOC_UI_REASONS.documentApiUnavailable : SUPERDOC_UI_REASONS.notReady;
 	};
+	const blocksContentStyling = (lockMode) => lockMode === "contentLocked" || lockMode === "sdtContentLocked";
+	const contentControlLockReason = (lockModesById) => {
+		for (const lockMode of lockModesById.values()) if (blocksContentStyling(lockMode)) return SUPERDOC_UI_REASONS.contentControlLocked;
+	};
 	const trackDecisionReason = (command, supported, readonly, selection$1, doc) => {
 		if (!supported) return command.scope === "all" ? SUPERDOC_UI_REASONS.bulkDecisionsDisabled : unavailableRouteReason(doc);
 		if (readonly) return SUPERDOC_UI_REASONS.documentReadonly;
@@ -3645,7 +3954,7 @@ function createSuperDocUI(options) {
 		if (support && (support.status === "supported" || support.enabled === true)) return void 0;
 		return SUPERDOC_UI_REASONS.bulkDecisionsDisabled;
 	};
-	const computeCommandState = (id, doc, selection$1, projectedInlineValues) => {
+	const computeCommandState = (id, doc, selection$1, projectedInlineValues, lockModesById = /* @__PURE__ */ new Map()) => {
 		if (customCommands.has(id)) return normalizeCommandState({
 			supported: true,
 			enabled: true,
@@ -3720,6 +4029,13 @@ function createSuperDocUI(options) {
 				supported: true,
 				reason: SUPERDOC_UI_REASONS.documentReadonly
 			}, "builtin");
+			const lockReason = contentControlLockReason(lockModesById);
+			if (lockReason) return normalizeCommandState({
+				enabled: false,
+				active: false,
+				supported: true,
+				reason: lockReason
+			}, "builtin");
 			const enabled = selectionBlockIds(selection$1).length > 0 || resolveInlineSelectionTarget(selection$1) != null;
 			return normalizeCommandState({
 				enabled,
@@ -3770,18 +4086,28 @@ function createSuperDocUI(options) {
 			value,
 			reason: SUPERDOC_UI_REASONS.documentReadonly
 		}, "builtin");
-		if (descriptor.inline && !resolveInlineSelectionTarget(selection$1)) return normalizeCommandState(selectionBlockIds(selection$1).length > 0 && typeof getHost()?.setPendingInlineFormat === "function" ? {
-			enabled: true,
-			active,
-			supported: true,
-			value
-		} : {
-			enabled: false,
-			active,
-			supported: true,
-			value,
-			reason: SUPERDOC_UI_REASONS.rangeSelectionRequired
-		}, "builtin");
+		if (descriptor.inline && !resolveInlineSelectionTarget(selection$1)) {
+			const lockReason = contentControlLockReason(lockModesById);
+			if (lockReason) return normalizeCommandState({
+				enabled: false,
+				active,
+				supported: true,
+				value,
+				reason: lockReason
+			}, "builtin");
+			return normalizeCommandState(selectionBlockIds(selection$1).length > 0 && typeof getHost()?.setPendingInlineFormat === "function" ? {
+				enabled: true,
+				active,
+				supported: true,
+				value
+			} : {
+				enabled: false,
+				active,
+				supported: true,
+				value,
+				reason: SUPERDOC_UI_REASONS.rangeSelectionRequired
+			}, "builtin");
+		}
 		if ((descriptor.blockParagraph || descriptor.list) && selectionBlockIds(selection$1).length === 0) return normalizeCommandState({
 			enabled: false,
 			active,
@@ -3795,6 +4121,16 @@ function createSuperDocUI(options) {
 			supported: true,
 			reason: SUPERDOC_UI_REASONS.rangeSelectionRequired
 		}, "builtin");
+		if (descriptor.inline) {
+			const lockReason = contentControlLockReason(lockModesById);
+			if (lockReason) return normalizeCommandState({
+				enabled: false,
+				active,
+				supported: true,
+				value,
+				reason: lockReason
+			}, "builtin");
+		}
 		return normalizeCommandState({
 			enabled: true,
 			active,
@@ -3857,6 +4193,9 @@ function createSuperDocUI(options) {
 		if (descriptor.list?.mode === "toggle-seed" && descriptor.list.seed) return readListSeed(doc, selection$1) === descriptor.list.seed;
 		const pending = pendingInlineActive(descriptor);
 		if (pending !== null) return pending;
+		const optimistic = optimisticInlineToggles.get(descriptor.id);
+		const selectionSignature$1 = selectionInlineValueSignature(selection$1);
+		if (selectionSignature$1 && optimistic?.selectionSignature === selectionSignature$1) return optimistic.active;
 		return commandIsActive(descriptor, selection$1);
 	};
 	const routedCommandValue = (descriptor, doc, selection$1, projectedInlineValues) => {
@@ -4483,6 +4822,9 @@ function createSuperDocUI(options) {
 		const selection$1 = computeSelection();
 		if (selection$1.status === "ready") pruneSelectionScopedAsyncReads(selection$1);
 		reconcilePendingInlineFormat(selection$1);
+		const selectionSignature$1 = selectionInlineValueSignature(selection$1);
+		for (const [commandId, optimistic] of optimisticInlineToggles) if (!selectionSignature$1 || optimistic.selectionSignature !== selectionSignature$1) optimisticInlineToggles.delete(commandId);
+		else if (optimistic.settled && selection$1.status === "ready") optimisticInlineToggles.delete(commandId);
 		return {
 			ready: getEditor() != null,
 			documentMode,
@@ -4503,7 +4845,10 @@ function createSuperDocUI(options) {
 	};
 	const syncOptimisticInlineSelection = (selection$1) => {
 		const nextSignature = selectionInlineValueSignature(selection$1);
-		if (nextSignature && lastOptimisticInlineSelectionSignature && nextSignature !== lastOptimisticInlineSelectionSignature) optimisticInlineValues.clear();
+		if (nextSignature && lastOptimisticInlineSelectionSignature && nextSignature !== lastOptimisticInlineSelectionSignature) {
+			optimisticInlineValues.clear();
+			optimisticInlineToggles.clear();
+		}
 		if (nextSignature) lastOptimisticInlineSelectionSignature = nextSignature;
 	};
 	let currentHostSelectionSource = null;
@@ -4581,24 +4926,48 @@ function createSuperDocUI(options) {
 		try {
 			const off = next.subscribe((event) => {
 				const type = event?.type;
-				if (type === "mutation:committed") lastEditableMutationAtMs = Date.now();
+				if (type === "source:complete" || type === "source:signals-complete") {
+					if (authoritativeTrackChangesPendingToken !== null) {
+						clearAuthoritativeTrackChangesRetry();
+						reviewMutationReconciler.onRender(true);
+					}
+					return;
+				}
+				if (type === "mutation:committed") {
+					lastEditableMutationAtMs = Date.now();
+					clearAuthoritativeTrackChangesRetry();
+					reviewMutationToken = {};
+				}
 				if (type === "mutation:committed" || type === "save:completed") {
 					const impact = type === "mutation:committed" ? getV2TrackedChangeMutationImpact(event) : null;
-					if (impact?.removedIds.size) markPostDecisionTrackChanges(new Set(impact.removedIds));
-					if (impact?.upsertIds.size) {
+					const supersedesPendingReviewReconcile = type === "mutation:committed" && reviewMutationReconciler.getPendingIds().size > 0;
+					if (impact?.removedIds.size) markPostDecisionTrackChanges(new Set(impact.removedIds), event.receipt);
+					const authoritativeHistoryImpact = impact?.reconcileMode === "authoritative" && impact.upsertIds.size > 0;
+					if (authoritativeHistoryImpact) {
+						invalidateDocumentContent();
+						clearAuthoritativeTrackChangesRetry();
+						authoritativeTrackChangesPendingToken = contentToken();
+						recompute();
+					}
+					if (impact?.upsertIds.size || supersedesPendingReviewReconcile) {
 						const receipt = event.origin === "history" ? null : event.receipt;
 						const readiness = getEditor()?.documentMutationReadiness;
-						const canWaitForExactPaint = typeof receipt?.txId === "string" && receipt.txId.length > 0 && typeof readiness?.whenPainted === "function";
+						const canWaitForReceiptPaint = typeof receipt?.txId === "string" && receipt.txId.length > 0 && typeof readiness?.whenPainted === "function";
+						const historyRenderEpoch = event.origin === "history" && typeof readiness?.getRenderEpoch === "function" ? safeCall(() => readiness.getRenderEpoch.call(readiness), null) : null;
+						const canWaitForHistoryPaint = event.origin === "history" && typeof readiness?.whenPainted === "function";
 						const upsertImpact = {
-							upsertIds: impact.upsertIds,
-							removedIds: /* @__PURE__ */ new Set()
+							upsertIds: impact?.upsertIds ?? /* @__PURE__ */ new Set(),
+							removedIds: /* @__PURE__ */ new Set(),
+							reconcileMode: impact?.reconcileMode === "authoritative" ? "authoritative" : "targeted"
 						};
-						if (canWaitForExactPaint) reviewMutationReconciler.enqueueAfterPaint(upsertImpact, () => readiness.whenPainted.call(readiness, receipt));
+						if (canWaitForReceiptPaint) reviewMutationReconciler.enqueueAfterPaint(upsertImpact, () => readiness.whenPainted.call(readiness, receipt));
+						else if (canWaitForHistoryPaint) reviewMutationReconciler.enqueueAfterPaint(upsertImpact, () => readiness.whenPainted.call(readiness, typeof historyRenderEpoch === "number" ? { afterEpoch: historyRenderEpoch } : void 0));
 						else {
 							reviewMutationReconciler.enqueue(upsertImpact);
-							reviewMutationReconciler.onRender();
+							reviewMutationReconciler.onRender(supersedesPendingReviewReconcile);
 						}
 					}
+					if (authoritativeHistoryImpact) return;
 					if (type === "mutation:committed" && isEditableTextMutationEvent(event)) {
 						lastTypingMutationAtMs = Date.now();
 						scheduleTypingDocumentContentInvalidation();
@@ -4753,7 +5122,10 @@ function createSuperDocUI(options) {
 	}
 	function executeTrackDecisionCommand(command, payload) {
 		if (command.scope === "id" && payload == null) {
-			if (state.selection.activeChangeIds.length > 1) return executeTrackDecisionTargets(command.kind, state.selection.activeChangeIds);
+			if (state.selection.activeChangeIds.length > 1) return executeTrackDecisionTarget(command.kind, {
+				kind: "ids",
+				ids: state.selection.activeChangeIds
+			}, null);
 			if (state.selection.activeChangeIds.length === 1 && !state.selection.empty && state.selection.selectionTarget) {
 				const route = activeChangePartialDecisionRoute();
 				if (route === "unavailable") return false;
@@ -4789,6 +5161,7 @@ function createSuperDocUI(options) {
 	}
 	let lastCommandSettlement = Promise.resolve(false);
 	let pendingCommandSettlement = null;
+	let lastInlineToggleCommandSettlement = Promise.resolve(false);
 	const awaitMutationReadiness = async (result) => {
 		if (!isSuccessfulReceipt(result)) return result;
 		const readiness = getEditor()?.documentMutationReadiness;
@@ -4816,6 +5189,69 @@ function createSuperDocUI(options) {
 			settled: awaitMutationReadiness(immediate)
 		};
 	};
+	const releaseInlineToggleMutation = () => {
+		const next = pendingInlineToggleMutations.shift();
+		if (!next) {
+			inlineToggleMutationActive = false;
+			resolveInlineToggleMutationIdle?.();
+			resolveInlineToggleMutationIdle = null;
+			return;
+		}
+		try {
+			next.resolve(disposed ? false : next.mutate());
+		} catch {
+			next.resolve(false);
+		}
+	};
+	const releaseInlineToggleMutationOnce = () => {
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			releaseInlineToggleMutation();
+		};
+	};
+	const scheduleInlineToggleMutation = (key, mutate) => {
+		if (!inlineToggleMutationActive) {
+			inlineToggleMutationActive = true;
+			inlineToggleMutationIdle = new Promise((resolve$1) => {
+				resolveInlineToggleMutationIdle = resolve$1;
+			});
+			try {
+				return {
+					result: mutate(),
+					release: releaseInlineToggleMutationOnce()
+				};
+			} catch (error) {
+				inlineToggleMutationActive = false;
+				resolveInlineToggleMutationIdle?.();
+				resolveInlineToggleMutationIdle = null;
+				throw error;
+			}
+		}
+		const pending = pendingInlineToggleMutations.find((mutation) => mutation.key === key);
+		if (pending) {
+			pending.mutate = mutate;
+			return {
+				result: pending.result,
+				release: () => void 0
+			};
+		}
+		let resolve;
+		const result = new Promise((settle) => {
+			resolve = settle;
+		});
+		pendingInlineToggleMutations.push({
+			key,
+			mutate,
+			result,
+			resolve
+		});
+		return {
+			result,
+			release: releaseInlineToggleMutationOnce()
+		};
+	};
 	const UNSUPPORTED_TRACKED_UI_MUTATION_ROUTES = new Set(["create.tableOfContents"]);
 	const unsupportedTrackedMutationReceipt = (route) => failedReceipt(`Tracked authoring is not supported for ${route}.`);
 	const editorMutationOptionsForRoute = (route) => {
@@ -4859,33 +5295,62 @@ function createSuperDocUI(options) {
 		});
 		return result;
 	};
-	const finalizeCommandSettlement = (promise) => promise.then((settled) => {
+	const captureOptimisticInlineToggle = (descriptor, selection$1, input, result) => {
+		if (descriptor.inline?.kind !== "toggle") return null;
+		if (!commandResultSucceeded(commandResultFromOperationResult(result))) return null;
+		if (typeof input.value !== "boolean" && input.value !== null) return null;
+		const selectionSignature$1 = selectionInlineValueSignature(selection$1);
+		if (!selectionSignature$1) return null;
+		const generation = ++optimisticInlineToggleGeneration;
+		optimisticInlineToggles.set(descriptor.id, {
+			selectionSignature: selectionSignature$1,
+			active: input.value === true,
+			generation,
+			settled: false
+		});
+		recompute();
+		return generation;
+	};
+	const settleOptimisticInlineToggle = (descriptor, generation, result) => {
+		if (generation == null) return;
+		const optimistic = optimisticInlineToggles.get(descriptor.id);
+		if (!optimistic || optimistic.generation !== generation) return;
+		if (!commandResultSucceeded(result)) {
+			optimisticInlineToggles.delete(descriptor.id);
+			return;
+		}
+		optimistic.settled = true;
+	};
+	const finalizeCommandSettlement = (promise, onSettled) => promise.then((settled) => {
+		onSettled?.(settled);
 		invalidateDocumentContent();
 		recompute();
 		return settled;
 	}, () => {
+		onSettled?.(false);
 		invalidateDocumentContent();
 		recompute();
 		return false;
 	});
-	const settleCommandExecution = (result) => {
+	const settleCommandExecution = (result, onSettled) => {
 		const pending = pendingCommandSettlement;
 		pendingCommandSettlement = null;
 		if (pending) {
-			lastCommandSettlement = finalizeCommandSettlement(pending);
+			lastCommandSettlement = finalizeCommandSettlement(pending, onSettled);
 			return commandResultFromOperationResult(result);
 		}
 		if (isPromiseLike(result)) {
-			lastCommandSettlement = finalizeCommandSettlement(settleOperationResult(result).settled);
+			lastCommandSettlement = finalizeCommandSettlement(settleOperationResult(result).settled, onSettled);
 			return true;
 		}
 		const settled = commandResultFromOperationResult(result);
 		if (isSuccessfulReceipt(settled)) {
 			if (typeof (getEditor()?.documentMutationReadiness)?.whenPainted === "function") {
-				lastCommandSettlement = finalizeCommandSettlement(awaitMutationReadiness(settled));
+				lastCommandSettlement = finalizeCommandSettlement(awaitMutationReadiness(settled), onSettled);
 				return settled;
 			}
 		}
+		onSettled?.(settled);
 		lastCommandSettlement = Promise.resolve(settled);
 		invalidateDocumentContent();
 		recompute();
@@ -5025,6 +5490,9 @@ function createSuperDocUI(options) {
 		return true;
 	};
 	const executeClearFormattingCommand = () => {
+		const doc = getDoc();
+		const { lockModesById } = computeActiveContentControlLockModes(doc?.contentControls, state.selection);
+		if (contentControlLockReason(lockModesById)) return false;
 		const immediateResults = [];
 		const settledResults = [];
 		const record = (result) => {
@@ -5040,7 +5508,6 @@ function createSuperDocUI(options) {
 				settledResults.push(Promise.resolve(false));
 			}
 		};
-		const doc = getDoc();
 		const defaultStyleId = getStyleCatalog().cache?.full.defaults.paragraphStyleId ?? DEFAULT_PARAGRAPH_STYLE_ID;
 		const rangeTarget = resolveInlineSelectionTarget(state.selection);
 		if (rangeTarget) {
@@ -5446,7 +5913,7 @@ function createSuperDocUI(options) {
 			const rows = Number(record.rows ?? record.rowCount);
 			const columns = Number(record.columns ?? record.cols ?? record.colCount);
 			if (!Number.isInteger(rows) || rows < 1 || !Number.isInteger(columns) || columns < 1) return false;
-			const caret = readDocumentMode() !== "suggesting" ? collapsedTextAddressFromSelection(state.selection) : null;
+			const caret = collapsedTextAddressFromSelection(state.selection);
 			const at = caret && typeof caret.blockId === "string" ? {
 				kind: "inParagraph",
 				target: paragraphTarget(caret.blockId),
@@ -5595,20 +6062,42 @@ function createSuperDocUI(options) {
 		const route = descriptor.docRoute;
 		if (!route) return false;
 		if (descriptor.mutates && readDocumentMode() === "viewing") return false;
-		const op = resolveDocOperation(getDoc(), route);
+		const doc = getDoc();
+		const op = resolveDocOperation(doc, route);
 		if (!op) return false;
 		if (descriptor.inline) {
+			const { lockModesById } = computeActiveContentControlLockModes(doc?.contentControls, state.selection);
+			if (contentControlLockReason(lockModesById)) return false;
 			const target = resolveInlineSelectionTarget(state.selection);
 			if (!target) {
 				if (state.selection.empty === false) return settleCommandExecution(false);
 				return settleCommandExecution(storePendingInlineFormat(descriptor, normalized));
 			}
-			const active = commandIsActive(descriptor, state.selection);
+			const active = commandActiveState(descriptor, doc, state.selection);
 			const input = buildInlineFormatInput(descriptor.inline, target, normalized, active);
 			if (!input) return false;
+			let releaseScheduledMutation = null;
 			try {
-				return settleCommandExecution(decorateInlineCommandResult(descriptor, state.selection, input, callInlineFormatMutation(route, op, input)));
+				const commandEditor = getEditor();
+				const commandMode = readDocumentMode();
+				const mutate = () => {
+					if (getEditor() !== commandEditor || getDoc() !== doc || readDocumentMode() !== commandMode) return false;
+					return callInlineFormatMutation(route, op, input);
+				};
+				const selectionSignature$1 = selectionInlineValueSignature(state.selection) ?? selectionKey(state.selection);
+				const scheduledMutation = descriptor.inline.kind === "toggle" ? scheduleInlineToggleMutation(`${descriptor.id}:${selectionSignature$1}`, mutate) : null;
+				releaseScheduledMutation = scheduledMutation?.release ?? null;
+				const mutationResult = scheduledMutation ? scheduledMutation.result : mutate();
+				const optimisticGeneration = captureOptimisticInlineToggle(descriptor, state.selection, input, mutationResult);
+				const immediate = settleCommandExecution(decorateInlineCommandResult(descriptor, state.selection, input, mutationResult), (settled) => {
+					settleOptimisticInlineToggle(descriptor, optimisticGeneration, settled);
+					releaseScheduledMutation?.();
+					releaseScheduledMutation = null;
+				});
+				if (descriptor.inline.kind === "toggle") lastInlineToggleCommandSettlement = lastCommandSettlement;
+				return immediate;
 			} catch {
+				releaseScheduledMutation?.();
 				return false;
 			}
 		}
@@ -5637,6 +6126,15 @@ function createSuperDocUI(options) {
 		recompute();
 	};
 	const executeCopyFormat = async () => {
+		const visibleActiveMarksAtClick = [
+			"bold",
+			"italic",
+			"underline",
+			"strikethrough"
+		].filter((id) => state.toolbar.commands[id]?.active === true);
+		const inlineToggleSettlement = await lastInlineToggleCommandSettlement;
+		await inlineToggleMutationIdle;
+		const visibleActiveMarks = commandResultSucceeded(inlineToggleSettlement) ? visibleActiveMarksAtClick : [];
 		const DOUBLE_CLICK_MS = 500;
 		const now = Date.now();
 		if (painter.mode !== "idle") {
@@ -5659,11 +6157,9 @@ function createSuperDocUI(options) {
 			...painter,
 			lastClickAt: now
 		};
-		const captureSlice = state.selection;
+		const captureSlice = await readSelectionInfoFresh();
 		const sourceKey = `${selectionKey(captureSlice)}:${contentToken()}`;
-		const captureProjected = sourceKey && sourceKey === frozenProjectedValuesKey ? frozenProjectedValues : void 0;
-		const sel = readSelectionInfoLive().value;
-		const painterSnapshot = await captureFormatPainter(sel, captureSlice, captureProjected);
+		const painterSnapshot = await captureFormatPainter(null, captureSlice, sourceKey && sourceKey === frozenProjectedValuesKey ? frozenProjectedValues : void 0, visibleActiveMarks);
 		if (captureEpoch !== painterCaptureEpoch) return true;
 		painter = {
 			...painter,
@@ -5676,7 +6172,7 @@ function createSuperDocUI(options) {
 		recompute();
 		return true;
 	};
-	const captureFormatPainter = async (selection$1, captureSlice, captureProjected) => {
+	const captureFormatPainter = async (selection$1, captureSlice, captureProjected, visibleActiveMarks = []) => {
 		const selTarget = captureSlice?.target ?? selection$1?.target;
 		if (!selTarget || selTarget["kind"] !== "text") return null;
 		const segments = Array.isArray(selTarget["segments"]) ? selTarget["segments"] : [];
@@ -5700,8 +6196,8 @@ function createSuperDocUI(options) {
 			underline: "underline",
 			strikethrough: "strike"
 		};
-		const activeMarks = captureSlice?.activeMarks ?? (Array.isArray(selection$1?.["activeMarks"]) ? selection$1["activeMarks"] : []);
-		for (const [markName, patchKey] of Object.entries(MARK_TO_PATCH)) if (activeMarks.includes(markName)) inlinePatch[patchKey] = true;
+		const activeMarks = new Set([...captureSlice?.activeMarks ?? (Array.isArray(selection$1?.["activeMarks"]) ? selection$1["activeMarks"] : []), ...visibleActiveMarks]);
+		for (const [markName, patchKey] of Object.entries(MARK_TO_PATCH)) if (activeMarks.has(markName)) inlinePatch[patchKey] = true;
 		const projectedInlineValues = captureProjected ?? await readFormatPainterInlineValues(captureSlice ?? selectionSliceFromInfo(selection$1, "ready"));
 		if (projectedInlineValues.fontFamily) inlinePatch["fontFamily"] = projectedInlineValues.fontFamily;
 		if (projectedInlineValues.color) inlinePatch["color"] = projectedInlineValues.color;
@@ -5855,6 +6351,12 @@ function createSuperDocUI(options) {
 		}
 		const doc = getDoc();
 		if (!doc) return;
+		const targetSelection = selectionSliceFromInfo(selection$1, "ready");
+		const { lockModesById } = computeActiveContentControlLockModes(doc.contentControls, targetSelection);
+		if (contentControlLockReason(lockModesById)) {
+			recompute();
+			return;
+		}
 		const selTarget = selection$1["target"];
 		const selectionTarget = selection$1["selectionTarget"];
 		if (!(selection$1["empty"] === true) && Object.keys(snap.inline).length > 0) {
@@ -5954,12 +6456,15 @@ function createSuperDocUI(options) {
 	};
 	const executeCommandAsync = (id, payload, context) => {
 		const prepared = prepareCommandSelectionAsync(id, payload);
-		if (prepared) return prepared.then(() => {
+		const settlement = prepared ? prepared.then(() => {
 			executeCommand(id, payload, context);
 			return lastCommandSettlement;
-		});
-		executeCommand(id, payload, context);
-		return lastCommandSettlement;
+		}) : (() => {
+			executeCommand(id, payload, context);
+			return lastCommandSettlement;
+		})();
+		if (getCommandDescriptor(id)?.inline?.kind === "toggle") lastInlineToggleCommandSettlement = settlement;
+		return settlement;
 	};
 	const makeCommandHandle = (id) => ({
 		id,
@@ -6426,6 +6931,7 @@ function createSuperDocUI(options) {
 		setActive: (input) => {
 			if (input == null) {
 				setExplicitActiveChange(null);
+				mirrorTrackedChangeFocusToHost(null);
 				recompute();
 				return true;
 			}
@@ -6435,6 +6941,7 @@ function createSuperDocUI(options) {
 				story: input.story
 			};
 			if (typeof requested.id !== "string" || requested.id.length === 0) return false;
+			const paintedEntityId = requested.id;
 			if (requested.story) {
 				const allStoryItems = readAllStoryTrackChanges();
 				if (!allStoryItems) return false;
@@ -6447,7 +6954,9 @@ function createSuperDocUI(options) {
 				if (!bodyItems.some((item) => readEntityId(item) === publicId)) return false;
 				requested.id = publicId;
 			}
+			if (paintedEntityId !== requested.id) requested.paintedEntityId = paintedEntityId;
 			setExplicitActiveChange(requested);
+			mirrorTrackedChangeFocusToHost(requested);
 			recompute();
 			return true;
 		},
@@ -6466,10 +6975,11 @@ function createSuperDocUI(options) {
 				reason: SUPERDOC_UI_REASONS.targetUnresolved
 			};
 			const previousActiveChange = explicitActiveChange;
-			setExplicitActiveChange(story ? {
+			const requestedActiveChange = story ? {
 				id: changeId,
 				story
-			} : { id: changeId });
+			} : { id: changeId };
+			setExplicitActiveChange(requestedActiveChange);
 			recompute();
 			const optimisticActiveChange = explicitActiveChange;
 			const optimisticRevision = explicitActiveChangeRevision;
@@ -6485,6 +6995,7 @@ function createSuperDocUI(options) {
 				ok: false
 			};
 			if (!result.ok && result.reason !== SUPERDOC_UI_REASONS.targetNotVisible) rollback();
+			else mirrorTrackedChangeFocusToHost(requestedActiveChange);
 			return result;
 		}
 	};
@@ -6511,12 +7022,13 @@ function createSuperDocUI(options) {
 		const tcApi = getDoc()?.trackChanges;
 		const isAllTarget = target.scope === "all";
 		const isRangeTarget = target.kind === "range";
+		const isMultiIdTarget = target.kind === "ids";
 		if (bulkTrackDecisionBlockedReason({
 			kind,
 			scope: isAllTarget ? "all" : "id"
 		}, tcApi)) return false;
 		const legacyName = isAllTarget ? `${kind}All` : kind;
-		const op = !isRangeTarget && !story && tcApi && typeof tcApi[legacyName] === "function" ? tcApi[legacyName] : null;
+		const op = !isRangeTarget && !isMultiIdTarget && !story && tcApi && typeof tcApi[legacyName] === "function" ? tcApi[legacyName] : null;
 		const decide = tcApi && typeof tcApi.decide === "function" ? tcApi.decide : null;
 		if (!op && !decide) return false;
 		return op ? op.call(tcApi, changeId ?? {}) : decide.call(tcApi, {
@@ -6524,23 +7036,6 @@ function createSuperDocUI(options) {
 			target
 		});
 	};
-	const executeTrackDecisionTargets = (kind, changeIds) => {
-		const immediateResults = [];
-		const settledResults = [];
-		for (const changeId of changeIds) try {
-			const result = settleOperationResult(callTrackDecisionTarget(kind, {
-				kind: "id",
-				id: changeId
-			}, changeId));
-			immediateResults.push(result.immediate);
-			settledResults.push(result.settled);
-		} catch {
-			immediateResults.push(false);
-			settledResults.push(Promise.resolve(false));
-		}
-		pendingCommandSettlement = Promise.all(settledResults).then((results) => combineCommandResults(results));
-		return settleCommandExecution(combineCommandResults(immediateResults));
-	};
 	const contentControlsSub = sliceHandle((s) => s.contentControls);
 	const findContentControl = (id) => {
 		return contentControlsSub.get().items.find((item) => item?.id === id) ?? null;
@@ -7464,10 +7959,16 @@ function createSuperDocUI(options) {
 		if (disposed) return;
 		disposed = true;
 		reviewMutationReconciler.reset();
+		clearAuthoritativeTrackChangesRetry();
 		if (foregroundAsyncRetryTimer) {
 			clearTimeout(foregroundAsyncRetryTimer);
 			foregroundAsyncRetryTimer = null;
 		}
+		if (asyncReadFailureRetryTimer) {
+			clearTimeout(asyncReadFailureRetryTimer);
+			asyncReadFailureRetryTimer = null;
+			asyncReadFailureRetryAtMs = 0;
+		}
 		if (pendingEffectiveInlineRead?.timer) {
 			clearTimeout(pendingEffectiveInlineRead.timer);
 			pendingEffectiveInlineRead.timer = null;