@stll/folio-core 0.11.0 → 0.13.0

package/dist/controller/noteEditorManager.js

@@ -0,0 +1,210 @@
+import { ExtensionManager } from "../prosemirror/extensions/ExtensionManager.js";
+import { ensureBaseDirectionInState } from "../prosemirror/extensions/features/AutoBidiDetectionExtension.js";
+import { createDocumentStylesPlugin } from "../prosemirror/plugins/documentStyles.js";
+import { ensureParaIdsInState } from "../prosemirror/extensions/features/ParaIdAllocatorExtension.js";
+import { createStarterKit } from "../prosemirror/extensions/StarterKit.js";
+import { schema } from "../prosemirror/schema/index.js";
+import { footnoteToProseDoc } from "../prosemirror/conversion/toProseDoc.js";
+import { proseDocToBlocks } from "../prosemirror/conversion/fromProseDoc.js";
+import { isSeparatorEndnote, isSeparatorFootnote } from "../docx/footnoteParser.js";
+import { EditorState } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+//#region src/controller/noteEditorManager.ts
+/** Framework-neutral lifecycle owner for editable footnote and endnote stories. */
+const EMPTY_PLUGINS = [];
+const storyMapKey = ({ kind, noteId }) => `${kind}:${String(noteId)}`;
+const isNormalFootnote = (note) => !isSeparatorFootnote(note);
+const isNormalEndnote = (note) => !isSeparatorEndnote(note);
+const enumerateDocumentNoteStories = (document) => [...(document?.package.footnotes ?? []).filter(isNormalFootnote).map(({ id }) => ({
+	kind: "footnote",
+	noteId: id
+})), ...(document?.package.endnotes ?? []).filter(isNormalEndnote).map(({ id }) => ({
+	kind: "endnote",
+	noteId: id
+}))];
+const resolveNote = (document, story) => {
+	return (story.kind === "footnote" ? document?.package.footnotes : document?.package.endnotes)?.find(({ id }) => id === story.noteId) ?? null;
+};
+const noteToProseDocument = (note, styles, theme) => {
+	const options = {};
+	if (styles) options.styles = styles;
+	if (theme !== void 0) options.theme = theme;
+	return footnoteToProseDoc(note.content, options);
+};
+const buildInitialState = (document, styles, manager, externalPlugins) => {
+	return ensureBaseDirectionInState(ensureParaIdsInState(EditorState.create({
+		doc: document,
+		schema,
+		plugins: [
+			...manager.getPlugins(),
+			...externalPlugins,
+			createDocumentStylesPlugin(styles)
+		]
+	})));
+};
+const createNoteEditorManager = (deps) => {
+	const mounted = /* @__PURE__ */ new Map();
+	let active = null;
+	const updateVisibility = () => {
+		const activeKey = active ? storyMapKey(active) : null;
+		for (const [key, story] of mounted) story.mountNode.hidden = key !== activeKey;
+	};
+	const destroyMounted = (story) => {
+		story.view.destroy();
+		story.manager.destroy();
+		story.mountNode.remove();
+	};
+	const destroy = () => {
+		for (const story of mounted.values()) destroyMounted(story);
+		mounted.clear();
+		active = null;
+	};
+	const sync = () => {
+		const host = deps.getHost();
+		if (!host) return;
+		const document = deps.getDocument();
+		const styles = deps.getStyles();
+		const theme = deps.getTheme();
+		const externalPlugins = deps.getPlugins?.() ?? EMPTY_PLUGINS;
+		const wanted = new Map(enumerateDocumentNoteStories(document).map((story) => [storyMapKey(story), story]));
+		const activeKey = active ? storyMapKey(active) : null;
+		for (const [key, story] of mounted) {
+			if (wanted.has(key)) continue;
+			destroyMounted(story);
+			mounted.delete(key);
+		}
+		for (const [key, storyKey] of wanted) {
+			if (!mounted.has(key) && key !== activeKey) continue;
+			const note = resolveNote(document, storyKey);
+			if (!note) continue;
+			const existing = mounted.get(key);
+			if (existing) {
+				if (existing.mountNode.parentElement !== host) host.append(existing.mountNode);
+				const nextProseDocument = noteToProseDocument(note, styles, theme);
+				const contextIsCurrent = existing.appliedStyles === styles && existing.appliedTheme === theme && existing.appliedPlugins === externalPlugins;
+				if ((existing.appliedNote === note && existing.appliedContent === note.content || existing.appliedProseDocument.eq(nextProseDocument)) && contextIsCurrent) {
+					existing.appliedNote = note;
+					existing.appliedContent = note.content;
+					existing.appliedProseDocument = nextProseDocument;
+					continue;
+				}
+				existing.view.updateState(buildInitialState(nextProseDocument, styles, existing.manager, externalPlugins));
+				existing.appliedNote = note;
+				existing.appliedContent = note.content;
+				existing.appliedStyles = styles;
+				existing.appliedTheme = theme;
+				existing.appliedPlugins = externalPlugins;
+				existing.appliedProseDocument = nextProseDocument;
+				existing.dirty = false;
+				continue;
+			}
+			const manager = new ExtensionManager(createStarterKit());
+			manager.buildSchema();
+			manager.initializeRuntime();
+			const mountNode = host.ownerDocument.createElement("div");
+			mountNode.dataset["noteKind"] = storyKey.kind;
+			mountNode.dataset["noteId"] = String(storyKey.noteId);
+			host.append(mountNode);
+			const proseDocument = noteToProseDocument(note, styles, theme);
+			const view = new EditorView(mountNode, {
+				state: buildInitialState(proseDocument, styles, manager, externalPlugins),
+				dispatchTransaction(transaction) {
+					view.updateState(view.state.apply(transaction));
+					const mountedStory = mounted.get(key);
+					if (mountedStory && transaction.docChanged) mountedStory.dirty = true;
+					deps.onTransaction?.({
+						...storyKey,
+						docChanged: transaction.docChanged,
+						selectionChanged: transaction.selectionSet,
+						view
+					});
+				}
+			});
+			mounted.set(key, {
+				appliedContent: note.content,
+				appliedNote: note,
+				appliedPlugins: externalPlugins,
+				appliedProseDocument: proseDocument,
+				appliedStyles: styles,
+				appliedTheme: theme,
+				dirty: false,
+				manager,
+				mountNode,
+				note: storyKey,
+				view
+			});
+		}
+		if (active && !wanted.has(storyMapKey(active))) active = null;
+		updateVisibility();
+	};
+	return {
+		activate: (story) => {
+			active = story;
+			sync();
+			if (!story) return null;
+			const view = mounted.get(storyMapKey(story))?.view ?? null;
+			if (view) return view;
+			active = null;
+			updateVisibility();
+			return null;
+		},
+		destroy,
+		getActive: () => active,
+		getView: (story) => mounted.get(storyMapKey(story))?.view ?? null,
+		listStories: () => enumerateDocumentNoteStories(deps.getDocument()),
+		snapshotDocument: (document) => {
+			let footnotes = document.package.footnotes;
+			let endnotes = document.package.endnotes;
+			let footnotesChanged = false;
+			let endnotesChanged = false;
+			for (const story of mounted.values()) {
+				if (!story.dirty) continue;
+				if (story.note.kind === "footnote") {
+					const index = footnotes?.findIndex(({ id }) => id === story.note.noteId) ?? -1;
+					const current = index === -1 ? null : footnotes?.at(index);
+					if (!current || !footnotes) continue;
+					if (!footnotesChanged) {
+						footnotes = [...footnotes];
+						footnotesChanged = true;
+					}
+					const updated = {
+						...current,
+						content: proseDocToBlocks(story.view.state.doc)
+					};
+					footnotes[index] = updated;
+					story.appliedNote = updated;
+					story.appliedContent = updated.content;
+					story.appliedProseDocument = noteToProseDocument(updated, story.appliedStyles, story.appliedTheme);
+					continue;
+				}
+				const index = endnotes?.findIndex(({ id }) => id === story.note.noteId) ?? -1;
+				const current = index === -1 ? null : endnotes?.at(index);
+				if (!current || !endnotes) continue;
+				if (!endnotesChanged) {
+					endnotes = [...endnotes];
+					endnotesChanged = true;
+				}
+				const updated = {
+					...current,
+					content: proseDocToBlocks(story.view.state.doc)
+				};
+				endnotes[index] = updated;
+				story.appliedNote = updated;
+				story.appliedContent = updated.content;
+				story.appliedProseDocument = noteToProseDocument(updated, story.appliedStyles, story.appliedTheme);
+			}
+			if (!footnotesChanged && !endnotesChanged) return document;
+			return {
+				...document,
+				package: {
+					...document.package,
+					...footnotesChanged && footnotes ? { footnotes } : {},
+					...endnotesChanged && endnotes ? { endnotes } : {}
+				}
+			};
+		},
+		sync
+	};
+};
+//#endregion
+export { createNoteEditorManager, enumerateDocumentNoteStories };

