superdoc 2.20.1-next.1 → 2.20.1-next.11

package/dist/chunks/{create-super-doc-ui-DFCfYEpW.cjs → create-super-doc-ui-yKesgn9b.cjs}

@@ -1,5 +1,563 @@
 const require__plugin_vue_export_helper = require("./_plugin-vue_export-helper-CYxINHh_.cjs");
+//#region src/internal/diagnostics/workflow-recording.ts
+var fields$1 = /* @__PURE__ */ new Set([
+	"documentId",
+	"actionId",
+	"commandId",
+	"operation",
+	"source",
+	"origin",
+	"phase",
+	"kind",
+	"status",
+	"success",
+	"changed",
+	"reason",
+	"code",
+	"direction",
+	"outcome",
+	"receipt",
+	"result",
+	"failure",
+	"rejection",
+	"txId",
+	"documentEpoch",
+	"commitSequence",
+	"targetCommitSequence",
+	"paintedCommitSequence",
+	"renderInputEpoch",
+	"paintedRenderInputEpoch",
+	"health",
+	"selection",
+	"selectionBefore",
+	"selectionAfter",
+	"snapshot",
+	"target",
+	"start",
+	"end",
+	"anchor",
+	"focus",
+	"story",
+	"storyType",
+	"storyId",
+	"refId",
+	"noteId",
+	"textboxId",
+	"position",
+	"offset",
+	"unit",
+	"value",
+	"blockId",
+	"blockOffset",
+	"fragmentId",
+	"pageIndex",
+	"layoutEpoch",
+	"revision",
+	"sourceCommit",
+	"selectionLineageId",
+	"selectionIntentSequence",
+	"intentSequence",
+	"intentId",
+	"authoringMode",
+	"editableCommandKind",
+	"inputKind",
+	"visualIntent",
+	"preEdit",
+	"postEdit",
+	"fallback",
+	"selectionRevision",
+	"timing",
+	"selectionTargetMs",
+	"textReplaceMs",
+	"postEditSelectionMs",
+	"totalMs",
+	"inputAtMs",
+	"dispatchAtMs",
+	"committedAtMs",
+	"durationMs",
+	"elapsedMs",
+	"affectedStories",
+	"tableId",
+	"cellId",
+	"contentControlId",
+	"outsideContentControl",
+	"trackedBlockOffset",
+	"projectionBlockId",
+	"geometryBlockId",
+	"geometryBlockOffset",
+	"geometryTrackedBlockOffset",
+	"lineAffinity",
+	"inlineAffinity",
+	"stability",
+	"nativeId",
+	"paraId",
+	"partId",
+	"partRevision",
+	"storyRevision",
+	"pathFingerprint",
+	"path",
+	"index",
+	"name",
+	"id",
+	"range",
+	"hasRangeSelection",
+	"inputType",
+	"dataLength",
+	"isComposing",
+	"repeat",
+	"altKey",
+	"ctrlKey",
+	"metaKey",
+	"shiftKey",
+	"key",
+	"button",
+	"buttons",
+	"pointerType",
+	"clickCount",
+	"x",
+	"y",
+	"selector",
+	"domPath",
+	"scrollLeft",
+	"scrollTop",
+	"command",
+	"segments",
+	"nodeId",
+	"byteSpan",
+	"sdtId",
+	"controlId",
+	"scope",
+	"coordinateSpace",
+	"contentControlIds",
+	"scrollAncestors",
+	"layoutBlockRef",
+	"contextSource"
+]);
+var contentFields$1 = /* @__PURE__ */ new Set([
+	"text",
+	"data",
+	"message",
+	"errorMessage",
+	"quotedText"
+]);
+var inputTypes = [
+	"keydown",
+	"keyup",
+	"beforeinput",
+	"pointerdown",
+	"pointermove",
+	"pointerup",
+	"click",
+	"dblclick",
+	"mousedown",
+	"mouseup",
+	"scroll",
+	"compositionstart",
+	"compositionend",
+	"paste",
+	"cut",
+	"drop",
+	"dragstart"
+];
+var namedKeys = /* @__PURE__ */ new Set([
+	"Alt",
+	"AltGraph",
+	"CapsLock",
+	"Control",
+	"Meta",
+	"NumLock",
+	"ScrollLock",
+	"Shift",
+	"Enter",
+	"Tab",
+	"ArrowLeft",
+	"ArrowRight",
+	"ArrowUp",
+	"ArrowDown",
+	"End",
+	"Home",
+	"PageDown",
+	"PageUp",
+	"Backspace",
+	"Delete",
+	"Insert",
+	"Escape",
+	"ContextMenu",
+	"Pause",
+	"Dead",
+	"Process",
+	"Unidentified"
+]);
+var nextSession$1 = 0;
+function own$1(value, key) {
+	return value && typeof value === "object" ? Object.getOwnPropertyDescriptor(value, key)?.value : void 0;
+}
+function budget(value, fallback, maximum) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= maximum ? value : fallback;
+}
+var WorkflowRecorder = class {
+	constructor(root, version) {
+		this.root = root;
+		this.version = version;
+		this.session = null;
+		this.events = [];
+		this.startMs = 0;
+		this.maxEvents = 2e4;
+		this.maxBytes = 8388608;
+		this.closed = false;
+		this.pendingIntents = /* @__PURE__ */ new Set();
+		this.heldKeys = /* @__PURE__ */ new Set();
+		this.heldButtons = /* @__PURE__ */ new Set();
+		this.cleanups = [];
+		const recorder = this;
+		this.api = Object.freeze({
+			get active() {
+				return recorder.active;
+			},
+			start: (options) => this.start(options),
+			stop: () => this.stop(),
+			getSnapshot: () => this.snapshot()
+		});
+	}
+	attachInputs() {
+		const view = this.root.ownerDocument.defaultView;
+		if (!view) throw new Error("Workflow recording requires a browser window.");
+		try {
+			for (const type of inputTypes) {
+				const listener = (event) => {
+					if (!this.active || !event.isTrusted) return;
+					try {
+						if (event.target instanceof view.Node && this.root.contains(event.target)) this.input(event);
+						else if (event.type === "keyup" ? this.heldKeys.delete(event.key) : event.type === "pointerup" ? this.heldButtons.delete(event.button) : false) this.unsupported("input-released-outside-mount");
+					} catch {
+						this.fail("capture-failure");
+					}
+				};
+				view.addEventListener(type, listener, true);
+				this.cleanups.push(() => view.removeEventListener(type, listener, true));
+			}
+		} catch (error) {
+			this.detachInputs();
+			throw error;
+		}
+	}
+	detachInputs() {
+		const cleanups = this.cleanups;
+		this.cleanups = [];
+		for (const cleanup of cleanups) try {
+			cleanup();
+		} catch {}
+	}
+	get active() {
+		return this.session?.status === "recording";
+	}
+	start(options = {}) {
+		if (this.closed) throw new Error("Cannot record a destroyed SuperDoc instance.");
+		if (this.active) throw new Error("Stop the active workflow recording first.");
+		this.maxEvents = budget(own$1(options, "maxEvents"), 2e4, 1e5);
+		this.maxBytes = budget(own$1(options, "maxBytes"), 8388608, 67108864);
+		const view = this.root.ownerDocument.defaultView;
+		this.events = [];
+		this.pendingIntents.clear();
+		this.startMs = view.performance.now();
+		this.session = {
+			schemaVersion: 1,
+			sessionId: `workflow-${Date.now()}-${++nextSession$1}`,
+			version: this.version(),
+			status: "recording",
+			startedAt: Date.now(),
+			durationMs: 0,
+			timeOrigin: view.performance.timeOrigin,
+			startTimeMs: this.startMs,
+			captureContent: own$1(options, "captureContent") === true,
+			viewport: {
+				width: view.innerWidth,
+				height: view.innerHeight,
+				devicePixelRatio: view.devicePixelRatio
+			},
+			retainedBytes: 0,
+			replayUnsupportedReasons: [],
+			pendingIntentIds: []
+		};
+		try {
+			this.attachInputs();
+			this.observe("workflow:started", () => ({
+				scrollTop: this.root.scrollTop,
+				scrollLeft: this.root.scrollLeft
+			}));
+		} catch {
+			this.fail("capture-failure");
+		}
+		return this.snapshot();
+	}
+	observe(type, read) {
+		if (!this.active) return;
+		try {
+			let remaining = 4096;
+			const copy = (value, depth = 0) => {
+				if (--remaining < 0 || depth > 14) throw new Error("payload-limit");
+				if (value === null || typeof value === "boolean") return value;
+				if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+				if (typeof value === "string") {
+					if (value.length > 32768) throw new Error("payload-limit");
+					return value;
+				}
+				if (!value || typeof value !== "object") return void 0;
+				if (Array.isArray(value)) {
+					if (value.length > 256) throw new Error("payload-limit");
+					return Array.from({ length: value.length }, (_, i) => copy(own$1(value, String(i)), depth + 1) ?? null);
+				}
+				const result = {};
+				for (const key of fields$1) {
+					const item = own$1(value, key);
+					if (key === "value" && typeof item === "string" && !this.session.captureContent) continue;
+					if (item !== void 0) result[key] = copy(item, depth + 1);
+				}
+				if (this.session.captureContent) for (const key of contentFields$1) {
+					const item = own$1(value, key);
+					if (item !== void 0) result[key] = copy(item, depth + 1);
+				}
+				return result;
+			};
+			const event = {
+				sequence: this.events.length + 1,
+				atMs: this.root.ownerDocument.defaultView.performance.now() - this.startMs,
+				type,
+				data: copy(read()) ?? {}
+			};
+			const serialized = JSON.stringify(event);
+			if (this.events.length >= this.maxEvents || this.session.retainedBytes + serialized.length * 2 > this.maxBytes) {
+				this.fail("capture-limit");
+				return;
+			}
+			this.events.push(serialized);
+			this.session.retainedBytes += serialized.length * 2;
+			if (type === "interaction:intent") {
+				const id = `${event.data.documentId ?? ""}/${event.data.selectionLineageId}/${event.data.intentSequence}`;
+				if (event.data.phase === "enqueued" || event.data.phase === "executing") this.pendingIntents.add(id);
+				if (event.data.phase === "settled" || event.data.phase === "failed") this.pendingIntents.delete(id);
+			}
+		} catch {
+			this.fail("capture-failure");
+		}
+	}
+	unsupported(reason) {
+		if (!this.session.replayUnsupportedReasons.includes(reason)) this.session.replayUnsupportedReasons.push(reason);
+	}
+	fail(reason) {
+		if (!this.session) return;
+		this.unsupported(reason);
+		try {
+			this.session.durationMs = this.root.ownerDocument.defaultView.performance.now() - this.startMs;
+		} catch {}
+		this.session.status = "incomplete";
+		this.clearHeldInput();
+		this.detachInputs();
+	}
+	input(event) {
+		if (!this.active || !event.isTrusted) return;
+		try {
+			const target = event.target instanceof this.root.ownerDocument.defaultView.Element ? event.target : this.root;
+			const pointer = event;
+			if (event.type === "pointermove" && pointer.buttons === 0) return;
+			let element = target;
+			let selector = null;
+			while (element && element !== this.root) {
+				for (const attribute of [
+					"data-layout-fragment-id",
+					"data-layout-block-ref",
+					"data-page-index",
+					"data-item",
+					"data-testid",
+					"aria-label"
+				]) {
+					const value = element.getAttribute(attribute);
+					if (value) {
+						selector = `[${attribute}=${JSON.stringify(value)}]`;
+						break;
+					}
+				}
+				if (selector) break;
+				element = element.parentElement;
+			}
+			if (!selector && target !== this.root) {
+				const path = [];
+				element = target;
+				while (element && element !== this.root) {
+					const parent = element.parentElement;
+					if (!parent) break;
+					path.unshift(`:nth-child(${Array.prototype.indexOf.call(parent.children, element) + 1})`);
+					element = parent;
+				}
+				if (element === this.root) selector = `:scope > ${path.join(" > ")}`;
+				element = target;
+			}
+			const modifiers = event;
+			const paintedTarget = { selector };
+			if (event.type.startsWith("pointer") || [
+				"mousedown",
+				"mouseup",
+				"click",
+				"dblclick"
+			].includes(event.type)) {
+				const path = [];
+				let part = element ?? this.root;
+				while (part && part !== this.root) {
+					const parent = part.parentElement;
+					if (!parent) break;
+					path.unshift(`:nth-child(${Array.prototype.indexOf.call(parent.children, part) + 1})`);
+					part = parent;
+				}
+				if (part === this.root && path.length) paintedTarget.domPath = `:scope > ${path.join(" > ")}`;
+				const controls = /* @__PURE__ */ new Set();
+				for (let ancestor = target; ancestor && ancestor !== this.root; ancestor = ancestor.parentElement) {
+					for (const [attribute, field] of [
+						["data-source-node-id", "blockId"],
+						["data-layout-fragment-id", "fragmentId"],
+						["data-layout-block-ref", "layoutBlockRef"],
+						["data-layout-story", "storyId"],
+						["data-page-index", "pageIndex"]
+					]) {
+						const value = ancestor.getAttribute(attribute);
+						if (value && paintedTarget[field] == null) paintedTarget[field] = field === "pageIndex" ? Number(value) : value;
+					}
+					const control = ancestor.getAttribute("data-sdt-id") ?? ancestor.getAttribute("data-sdt-container-id");
+					if (control) controls.add(control);
+					if (ancestor.classList.contains("superdoc-table-fragment") && paintedTarget.tableId == null) paintedTarget.tableId = ancestor.getAttribute("data-layout-block-ref");
+				}
+				paintedTarget.contentControlIds = [...controls];
+				paintedTarget.contextSource = "painted-pointer";
+				if (paintedTarget.fragmentId && paintedTarget.pageIndex != null) paintedTarget.selector = `[data-page-index="${paintedTarget.pageIndex}"] ${selector}`;
+				const scrollAncestors = [];
+				for (let ancestor = target; ancestor; ancestor = ancestor.parentElement) {
+					const style = this.root.ownerDocument.defaultView.getComputedStyle(ancestor);
+					const scrollable = ancestor === this.root || /auto|scroll/.test(`${style.overflowX} ${style.overflowY}`);
+					if (ancestor.scrollLeft || ancestor.scrollTop || scrollable && (ancestor.scrollWidth > ancestor.clientWidth || ancestor.scrollHeight > ancestor.clientHeight)) {
+						const path = [];
+						let part = ancestor;
+						while (part && part !== this.root) {
+							const parent = part.parentElement;
+							if (!parent) break;
+							path.unshift(`:nth-child(${Array.prototype.indexOf.call(parent.children, part) + 1})`);
+							part = parent;
+						}
+						if (part === this.root) scrollAncestors.push({
+							selector: ancestor === this.root ? null : `:scope > ${path.join(" > ")}`,
+							scrollLeft: ancestor.scrollLeft,
+							scrollTop: ancestor.scrollTop
+						});
+					}
+					if (ancestor === this.root) break;
+					if (scrollAncestors.length >= 32) throw new Error("scroll-ancestor-limit");
+				}
+				paintedTarget.scrollAncestors = scrollAncestors;
+			}
+			const data = {
+				target: paintedTarget,
+				inputAtMs: event.timeStamp > this.root.ownerDocument.defaultView.performance.timeOrigin ? event.timeStamp - this.root.ownerDocument.defaultView.performance.timeOrigin : event.timeStamp,
+				altKey: modifiers.altKey,
+				ctrlKey: modifiers.ctrlKey,
+				metaKey: modifiers.metaKey,
+				shiftKey: modifiers.shiftKey
+			};
+			if (event.type === "keydown" || event.type === "keyup") {
+				const key = modifiers.key;
+				if (event.type === "keydown") this.heldKeys.add(key);
+				else this.heldKeys.delete(key);
+				const named = namedKeys.has(key) || /^F(?:[1-9]|1\d|2[0-4])$/.test(key);
+				data.key = !named && !this.session.captureContent ? void 0 : key;
+				data.repeat = modifiers.repeat;
+				data.isComposing = modifiers.isComposing;
+				if (!named && !this.session.captureContent) this.unsupported("content-redacted");
+				if (modifiers.isComposing || key === "Dead" || key === "Process") this.unsupported("ime");
+			} else if (event.type.startsWith("pointer") || [
+				"mousedown",
+				"mouseup",
+				"click",
+				"dblclick"
+			].includes(event.type)) {
+				const rect = (element ?? this.root).getBoundingClientRect();
+				if (event.type === "pointerdown") this.heldButtons.add(pointer.button);
+				if (event.type === "pointerup") this.heldButtons.delete(pointer.button);
+				Object.assign(data, {
+					button: pointer.button,
+					buttons: pointer.buttons,
+					pointerType: pointer.pointerType ?? "mouse",
+					clickCount: pointer.detail,
+					x: pointer.clientX - rect.left,
+					y: pointer.clientY - rect.top
+				});
+				if (pointer.pointerType && pointer.pointerType !== "mouse") this.unsupported("non-mouse-pointer");
+				if (!selector) this.unsupported("unresolved-pointer-target");
+			} else if (event.type === "scroll") {
+				Object.assign(data, {
+					scrollTop: target.scrollTop,
+					scrollLeft: target.scrollLeft
+				});
+				if (target !== this.root && !selector) this.unsupported("unresolved-scroll-target");
+			} else {
+				const input = event;
+				Object.assign(data, {
+					inputType: input.inputType,
+					dataLength: input.data?.length,
+					...this.session.captureContent ? { data: input.data } : {}
+				});
+				if (input.data && !this.session.captureContent) this.unsupported("content-redacted");
+				if ([
+					"paste",
+					"cut",
+					"drop",
+					"dragstart",
+					"compositionstart",
+					"compositionend"
+				].includes(event.type)) this.unsupported(event.type);
+				if (event.type === "beforeinput" && input.inputType !== "insertText" && !input.inputType?.startsWith("delete")) this.unsupported(`beforeinput:${input.inputType}`);
+			}
+			this.observe(`browser:${event.type}`, () => data);
+		} catch {
+			this.fail("capture-failure");
+		}
+	}
+	clearHeldInput() {
+		this.heldKeys.clear();
+		this.heldButtons.clear();
+	}
+	stop() {
+		if (this.active) {
+			if (this.heldKeys.size || this.heldButtons.size) this.unsupported("held-input-at-stop");
+			this.session.durationMs = this.root.ownerDocument.defaultView.performance.now() - this.startMs;
+			this.session.status = "stopped";
+			this.clearHeldInput();
+		}
+		this.detachInputs();
+		return this.snapshot();
+	}
+	snapshot() {
+		if (!this.session) return null;
+		return {
+			...this.session,
+			viewport: { ...this.session.viewport },
+			durationMs: this.active ? this.root.ownerDocument.defaultView.performance.now() - this.startMs : this.session.durationMs,
+			replayUnsupportedReasons: [...this.session.replayUnsupportedReasons],
+			events: this.events.map((event) => JSON.parse(event)),
+			pendingIntentIds: [...this.pendingIntents]
+		};
+	}
+	close() {
+		if (this.active) this.fail("instance-destroyed");
+		this.closed = true;
+		this.detachInputs();
+	}
+};
+//#endregion
 //#region src/internal/diagnostics/interaction-history.ts
