superdoc 2.22.0-next.9 → 2.22.1-next.1

package/dist/chunks/{create-super-doc-ui-DTLJMJIl.cjs → create-super-doc-ui-MSiU8Kg0.cjs}

@@ -3993,6 +3993,65 @@ var INCREMENTAL_DEPENDENCY_CERTIFICATE_CLASSES = Object.freeze([
 ]);
 new Set(INCREMENTAL_DEPENDENCY_CERTIFICATE_CLASSES);
 //#endregion
+//#region ../document-api/src/types/story.types.ts
+/** All recognized story types. */
+var STORY_TYPES = [
+	"body",
+	"headerFooterSlot",
+	"headerFooterPart",
+	"footnote",
+	"endnote",
+	"textbox"
+];
+/** Valid header/footer story kinds. */
+var STORY_HEADER_FOOTER_KINDS = ["header", "footer"];
+/** Valid header/footer slot variants. */
+var STORY_HEADER_FOOTER_VARIANTS = [
+	"default",
+	"first",
+	"even"
+];
+/** Valid header/footer slot resolution modes. */
+var STORY_HEADER_FOOTER_RESOLUTIONS = ["effective", "explicit"];
+/** Valid header/footer slot write modes. */
+var STORY_HEADER_FOOTER_ON_WRITE_VALUES = [
+	"materializeIfInherited",
+	"editResolvedPart",
+	"error"
+];
+/**
+* Type guard: returns `true` if `value` is a valid {@link StoryLocator}.
+*
+* Checks the full discriminated-union shape so malformed partial locators do
+* not leak through validation and fail later with raw property-access errors.
+*/
+function isStoryLocator(value) {
+	if (!isObjectRecord(value) || value.kind !== "story" || !isStringEnumMember(value.storyType, STORY_TYPES)) return false;
+	switch (value.storyType) {
+		case "body": return true;
+		case "headerFooterSlot": return isSectionAddress(value.section) && isStringEnumMember(value.headerFooterKind, STORY_HEADER_FOOTER_KINDS) && isStringEnumMember(value.variant, STORY_HEADER_FOOTER_VARIANTS) && isOptionalStringEnumMember(value.resolution, STORY_HEADER_FOOTER_RESOLUTIONS) && isOptionalStringEnumMember(value.onWrite, STORY_HEADER_FOOTER_ON_WRITE_VALUES);
+		case "headerFooterPart": return isNonEmptyString(value.refId);
+		case "footnote":
+		case "endnote": return isNonEmptyString(value.noteId);
+		case "textbox": return isNonEmptyString(value.textboxId);
+	}
+}
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function isStringEnumMember(value, allowed) {
+	return typeof value === "string" && allowed.includes(value);
+}
+function isOptionalStringEnumMember(value, allowed) {
+	return value === void 0 || isStringEnumMember(value, allowed);
+}
+function isSectionAddress(value) {
+	return isObjectRecord(value) && value.kind === "section" && typeof value.sectionId === "string" && value.sectionId.length > 0;
+}
+//#endregion
 //#region ../document-api/src/format/inline-run-patch.ts
 var schemaBooleanOrNull = () => ({ oneOf: [{ type: "boolean" }, { type: "null" }] });
 var schemaStringOrNull = () => ({ oneOf: [{
@@ -5703,6 +5762,13 @@ function selectionTargetFromTextTarget(target) {
 		...story ? { story } : {}
 	};
 }
+function capturedTableCellTarget(value) {
+	if (!value || typeof value !== "object") return null;
+	const target = value;
+	if (target.kind !== "selection" || target.coordinateSpace !== void 0 && target.coordinateSpace !== "visible" && target.coordinateSpace !== "tracked" || target.story !== void 0 && !isStoryLocator(target.story)) return null;
+	for (const point of [target.start, target.end]) if (!point || point.kind !== "text" || typeof point.blockId !== "string" || point.blockId.length === 0 || !Number.isInteger(point.offset) || point.offset < 0 || point.story !== void 0 && !isStoryLocator(point.story)) return null;
+	return value;
+}
 function selectionTargetForRestore(capture) {
 	if (capture.selectionTarget) return capture.selectionTarget;
 	return selectionTargetFromTextTarget(capture.target);
@@ -7042,11 +7108,11 @@ function createSuperDocUI(options) {
 	};
 	const selectionScopedAsyncReadKeys = (selection) => {
 		const signature = selectionSignature(selection);
-		const effectiveUniformitySignature = selectionEffectiveUniformitySignature(selection);
+		const effectiveUniformityKey = effectiveInlineUniformityCacheKey(selection);
 		return /* @__PURE__ */ new Set([
 			`contentControls:inRange:${signature}`,
 			`query:${signature}`,
-			...effectiveUniformitySignature ? [`effInline:${effectiveUniformitySignature}`] : []
+			...effectiveUniformityKey ? [effectiveUniformityKey] : []
 		]);
 	};
 	const pruneSelectionScopedAsyncReads = (selection) => {
@@ -7940,7 +8006,7 @@ function createSuperDocUI(options) {
 		if (!sawWholeRun) return {};
 		return collapseMarkSets(wholeSets);
 	};
-	const completeProjectedInlineValues = (selection, direct) => {
+	const completeProjectedInlineValues = (selection, direct, effectiveInput = effectiveInlineUniformityInput(selection)) => {
 		if (direct.fontFamily !== void 0 && direct.fontSize !== void 0 && direct.color !== void 0 && direct.highlight !== void 0) return {
 			values: direct,
 			effectiveUniformityStatus: "ready"
@@ -7954,7 +8020,7 @@ function createSuperDocUI(options) {
 			...direct
 		};
 		if (!selection.empty && (combined.fontFamily === void 0 || combined.fontSize === void 0)) {
-			const uniformity = resolveEffectiveInlineUniformityValues(selection);
+			const uniformity = resolveEffectiveInlineUniformityValues(selection, effectiveInput);
 			if (uniformity.values) {
 				if (combined.fontFamily === void 0 && uniformity.values.fontFamily !== void 0) combined.fontFamily = uniformity.values.fontFamily;
 				if (combined.fontSize === void 0 && uniformity.values.fontSize !== void 0) combined.fontSize = uniformity.values.fontSize;
@@ -7984,9 +8050,23 @@ function createSuperDocUI(options) {
 		"underline",
 		"strikethrough"
 	];
-	const readEffectiveInlineUniformityCached = (selection) => {
-		const target = selection.selectionTarget;
-		if (!target) return {
+	function effectiveInlineUniformityInput(selection) {
+		const cellTarget = currentCellSelectionTarget();
+		const target = cellTarget ?? selection.selectionTarget;
+		if (!target) return null;
+		const tableCellSelection = cellTarget ? tableCellSelectionForTarget(cellTarget) : null;
+		return {
+			target,
+			offsetSpace: "selection",
+			...tableCellSelection ? { tableCellSelection } : {}
+		};
+	}
+	function effectiveInlineUniformityCacheKey(selection, input = effectiveInlineUniformityInput(selection)) {
+		if (!input) return null;
+		return `effInline:${input.tableCellSelection ? `${selectionKey({ selectionTarget: input.target })}|cells:${JSON.stringify(input.tableCellSelection)}` : selectionEffectiveUniformitySignature(selection) ?? selectionSignature(selection)}`;
+	}
+	const readEffectiveInlineUniformityCached = (selection, input = effectiveInlineUniformityInput(selection)) => {
+		if (!input) return {
 			value: null,
 			status: "ready"
 		};
@@ -7995,15 +8075,13 @@ function createSuperDocUI(options) {
 			value: null,
 			status: "ready"
 		};
-		const signature = selectionEffectiveUniformitySignature(selection) ?? selectionSignature(selection);
-		return readAsync(`effInline:${signature}`, contentToken(), () => op({
-			target,
-			offsetSpace: "selection",
+		return readAsync(effectiveInlineUniformityCacheKey(selection, input), contentToken(), () => op({
+			...input,
 			keys: EFFECTIVE_INLINE_UNIFORMITY_KEYS
 		}), (raw) => raw && typeof raw === "object" ? raw : null);
 	};
-	const resolveEffectiveInlineUniformityValues = (selection) => {
-		const { value, status } = readEffectiveInlineUniformityCached(selection);
+	const resolveEffectiveInlineUniformityValues = (selection, input = effectiveInlineUniformityInput(selection)) => {
+		const { value, status } = readEffectiveInlineUniformityCached(selection, input);
 		if (!value || value.success !== true) return {
 			values: null,
 			status
@@ -8057,16 +8135,12 @@ function createSuperDocUI(options) {
 		const fromWorker = values?.[key];
 		return fromWorker !== void 0 ? fromWorker : null;
 	};
-	const readEffectiveInlineUniformityNow = async (selection) => {
-		const target = selection.selectionTarget;
-		if (!target) return null;
+	const readEffectiveInlineUniformityNow = async (input) => {
+		if (!input) return null;
 		const op = resolveDocOperation(getDoc(), "format.readEffectiveInlineUniformity");
 		if (!op) return null;
 		try {
-			const raw = await Promise.resolve(op({
-				target,
-				offsetSpace: "selection"
-			}));
+			const raw = await Promise.resolve(op(input));
 			return raw && typeof raw === "object" && raw.success === true ? raw : null;
 		} catch {
 			return null;
@@ -8081,8 +8155,8 @@ function createSuperDocUI(options) {
 			else delete projected[key];
 		}
 	};
-	const projectSelectionInlineValuesWithStatus = (selection) => completeProjectedInlineValues(selection, projectInlineValuesFromQueryItem(resolveSelectionTextQueryItem(selection), selection));
-	const projectSelectionInlineValues = (selection) => projectSelectionInlineValuesWithStatus(selection).values;
+	const projectSelectionInlineValuesWithStatus = (selection, effectiveInput = effectiveInlineUniformityInput(selection)) => completeProjectedInlineValues(selection, projectInlineValuesFromQueryItem(resolveSelectionTextQueryItem(selection), selection), effectiveInput);
+	const projectSelectionInlineValues = (selection, effectiveInput = effectiveInlineUniformityInput(selection)) => projectSelectionInlineValuesWithStatus(selection, effectiveInput).values;
 	/**
 	* Read command-critical inline values for format-painter capture. Reactive
 	* command state intentionally serves stale values while its worker read is
@@ -8091,20 +8165,21 @@ function createSuperDocUI(options) {
 	* without changing the non-blocking toolbar snapshot policy.
 	*/
 	const readFormatPainterInlineValues = async (selection) => {
+		const effectiveInput = effectiveInlineUniformityInput(selection);
 		const query = getDoc()?.query;
 		const request = selectionTextQueryRequest(selection);
-		if (typeof query?.match !== "function" || !request) return projectSelectionInlineValues(selection);
+		if (typeof query?.match !== "function" || !request) return projectSelectionInlineValues(selection, effectiveInput);
 		try {
 			const raw = await Promise.resolve(query.match(request));
 			const direct = projectInlineValuesFromQueryItem(pickSelectionTextQueryItem(raw && typeof raw === "object" ? raw : null, selection), selection);
-			const completed = completeProjectedInlineValues(selection, direct);
+			const completed = completeProjectedInlineValues(selection, direct, effectiveInput);
 			if (completed.effectiveUniformityStatus !== "ready" && (direct.fontFamily === void 0 || direct.fontSize === void 0)) {
-				const effective = await readEffectiveInlineUniformityNow(selection);
+				const effective = await readEffectiveInlineUniformityNow(effectiveInput);
 				if (effective) applyEffectiveInlineUniformity(completed.values, direct, effective);
 			}
 			return completed.values;
 		} catch {
-			return projectSelectionInlineValues(selection);
+			return projectSelectionInlineValues(selection, effectiveInput);
 		}
 	};
 	const readBlockNode = async (address) => {
@@ -8347,7 +8422,7 @@ function createSuperDocUI(options) {
 				supported: true,
 				reason: lockReason
 			}, "builtin");
-			const enabled = selectionBlockIds(selection).length > 0 || resolveInlineSelectionTarget(selection) != null;
+			const enabled = selectionBlockIds(selection).length > 0 || resolveInlineCommandTarget(selection) != null;
 			return normalizeCommandState({
 				enabled,
 				active: false,
@@ -8401,7 +8476,7 @@ function createSuperDocUI(options) {
 			value,
 			reason: SUPERDOC_UI_REASONS.documentReadonly
 		}, "builtin");
-		if (descriptor.inline && !resolveInlineSelectionTarget(selection)) {
+		if (descriptor.inline && !resolveInlineCommandTarget(selection)) {
 			const lockReason = contentControlLockReason(lockModesById);
 			if (lockReason) return normalizeCommandState({
 				enabled: false,
@@ -10356,9 +10431,32 @@ function createSuperDocUI(options) {
 	* option is not part of public `MutationOptions`; this is the same cast
 	* pattern the delete/replace callers use.
 	*/
-	const callInlineFormatMutation = (route, op, input, selection = state.selection) => {
+	function currentCellSelectionTarget() {
+		const handles = safeCall(() => getHost()?.getHandles?.(), null);
+		if (!(handles?.selection?.getSnapshot?.())?.tableCells) return null;
+		const resolved = handles?.selection?.toSelectionTarget?.();
+		return resolved?.kind === "ok" && resolved.mode === "range" ? capturedTableCellTarget(resolved.target) : null;
+	}
+	function resolveInlineCommandTarget(selection) {
+		return currentCellSelectionTarget() ?? resolveInlineSelectionTarget(selection);
+	}
+	function tableCellSelectionForTarget(target) {
+		const cellTarget = currentCellSelectionTarget();
+		const candidate = target;
+		if (!cellTarget || candidate?.start?.blockId !== cellTarget.start.blockId || candidate?.end?.blockId !== cellTarget.end.blockId || candidate?.start?.offset !== cellTarget.start.offset || candidate?.end?.offset !== cellTarget.end.offset) return null;
+		return {
+			anchorBlockId: cellTarget.start.blockId,
+			focusBlockId: cellTarget.end.blockId
+		};
+	}
+	const callInlineFormatMutation = (route, op, input, selection = state.selection, tableCellSelection = tableCellSelectionForTarget(input?.target)) => {
 		const options = editorMutationOptionsForRoute(route);
 		if (options && options.success === false) return options;
+		if (tableCellSelection) return op(input, {
+			...options,
+			offsetSpace: "selection",
+			tableCellSelection
+		});
 		if (!selection.selectionTarget) return options ? op(input, options) : op(input);
 		return op(input, {
 			...options,
@@ -10464,7 +10562,7 @@ function createSuperDocUI(options) {
 			}
 		};
 		const defaultStyleId = getStyleCatalog().cache?.full.defaults.paragraphStyleId ?? DEFAULT_PARAGRAPH_STYLE_ID;
-		const rangeTarget = resolveInlineSelectionTarget(state.selection);
+		const rangeTarget = resolveInlineCommandTarget(state.selection);
 		if (rangeTarget) {
 			const inlineOp = resolveDocOperation(doc, "format.apply");
 			if (inlineOp) try {
@@ -11061,8 +11159,8 @@ function createSuperDocUI(options) {
 		if (state.selection.status !== "ready") return false;
 		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 || canStorePendingInlineFormat(state.selection);
+		if (descriptor.inline?.kind === "clear") return selectionBlockIds(state.selection).length > 0 || resolveInlineCommandTarget(state.selection) != null;
+		if (descriptor.inline) return resolveInlineCommandTarget(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;
@@ -11126,7 +11224,7 @@ function createSuperDocUI(options) {
 		if (descriptor.inline) {
 			const { lockModesById } = computeActiveContentControlLockModes(doc?.contentControls, state.selection);
 			if (contentControlLockReason(lockModesById)) return false;
-			const target = resolveInlineSelectionTarget(state.selection);
+			const target = resolveInlineCommandTarget(state.selection);
 			if (!target) {
 				if (!canStorePendingInlineFormat(state.selection)) return settleCommandExecution(false);
 				return settleCommandExecution(storePendingInlineFormat(descriptor, normalized));
@@ -11134,6 +11232,8 @@ function createSuperDocUI(options) {
 			const active = commandActiveState(descriptor, doc, state.selection);
 			const input = buildInlineFormatInput(descriptor.inline, target, normalized, active);
 			if (!input) return false;
+			const commandSelection = state.selection;
+			const tableCellSelection = tableCellSelectionForTarget(target);
 			let releaseScheduledMutation = null;
 			try {
 				const commandEditor = getEditor();
@@ -11141,7 +11241,7 @@ function createSuperDocUI(options) {
 				const commandMode = readDocumentMode();
 				const mutate = () => {
 					if (getEditor() !== commandEditor || commandEditor?.doc !== commandDocSource || readDocumentMode() !== commandMode) return false;
-					return callInlineFormatMutation(route, op, input);
+					return callInlineFormatMutation(route, op, input, commandSelection, tableCellSelection);
 				};
 				const selectionSignature = selectionInlineValueSignature(state.selection) ?? selectionKey(state.selection);
 				const scheduledMutation = descriptor.inline.kind === "toggle" ? scheduleInlineToggleMutation(`${descriptor.id}:${selectionSignature}`, mutate) : null;
@@ -11452,34 +11552,42 @@ function createSuperDocUI(options) {
 		if (painter.pointerSelecting || painter.keyboardSelecting) return;
 		const selectionApi = getDoc()?.selection;
 		const readSelection = async () => {
+			const cellTarget = currentCellSelectionTarget();
+			const tableCellSelection = tableCellSelectionForTarget(cellTarget);
 			const rawSelection = typeof selectionApi?.["current"] === "function" ? await Promise.resolve(selectionApi["current"]({ includeText: true })) : readSelectionInfoLive().value;
-			return normalizeSelectionInfo(rawSelection);
+			return {
+				selection: normalizeSelectionInfo(rawSelection),
+				cellTarget,
+				tableCellSelection
+			};
 		};
 		const waitForSelectionSettle = () => new Promise((resolve) => setTimeout(resolve, 16));
 		const MAX_SELECTION_ATTEMPTS = 8;
-		let sel = null;
+		let selectionRead = null;
 		let key = "";
 		for (let attempt = 0; attempt < MAX_SELECTION_ATTEMPTS; attempt += 1) {
 			if (attempt > 0) await waitForSelectionSettle();
 			if (painter.mode === "idle" || painter.pointerSelecting || painter.keyboardSelecting) return;
-			sel = await readSelection();
+			selectionRead = await readSelection();
+			const sel = selectionRead.selection;
 			if (!sel || sel["empty"]) continue;
 			key = selectionKey(sel);
 			if (key === painter.sourceSelectionKey) continue;
 			break;
 		}
-		if (sel && !sel["empty"] && key !== painter.sourceSelectionKey) {
-			await applyFormatPainter(sel);
+		if (selectionRead?.selection && !selectionRead.selection["empty"] && key !== painter.sourceSelectionKey) {
+			await applyFormatPainter(selectionRead.selection, selectionRead.cellTarget, selectionRead.tableCellSelection);
 			return;
 		}
 		if (painter.snapshot?.paragraph) {
-			const caretSel = await readSelection();
+			const caretRead = await readSelection();
+			const caretSel = caretRead.selection;
 			if (!caretSel) return;
 			if (selectionKey(caretSel) === painter.sourceSelectionKey) return;
-			await applyFormatPainter(caretSel);
+			await applyFormatPainter(caretSel, caretRead.cellTarget, caretRead.tableCellSelection);
 		}
 	};
-	const applyFormatPainter = async (selection) => {
+	const applyFormatPainter = async (selection, cellTarget, tableCellSelection) => {
 		const snap = painter.snapshot;
 		if (!snap) {
 			if (painter.mode === "armed") exitFormatPainter();
@@ -11494,14 +11602,14 @@ function createSuperDocUI(options) {
 			return;
 		}
 		const selTarget = selection["target"];
-		const selectionTarget = selection["selectionTarget"];
+		const selectionTarget = cellTarget ?? selection.selectionTarget;
 		if (!(selection["empty"] === true) && Object.keys(snap.inline).length > 0) {
 			const inlineOp = resolveDocOperation(doc, "format.apply");
 			if (inlineOp && selectionTarget) try {
 				if (!commandResultSucceeded(commandResultFromOperationResult(await Promise.resolve(callInlineFormatMutation("format.apply", inlineOp, {
 					target: selectionTarget,
 					inline: snap.inline
-				}, selection))))) {
+				}, selection, tableCellSelection))))) {
 					recompute();
 					return;
 				}
@@ -11690,10 +11798,13 @@ function createSuperDocUI(options) {
 		current: () => readSelectionInfoLive().value,
 		capture: () => {
 			const snapshot = selectionSub.get();
-			if (snapshot.empty || !snapshot.target && !snapshot.selectionTarget) return null;
+			if (snapshot.empty) return null;
+			const cells = currentCellSelectionTarget();
+			if (!snapshot.target && !snapshot.selectionTarget && !cells) return null;
 			return {
 				...snapshot,
-				capturedAt: Date.now()
+				capturedAt: Date.now(),
+				...cells ? { _tableCellSelectionTarget: cells } : {}
 			};
 		},
 		restore: (capture) => {
@@ -11712,7 +11823,13 @@ function createSuperDocUI(options) {
 				ok: false,
 				reason: SUPERDOC_UI_REASONS.notReady
 			});
-			const target = selectionTargetForRestore(capture);
+			const hasCellTarget = "_tableCellSelectionTarget" in capture;
+			const cellTarget = hasCellTarget ? capturedTableCellTarget(capture._tableCellSelectionTarget) : null;
+			if (hasCellTarget && !cellTarget) return done({
+				ok: false,
+				reason: SUPERDOC_UI_REASONS.targetUnresolved
+			});
+			const target = cellTarget ?? selectionTargetForRestore(capture);
 			if (!target) return done({
 				ok: false,
 				reason: SUPERDOC_UI_REASONS.targetUnresolved
@@ -11723,7 +11840,7 @@ function createSuperDocUI(options) {
 				reason: resolved.reason
 			});
 			try {
-				return done(normalizeHostSelectionApplyResult(resolved.helper.apply(target)));
+				return done(normalizeHostSelectionApplyResult(cellTarget ? resolved.helper.apply(target, { tableCells: true }) : resolved.helper.apply(target)));
 			} catch {
 				return done({
 					ok: false,

package/dist/collaboration-upgrade-engine.cjs

@@ -19,7 +19,7 @@ var COLLABORATION_UPGRADE_ENGINE_MINIMUM_NODE_MAJOR = 20;
 var PRIVATE_ENGINE_INFO = (0, _superdoc_docx_engine_collaboration_upgrade_engine.getCollaborationUpgradeEngineInfo)();
 var ENGINE_INFO = Object.freeze({
 	...PRIVATE_ENGINE_INFO,
-	superdocVersion: "2.22.0-next.9",
+	superdocVersion: "2.22.1-next.1",
 	roomSchemaVersion: Object.freeze({ ...PRIVATE_ENGINE_INFO.roomSchemaVersion }),
 	supportedBundleVersions: SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS,
 	supportedV1ReaderContractVersions: SUPPORTED_V1_READER_CONTRACT_VERSIONS

package/dist/collaboration-upgrade-engine.es.js

@@ -18,7 +18,7 @@ var COLLABORATION_UPGRADE_ENGINE_MINIMUM_NODE_MAJOR = 20;
 var PRIVATE_ENGINE_INFO = getCollaborationUpgradeEngineInfo$1();
 var ENGINE_INFO = Object.freeze({
 	...PRIVATE_ENGINE_INFO,
-	superdocVersion: "2.22.0-next.9",
+	superdocVersion: "2.22.1-next.1",
 	roomSchemaVersion: Object.freeze({ ...PRIVATE_ENGINE_INFO.roomSchemaVersion }),
 	supportedBundleVersions: SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS,
 	supportedV1ReaderContractVersions: SUPPORTED_V1_READER_CONTRACT_VERSIONS

package/dist/document-api/src/content-controls/content-controls.types.d.ts

@@ -247,6 +247,8 @@ export interface ContentControlsUnwrapInput {
 }
 export interface ContentControlsDeleteInput {
     target: ContentControlTarget;
+    /** Override only this target's deletion lock; document and ancestor protection still apply. */
+    overrideDeletionLock?: boolean;
 }
 export interface ContentControlsCopyInput {
     target: ContentControlTarget;

package/dist/document-api/src/contract/operation-definitions.d.ts

@@ -2283,8 +2283,8 @@ export declare const OPERATION_DEFINITIONS: {
     };
     readonly 'contentControls.delete': {
         readonly memberPath: "contentControls.delete";
-        readonly description: "Delete a content control and its content from the document.";
-        readonly expectedResult: "Returns a ContentControlMutationResult; reports NO_OP if already removed.";
+        readonly description: "Delete a content control and its content. Set overrideDeletionLock to remove a deletion-locked target without first unlocking it.";
+        readonly expectedResult: "Returns a ContentControlMutationResult; reports NO_OP if already removed. An explicit override deletes in one history entry; Undo restores the original control and lock.";
         readonly requiresDocumentContext: true;
         readonly metadata: CommandStaticMetadata;
         readonly referenceDocPath: "content-controls/delete.mdx";

package/dist/layout-engine/contracts/src/index.d.ts

@@ -840,6 +840,8 @@ export declare const isExplicitNoneBorder: (border?: unknown) => boolean;
  */
 export declare const resolveBorderConflict: (first?: BorderSpec, second?: BorderSpec) => BorderSpec | undefined;
 export type TableCellAttrs = {
+    /** Resolved ordinary Latin text rotation from w:tcPr/w:textDirection. */
+    textDirection?: 'btLr' | 'tbRl';
     borders?: CellBorders;
     padding?: BoxSpacing;
     verticalAlign?: 'top' | 'middle' | 'center' | 'bottom';
@@ -891,6 +893,8 @@ export type TableCell = {
     attrs?: TableCellAttrs;
     sourceAnchor?: SourceAnchor;
 };
+/** Read the resolved cell axis, with compatibility for older raw carriers. */
+export declare function getTableCellTextDirection(attrs: TableCellAttrs | undefined): 'btLr' | 'tbRl' | undefined;
 export type TableRowProperties = {
     repeatHeader?: boolean;
     cantSplit?: boolean;
@@ -1671,13 +1675,9 @@ export declare function allExplicitColumnWidthsEqual(widths: readonly number[]):
 /**
  * Shared "genuinely unequal explicit column widths" predicate (SD-2324).
  *
- * The layout engine skips end-of-section column balancing exactly when this
- * is true: Word fills genuinely-unequal explicit columns column-by-column
- * rather than rebalancing them. Host retained-layout dependency scanning
- * (SD-3772) consumes the same predicate so checkpoint admission can never
- * drift from the engine's balancing semantics. Explicit widths that are all
- * EQUAL (`equalWidth="0"` with every `<w:col w:w>` equal) still balance like
- * implicit equal columns and are NOT genuinely unequal.
+ * Unequal geometry requires width-aware paragraph reflow during balancing;
+ * equal explicit widths can use the same fixed-line balancing as implicit
+ * equal columns. This predicate describes geometry, not balancing eligibility.
  */
 export declare function hasGenuinelyUnequalExplicitColumnWidths(columns: {
     equalWidth?: boolean | undefined;
@@ -2067,6 +2067,8 @@ export type ParagraphAttrs = {
      * See `@superdoc/contracts/direction-context` for axis semantics.
      */
     directionContext?: ParagraphDirectionContext;
+    /** Authored paragraph writing-mode override; kept distinct from inherited cell rotation. */
+    textDirection?: string;
     isTocEntry?: boolean;
     tocInstruction?: string;
     /** Stable id shared by every paragraph in the same TOC (docPartObj uniqueId or parent sdBlockId). */
@@ -2258,6 +2260,8 @@ export type Line = {
     justificationPlan?: LineJustificationPlan;
     /** True when this line used author-defined OOXML tab stops, not synthesized default stops. */
     hasExplicitTabStops?: boolean;
+    /** A single first-line start tab ends at the hanging indent, leaving body text justifiable. */
+    justifyAfterHangingTab?: boolean;
     segments?: LineSegment[];
     leaders?: LeaderDecoration[];
     bars?: BarDecoration[];
@@ -2411,6 +2415,12 @@ export type TableCellMeasure = {
     paragraph?: ParagraphMeasure;
     width: number;
     height: number;
+    /** Resolved whole-cell rotated flow; dimensions exclude physical padding/borders. */
+    verticalText?: {
+        direction: 'btLr' | 'tbRl';
+        inlineSize: number;
+        blockSize: number;
+    };
     /** Starting grid column index (0-based) */
     gridColumnStart?: number;
     /** Number of grid columns this cell spans */

package/dist/layout-engine/contracts/src/justify-utils.d.ts

@@ -20,6 +20,8 @@ export type ShouldApplyJustifyParams = {
     hasExplicitPositioning?: boolean;
     /** Whether the line used author-defined OOXML tab stops. */
     hasExplicitTabStops?: boolean;
+    /** Whether a single start tab only separates a hanging prefix from the body. */
+    justifyAfterHangingTab?: boolean;
     /** Whether this is the last line of the paragraph. */
     isLastLineOfParagraph: boolean;
     /** Whether the paragraph ends with a soft break (Shift+Enter / LineBreak run). */
@@ -33,13 +35,14 @@ export type ShouldApplyJustifyParams = {
  * Justify is applied when ALL of the following are true:
  * - Alignment is 'justify'
  * - No explicit skip override
- * - Line doesn't have author-defined tab stops
+ * - Line has no column-aligned tab stops
  * - Line is NOT the last line, OR paragraph ends with a soft break
  *
  * This matches Microsoft Word's behavior:
  * - All lines are justified except the true last line
  * - Soft breaks (Shift+Enter) do NOT count as "last line"
- * - Explicit tab-aligned text is never justified
+ * - Explicit column-aligned text is never justified
+ * - A single start tab at the hanging indent leaves body text justifiable
  * - Default/manual tab-aligned text can still be justified
  *
  * @param params - Parameters for justify decision

package/dist/layout-engine/layout-bridge/src/incrementalLayout.d.ts

@@ -1,6 +1,6 @@
 import { NonFlowingPageRelativeAnchorDependencyProof, PageCheckpointDependencyClass, FlowBlock, Layout, LayoutBlockResumeCheckpoint, Measure, Page, HeaderFooterLayout, ColumnLayout } from '../../contracts/src/index.js';
 import { FontMeasureCapabilities, FontMeasureContext } from '../../../shared/font-system/src/index.js';
-import { LayoutOptions, HeaderFooterConstraints, LayoutExecutionCheckpoint } from '../../layout-engine/src/index.js';
+import { LayoutContinuationResume, LayoutOptions, HeaderFooterConstraints, LayoutExecutionCheckpoint } from '../../layout-engine/src/index.js';
 import { computeDirtyRegions } from './diff.js';
 import { MeasureCache } from './cache.js';
 import { HeaderFooterBatch } from './layoutHeaderFooter.js';
@@ -127,8 +127,28 @@ export type IncrementalLayoutResult = {
      * and `pageTokenTotalMs` includes token remeasure/relayout details.
      */
     bridgeTiming: IncrementalLayoutBridgeTiming;
+    progressive?: {
+        status: 'pending';
+        completedPageRange: {
+            startPageIndex: number;
+            endPageIndexExclusive: number;
+        };
+        completedRanges: readonly {
+            startOrdinal: number;
+            endOrdinalExclusive: number;
+        }[];
+        resume: LayoutContinuationResume;
+        continuation: IncrementalLayoutContinuation;
+        pageCountFieldsExact: false;
+    };
+    progressiveFallbackReason?: string;
+};
+export type IncrementalLayoutContinuation = {
+    advance(execution?: IncrementalLayoutExecutionControl): Promise<IncrementalLayoutResult>;
+    dispose(): void;
 };
 export type IncrementalLayoutBridgeTiming = {
+    paginationPreparationRejection?: string;
     /** Content-free reason a document used the conservative note fallback. */
     footnoteCoupledRejection?: string;
     totalMs: number;
@@ -184,6 +204,7 @@ export type IncrementalLayoutBridgeTiming = {
         pagesPaginated: number | null;
         pagesSplicedByReuse: number;
         paginationPasses: number;
+        paginationPreparationReuses?: number;
         pageTokenRelayouts: number;
         headerFooterPreLayoutReuses: number;
         headerFooterPreLayoutBodyBlocksEnumerated: number;
@@ -351,8 +372,7 @@ export type IncrementalPaginationProof = IncrementalPaginationProofBase & ({
         predecessorBlockId: string | null;
     };
     /**
-     * SD-3772 D1: true means the host proved (via the shared
-     * `hasGenuinelyUnequalExplicitColumnWidths` predicate) that no
+     * SD-3772 D1: true means the host proved that no
      * potentially balanceable multi-column section exists anywhere in the
      * retained document. Balancing is a post-pagination finalizer that a
      * mid-section checkpoint cannot seed. False is admissible only
@@ -513,8 +533,14 @@ export interface IncrementalLayoutExecutionControl {
     yieldEveryBlocks?: number;
     /** Time-aware mounted probe. Null is the allocation-free under-budget path. */
     checkpointIfDue?: (checkpoint?: LayoutExecutionCheckpoint) => Promise<void> | null;
+    progressive?: {
+        firstBatchPageCount?: number;
+        restartBeforeBlockIndex?: number;
+        restartBeforePageIndex?: number;
+    };
 }
-export declare function incrementalLayout(previousBlocks: FlowBlock[], _previousLayout: Layout | null, nextBlocks: FlowBlock[], options: LayoutOptions, measureBlock: (block: FlowBlock, constraints: {
+export declare function incrementalLayout(...args: Parameters<typeof incrementalLayoutComplete>): Promise<IncrementalLayoutResult>;
+declare function incrementalLayoutComplete(previousBlocks: FlowBlock[], _previousLayout: Layout | null, nextBlocks: FlowBlock[], options: LayoutOptions, measureBlock: (block: FlowBlock, constraints: {
     maxWidth: number;
     maxHeight: number;
 }) => Promise<Measure>, headerFooter?: {

package/dist/layout-engine/layout-bridge/src/index.d.ts

@@ -4,9 +4,9 @@ export type { HeaderFooterType } from '../../contracts/src/index.js';
 export { selectHeaderFooterVariantForPage, resolveEffectiveHeaderFooterRef, type HeaderFooterKind, type HeaderFooterVariant, type HeaderFooterSectionRefs, type HeaderFooterResolutionSection, type HeaderFooterVariantSelectionInput, type HeaderFooterEffectiveRefInput, type HeaderFooterEffectiveRefResult, } from '../../contracts/src/index.js';
 export { extractIdentifierFromConverter, getHeaderFooterType, defaultHeaderFooterIdentifier, resolveHeaderFooterForPage, buildMultiSectionIdentifier, defaultMultiSectionIdentifier, getHeaderFooterTypeForSection, getHeaderFooterIdForPage, resolveHeaderFooterForPageAndSection, } from './headerFooterUtils.js';
 export type { HeaderFooterIdentifier, MultiSectionHeaderFooterIdentifier, SectionHeaderFooterIds, } from './headerFooterUtils.js';
-export { layoutHeaderFooterWithCache, invalidateHeaderFooterMeasureCache, type HeaderFooterBatchResult, getBucketForPageNumber, getBucketRepresentative, } from './layoutHeaderFooter.js';
+export { layoutHeaderFooterWithCache, createRetainedHeaderFooterPageReader, invalidateHeaderFooterMeasureCache, type HeaderFooterBatchResult, getBucketForPageNumber, getBucketRepresentative, } from './layoutHeaderFooter.js';
 export type { HeaderFooterBatch, DigitBucket } from './layoutHeaderFooter.js';
-export { resolveHeaderFooterTokens, PROVISIONAL_PAGE_COUNT_PLACEHOLDER, type ResolveHeaderFooterTokensOptions, } from './resolveHeaderFooterTokens.js';
+export { resolveHeaderFooterTokens, cloneHeaderFooterBlocks, PROVISIONAL_PAGE_COUNT_PLACEHOLDER, type ResolveHeaderFooterTokensOptions, } from './resolveHeaderFooterTokens.js';
 export { buildPageStyleReferenceResolver, flowBlocksContainCrossReferenceMetadata, type PageStyleReferenceResolver, } from './resolveLiveCrossReferences.js';
 export { findWordBoundaries, findParagraphBoundaries } from './text-boundaries.js';
 export type { BoundaryRange } from './text-boundaries.js';
@@ -14,7 +14,7 @@ export { buildSectionAwareHeaderFooterLayoutKey, buildSectionContentWidth, build
 export type { HeaderFooterSectionKind, HeaderFooterRefs, SectionAwareHeaderFooterMeasurementGroup, } from './sectionAwareHeaderFooter.js';
 export { clearIncrementalModuleState, incrementalLayout, measureCache, normalizeMargin } from './incrementalLayout.js';
 export { hashMeasureContent } from './cache.js';
-export type { HeaderFooterLayoutResult, HeaderFooterGeometrySeed, IncrementalLayoutBridgeTiming, IncrementalLayoutResult, IncrementalLayoutExecutionControl, IncrementalMeasureReuseProof, IncrementalLayoutReuseOptions, IncrementalLayoutReuseSummary, IncrementalSectionPageNumberTransform, IncrementalLayoutTailAdoption, IncrementalLayoutTailDisposition, IncrementalPaginationProof, LayoutPositionTransform, FootnoteReserveSeed, } from './incrementalLayout.js';
+export type { HeaderFooterLayoutResult, HeaderFooterGeometrySeed, IncrementalLayoutBridgeTiming, IncrementalLayoutResult, IncrementalLayoutExecutionControl, IncrementalLayoutContinuation, IncrementalMeasureReuseProof, IncrementalLayoutReuseOptions, IncrementalLayoutReuseSummary, IncrementalSectionPageNumberTransform, IncrementalLayoutTailAdoption, IncrementalLayoutTailDisposition, IncrementalPaginationProof, LayoutPositionTransform, FootnoteReserveSeed, } from './incrementalLayout.js';
 export { collectFootnoteLedgers, getPreferredReserveCandidates, getPreferredReserveTrialTargets, isMandatoryOnlyFootnotePage, scoreFootnoteWindow, summarizeFootnoteWindow, } from './footnote-scorer.js';
 export type { FootnotePreferredReserveCandidate, FootnoteWindowScoreInput, FootnoteWindowScoreReason, FootnoteWindowScoreResult, FootnoteWindowStats, } from './footnote-scorer.js';
 export { computeDisplayPageNumber } from '../../layout-engine/src/index.js';