package/dist/document-operations.d.ts

@@ -3,8 +3,8 @@ import { FolioAIEditView } from "./ai-edits/apply.js";
 
 //#region src/document-operations.d.ts
 declare const FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION: 1;
-declare const FOLIO_DOCUMENT_OPERATION_TYPES: readonly ["replaceInBlock", "replaceRange", "commentOnRange", "formatRange", "insertAfterBlock", "insertBeforeBlock", "replaceBlock", "deleteBlock", "commentOnBlock", "insertSignatureTable"];
-declare const FOLIO_DOCUMENT_OPERATION_MODES: readonly ["direct", "tracked-changes"];
+declare const FOLIO_DOCUMENT_OPERATION_TYPES: readonly ["replaceInBlock", "replaceRange", "commentOnRange", "formatRange", "insertAfterBlock", "insertBeforeBlock", "replaceBlock", "deleteBlock", "commentOnBlock", "insertSignatureTable", "insertTableRow", "deleteTableRow", "insertTableColumn", "deleteTableColumn", "mergeTableCells", "splitTableCell"];
+declare const FOLIO_DOCUMENT_OPERATION_MODES: readonly ["direct", "tracked-changes", "suggested"];
 declare const FOLIO_DOCUMENT_OPERATION_STORIES: readonly ["main", "header", "footer", "footnote", "endnote"];
 declare const FOLIO_DOCUMENT_OPERATION_PRECONDITIONS: readonly ["blockTextHash"];
 declare const FOLIO_DOCUMENT_OPERATION_BATCH_MODES: readonly ["best-effort", "atomic"];
