superdoc 2.0.0-next.28 → 2.0.0-next.29

package/dist/chunks/{create-super-doc-ui-BlnUCtrx.es.js → create-super-doc-ui-BKVf2uCM.es.js}

@@ -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;
@@ -2276,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,
@@ -2531,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();
@@ -2576,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,
@@ -2606,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,
@@ -2615,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();
@@ -2628,6 +2831,7 @@ function createSuperDocUI(options) {
 				editor,
 				adapter,
 				documentId: rawDocumentId == null ? null : String(rawDocumentId),
+				reconcileToken: reviewMutationToken,
 				v2TrackedChanges,
 				docTrackChanges
 			};
@@ -2641,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 {
@@ -2689,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,
@@ -3087,8 +3298,11 @@ 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;
@@ -3107,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) => {
@@ -3298,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;
@@ -3309,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 : []);
@@ -3968,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) => {
@@ -4594,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,
@@ -4614,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;
@@ -4692,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();
@@ -4903,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;
@@ -4930,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) => {
@@ -4973,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();
@@ -5722,12 +6073,31 @@ function createSuperDocUI(options) {
 				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;
 			}
 		}
@@ -5756,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") {
@@ -5778,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,
@@ -5795,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"] : [];
@@ -5819,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;
@@ -6079,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,
@@ -7579,6 +7959,7 @@ function createSuperDocUI(options) {
 		if (disposed) return;
 		disposed = true;
 		reviewMutationReconciler.reset();
+		clearAuthoritativeTrackChangesRetry();
 		if (foregroundAsyncRetryTimer) {
 			clearTimeout(foregroundAsyncRetryTimer);
 			foregroundAsyncRetryTimer = null;