superdoc 2.24.0-next.1 → 2.24.0-next.3

package/dist/chunks/{create-super-doc-ui-D_FbXpOQ.cjs → create-super-doc-ui-bTFGKVRb.cjs}

@@ -5939,6 +5939,7 @@ function buildTableCommandInput(action, context) {
 		};
 		case "delete-table": return { nodeId };
 		case "merge-cells": {
+			if (!context.canMerge) return null;
 			const range = mergeRange ?? {
 				start: {
 					rowIndex,
@@ -6074,6 +6075,18 @@ function createSuperDocUI(options) {
 		const host = getEditor()?.host;
 		return host && typeof host === "object" ? host : null;
 	};
+	/**
+	* The host selection snapshot a selection read, slice, or capture was
+	* resolved from. The host replaces its snapshot object on every selection
+	* change, so an identical object means the selection has not moved since.
+	*/
+	const selectionHostSnapshots = /* @__PURE__ */ new WeakMap();
+	const readHostSelectionSnapshot = () => {
+		const selectionHandle = (safeCall(() => getHost()?.getHandles?.() ?? null, null)?.editing)?.selection;
+		if (typeof selectionHandle?.getSnapshot !== "function") return null;
+		const snapshot = safeCall(() => selectionHandle.getSnapshot(), null);
+		return snapshot && typeof snapshot === "object" ? snapshot : null;
+	};
 	const createFirstPartyCommandDoc = () => {
 		const editor = getEditor();
 		const doc = editor?.doc;
@@ -6245,7 +6258,7 @@ function createSuperDocUI(options) {
 	};
 	const resolveTableContext = () => {
 		const snapshot = readHostTableContext();
-		if (!snapshot || snapshot.inTable !== true) return null;
+		if (!snapshot || snapshot.inTable !== true || snapshot.status && snapshot.status !== "ready") return null;
 		const table = snapshot.table;
 		const tableNodeId = typeof table?.nodeId === "string" && table.nodeId.length > 0 ? table.nodeId : null;
 		if (!tableNodeId) return null;
@@ -6257,12 +6270,15 @@ function createSuperDocUI(options) {
 		if (rowIndex == null || columnIndex == null) return null;
 		const cellNodeId = typeof cell?.nodeId === "string" && cell.nodeId.length > 0 ? cell.nodeId : null;
 		const range = snapshot.cellRange;
+		const mergeRange = readMergeRange(range);
+		const metadata = snapshot.tableSelection;
 		return {
 			tableNodeId,
 			rowIndex,
 			columnIndex,
 			cellNodeId,
-			mergeRange: readMergeRange(range)
+			mergeRange,
+			canMerge: metadata == null || metadata.selectionMode === "cells" && metadata.isRectangular === true
 		};
 	};
 	const customCommands = /* @__PURE__ */ new Map();
@@ -7278,12 +7294,21 @@ function createSuperDocUI(options) {
 			...EMPTY_SELECTION,
 			status
 		};
+		const slice = buildSelectionSlice(info, status);
+		const hostSelection = selectionHostSnapshots.get(info);
+		if (hostSelection) selectionHostSnapshots.set(slice, hostSelection);
+		return slice;
+	};
+	const buildSelectionSlice = (info, status) => {
 		const target = info.target ?? null;
 		const quotedText = typeof info.text === "string" ? info.text : "";
 		return {
 			status,
 			empty: info.empty === true,
 			target,
+			trackedTarget: info.trackedTarget ?? null,
+			trackedChangeRangeDecisionSupported: info.trackedChangeRangeDecisionSupported,
+			trackedChangesWhollySelected: info.trackedChangesWhollySelected,
 			selectionTarget: info.selectionTarget ?? null,
 			tableSelection: info.tableSelection ?? null,
 			activeMarks: Array.isArray(info.activeMarks) ? info.activeMarks : [],
@@ -7292,18 +7317,22 @@ function createSuperDocUI(options) {
 			quotedText
 		};
 	};
-	const readSelectionInfoLive = () => {
-		const selectionApi = getDoc()?.selection;
-		return readAsync("selection", selectionReadToken(), () => selectionApi?.current ? selectionApi.current({ includeText: true }) : void 0, normalizeSelectionInfo);
-	};
+	const readSelectionInfoLive = () => readAsync("selection", selectionReadToken(), selectionCurrentRun, normalizeSelectionInfo);
 	const computeSelection = () => {
 		const { value: info, status } = readSelectionInfoLive();
 		return selectionSliceFromInfo(info, status);
 	};
-	const selectionCurrentRun = () => {
+	function selectionCurrentRun() {
 		const selectionApi = getDoc()?.selection;
-		return selectionApi?.current ? selectionApi.current({ includeText: true }) : void 0;
-	};
+		if (!selectionApi?.current) return void 0;
+		const hostSelection = readHostSelectionSnapshot();
+		const tag = (info) => {
+			if (hostSelection && info && typeof info === "object") selectionHostSnapshots.set(info, hostSelection);
+			return info;
+		};
+		const result = selectionApi.current({ includeText: true });
+		return isPromiseLike(result) ? Promise.resolve(result).then(tag) : tag(result);
+	}
 	/** True when a host sync snapshot is a resolved collapsed caret (not a range). */
 	const isCollapsedCaretSnapshot = (info) => {
 		if (info.empty !== true) return false;
@@ -8283,6 +8312,10 @@ function createSuperDocUI(options) {
 		if (!supported) return command.scope === "all" ? SUPERDOC_UI_REASONS.bulkDecisionsDisabled : unavailableRouteReason(doc);
 		if (disabledReason) return disabledReason;
 		if (command.scope !== "all" && selection.activeChangeIds.length === 0) return SUPERDOC_UI_REASONS.selectionRequired;
+		if (command.scope !== "all") {
+			const plan = planSelectionTrackDecision(selection, true);
+			if (plan?.kind === "blocked") return plan.reason;
+		}
 	};
 	const findTrackChangeForPermission = (id) => {
 		syncCoordinatorEditor();
@@ -8302,20 +8335,22 @@ function createSuperDocUI(options) {
 		if (typeof canPerform !== "function" || ids.length === 0) return void 0;
 		const currentUser = superdoc.config && typeof superdoc.config === "object" ? superdoc.config.user : null;
 		for (const id of ids) {
-			const trackedChange = findTrackChangeForPermission(id) ?? { id };
-			const isOwn = trackedChangeOwnedByCurrentUser(trackedChange, currentUser);
-			const permission = kind === "accept" ? isOwn ? "RESOLVE_OWN" : "RESOLVE_OTHER" : isOwn ? "REJECT_OWN" : "REJECT_OTHER";
-			let allowed;
-			try {
-				allowed = canPerform.call(superdoc, {
-					permission,
-					trackedChange,
-					comment: null
-				});
-			} catch {
-				return;
+			const trackedChange = findTrackChangeForPermission(id);
+			const isOwn = trackedChange ? trackedChangeOwnedByCurrentUser(trackedChange, currentUser) : false;
+			const permissions = trackedChange ? [kind === "accept" ? isOwn ? "RESOLVE_OWN" : "RESOLVE_OTHER" : isOwn ? "REJECT_OWN" : "REJECT_OTHER"] : kind === "accept" ? ["RESOLVE_OWN", "RESOLVE_OTHER"] : ["REJECT_OWN", "REJECT_OTHER"];
+			for (const candidate of permissions) {
+				let allowed;
+				try {
+					allowed = canPerform.call(superdoc, {
+						permission: candidate,
+						trackedChange: trackedChange ?? { id },
+						comment: null
+					});
+				} catch {
+					return trackedChange ? void 0 : SUPERDOC_UI_REASONS.permissionDenied;
+				}
+				if (allowed === false || !trackedChange && allowed !== true) return SUPERDOC_UI_REASONS.permissionDenied;
 			}
-			if (allowed === false) return SUPERDOC_UI_REASONS.permissionDenied;
 		}
 	};
 	const hostCommandSupport = (command) => {
@@ -9156,7 +9191,7 @@ function createSuperDocUI(options) {
 			reason: SUPERDOC_UI_REASONS.documentReadonly
 		}, "builtin");
 		const context = resolveTableContext();
-		if (!(context != null && (!descriptor.table.requiresCell || context.cellNodeId != null))) return normalizeCommandState({
+		if (!(context != null && (!descriptor.table.requiresCell || context.cellNodeId != null) && (descriptor.table.action !== "merge-cells" || context.canMerge))) return normalizeCommandState({
 			enabled: false,
 			active: false,
 			supported: true,
@@ -9995,14 +10030,22 @@ function createSuperDocUI(options) {
 	* ordinary/insertion selections are visible-space, while a selection that
 	* reaches painted deleted text is projected in tracked space by the host.
 	*
-	* A cross-block or malformed selection fails closed. Its intermediate block
-	* coverage cannot be reconstructed from two endpoints without guessing.
+	* Cross-block coverage must come from the model-backed tracked target;
+	* intermediate block lengths cannot be inferred from the endpoints.
 	*/
 	function trackDecisionRangeFromSelection(selection) {
 		if (selection.empty) return null;
 		const explicit = selection.selectionTarget;
 		const start = explicit?.start;
 		const end = explicit?.end;
+		if (start?.kind === "text" && end?.kind === "text" && start.blockId !== end.blockId) {
+			const range = selection.trackedTarget;
+			return range ? {
+				kind: "range",
+				coordinateSpace: "tracked",
+				range
+			} : null;
+		}
 		if (explicit?.kind !== "selection" || start?.kind !== "text" || end?.kind !== "text" || typeof start.blockId !== "string" || start.blockId !== end.blockId || !Number.isInteger(start.offset) || !Number.isInteger(end.offset) || start.offset < 0 || end.offset < 0 || start.offset === end.offset) return null;
 		const rangeStart = Math.min(start.offset, end.offset);
 		const rangeEnd = Math.max(start.offset, end.offset);
@@ -10047,32 +10090,20 @@ function createSuperDocUI(options) {
 	function normalizeTrackDecisionText(value) {
 		return typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
 	}
-	function activeChangePartialDecisionRoute() {
-		const activeId = state.selection.activeChangeIds[0];
+	function activeChangePartialDecisionRoute(selection = state.selection) {
+		const activeId = selection.activeChangeIds[0];
 		if (!activeId) return "unavailable";
-		const story = selectionStoryLocator(state.selection);
-		const item = (state.trackChanges.status === "ready" ? state.trackChanges.items.find((candidate) => entityRowMatchesRequest(candidate, activeId, story)) : void 0) ?? readBodyTrackChangeForDecision(activeId, story) ?? readAllStoryTrackChanges()?.find((candidate) => entityRowMatchesRequest(candidate, activeId, story));
+		const story = selectionStoryLocator(selection);
+		const trackChanges = state?.trackChanges;
+		const item = (trackChanges?.status === "ready" ? trackChanges.items.find((candidate) => entityRowMatchesRequest(candidate, activeId, story)) : void 0) ?? readBodyTrackChangeForDecision(activeId, story) ?? readAllStoryTrackChanges()?.find((candidate) => entityRowMatchesRequest(candidate, activeId, story));
 		if (!item) return "unavailable";
 		const change = trackChangesItemPayload(item);
 		const type = change.type;
 		const grouping = change.grouping;
-		if (selectedTextCoversTrackChangeText(state.selection, item)) return "id";
+		if (selectedTextCoversTrackChangeText(selection, item)) return "id";
 		if (type === "replacement" && grouping === "replacement-pair") return "range";
 		return (type === "insertion" || type === "deletion" || type === "insert" || type === "delete") && grouping === "standalone" ? "range" : "id";
 	}
-	function executeTrackDecisionRangeWithIdFallback(kind, rangeTarget, changeId, story) {
-		const fallback = () => callTrackDecisionTarget(kind, trackDecisionIdTarget(changeId, story), changeId, story);
-		try {
-			const result = callTrackDecisionTarget(kind, rangeTarget, changeId, story);
-			if (isPromiseLike(result)) return settleCommandExecution(Promise.resolve(result).then((settled) => {
-				return commandResultSucceeded(commandResultFromOperationResult(settled)) ? settled : fallback();
-			}));
-			const commandResult = commandResultFromOperationResult(result);
-			return settleCommandExecution(commandResultSucceeded(commandResult) ? result : fallback());
-		} catch {
-			return false;
-		}
-	}
 	/** A decision target carried by the payload itself, independent of the selection. */
 	function explicitTrackDecisionTarget(payload) {
 		if (typeof payload === "string" && payload.length > 0) return {
@@ -10116,29 +10147,88 @@ function createSuperDocUI(options) {
 			story
 		} : null;
 	}
+	/**
+	* The selection-derived decision for a review command. The command gate and
+	* execution share these rules so an enabled command always has a target.
+	* `null` means the selection does not drive the decision (no active change
+	* or a collapsed caret) and the caller falls back to the active change id.
+	* `gateOnly` stops after the blocking rules and returns only a block or null.
+	*/
+	function planSelectionTrackDecision(selection, gateOnly = false) {
+		if (selection.tableSelection?.kind === "tableCells" && (selection.tableSelection.type === "cells" || selection.tableSelection.type === "table")) return {
+			kind: "blocked",
+			reason: SUPERDOC_UI_REASONS.operationUnavailable
+		};
+		const ids = selection.activeChangeIds;
+		if (ids.length > 1) {
+			if (selection.empty || selection.trackedChangesWhollySelected === true) return {
+				kind: "ids",
+				ids
+			};
+			if (selection.trackedChangeRangeDecisionSupported === false) return {
+				kind: "blocked",
+				reason: SUPERDOC_UI_REASONS.operationUnavailable
+			};
+			const target = trackDecisionRangeFromSelection(selection);
+			return target ? {
+				kind: "range",
+				target,
+				changeId: null,
+				permissionIds: ids
+			} : {
+				kind: "blocked",
+				reason: SUPERDOC_UI_REASONS.targetUnresolved
+			};
+		}
+		if (ids.length !== 1 || selection.empty) return null;
+		const activeId = ids[0];
+		let routeValue;
+		const route = () => routeValue ??= selection.trackedChangesWhollySelected === true ? "id" : activeChangePartialDecisionRoute(selection);
+		if (selection.trackedChangeRangeDecisionSupported === false && route() !== "id") return {
+			kind: "blocked",
+			reason: SUPERDOC_UI_REASONS.operationUnavailable
+		};
+		if (!selection.selectionTarget) return null;
+		const target = trackDecisionRangeFromSelection(selection);
+		if (!target && route() !== "id") return {
+			kind: "blocked",
+			reason: SUPERDOC_UI_REASONS.targetUnresolved
+		};
+		if (gateOnly) return null;
+		if (route() === "id") {
+			const selectedStory = selectionStoryLocator(selection);
+			return {
+				kind: "id",
+				id: activeId,
+				story: selectedStory && storyLocatorSignature(selectedStory) !== storyLocatorSignature(null) ? selectedStory : void 0
+			};
+		}
+		if (route() === "unavailable" && !selection.trackedTarget) return { kind: "unavailable" };
+		return target ? {
+			kind: "range",
+			target,
+			changeId: activeId,
+			story: nonBodySelectionStoryLocator(selection)
+		} : {
+			kind: "blocked",
+			reason: SUPERDOC_UI_REASONS.targetUnresolved
+		};
+	}
 	function executeTrackDecisionCommand(command, payload) {
 		if (command.scope === "id" && payload == null) {
-			if (state.selection.activeChangeIds.length > 1) return executeTrackDecisionTarget(command.kind, {
-				kind: "ids",
-				ids: state.selection.activeChangeIds
-			}, null);
-			if (state.selection.activeChangeIds.length === 1 && !state.selection.empty && state.selection.selectionTarget) {
-				const route = activeChangePartialDecisionRoute();
-				if (route === "unavailable") return false;
-				if (route === "range") {
-					const target = trackDecisionRangeFromSelection(state.selection);
-					const story = nonBodySelectionStoryLocator(state.selection);
-					return target ? executeTrackDecisionRangeWithIdFallback(command.kind, target, state.selection.activeChangeIds[0], story) : false;
-				}
-				if (route === "id") {
-					const activeId = state.selection.activeChangeIds[0];
-					const selectedStory = selectionStoryLocator(state.selection);
-					const story = selectedStory && storyLocatorSignature(selectedStory) !== storyLocatorSignature(null) ? selectedStory : void 0;
-					return executeTrackDecision(command.kind, story ? {
-						id: activeId,
-						story
-					} : activeId);
-				}
+			const plan = planSelectionTrackDecision(state.selection);
+			switch (plan?.kind) {
+				case "blocked":
+				case "unavailable": return false;
+				case "ids": return executeTrackDecisionTarget(command.kind, {
+					kind: "ids",
+					ids: plan.ids
+				}, null, void 0, plan.ids);
+				case "range": return executeTrackDecisionTarget(command.kind, plan.target, plan.changeId, plan.story, plan.permissionIds);
+				case "id": return executeTrackDecision(command.kind, plan.story ? {
+					id: plan.id,
+					story: plan.story
+				} : plan.id);
 			}
 		}
 		const resolved = resolveTrackDecisionTarget(command, payload);
@@ -11807,11 +11897,14 @@ function createSuperDocUI(options) {
 			if (snapshot.empty) return null;
 			const cells = currentCellSelectionTarget();
 			if (!snapshot.target && !snapshot.selectionTarget && !cells) return null;
-			return {
+			const capture = {
 				...snapshot,
 				capturedAt: Date.now(),
 				...cells ? { _tableCellSelectionTarget: cells } : {}
 			};
+			const hostSelection = selectionHostSnapshots.get(snapshot);
+			if (hostSelection) selectionHostSnapshots.set(capture, hostSelection);
+			return capture;
 		},
 		restore: (capture) => {
 			const done = (result) => {
@@ -11840,6 +11933,8 @@ function createSuperDocUI(options) {
 				ok: false,
 				reason: SUPERDOC_UI_REASONS.targetUnresolved
 			});
+			const heldHostSelection = selectionHostSnapshots.get(capture);
+			if (!hasCellTarget && target.coordinateSpace === "tracked" && heldHostSelection !== void 0 && readHostSelectionSnapshot() === heldHostSelection) return done({ ok: true });
 			const resolved = getSelectionApplyHelper();
 			if (!("helper" in resolved)) return done({
 				ok: false,
@@ -12676,20 +12771,20 @@ function createSuperDocUI(options) {
 		if (run() === false) return Promise.resolve(false);
 		return lastCommandSettlement;
 	};
-	const executeTrackDecisionTarget = (kind, target, changeId, story) => {
+	const executeTrackDecisionTarget = (kind, target, changeId, story, selectionChangeIds) => {
 		try {
-			return settleCommandExecution(callTrackDecisionTarget(kind, target, changeId, story));
+			return settleCommandExecution(callTrackDecisionTarget(kind, target, changeId, story, selectionChangeIds));
 		} catch {
 			return false;
 		}
 	};
-	const callTrackDecisionTarget = (kind, target, changeId, story) => {
+	const callTrackDecisionTarget = (kind, target, changeId, story, selectionChangeIds) => {
 		if (trackedChangeDecisionsAreDisabled()) return false;
 		const tcApi = getDoc()?.trackChanges;
 		const isAllTarget = target.kind === "all" || target.scope === "all";
 		const isRangeTarget = target.kind === "range";
 		const isMultiIdTarget = target.kind === "ids";
-		const permissionIds = isAllTarget ? [] : isMultiIdTarget && Array.isArray(target.ids) ? target.ids.filter((id) => typeof id === "string" && id.length > 0) : changeId ? [changeId] : [];
+		const permissionIds = isAllTarget ? [] : selectionChangeIds ?? (isMultiIdTarget && Array.isArray(target.ids) ? target.ids.filter((id) => typeof id === "string" && id.length > 0) : changeId ? [changeId] : []);
 		if (permissionIds.length > 0 && trackedChangeDecisionPermissionReason(kind, permissionIds)) return false;
 		if (bulkTrackDecisionBlockedReason({
 			kind,
@@ -13061,7 +13156,13 @@ function createSuperDocUI(options) {
 		return {
 			point,
 			entities: validInput ? entityAt(point) : [],
-			selection: state.selection,
+			selection: (() => {
+				const current = computeSelection();
+				return current.status === "ready" ? current : {
+					...current,
+					tableSelection: null
+				};
+			})(),
 			position: null,
 			insideSelection: false
 		};
@@ -13278,21 +13379,67 @@ function createSuperDocUI(options) {
 		columnIndex: null,
 		cellNodeId: null,
 		rows: null,
-		columns: null
+		columns: null,
+		status: "ready",
+		cellRange: null,
+		tableSelection: null
+	};
+	const publicTableContext = (snapshot) => {
+		const status = snapshot?.status === "pending" || snapshot?.status === "stale" ? snapshot.status : "ready";
+		if (!snapshot || snapshot.inTable !== true || status !== "ready") return {
+			...EMPTY_TABLE_CONTEXT,
+			status
+		};
+		const table = snapshot.table;
+		const row = snapshot.row;
+		const column = snapshot.column;
+		const cell = snapshot.cell;
+		if (typeof table?.nodeId !== "string") return {
+			...EMPTY_TABLE_CONTEXT,
+			status
+		};
+		return {
+			inTable: true,
+			status,
+			tableNodeId: table.nodeId,
+			rowIndex: typeof row?.index === "number" ? row.index : null,
+			columnIndex: typeof column?.index === "number" ? column.index : null,
+			cellNodeId: typeof cell?.nodeId === "string" ? cell.nodeId : null,
+			rows: typeof table.rows === "number" ? table.rows : null,
+			columns: typeof table.columns === "number" ? table.columns : null,
+			cellRange: readMergeRange(snapshot.cellRange),
+			tableSelection: snapshot.tableSelection ?? null
+		};
 	};
 	const tables = {
-		getContext: () => {
-			const context = resolveTableContext();
-			if (!context) return { ...EMPTY_TABLE_CONTEXT };
-			const table = readHostTableContext()?.table;
+		getContext: () => publicTableContext(readHostTableContext()),
+		getContextAsync: async () => {
+			for (let attempt = 0; attempt < 2; attempt += 1) {
+				const token = selectionReadToken();
+				const host = getHost();
+				const read = host?.getTableContextAsync;
+				if (typeof read !== "function") return publicTableContext(readHostTableContext());
+				let snapshot = null;
+				try {
+					snapshot = await read.call(host);
+				} catch {
+					return {
+						...EMPTY_TABLE_CONTEXT,
+						status: "pending"
+					};
+				}
+				if (disposed) return {
+					...EMPTY_TABLE_CONTEXT,
+					status: "pending"
+				};
+				if (token !== selectionReadToken() || host !== getHost()) continue;
+				const context = publicTableContext(snapshot);
+				if (context.status === "stale") continue;
+				return context;
+			}
 			return {
-				inTable: true,
-				tableNodeId: context.tableNodeId,
-				rowIndex: context.rowIndex,
-				columnIndex: context.columnIndex,
-				cellNodeId: context.cellNodeId,
-				rows: typeof table?.rows === "number" ? table.rows : null,
-				columns: typeof table?.columns === "number" ? table.columns : null
+				...EMPTY_TABLE_CONTEXT,
+				status: "stale"
 			};
 		},
 		isInTable: () => resolveTableContext() != null

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.24.0-next.1",
+	superdocVersion: "2.24.0-next.3",
 	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.24.0-next.1",
+	superdocVersion: "2.24.0-next.3",
 	roomSchemaVersion: Object.freeze({ ...PRIVATE_ENGINE_INFO.roomSchemaVersion }),
 	supportedBundleVersions: SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS,
 	supportedV1ReaderContractVersions: SUPPORTED_V1_READER_CONTRACT_VERSIONS

package/dist/document-api/src/selection/selection.types.d.ts

@@ -1,6 +1,8 @@
 import { SelectionTarget, TextTarget } from '../types/address.js';
 export interface SelectionTableCellsTarget {
     kind: 'tableCells';
+    selectionMode?: 'cells';
+    isRectangular?: true;
     tableId: string;
     start: {
         rowIndex: number;
@@ -12,15 +14,33 @@ export interface SelectionTableCellsTarget {
     };
     story?: SelectionTarget['story'];
 }
-/** Table identity for a caret, rectangular cell selection, or whole-grid selection. */
-export interface TableSelectionInfo extends SelectionTableCellsTarget {
-    /** `cell` includes a caret or text range contained in one cell. */
+/** Table/cell context for the selection; bounds alone are not an editing target. */
+export interface TableSelectionInfo {
+    kind: 'tableCells';
+    tableId: string;
+    story?: SelectionTarget['story'];
+    /** Inclusive logical bounds, including each selected owner's span. */
+    start: {
+        rowIndex: number;
+        columnIndex: number;
+    };
+    end: {
+        rowIndex: number;
+        columnIndex: number;
+    };
+    /** Whole-table identity requires whole-cell selection intent. */
     type: 'table' | 'cell' | 'cells';
-    /** Selected cells in row-major order, using opaque Document API node IDs. */
+    /** Text context preserves exact character targets; cells denotes whole-cell intent. */
+    selectionMode: 'text' | 'cells';
+    /** Whether the exact cells fill the bounding rectangle without holes. */
+    isRectangular: boolean;
+    /** Exact logical owners in row-major order; vertical continuations are deduplicated. */
     cells: {
         nodeId: string;
         rowIndex: number;
         columnIndex: number;
+        rowspan: number;
+        colspan: number;
     }[];
 }
 export type SelectionExtractOoxmlInput = {
@@ -123,6 +143,12 @@ export interface SelectionInfo {
      * full selection.
      */
     target: TextTarget | null;
+    /** Deletion-inclusive multi-block text coverage for range review decisions, when resolvable. */
+    trackedTarget?: TextTarget | null;
+    /** Whether this exact text range supports tracked-change decisions; excludes permissions. */
+    trackedChangeRangeDecisionSupported?: boolean;
+    /** Whether the selection covers every tracked-text fragment of each active change. */
+    trackedChangesWhollySelected?: boolean;
     /**
      * Explicit selection envelope for the current live selection, or `null` when
      * the runtime cannot project one truthfully.
@@ -132,10 +158,11 @@ export interface SelectionInfo {
      */
     selectionTarget?: SelectionTarget | null;
     /**
-     * V2 browser table selection with inclusive, zero-based grid coordinates.
-     * Rectangles in unmerged tables clear `target` and `selectionTarget`.
-     * Rectangles in tables containing merged cells return null and empty text.
-     * A single-cell caret/text range preserves its text targets and `empty` value.
+     * V2 browser cell context with inclusive, zero-based logical bounds.
+     * Whole-cell selections clear text targets. Character selections preserve
+     * their targets and include the containing cells, including endpoint cells.
+     * Exact cell IDs and spans describe merged or nonrectangular selections;
+     * only rectangular whole-cell metadata can become a table-cells target.
      */
     tableSelection?: TableSelectionInfo | null;
     /**

package/dist/public/ui-react.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_create_super_doc_ui = require("../chunks/create-super-doc-ui-D_FbXpOQ.cjs");
+const require_create_super_doc_ui = require("../chunks/create-super-doc-ui-bTFGKVRb.cjs");
 const require_slice_source = require("../chunks/slice-source-CFaqq0Vo.cjs");
 let react = require("react");
 //#region src/public/ui/react.ts

package/dist/public/ui-react.es.js

@@ -1,4 +1,4 @@
-import { t as createSuperDocUI } from "../chunks/create-super-doc-ui-DFNXiKvQ.es.js";
+import { t as createSuperDocUI } from "../chunks/create-super-doc-ui-8UTu16Lw.es.js";
 import { t as toSliceSource } from "../chunks/slice-source-gfOhG2MW.es.js";
 import { createContext, createElement, useCallback, useContext, useEffect, useRef, useState } from "react";
 //#region src/public/ui/react.ts

package/dist/public/ui-vue.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_create_super_doc_ui = require("../chunks/create-super-doc-ui-D_FbXpOQ.cjs");
+const require_create_super_doc_ui = require("../chunks/create-super-doc-ui-bTFGKVRb.cjs");
 const require_slice_source = require("../chunks/slice-source-CFaqq0Vo.cjs");
 let superdoc_entry_vue = require("vue");
 //#region src/public/ui/vue.ts

package/dist/public/ui-vue.es.js

@@ -1,4 +1,4 @@
-import { t as createSuperDocUI } from "../chunks/create-super-doc-ui-DFNXiKvQ.es.js";
+import { t as createSuperDocUI } from "../chunks/create-super-doc-ui-8UTu16Lw.es.js";
 import { t as toSliceSource } from "../chunks/slice-source-gfOhG2MW.es.js";
 import { computed, inject, onScopeDispose, provide, shallowRef, toRaw, toValue, watch } from "vue";
 //#region src/public/ui/vue.ts

package/dist/public/ui.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_create_super_doc_ui = require("../chunks/create-super-doc-ui-D_FbXpOQ.cjs");
+const require_create_super_doc_ui = require("../chunks/create-super-doc-ui-bTFGKVRb.cjs");
 exports.BUILT_IN_COMMAND_IDS = require_create_super_doc_ui.BUILT_IN_COMMAND_IDS;
 exports.createSuperDocUI = require_create_super_doc_ui.createSuperDocUI;
 exports.shallowEqual = require_create_super_doc_ui.shallowEqual;

package/dist/public/ui.es.js

@@ -1,2 +1,2 @@
-import { a as BUILT_IN_COMMAND_IDS, t as createSuperDocUI, u as shallowEqual } from "../chunks/create-super-doc-ui-DFNXiKvQ.es.js";
+import { a as BUILT_IN_COMMAND_IDS, t as createSuperDocUI, u as shallowEqual } from "../chunks/create-super-doc-ui-8UTu16Lw.es.js";
 export { BUILT_IN_COMMAND_IDS, createSuperDocUI, shallowEqual };

package/dist/superdoc/src/public/ui/types.d.ts

@@ -551,6 +551,12 @@ export interface SelectionSlice {
     empty: boolean;
     /** Resolved text target for the selection, when available. */
     target: TextTarget | null;
+    /** Deletion-inclusive multi-block coverage for range review decisions, when available. */
+    trackedTarget?: TextTarget | null;
+    /** Whether this exact text range supports tracked-change decisions; excludes permissions. */
+    trackedChangeRangeDecisionSupported?: boolean;
+    /** Whether the selection covers every tracked-text fragment of each active change. */
+    trackedChangesWhollySelected?: boolean;
     /** Explicit start/end selection target, when available. */
     selectionTarget: SelectionTarget | null;
     /** Table/cell identities from the settled public selection read, when supported. */
@@ -1270,6 +1276,20 @@ export interface MetadataHandle {
  * through; custom UIs read it to enable / label their own table controls.
  */
 export interface TableContextInfo {
+    /** Runtime always supplies status; stale/pending snapshots carry no previous cell IDs. */
+    status?: SliceStatus;
+    /** Inclusive logical bounding geometry; use tableSelection for exact membership. */
+    cellRange?: {
+        start: {
+            rowIndex: number;
+            columnIndex: number;
+        };
+        end: {
+            rowIndex: number;
+            columnIndex: number;
+        };
+    } | null;
+    tableSelection?: SelectionInfo['tableSelection'];
     /** Whether the current selection is inside a table. */
     inTable: boolean;
     /** Stable node id of the enclosing table, when resolved. */
@@ -1289,6 +1309,8 @@ export interface TableContextInfo {
 export interface TablesHandle {
     /** Read the current table context snapshot. */
     getContext(): TableContextInfo;
+    /** Resolve fresh, bounded table context for immediate context-menu callbacks. */
+    getContextAsync(): Promise<TableContextInfo>;
     /** Convenience: whether the current selection is inside a table. */
     isInTable(): boolean;
 }