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

package/dist/chunks/{create-super-doc-ui-B4_V1haj.es.js → create-super-doc-ui-0CZTlOvl.es.js}

@@ -1,5 +1,563 @@
 import { $ as watch, D as normalizeClass, E as nextTick, F as openBlock, H as shallowRef, L as ref, N as onMounted, R as renderList, U as toDisplayString, a as computed, c as createCommentVNode, f as createTextVNode, h as defineComponent, j as onBeforeUnmount, l as createElementBlock, n as Fragment, q as unref, rt as withModifiers, t as _plugin_vue_export_helper_default, u as createElementVNode } from "./_plugin-vue_export-helper-DHiJKCsy.es.js";
+//#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
 /**
@@ -5683,6 +6250,7 @@ function createSuperDocUI(options) {
 	let asyncReadFailureRetryAtMs = 0;
 	let foregroundAsyncRetryTimer = null;
 	let pendingSelectionSeedValidationToken = null;
+	let typedCaretValidationHeld = false;
 	let typingContentInvalidationTimer = null;
 	const pendingAsyncReadSettlements = [];
 	const scheduleAsyncRefresh = () => {
@@ -6120,6 +6688,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);
@@ -6258,7 +6836,7 @@ function createSuperDocUI(options) {
 				}
 				if (pendingPostPaintSelectionRefresh) continue;
 				selectionEpoch += 1;
-				refreshSelectionFromHost();
+				refreshSelectionFromHost(void 0, true);
 				recompute(paintCompleted ? "post-paint-selection" : "post-paint-selection-failed");
 			}
 		};
@@ -6269,7 +6847,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) => {
@@ -6363,6 +6945,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;
@@ -6484,6 +7073,7 @@ function createSuperDocUI(options) {
 		heldSettledInlineValues = null;
 		optimisticParagraphAlignment = null;
 		pendingSelectionSeedValidationToken = null;
+		typedCaretValidationHeld = false;
 		coldAsyncReadDeferrals.clear();
 		demandedHeavyReads.clear();
 		incompleteTrackChangesDirectoryReadTokens.clear();
@@ -6665,9 +7255,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;
@@ -6677,8 +7268,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;
@@ -6690,10 +7287,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;
@@ -7660,6 +8253,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,
@@ -7814,7 +8408,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,
@@ -10466,7 +11060,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;
@@ -10532,7 +11126,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);
@@ -13633,4 +14227,4 @@ function commandIsActive(descriptor, selection) {
 	return descriptor.activeMark ? selection.activeMarks.includes(descriptor.activeMark) : false;
 }
 //#endregion
-export { BUILT_IN_COMMAND_IDS as a, createImageFilePicker as c, DOM_CLASS_NAMES as d, closeInteractionHistory as f, registerFirstPartyCommandMutation as i, resolveImageSrc as l, recordInteraction as m, executeFirstPartyCommandAsync as n, applyV2CommentInvalidationFromMutation as o, createInteractionHistory as p, readFirstPartyPageNumbers as r, getV2TrackedChangeMutationImpact as s, createSuperDocUI as t, shallowEqual as u };
+export { BUILT_IN_COMMAND_IDS as a, createImageFilePicker as c, DOM_CLASS_NAMES as d, closeInteractionHistory as f, recordInteraction as g, isWorkflowRecordingEnabled as h, registerFirstPartyCommandMutation as i, resolveImageSrc as l, getWorkflowRecording as m, executeFirstPartyCommandAsync as n, applyV2CommentInvalidationFromMutation as o, createInteractionHistory as p, readFirstPartyPageNumbers as r, getV2TrackedChangeMutationImpact as s, createSuperDocUI as t, shallowEqual as u };