+function isWorkflowRecordingEnabled(config) {
+	try {
+		return own(own(own(config, "diagnostics"), "recording"), "enabled") === true;
+	} catch {
+		return false;
+	}
+}
 var recorders = /* @__PURE__ */ new WeakMap();
 var nextSession = 0;
 var fields = [
@@ -105,7 +663,7 @@ function limit(value, fallback, ceiling) {
 	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= ceiling ? value : fallback;
 }
 var InteractionRecorder = class {
-	constructor(config, version) {
+	constructor(config, version, root) {
 		this.version = version;
 		this.sessionId = `interaction-${++nextSession}`;
 		this.slots = [];
@@ -119,6 +677,9 @@ var InteractionRecorder = class {
 		this.failures = 0;
 		this.closed = false;
 		this.cleanups = [];
+		if (isWorkflowRecordingEnabled(config)) try {
+			this.workflow = new WorkflowRecorder(root, version);
+		} catch {}
 		const history = own(own(config, "diagnostics"), "history");
 		this.enabled = own(history, "enabled") !== false;
 		this.captureContent = own(history, "captureContent") === true;
@@ -126,6 +687,7 @@ var InteractionRecorder = class {
 		this.maxBytes = limit(own(history, "maxBytes"), 1048576, 16777216);
 	}
 	record(type, read) {
+		this.workflow?.observe(type, read);
 		if (!this.enabled || this.closed) return;
 		try {
 			let truncated = false;
@@ -202,7 +764,7 @@ var InteractionRecorder = class {
 		}
 	}
 	action() {
-		return this.enabled && !this.closed ? `${this.sessionId}:${++this.actions}` : void 0;
+		return (this.enabled || this.workflow?.active) && !this.closed ? `${this.sessionId}:${++this.actions}` : void 0;
 	}
 	snapshot() {
 		const events = [];
@@ -286,6 +848,7 @@ var InteractionRecorder = class {
 		}
 	}
 	close() {
+		this.workflow?.close();
 		this.closed = true;
 		for (const cleanup of this.cleanups) try {
 			cleanup();
@@ -312,10 +875,11 @@ var unavailable = Object.freeze({
 });
 function createInteractionHistory(owner, config, version, root) {
 	try {
-		const recorder = new InteractionRecorder(config, version);
+		const recorder = new InteractionRecorder(config, version, root);
 		recorders.set(owner, recorder);
 		recorder.attach(root);
 		const handle = Object.freeze({
+			...recorder.workflow ? { recording: recorder.workflow.api } : {},
 			getSnapshot: () => {
 				try {
 					return recorder.snapshot();
@@ -360,6 +924,9 @@ function closeInteractionHistory(owner) {
 		recorders.delete(owner);
 	} catch {}
 }
+function getWorkflowRecording(owner) {
+	return recorders.get(owner)?.workflow?.api;
+}
 //#endregion
 //#region ../layout-engine/dom-contract/src/class-names.ts
 /**
@@ -5684,6 +6251,7 @@ function createSuperDocUI(options) {
 	let asyncReadFailureRetryAtMs = 0;
 	let foregroundAsyncRetryTimer = null;
 	let pendingSelectionSeedValidationToken = null;
+	let typedCaretValidationHeld = false;
 	let typingContentInvalidationTimer = null;
 	const pendingAsyncReadSettlements = [];
 	const scheduleAsyncRefresh = () => {
@@ -6121,6 +6689,16 @@ function createSuperDocUI(options) {
 				scheduleForegroundAsyncRetry();
 				return;
 			}
+			if (typedCaretValidationHeld && Date.now() - lastTypingMutationAtMs < HEAVY_READ_IDLE_MS) {
+				const token = selectionReadToken();
+				if (asyncReads.get("selection")?.token !== token) {
+					refreshSelectionFromHost(void 0, true);
+					if (asyncReads.get("selection")?.token === token) recompute();
+				}
+				scheduleForegroundAsyncRetry(HEAVY_READ_IDLE_POLL_MS);
+				return;
+			}
+			typedCaretValidationHeld = false;
 			const validationToken = pendingSelectionSeedValidationToken;
 			pendingSelectionSeedValidationToken = null;
 			if (validationToken === selectionReadToken()) issueAsyncRead("selection", validationToken, selectionCurrentRun, normalizeSelectionInfo);
@@ -6259,7 +6837,7 @@ function createSuperDocUI(options) {
 				}
 				if (pendingPostPaintSelectionRefresh) continue;
 				selectionEpoch += 1;
-				refreshSelectionFromHost();
+				refreshSelectionFromHost(void 0, true);
 				recompute(paintCompleted ? "post-paint-selection" : "post-paint-selection-failed");
 			}
 		};
@@ -6270,7 +6848,11 @@ function createSuperDocUI(options) {
 		if (typingContentInvalidationTimer) clearTimeout(typingContentInvalidationTimer);
 		typingContentInvalidationTimer = setTimeout(() => {
 			typingContentInvalidationTimer = null;
-			if (!disposed) invalidateDocumentContentAndRecompute();
+			if (!disposed) {
+				invalidateDocumentContent();
+				if (typedCaretValidationHeld && !foregroundMutationActive()) refreshSelectionFromHost(void 0, true);
+				recompute();
+			}
 		}, 500);
 	};
 	const issueAsyncRead = (key, token, run, normalize) => {
@@ -6364,6 +6946,13 @@ function createSuperDocUI(options) {
 			value: entry.value,
 			status: "ready"
 		};
+		if (key === "selection" && typedCaretValidationHeld && Date.now() - lastTypingMutationAtMs < HEAVY_READ_IDLE_MS) {
+			scheduleForegroundAsyncRetry(HEAVY_READ_IDLE_POLL_MS);
+			return {
+				value: entry?.hasSettled ? entry.value : null,
+				status: entry?.hasSettled ? "stale" : "pending"
+			};
+		}
 		if (isHeavyDocReadKey(key) && !heavyReadDemandActive(key, token)) {
 			if (hostSourceLoadPhase() === "loading") {
 				heavyReadsHeldUntilIdle = true;
@@ -6485,6 +7074,7 @@ function createSuperDocUI(options) {
 		heldSettledInlineValues = null;
 		optimisticParagraphAlignment = null;
 		pendingSelectionSeedValidationToken = null;
+		typedCaretValidationHeld = false;
 		coldAsyncReadDeferrals.clear();
 		demandedHeavyReads.clear();
 		incompleteTrackChangesDirectoryReadTokens.clear();
@@ -6666,9 +7256,10 @@ function createSuperDocUI(options) {
 	* same carrier, or while an active typing dispatch advances the same caret by
 	* one code point. Pending work alone never carries review command context.
 	*/
-	const refreshSelectionFromHost = (hostSelectionSnapshot) => {
+	const refreshSelectionFromHost = (hostSelectionSnapshot, afterTypingPaint = false) => {
 		const foreground = foregroundMutationState();
 		if (isNonCollapsedHostSelection(hostSelectionSnapshot) && !(foreground && foreground.active > 0)) {
+			typedCaretValidationHeld = false;
 			pendingSelectionSeedValidationToken = null;
 			issueAsyncRead("selection", selectionReadToken(), selectionCurrentRun, normalizeSelectionInfo);
 			return;
@@ -6678,8 +7269,14 @@ function createSuperDocUI(options) {
 		if (typeof read !== "function") return;
 		const seed = normalizeSelectionInfo(safeCall(() => read.call(host), null));
 		if (!seed || !isCollapsedCaretSnapshot(seed)) return;
+		const previousCaret = collapsedTextAddressFromSelection(state.selection);
+		const nextCaret = collapsedTextAddressFromTarget(seed.selectionTarget) ?? collapsedTextAddressFromTarget(seed.target);
+		const previousRange = previousCaret?.range;
+		const nextRange = nextCaret?.range;
+		const sameSeedCaret = Boolean(previousCaret && nextCaret && previousCaret.blockId === nextCaret.blockId && storyLocatorSignature(previousCaret.story) === storyLocatorSignature(nextCaret.story) && previousRange?.start === nextRange?.start);
+		typedCaretValidationHeld = Boolean(foreground && foreground.active > 0) || typedCaretValidationHeld && (afterTypingPaint || sameSeedCaret);
 		const token = selectionReadToken();
-		const deferAuthoritativeRead = Boolean(foreground && (foreground.active > 0 || foreground.pending > 0));
+		const deferAuthoritativeRead = Boolean(foreground && (foreground.active > 0 || foreground.pending > 0)) || typedCaretValidationHeld && Date.now() - lastTypingMutationAtMs < HEAVY_READ_IDLE_MS;
 		if (!deferAuthoritativeRead) {
 			pendingSelectionSeedValidationToken = null;
 			if (issueAsyncRead("selection", token, selectionCurrentRun, normalizeSelectionInfo)) return;
@@ -6691,10 +7288,6 @@ function createSuperDocUI(options) {
 		const seedMarks = Array.isArray(seed.activeMarks) && seed.activeMarks.length > 0 ? seed.activeMarks : Array.isArray(state.selection.activeMarks) ? state.selection.activeMarks : [];
 		const seedCommentIds = Array.isArray(seed.activeCommentIds) ? seed.activeCommentIds : [];
 		const paintedTrackChangeId = readCollapsedHostTrackChangeId(hostSelectionSnapshot);
-		const previousCaret = collapsedTextAddressFromSelection(state.selection);
-		const nextCaret = collapsedTextAddressFromTarget(seed.selectionTarget) ?? collapsedTextAddressFromTarget(seed.target);
-		const previousRange = previousCaret?.range;
-		const nextRange = nextCaret?.range;
 		const sameActiveTypingCaret = Boolean(foreground && foreground.active > 0 && previousCaret && nextCaret && previousCaret.blockId === nextCaret.blockId && storyLocatorSignature(previousCaret.story) === storyLocatorSignature(nextCaret.story) && typeof previousRange?.start === "number" && typeof nextRange?.start === "number" && Math.abs(nextRange.start - previousRange.start) <= 2);
 		const carriedChangeIds = paintedTrackChangeId != null || sameActiveTypingCaret ? state.selection.activeChangeIds.filter((id) => paintedTrackChangeId == null || buildTrackedChangeIdContext(state.trackChanges.items).aliasesFor(id).includes(paintedTrackChangeId)) : [];
 		const seedChangeIds = Array.isArray(seed.activeChangeIds) && seed.activeChangeIds.length > 0 ? seed.activeChangeIds : carriedChangeIds;
@@ -7661,6 +8254,7 @@ function createSuperDocUI(options) {
 		if (support && (support.status === "supported" || support.enabled === true)) return void 0;
 		return SUPERDOC_UI_REASONS.bulkDecisionsDisabled;
 	};
+	const canStorePendingInlineFormat = (selection) => selection.empty && collapsedTextAddressFromSelection(selection) != null && typeof getHost()?.setPendingInlineFormat === "function";
 	const computeCommandState = (id, doc, selection, projectedInlineValues, lockModesById = /* @__PURE__ */ new Map()) => {
 		if (customCommands.has(id)) return normalizeCommandState({
 			supported: true,
@@ -7815,7 +8409,7 @@ function createSuperDocUI(options) {
 				value,
 				reason: lockReason
 			}, "builtin");
-			return normalizeCommandState(selectionBlockIds(selection).length > 0 && typeof getHost()?.setPendingInlineFormat === "function" ? {
+			return normalizeCommandState(canStorePendingInlineFormat(selection) ? {
 				enabled: true,
 				active,
 				supported: true,
@@ -10467,7 +11061,7 @@ function createSuperDocUI(options) {
 		if (trackDecisionCommand(id)?.scope === "id") return true;
 		if (!descriptor || descriptor.disposition !== "routed") return true;
 		if (descriptor.inline?.kind === "clear") return selectionBlockIds(state.selection).length > 0 || resolveInlineSelectionTarget(state.selection) != null;
-		if (descriptor.inline) return resolveInlineSelectionTarget(state.selection) != null || selectionBlockIds(state.selection).length > 0;
+		if (descriptor.inline) return resolveInlineSelectionTarget(state.selection) != null || canStorePendingInlineFormat(state.selection);
 		if (descriptor.blockParagraph || descriptor.list) return selectionBlockIds(state.selection).length > 0;
 		if (descriptor.link) return linkPayloadHasExplicitTarget(payload) || selectionTextAddresses(state.selection).length > 0 || collapsedTextAddressFromSelection(state.selection) != null || commandActiveState(descriptor, getDoc(), state.selection);
 		return true;
@@ -10533,7 +11127,7 @@ function createSuperDocUI(options) {
 			if (contentControlLockReason(lockModesById)) return false;
 			const target = resolveInlineSelectionTarget(state.selection);
 			if (!target) {
-				if (state.selection.empty === false) return settleCommandExecution(false);
+				if (!canStorePendingInlineFormat(state.selection)) return settleCommandExecution(false);
 				return settleCommandExecution(storePendingInlineFormat(descriptor, normalized));
 			}
 			const active = commandActiveState(descriptor, doc, state.selection);
@@ -13688,6 +14282,18 @@ Object.defineProperty(exports, "getV2TrackedChangeMutationImpact", {
 		return getV2TrackedChangeMutationImpact;
 	}
 });
+Object.defineProperty(exports, "getWorkflowRecording", {
+	enumerable: true,
+	get: function() {
+		return getWorkflowRecording;
+	}
+});
+Object.defineProperty(exports, "isWorkflowRecordingEnabled", {
+	enumerable: true,
+	get: function() {
+		return isWorkflowRecordingEnabled;
+	}
+});
 Object.defineProperty(exports, "readFirstPartyPageNumbers", {
 	enumerable: true,
 	get: function() {