@@ -13,16 +13,22 @@ type FolioDocumentOperationMode = FolioAIEditApplyMode;
 type FolioDocumentOperationPrecondition = FolioAIEditPrecondition;
 type FolioDocumentOperationType = FolioDocumentOperation["type"];
 declare const FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE: Readonly<{
-  readonly replaceInBlock: readonly ["direct", "tracked-changes"];
-  readonly replaceRange: readonly ["direct", "tracked-changes"];
+  readonly replaceInBlock: readonly ["direct", "tracked-changes", "suggested"];
+  readonly replaceRange: readonly ["direct", "tracked-changes", "suggested"];
   readonly commentOnRange: readonly ["direct", "tracked-changes"];
-  readonly formatRange: readonly ["direct"];
-  readonly insertAfterBlock: readonly ["direct", "tracked-changes"];
-  readonly insertBeforeBlock: readonly ["direct", "tracked-changes"];
-  readonly replaceBlock: readonly ["direct", "tracked-changes"];
-  readonly deleteBlock: readonly ["direct", "tracked-changes"];
+  readonly formatRange: readonly ["direct", "tracked-changes", "suggested"];
+  readonly insertAfterBlock: readonly ["direct", "tracked-changes", "suggested"];
+  readonly insertBeforeBlock: readonly ["direct", "tracked-changes", "suggested"];
+  readonly replaceBlock: readonly ["direct", "tracked-changes", "suggested"];
+  readonly deleteBlock: readonly ["direct", "tracked-changes", "suggested"];
   readonly commentOnBlock: readonly ["direct", "tracked-changes"];
-  readonly insertSignatureTable: readonly ["direct"];
+  readonly insertSignatureTable: readonly ["direct", "suggested"];
+  readonly insertTableRow: readonly ["direct", "tracked-changes", "suggested"];
+  readonly deleteTableRow: readonly ["direct", "tracked-changes", "suggested"];
+  readonly insertTableColumn: readonly ["direct", "tracked-changes", "suggested"];
+  readonly deleteTableColumn: readonly ["direct", "tracked-changes", "suggested"];
+  readonly mergeTableCells: readonly ["direct", "tracked-changes"];
+  readonly splitTableCell: readonly ["direct", "tracked-changes"];
 }>;
 type FolioDocumentOperationCapabilities = {
   readonly version: typeof FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION;
@@ -96,10 +102,36 @@ type FolioDocumentOperationAffectedTarget = {
   story: FolioDocumentOperationStory;
   anchorBlockId: string;
   position: "before" | "after";
-  content: "block" | "signatureTable";
+  content: "block" | "signatureTable" | "tableRow" | "tableColumn";
 } | {
   type: "comment";
   commentId: number;
+} | {
+  type: "tableRow";
+  story: FolioDocumentOperationStory;
+  anchorBlockId: string;
+  effect: "deleted";
+} | {
+  type: "tableColumn";
+  story: FolioDocumentOperationStory;
+  anchorBlockId: string;
+  effect: "deleted";
+} | ({
+  type: "tableCells";
+  story: FolioDocumentOperationStory;
+  anchorBlockId: string;
+  effect: "merged";
+} & ({
+  endAnchorBlockId: string;
+  rowCount?: never;
+} | {
+  rowCount: number;
+  endAnchorBlockId?: never;
+})) | {
+  type: "tableCell";
+  story: FolioDocumentOperationStory;
+  anchorBlockId: string;
+  effect: "split";
 };
 /** Input-ordered effect receipt for one successfully applied operation. */
 type FolioDocumentOperationReceipt = {

package/dist/document-operations.js

@@ -12,9 +12,19 @@ const FOLIO_DOCUMENT_OPERATION_TYPES = Object.freeze([
 	"replaceBlock",
 	"deleteBlock",
 	"commentOnBlock",
-	"insertSignatureTable"
+	"insertSignatureTable",
+	"insertTableRow",
+	"deleteTableRow",
+	"insertTableColumn",
+	"deleteTableColumn",
+	"mergeTableCells",
+	"splitTableCell"
+]);
+const FOLIO_DOCUMENT_OPERATION_MODES = Object.freeze([
+	"direct",
+	"tracked-changes",
+	"suggested"
 ]);
-const FOLIO_DOCUMENT_OPERATION_MODES = Object.freeze(["direct", "tracked-changes"]);
 const FOLIO_DOCUMENT_OPERATION_STORIES = Object.freeze([
 	"main",
 	"header",
@@ -24,19 +34,26 @@ const FOLIO_DOCUMENT_OPERATION_STORIES = Object.freeze([
 ]);
 const FOLIO_DOCUMENT_OPERATION_PRECONDITIONS = Object.freeze(["blockTextHash"]);
 const FOLIO_DOCUMENT_OPERATION_BATCH_MODES = Object.freeze(["best-effort", "atomic"]);
-const DIRECT_AND_TRACKED_MODES = FOLIO_DOCUMENT_OPERATION_MODES;
-const DIRECT_ONLY_MODES = Object.freeze(["direct"]);
+const DIRECT_AND_TRACKED_MODES = Object.freeze(["direct", "tracked-changes"]);
+const DIRECT_TRACKED_AND_SUGGESTED_MODES = FOLIO_DOCUMENT_OPERATION_MODES;
+const DIRECT_AND_SUGGESTED_MODES = Object.freeze(["direct", "suggested"]);
 const FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE = Object.freeze({
-	replaceInBlock: DIRECT_AND_TRACKED_MODES,
-	replaceRange: DIRECT_AND_TRACKED_MODES,
+	replaceInBlock: DIRECT_TRACKED_AND_SUGGESTED_MODES,
+	replaceRange: DIRECT_TRACKED_AND_SUGGESTED_MODES,
 	commentOnRange: DIRECT_AND_TRACKED_MODES,
-	formatRange: DIRECT_ONLY_MODES,
-	insertAfterBlock: DIRECT_AND_TRACKED_MODES,
-	insertBeforeBlock: DIRECT_AND_TRACKED_MODES,
-	replaceBlock: DIRECT_AND_TRACKED_MODES,
-	deleteBlock: DIRECT_AND_TRACKED_MODES,
+	formatRange: DIRECT_TRACKED_AND_SUGGESTED_MODES,
+	insertAfterBlock: DIRECT_TRACKED_AND_SUGGESTED_MODES,
+	insertBeforeBlock: DIRECT_TRACKED_AND_SUGGESTED_MODES,
+	replaceBlock: DIRECT_TRACKED_AND_SUGGESTED_MODES,
+	deleteBlock: DIRECT_TRACKED_AND_SUGGESTED_MODES,
 	commentOnBlock: DIRECT_AND_TRACKED_MODES,
-	insertSignatureTable: DIRECT_ONLY_MODES
+	insertSignatureTable: DIRECT_AND_SUGGESTED_MODES,
+	insertTableRow: DIRECT_TRACKED_AND_SUGGESTED_MODES,
+	deleteTableRow: DIRECT_TRACKED_AND_SUGGESTED_MODES,
+	insertTableColumn: DIRECT_TRACKED_AND_SUGGESTED_MODES,
+	deleteTableColumn: DIRECT_TRACKED_AND_SUGGESTED_MODES,
+	mergeTableCells: DIRECT_AND_TRACKED_MODES,
+	splitTableCell: DIRECT_AND_TRACKED_MODES
 });
 const DOCUMENT_OPERATION_CAPABILITIES = Object.freeze({
 	version: 1,
@@ -51,8 +68,8 @@ const DOCUMENT_OPERATION_CAPABILITIES = Object.freeze({
 const getFolioDocumentOperationCapabilities = () => DOCUMENT_OPERATION_CAPABILITIES;
 const includesDocumentOperationMode = (supportedModes, mode) => supportedModes.includes(mode);
 const isFolioDocumentOperationModeSupported = (operationType, mode) => {
+	if (!Object.hasOwn(FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE, operationType)) return false;
 	const supportedModes = FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE[operationType];
-	if (supportedModes === void 0) return false;
 	return includesDocumentOperationMode(supportedModes, mode);
 };
 const isSupportedFolioDocumentOperationVersion = (value) => value === 1;
@@ -94,6 +111,15 @@ const readOptionalBoolean = (value, key, path) => {
 	if (typeof candidate === "boolean") return candidate;
 	return invalidBatch(`${path}.${key}`, "expected a boolean when provided");
 };
+const readOptionalStringArray = (value, key, path) => {
+	const candidate = value[key];
+	if (candidate === void 0) return;
+	if (!Array.isArray(candidate)) return invalidBatch(`${path}.${key}`, "expected an array when provided");
+	return candidate.map((item, index) => {
+		if (typeof item === "string") return item;
+		return invalidBatch(`${path}.${key}[${index}]`, "expected a string");
+	});
+};
 const readNonNegativeInteger = (value, key, path) => {
 	const candidate = value[key];
 	if (typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 0) return candidate;
@@ -183,7 +209,8 @@ const COMMON_OPERATION_KEYS = [
 	"blockId",
 	"severity",
 	"area",
-	"precondition"
+	"precondition",
+	"suggestionId"
 ];
 const parseSignatureParties = (value, path) => {
 	const parties = value["parties"];
@@ -211,10 +238,12 @@ const parseDocumentOperation = (value, index) => {
 	const type = readString(value, "type", path);
 	const reviewMeta = readReviewMeta(value, path);
 	const precondition = readOptionalPrecondition(value, path);
+	const suggestionId = readOptionalString(value, "suggestionId", path);
 	const comment = readOptionalComment(value, path);
 	const operationMeta = {
 		...reviewMeta,
-		...precondition !== void 0 && { precondition }
+		...precondition !== void 0 && { precondition },
+		...suggestionId !== void 0 && { suggestionId }
 	};
 	if (type === "replaceRange") {
 		assertAllowedKeys(value, path, [
@@ -225,7 +254,8 @@ const parseDocumentOperation = (value, index) => {
 			"comment",
 			"severity",
 			"area",
-			"precondition"
+			"precondition",
+			"suggestionId"
 		]);
 		return {
 			...operationMeta,
@@ -263,7 +293,8 @@ const parseDocumentOperation = (value, index) => {
 			"formatting",
 			"severity",
 			"area",
-			"precondition"
+			"precondition",
+			"suggestionId"
 		]);
 		return {
 			...operationMeta,
@@ -382,6 +413,98 @@ const parseDocumentOperation = (value, index) => {
 			...comment !== void 0 && { comment }
 		};
 	}
+	if (type === "insertTableRow") {
+		assertAllowedKeys(value, path, [
+			...COMMON_OPERATION_KEYS,
+			"position",
+			"cellTexts"
+		]);
+		const position = value["position"];
+		if (position !== void 0 && position !== "after" && position !== "before") return invalidBatch(`${path}.position`, "expected \"after\" or \"before\" when provided");
+		const cellTexts = readOptionalStringArray(value, "cellTexts", path);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			...position !== void 0 && { position },
+			...cellTexts !== void 0 && { cellTexts }
+		};
+	}
+	if (type === "deleteTableRow") {
+		assertAllowedKeys(value, path, COMMON_OPERATION_KEYS);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId
+		};
+	}
+	if (type === "insertTableColumn") {
+		assertAllowedKeys(value, path, [
+			...COMMON_OPERATION_KEYS,
+			"position",
+			"cellTexts"
+		]);
+		const position = value["position"];
+		if (position !== void 0 && position !== "after" && position !== "before") return invalidBatch(`${path}.position`, "expected \"after\" or \"before\" when provided");
+		const cellTexts = readOptionalStringArray(value, "cellTexts", path);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			...position !== void 0 && { position },
+			...cellTexts !== void 0 && { cellTexts }
+		};
+	}
+	if (type === "deleteTableColumn") {
+		assertAllowedKeys(value, path, COMMON_OPERATION_KEYS);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId
+		};
+	}
+	if (type === "mergeTableCells") {
+		assertAllowedKeys(value, path, [
+			...COMMON_OPERATION_KEYS,
+			"endBlockId",
+			"rowCount"
+		]);
+		const endBlockId = readOptionalString(value, "endBlockId", path);
+		const rawRowCount = value["rowCount"];
+		if (endBlockId === void 0 === (rawRowCount === void 0)) return invalidBatch(path, "expected exactly one of endBlockId or rowCount");
+		if (endBlockId !== void 0) {
+			if (endBlockId.length === 0) return invalidBatch(`${path}.endBlockId`, "expected a non-empty string");
+			return {
+				...operationMeta,
+				id,
+				type,
+				blockId,
+				endBlockId
+			};
+		}
+		const rowCount = readNonNegativeInteger(value, "rowCount", path);
+		if (rowCount < 2) return invalidBatch(`${path}.rowCount`, "expected an integer greater than or equal to 2");
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			rowCount
+		};
+	}
+	if (type === "splitTableCell") {
+		assertAllowedKeys(value, path, COMMON_OPERATION_KEYS);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId
+		};
+	}
 	return invalidBatch(`${path}.type`, `unsupported operation type "${type}"`);
 };
 const parseFolioDocumentOperationBatch = (value) => {
@@ -397,7 +520,7 @@ const parseFolioDocumentOperationBatch = (value) => {
 	const operations = value["operations"];
 	if (!Array.isArray(operations)) return invalidBatch("$.operations", "expected an array");
 	const mode = value["mode"];
-	if (mode !== void 0 && mode !== "direct" && mode !== "tracked-changes") return invalidBatch("$.mode", "expected \"direct\" or \"tracked-changes\" when provided");
+	if (mode !== void 0 && mode !== "direct" && mode !== "tracked-changes" && mode !== "suggested") return invalidBatch("$.mode", "expected \"direct\", \"tracked-changes\", or \"suggested\" when provided");
 	const atomic = readOptionalBoolean(value, "atomic", "$");
 	const dryRun = readOptionalBoolean(value, "dryRun", "$");
 	const parsedOperations = operations.map(parseDocumentOperation);
@@ -498,6 +621,51 @@ const getPrimaryAffectedTarget = (operation, story) => {
 			position: operation.position ?? "after",
 			content: "signatureTable"
 		};
+		case "insertTableRow": return {
+			type: "insertion",
+			story,
+			anchorBlockId: operation.blockId,
+			position: operation.position ?? "after",
+			content: "tableRow"
+		};
+		case "deleteTableRow": return {
+			type: "tableRow",
+			story,
+			anchorBlockId: operation.blockId,
+			effect: "deleted"
+		};
+		case "insertTableColumn": return {
+			type: "insertion",
+			story,
+			anchorBlockId: operation.blockId,
+			position: operation.position ?? "after",
+			content: "tableColumn"
+		};
+		case "deleteTableColumn": return {
+			type: "tableColumn",
+			story,
+			anchorBlockId: operation.blockId,
+			effect: "deleted"
+		};
+		case "mergeTableCells": return operation.rowCount !== void 0 ? {
+			type: "tableCells",
+			story,
+			anchorBlockId: operation.blockId,
+			rowCount: operation.rowCount,
+			effect: "merged"
+		} : {
+			type: "tableCells",
+			story,
+			anchorBlockId: operation.blockId,
+			endAnchorBlockId: operation.endBlockId,
+			effect: "merged"
+		};
+		case "splitTableCell": return {
+			type: "tableCell",
+			story,
+			anchorBlockId: operation.blockId,
+			effect: "split"
+		};
 	}
 };
 /** Build deterministic affected-target receipts from operations and their applied entries. */

package/dist/docx/blockContentParser.js

@@ -1,10 +1,10 @@
 import { elementToXml, findChild, getChildElements, getLocalName, mergeXmlnsDeclarations } from "./xmlParser.js";
+import { padDecimal } from "./numberingParser.js";
 import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
 import { parseSdtProperties } from "./sdtProperties.js";
 import { parseParagraph } from "./paragraphParser.js";
 import { appendBookmarkMarkerToLastParagraphInBlocks, prependBookmarkMarkersToFirstParagraphInBlocks } from "./bookmarkPlacement.js";
 import { convertBulletToUnicode } from "./bulletMarkers.js";
-import { padDecimal } from "./numberingParser.js";
 import { enrichParagraphTextBoxes } from "./paragraphTextBoxEnrichment.js";
 import { parseTable } from "./tableParser.js";
 //#region src/docx/blockContentParser.ts
@@ -53,7 +53,7 @@ const formatNumber = (value, numFmt) => {
 		default: return String(value);
 	}
 };
-const computeListMarker = (paragraph, { numbering, listCounters, abstractCounters, restartedNumIds, previousList }) => {
+const computeListMarker = (paragraph, { numbering, listCounters, abstractCounters, restartedNumIds, previousList, siblingNumIdsByAbstractNumId }) => {
 	const listRendering = paragraph.listRendering;
 	if (!listRendering || !numbering) {
 		previousList.abstractNumId = null;
@@ -73,6 +73,14 @@ const computeListMarker = (paragraph, { numbering, listCounters, abstractCounter
 	const counters = listCounters.get(numId);
 	if (!counters) return;
 	const abstractNumId = numbering.getAbstractNumId(numId);
+	if (firstEncounter && abstractNumId !== null) {
+		let siblingNumIds = siblingNumIdsByAbstractNumId.get(abstractNumId);
+		if (!siblingNumIds) {
+			siblingNumIds = /* @__PURE__ */ new Set();
+			siblingNumIdsByAbstractNumId.set(abstractNumId, siblingNumIds);
+		}
+		siblingNumIds.add(numId);
+	}
 	const styleNumbering = paragraph.formatting?.numPrFromStyle;
 	let resumedAbstractCounters;
 	const resumesRestartedInstance = firstEncounter && listRendering.startOverride === void 0 && abstractNumId !== null && previousList.abstractNumId === abstractNumId && previousList.numId !== null && previousList.numId !== numId && restartedNumIds.has(previousList.numId);
@@ -101,9 +109,13 @@ const computeListMarker = (paragraph, { numbering, listCounters, abstractCounter
 		counters[level + 1] = (childCounter === void 0 || Number.isNaN(childCounter) ? 0 : childCounter) + childAdvances;
 	}
 	if (abstractNumId !== null) {
-		if (resumedAbstractCounters) for (const [otherNumId, otherCounters] of listCounters) {
-			if (otherNumId === numId || numbering.getAbstractNumId(otherNumId) !== abstractNumId || !otherCounters.every((value, index) => Object.is(value, resumedAbstractCounters[index]))) continue;
-			for (let i = 0; i < otherCounters.length; i += 1) otherCounters[i] = counters[i] ?? NaN;
+		if (resumedAbstractCounters) {
+			const siblingNumIds = siblingNumIdsByAbstractNumId.get(abstractNumId);
+			for (const otherNumId of siblingNumIds ?? []) {
+				const otherCounters = listCounters.get(otherNumId);
+				if (otherNumId === numId || !otherCounters || !otherCounters.every((value, index) => Object.is(value, resumedAbstractCounters[index]))) continue;
+				for (let i = 0; i < otherCounters.length; i += 1) otherCounters[i] = counters[i] ?? NaN;
+			}
 		}
 		abstractCounters.set(abstractNumId, [...counters]);
 	}
@@ -140,6 +152,7 @@ const parseBlockContent = (parent, styles, theme, numbering, rels, media, option
 		fromStyle: false,
 		numId: null
 	},
+	siblingNumIdsByAbstractNumId: /* @__PURE__ */ new Map(),
 	options: {
 		...options,
 		rootXmlns: mergeXmlnsDeclarations(options?.rootXmlns ?? {}, parent)
@@ -154,13 +167,14 @@ const parseBlockContentWithState = (parent, styles, theme, numbering, rels, medi
 		if (localName === "p") {
 			const paragraph = parseParagraph(child, styles, theme, numbering, rels, media, state.options);
 			prependPendingBookmarkMarkers(paragraph, pendingBookmarkMarkers);
-			enrichParagraphTextBoxes(paragraph, child, styles, theme, numbering, rels, media);
+			enrichParagraphTextBoxes(paragraph, child, styles, theme, numbering, rels, media, parseTable);
 			computeListMarker(paragraph, {
 				numbering,
 				listCounters: state.listCounters,
 				abstractCounters: state.abstractCounters,
 				restartedNumIds: state.restartedNumIds,
-				previousList: state.previousList
+				previousList: state.previousList,
+				siblingNumIdsByAbstractNumId: state.siblingNumIdsByAbstractNumId
 			});
 			content.push(paragraph);
 			continue;

package/dist/docx/commentParser.js

@@ -75,7 +75,8 @@ function parseComments(commentsXml, styles, theme, rels, media, commentsExtensib
 	for (const child of children) {
 		if ((child.name?.replace(/^.*:/u, "") ?? "") !== "comment") continue;
 		const id = Number.parseInt(getAttribute(child, "w", "id") ?? "0", 10);
-		const author = getAttribute(child, "w", "author")?.trim() || "Unknown";
+		const rawAuthor = getAttribute(child, "w", "author");
+		const author = parseCommentAuthor(rawAuthor);
 		const rawInitials = getAttribute(child, "w", "initials");
 		const initials = rawInitials !== null ? String(rawInitials) : void 0;
 		const rawDate = getAttribute(child, "w", "date");
@@ -123,5 +124,9 @@ function parseComments(commentsXml, styles, theme, rels, media, commentsExtensib
 	}
 	return comments;
 }
+const parseCommentAuthor = (author) => {
+	if (author === "") return "";
+	return author?.trim() || "Unknown";
+};
 //#endregion
 export { parseComments, parseCommentsExtended };

package/dist/docx/commentRangeIntegrity.d.ts

@@ -0,0 +1,6 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/docx/commentRangeIntegrity.d.ts
+declare const withoutOrphanCommentRanges: (doc: document_d_exports.Document) => document_d_exports.Document;
+//#endregion
+export { withoutOrphanCommentRanges };