@stll/folio-core 0.37.5 → 0.38.0

package/dist/internal/compare/inline-presentation.js

@@ -0,0 +1,222 @@
+import { panic } from "better-result";
+//#region src/internal/compare/inline-presentation.ts
+/**
+* Canonical interpretation of the inline presentation carried by comparison
+* snapshots.
+*
+* Effective and explicitly authored values are separate facts. Every caller
+* compares them through the descriptor grammar below, so adding a supported
+* property cannot update redline planning while leaving verification behind.
+*/
+const NO_PRESENTATION_DIFFERENCE = Symbol("no-inline-presentation-difference");
+const HEX_COLOR = /^#?(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/u;
+const normalizeInlinePresentationColor = (color) => HEX_COLOR.test(color) ? color.replace(/^#/u, "").toUpperCase() : color;
+/**
+* The one grammar for every modeled run-presentation property. The
+* `SamePropertySet` constraint also rejects a field added to `FolioContentRun`
+* without a corresponding authored-formatting representation, or vice versa.
+*/
+const INLINE_PRESENTATION_GRAMMAR = {
+	boolean: [
+		"bold",
+		"italic",
+		"underline",
+		"strike"
+	],
+	string: ["fontFamily"],
+	number: ["fontSizePt"],
+	color: ["color"]
+};
+const INLINE_PRESENTATION_HOT_PATH_GRAMMAR = INLINE_PRESENTATION_GRAMMAR;
+/** Derived from the descriptor grammar; tests use it to prove full coverage. */
+const CANONICAL_INLINE_PRESENTATION_PROPERTIES = Object.freeze([
+	...INLINE_PRESENTATION_GRAMMAR.boolean,
+	...INLINE_PRESENTATION_GRAMMAR.string,
+	...INLINE_PRESENTATION_GRAMMAR.number,
+	...INLINE_PRESENTATION_GRAMMAR.color
+]);
+const canonicalColor = (value) => value === null || value === void 0 ? value : normalizeInlinePresentationColor(value);
+const writeCanonicalInlinePresentationDifferences = (base, revised, patch) => {
+	let changed = false;
+	const baseDirect = base?.directFormatting ?? {};
+	const revisedDirect = revised?.directFormatting ?? {};
+	for (const property of INLINE_PRESENTATION_HOT_PATH_GRAMMAR.boolean) {
+		const baseAuthored = baseDirect[property];
+		const revisedAuthored = revisedDirect[property];
+		const baseEffective = base?.[property] === true;
+		const revisedEffective = revised?.[property] === true;
+		let value;
+		if (baseAuthored !== revisedAuthored) value = revisedAuthored ?? null;
+		else if (baseEffective === revisedEffective) value = NO_PRESENTATION_DIFFERENCE;
+		else value = revisedEffective;
+		if (value !== NO_PRESENTATION_DIFFERENCE) {
+			changed = true;
+			if (patch !== null) patch[property] = value;
+		}
+	}
+	const stringProperty = INLINE_PRESENTATION_HOT_PATH_GRAMMAR.string[0];
+	let stringValue;
+	if (baseDirect[stringProperty] !== revisedDirect[stringProperty]) stringValue = revisedDirect[stringProperty] ?? null;
+	else if (base?.[stringProperty] === revised?.[stringProperty]) stringValue = NO_PRESENTATION_DIFFERENCE;
+	else stringValue = revised?.[stringProperty] ?? null;
+	if (stringValue !== NO_PRESENTATION_DIFFERENCE) {
+		changed = true;
+		if (patch !== null) patch[stringProperty] = stringValue;
+	}
+	const numberProperty = INLINE_PRESENTATION_HOT_PATH_GRAMMAR.number[0];
+	let numberValue;
+	if (baseDirect[numberProperty] !== revisedDirect[numberProperty]) numberValue = revisedDirect[numberProperty] ?? null;
+	else if (base?.[numberProperty] === revised?.[numberProperty]) numberValue = NO_PRESENTATION_DIFFERENCE;
+	else numberValue = revised?.[numberProperty] ?? null;
+	if (numberValue !== NO_PRESENTATION_DIFFERENCE) {
+		changed = true;
+		if (patch !== null) patch[numberProperty] = numberValue;
+	}
+	const colorProperty = INLINE_PRESENTATION_HOT_PATH_GRAMMAR.color[0];
+	const baseAuthoredColor = canonicalColor(baseDirect[colorProperty]);
+	const revisedAuthoredColor = canonicalColor(revisedDirect[colorProperty]);
+	const baseEffectiveColor = canonicalColor(base?.[colorProperty]);
+	const revisedEffectiveColor = canonicalColor(revised?.[colorProperty]);
+	let color;
+	if (baseAuthoredColor !== revisedAuthoredColor) color = revisedAuthoredColor ?? null;
+	else if (baseEffectiveColor === revisedEffectiveColor) color = NO_PRESENTATION_DIFFERENCE;
+	else color = revisedEffectiveColor ?? null;
+	if (color !== NO_PRESENTATION_DIFFERENCE) {
+		changed = true;
+		if (patch !== null) patch[colorProperty] = color;
+	}
+	return changed;
+};
+const canonicalInlinePresentationsEqual = (base, revised) => !writeCanonicalInlinePresentationDifferences(base, revised, null);
+const changedCanonicalInlinePresentation = (base, revised) => {
+	const patch = {};
+	return writeCanonicalInlinePresentationDifferences(base, revised, patch) ? patch : null;
+};
+const sameCanonicalInlinePresentationPatch = (left, right) => {
+	for (const property of INLINE_PRESENTATION_GRAMMAR.boolean) if (left[property] !== right[property]) return false;
+	for (const property of INLINE_PRESENTATION_GRAMMAR.string) if (left[property] !== right[property]) return false;
+	for (const property of INLINE_PRESENTATION_GRAMMAR.number) if (left[property] !== right[property]) return false;
+	for (const property of INLINE_PRESENTATION_GRAMMAR.color) if (left[property] !== right[property]) return false;
+	return true;
+};
+/**
+* Walk the shared UTF-16 coordinate space once. Run boundaries may differ;
+* malformed run streams never yield a trusted projection.
+*/
+const visitAlignedRunRanges = (options) => {
+	const { baseBlock, revisedBlock } = options;
+	if (baseBlock.text !== revisedBlock.text) return "unalignable";
+	const baseRuns = baseBlock.previewRuns ?? [{ text: baseBlock.text }];
+	const revisedRuns = revisedBlock.previewRuns ?? [{ text: revisedBlock.text }];
+	let baseRunIndex = 0;
+	let revisedRunIndex = 0;
+	let baseRunOffset = 0;
+	let revisedRunOffset = 0;
+	let baseBlockOffset = 0;
+	let revisedBlockOffset = 0;
+	let exceededBudget = false;
+	while (true) {
+		let baseRunText = baseRuns[baseRunIndex]?.text;
+		while (baseRunText !== void 0 && baseRunOffset === baseRunText.length) {
+			baseRunIndex++;
+			baseRunOffset = 0;
+			baseRunText = baseRuns[baseRunIndex]?.text;
+		}
+		let revisedRunText = revisedRuns[revisedRunIndex]?.text;
+		while (revisedRunText !== void 0 && revisedRunOffset === revisedRunText.length) {
+			revisedRunIndex++;
+			revisedRunOffset = 0;
+			revisedRunText = revisedRuns[revisedRunIndex]?.text;
+		}
+		if (baseRunIndex === baseRuns.length || revisedRunIndex === revisedRuns.length) {
+			if (!(baseRunIndex === baseRuns.length && revisedRunIndex === revisedRuns.length && baseBlockOffset === baseBlock.text.length && revisedBlockOffset === revisedBlock.text.length)) return "unalignable";
+			if (exceededBudget) return "budget-exceeded";
+			return "complete";
+		}
+		if (baseRunText === void 0 || revisedRunText === void 0) return "unalignable";
+		if (baseRunOffset === 0 && !baseBlock.text.startsWith(baseRunText, baseBlockOffset) || revisedRunOffset === 0 && !revisedBlock.text.startsWith(revisedRunText, revisedBlockOffset)) return "unalignable";
+		const length = Math.min(baseRunText.length - baseRunOffset, revisedRunText.length - revisedRunOffset);
+		const baseRun = baseRuns[baseRunIndex];
+		const revisedRun = revisedRuns[revisedRunIndex];
+		if (options.type === "equivalence") {
+			if (!canonicalInlinePresentationsEqual(baseRun, revisedRun)) return "stopped";
+		} else if (!exceededBudget) {
+			const formatting = changedCanonicalInlinePresentation(baseRun, revisedRun);
+			if (formatting !== null) {
+				const previous = options.segments.at(-1);
+				if (previous && previous.endOffset === baseBlockOffset && sameCanonicalInlinePresentationPatch(previous.formatting, formatting)) previous.endOffset += length;
+				else if (options.segments.length >= options.maxSegments) exceededBudget = true;
+				else options.segments.push({
+					startOffset: baseBlockOffset,
+					endOffset: baseBlockOffset + length,
+					formatting
+				});
+			}
+		}
+		baseRunOffset += length;
+		revisedRunOffset += length;
+		baseBlockOffset += length;
+		revisedBlockOffset += length;
+	}
+};
+const hasAlignedRunStream = (block) => {
+	if (block.previewRuns === void 0) return true;
+	let offset = 0;
+	for (const run of block.previewRuns) {
+		if (!block.text.startsWith(run.text, offset)) return false;
+		offset += run.text.length;
+	}
+	return offset === block.text.length;
+};
+/**
+* Collect coalesced canonical presentation differences in character order.
+* Invalid run streams take precedence over the segment budget, so malformed
+* content cannot change meaning as the caller's remaining budget changes.
+*/
+const canonicalInlinePresentationSegments = ({ baseBlock, revisedBlock, maxSegments }) => {
+	const segments = [];
+	const result = visitAlignedRunRanges({
+		type: "segments",
+		baseBlock,
+		revisedBlock,
+		maxSegments,
+		segments
+	});
+	switch (result) {
+		case "complete": return {
+			status: "compared",
+			segments
+		};
+		case "budget-exceeded": return {
+			status: "budget-exceeded",
+			maximum: maxSegments
+		};
+		case "unalignable": {
+			const baseAligned = hasAlignedRunStream(baseBlock);
+			if (baseAligned === hasAlignedRunStream(revisedBlock)) return {
+				status: "unalignable",
+				side: "both"
+			};
+			if (baseAligned) return {
+				status: "unalignable",
+				side: "revised"
+			};
+			return {
+				status: "unalignable",
+				side: "base"
+			};
+		}
+		case "stopped": return panic("A segment traversal cannot stop at a presentation difference");
+		default: return result;
+	}
+};
+/** Effective and authored presentation equality, independent of run splits. */
+const sameCanonicalInlinePresentation = (baseBlock, revisedBlock) => {
+	return visitAlignedRunRanges({
+		type: "equivalence",
+		baseBlock,
+		revisedBlock
+	}) === "complete";
+};
+//#endregion
+export { CANONICAL_INLINE_PRESENTATION_PROPERTIES, canonicalInlinePresentationSegments, sameCanonicalInlinePresentation };

package/dist/internal/paragraphFormattingSerialization.d.ts

@@ -6,6 +6,8 @@ type ClassifiedParagraphFormattingField = "alignment" | "bidi" | "kinsoku" | "ov
 type ExhaustiveParagraphFormatting = ExhaustiveFields<document_d_exports.ParagraphFormatting, ClassifiedParagraphFormattingField>;
 /** Compare numbering references by their emitted id and effective level. */
 declare const paragraphNumberingReferencesEqual: (left: ParagraphNumberingReference, right: ParagraphNumberingReference) => boolean;
+/** Compare the authored `w:numPr` attributes, including an absent `w:ilvl`. */
+declare const sameAuthoredParagraphNumberingReference: (left: ParagraphNumberingReference, right: ParagraphNumberingReference) => boolean;
 /** Whether resolved numbering still belongs to the paragraph's style tier. */
 declare const isStyleSourcedParagraphNumbering: (numPr: ParagraphNumberingReference, numPrFromStyle: ParagraphNumberingReference) => boolean;
 /** Exact fallback-emission instructions for the modeled part of `w:pPr`. */
@@ -20,4 +22,4 @@ type ModeledParagraphFormattingEmission = Readonly<{
  */
 declare const modelParagraphFormattingEmission: (input: ExhaustiveParagraphFormatting | undefined) => ModeledParagraphFormattingEmission;
 //#endregion
-export { ModeledParagraphFormattingEmission, isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission, paragraphNumberingReferencesEqual };
+export { ModeledParagraphFormattingEmission, isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission, paragraphNumberingReferencesEqual, sameAuthoredParagraphNumberingReference };

package/dist/internal/paragraphFormattingSerialization.js

@@ -17,6 +17,13 @@ const paragraphNumberingReferencesEqual = (left, right) => {
 	if (modeledLeft === null || modeledRight === null) return modeledLeft === null && modeledRight === null;
 	return modeledLeft.numId === modeledRight.numId && (modeledLeft.ilvl ?? 0) === (modeledRight.ilvl ?? 0);
 };
+/** Compare the authored `w:numPr` attributes, including an absent `w:ilvl`. */
+const sameAuthoredParagraphNumberingReference = (left, right) => {
+	const modeledLeft = modelParagraphNumberingReference(left);
+	const modeledRight = modelParagraphNumberingReference(right);
+	if (modeledLeft === null || modeledRight === null) return modeledLeft === null && modeledRight === null;
+	return modeledLeft.numId === modeledRight.numId && modeledLeft.ilvl === modeledRight.ilvl;
+};
 /** Whether resolved numbering still belongs to the paragraph's style tier. */
 const isStyleSourcedParagraphNumbering = (numPr, numPrFromStyle) => numPr != null && numPrFromStyle != null && paragraphNumberingReferencesEqual(numPr, numPrFromStyle);
 const serializeToggle = (name, value) => {
@@ -154,4 +161,4 @@ const modelParagraphFormattingEmission = (input) => {
 	return emission;
 };
 //#endregion
-export { isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission, paragraphNumberingReferencesEqual };
+export { isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission, paragraphNumberingReferencesEqual, sameAuthoredParagraphNumberingReference };

package/dist/internal/sectionReferenceResolution.d.ts

@@ -0,0 +1,21 @@
+import { document_d_exports } from "../types/document.js";
+import { RemovedSectionReference } from "./sectionEndpointResolution.js";
+import { Node } from "prosemirror-model";
+//#region src/internal/sectionReferenceResolution.d.ts
+type SectionReferenceInventory = {
+  references: readonly RemovedSectionReference[];
+  revisionRelationships: ReadonlySet<string>;
+};
+declare const captureSectionReferenceInventory: (document: Node, finalProperties: document_d_exports.SectionProperties | undefined) => SectionReferenceInventory;
+declare const resolvedSectionReferenceLosses: ({ before, after }: {
+  before: SectionReferenceInventory;
+  after: SectionReferenceInventory;
+}) => RemovedSectionReference[];
+declare const withSectionReferenceResolution: <T>({ document, removedReferences, repack }: {
+  document: document_d_exports.Document;
+  removedReferences: readonly RemovedSectionReference[];
+  repack: () => Promise<T>;
+}) => Promise<T>;
+declare const consumeSectionReferenceResolution: (document: document_d_exports.Document) => readonly RemovedSectionReference[];
+//#endregion
+export { SectionReferenceInventory, captureSectionReferenceInventory, consumeSectionReferenceResolution, resolvedSectionReferenceLosses, withSectionReferenceResolution };

package/dist/internal/sectionReferenceResolution.js

@@ -0,0 +1,72 @@
+import { expectParagraphAttrs } from "../prosemirror/attrs/index.js";
+import { panic } from "better-result";
+//#region src/internal/sectionReferenceResolution.ts
+const relationshipKey = ({ part, relationshipId }) => `${part}:${relationshipId}`;
+const referenceKey = (reference) => `${relationshipKey(reference)}:${reference.type}`;
+const captureSectionReferenceInventory = (document, finalProperties) => {
+	const references = [];
+	const revisionRelationships = /* @__PURE__ */ new Set();
+	const collect = (properties) => {
+		if (!properties) return;
+		const start = references.length;
+		const append = (selection) => {
+			for (const { type, rId } of selection.headerReferences ?? []) references.push({
+				part: "header",
+				type,
+				relationshipId: rId
+			});
+			for (const { type, rId } of selection.footerReferences ?? []) references.push({
+				part: "footer",
+				type,
+				relationshipId: rId
+			});
+		};
+		append(properties);
+		const history = properties.propertyChanges?.filter(({ previousReferences }) => previousReferences !== void 0) ?? [];
+		for (const change of history) if (change.previousReferences) append(change.previousReferences);
+		if (history.length > 0) for (const reference of references.slice(start)) revisionRelationships.add(relationshipKey(reference));
+	};
+	document.descendants((node) => {
+		if (node.type.name === "paragraph") collect(expectParagraphAttrs(node)._sectionProperties);
+	});
+	collect(finalProperties);
+	return {
+		references,
+		revisionRelationships
+	};
+};
+const resolvedSectionReferenceLosses = ({ before, after }) => {
+	const remaining = /* @__PURE__ */ new Map();
+	for (const reference of after.references) {
+		const key = referenceKey(reference);
+		remaining.set(key, (remaining.get(key) ?? 0) + 1);
+	}
+	const removed = [];
+	for (const reference of before.references) {
+		if (!before.revisionRelationships.has(relationshipKey(reference))) continue;
+		const key = referenceKey(reference);
+		const count = remaining.get(key) ?? 0;
+		if (count > 0) remaining.set(key, count - 1);
+		else removed.push(reference);
+	}
+	return removed;
+};
+const activeResolutions = /* @__PURE__ */ new WeakMap();
+const withSectionReferenceResolution = async ({ document, removedReferences, repack }) => {
+	if (activeResolutions.has(document)) panic("A section reference repack is already active");
+	activeResolutions.set(document, removedReferences.map((reference) => ({ ...reference })));
+	try {
+		const result = await repack();
+		if (activeResolutions.has(document)) panic("The section reference repack did not consume its resolution");
+		return result;
+	} finally {
+		activeResolutions.delete(document);
+	}
+};
+const consumeSectionReferenceResolution = (document) => {
+	const references = activeResolutions.get(document) ?? [];
+	activeResolutions.delete(document);
+	return references;
+};
+//#endregion
+export { captureSectionReferenceInventory, consumeSectionReferenceResolution, resolvedSectionReferenceLosses, withSectionReferenceResolution };

package/dist/layout-bridge/convert/toFlowBlocks.js

@@ -393,6 +393,7 @@ const RUN_FORMATTING_OVERRIDE_HANDLER_ENTRIES = Object.entries({
 	fontSizeCs(formatting, value) {
 		if (typeof value === "number") formatting.complexScriptFontSize = value / 2;
 	},
+	noProof() {},
 	hidden(formatting, value) {
 		if (typeof value === "boolean") formatting.hidden = value;
 	},

package/dist/markdown/renderRuns.js

@@ -148,6 +148,7 @@ function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 	const renderChild = (child) => {
 		if (child.type === "run") return renderRun(ctx, pkg, child, paraId);
 		if (child.type === "hyperlink") return renderHyperlink(ctx, pkg, child, paraId);
+		if (child.type === "mathEquation") return child.plainText ? escapeInline(child.plainText) : "";
 		return "";
 	};
 	if (ctx.opts.trackedChanges === "clean") {

package/dist/markdown/renderTable.js

@@ -160,6 +160,7 @@ function renderHtmlChildren(ctx, pkg, children, paraId) {
 	return children.map((child) => {
 		if (child.type === "run") return renderHtmlRun(ctx, pkg, child, paraId);
 		if (child.type === "hyperlink") return renderHtmlHyperlink(ctx, pkg, child, paraId);
+		if (child.type === "mathEquation") return child.plainText ? escapeHtml(child.plainText) : "";
 		return "";
 	}).join("");
 }

package/dist/prosemirror/attrs/index.js

@@ -1,4 +1,5 @@
 import { EMPHASIS_MARK_VALUES, FIELD_TYPE_VALUES, FONT_HINT_VALUES, FONT_THEME_VALUES, HIGHLIGHT_COLOR_VALUES, IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES, IMAGE_WRAP_TEXT_VALUES, IMAGE_WRAP_TYPE_VALUES, LINE_SPACING_RULE_VALUES, NUMBER_FORMAT_VALUES, OUTLINE_STYLE_ATTR_VALUES, PARAGRAPH_ALIGNMENT_VALUES, POSITIONAL_TAB_ALIGNMENT_VALUES, POSITIONAL_TAB_LEADER_VALUES, POSITIONAL_TAB_RELATIVE_TO_VALUES, SDT_LOCK_VALUES, SDT_TYPE_VALUES, SHADING_PATTERN_VALUES, TABLE_CELL_TEXT_DIRECTION_VALUES, TABLE_CELL_VERTICAL_ALIGNMENT_VALUES, TABLE_JUSTIFICATION_VALUES, TABLE_ROW_HEIGHT_RULE_VALUES, TABLE_WIDTH_TYPE_VALUES, TAB_LEADER_VALUES, TAB_STOP_ALIGNMENT_VALUES, TEXT_EFFECT_VALUES, THEME_COLOR_SLOT_VALUES, UNDERLINE_STYLE_VALUES } from "../../types/documentEnumValues.js";
+import { canonicalJson } from "../../utils/canonicalJson.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { isParagraphDirection } from "../paragraphDirection.js";
 import { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS, RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_VALUE_PROPERTIES, TRACKED_CHANGE_PROVENANCE_VALUES } from "../schema/marks.js";
@@ -241,6 +242,7 @@ const readParagraphAttrs = (node) => {
 	optionalRecord(attrs, "spacingFromDocDefaults", "paragraph.attrs.spacingFromDocDefaults", issues);
 	optionalRecord(attrs, "spacingFromImplicitDefaultStyle", "paragraph.attrs.spacingFromImplicitDefaultStyle", issues);
 	optionalTextFormatting(attrs, "defaultTextFormatting", "paragraph.attrs.defaultTextFormatting", issues);
+	optionalTextFormatting(attrs, "_tableRunFormatting", "paragraph.attrs._tableRunFormatting", issues);
 	optionalRecord(attrs, "numPr", "paragraph.attrs.numPr", issues);
 	validateNumPr(attrs["numPr"], issues);
 	optionalBookmarkArray(attrs["bookmarks"], issues);
@@ -814,7 +816,24 @@ const mergeNodeAttrs = (node, readAttrs, label, patch) => {
 	for (const [key, value] of Object.entries(mergedAttrs)) if (value !== void 0) nextAttrs[key] = value;
 	return nextAttrs;
 };
-const mergeImageAttrs = (node, patch) => mergeNodeAttrs(node, readImageAttrs, "image attrs", patch);
+const IMAGE_RESOURCE_ATTRS = /* @__PURE__ */ new Set([
+	"rId",
+	"_docxRawXml",
+	"_docxRawXmlMode",
+	"_docxObjectPreview"
+]);
+const imageAttrValuesEqual = (left, right) => {
+	if (left === right) return true;
+	if ((left === void 0 || left === null) && (right === void 0 || right === null)) return true;
+	return canonicalJson(left) === canonicalJson(right);
+};
+const mergeImageAttrs = (node, patch) => {
+	const current = expectImageAttrs(node);
+	const merged = mergeNodeAttrs(node, readImageAttrs, "image attrs", patch);
+	if (!Object.entries(patch).some(([key, value]) => !IMAGE_RESOURCE_ATTRS.has(key) && !imageAttrValuesEqual(Reflect.get(current, key), value)) || current._docxRawXml === void 0 || current._docxRawXmlMode === DRAWING_RAW_XML_MODES.PRESERVE_ONLY) return merged;
+	const { _docxRawXml: _discardedRawXml, ...editableAttrs } = merged;
+	return editableAttrs;
+};
 const mergeParagraphAttrs = (node, patch) => mergeNodeAttrs(node, readParagraphAttrs, "paragraph attrs", patch);
 const mergeTableAttrs = (node, patch) => mergeNodeAttrs(node, readTableAttrs, "table attrs", patch);
 const mergeTableRowAttrs = (node, patch) => mergeNodeAttrs(node, readTableRowAttrs, "table row attrs", patch);

package/dist/prosemirror/commands/comments.d.ts

@@ -1,4 +1,5 @@
 import { Command, EditorState } from "prosemirror-state";
+import { Mapping } from "prosemirror-transform";
 //#region src/prosemirror/commands/comments.d.ts
 /**
  * Add a comment mark to the current selection.
@@ -46,6 +47,15 @@ declare function rejectAllChanges(): Command;
  * mapped through concurrent edits.
  */
 declare function resolveAllChangesInHeadlessState(state: EditorState, mode: ResolveMode): EditorState;
+/**
+ * Resolve through the editor command path when a caller must map a position in
+ * the reviewed document back to the tracked source. The bulk resolver is
+ * faster, but deliberately replaces inline content without retaining mapping.
+ */
+declare const resolveAllChangesInHeadlessStateWithMapping: (state: EditorState, mode: ResolveMode) => {
+  state: EditorState;
+  mapping: Mapping;
+};
 /**
  * Find the document range covered by all revision carriers with any of the
  * given ids. Returns null when none are present (already accepted/rejected, or
@@ -174,4 +184,4 @@ declare function findNextChange(state: EditorState, startPos: number): ChangeRan
  */
 declare function findPreviousChange(state: EditorState, startPos: number): ChangeRange | null;
 //#endregion
-export { AcceptSuggestionOptions, FolioSuggestion, ParagraphBoundaryChange, SuggestionAppliedAs, SuggestionKind, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState };
+export { AcceptSuggestionOptions, FolioSuggestion, ParagraphBoundaryChange, SuggestionAppliedAs, SuggestionKind, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState, resolveAllChangesInHeadlessStateWithMapping };

package/dist/prosemirror/commands/comments.js

@@ -12,12 +12,14 @@ import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { reconstructRejectedRunFormattingMarks } from "../runPropertyChangeResolution.js";
 import { paragraphRunStyleContextAt } from "../runStyleFormatting.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
+import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
 import { reconcileTableGridAfterColumnRemoval } from "../tableGridMutation.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
 import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
 import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
 import { TableMap, removeRow } from "prosemirror-tables";
-import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
+import { Mapping } from "prosemirror-transform";
+import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
 //#region src/prosemirror/commands/comments.ts
 /**
 * Add a comment mark to the current selection.
@@ -120,7 +122,11 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 						if (matches.length > 0) {
 							const remaining = sectionChanges.filter((c) => revisionSet !== null && (!c.info || !revisionSet.has(c.info.id)));
 							let restored = { ...sectionProperties };
-							if (mode === "reject") for (const change of matches.toReversed()) restored = sectionRejectProperties(restored, change.previousProperties);
+							if (mode === "reject") for (const change of matches.toReversed()) restored = sectionRejectProperties({
+								live: restored,
+								previousProperties: change.previousProperties,
+								previousReferences: change.previousReferences
+							});
 							delete restored.propertyChanges;
 							if (remaining.length > 0) restored.propertyChanges = remaining;
 							nextAttrs = nextAttrs ?? { ...node.attrs };
@@ -132,7 +138,12 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 						nextAttrs,
 						paragraphPosition: pos,
 						styleResolver,
-						tr
+						tr,
+						...mode === "reject" && { shouldRebase: (inline) => {
+							const deleted = inline.marks.some(({ type }) => type.name === "deletion");
+							const direct = inline.marks.some(({ type }) => type.name === "runFormattingOverride");
+							return !deleted || !direct;
+						} }
 					});
 					else tr.setNodeMarkup(pos, void 0, nextAttrs);
 					return true;
@@ -309,11 +320,45 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 				removedEndpointCount: removedSectionEndpointCount,
 				removedReferences: removedSectionReferences
 			});
+			if (!terminalTableDeletionIsPending(tr)) resolveTerminalTableReviewCarrier(tr, mode);
 			if (tr.steps.length > 0) dispatch(tr);
 		}
 		return true;
 	};
 }
+/**
+* The receiver belongs to the deleted terminal table, not every revision in
+* the document. Keep it through independently resolved changes, then resolve
+* it as soon as that table's deletion has been decided.
+*/
+const terminalTableDeletionIsPending = (tr) => {
+	let terminalTable = null;
+	for (let index = tr.doc.childCount - 1; index >= 0; index--) {
+		const node = tr.doc.child(index);
+		if (node.type.name === "table") {
+			terminalTable = node;
+			break;
+		}
+	}
+	if (terminalTable === null) return false;
+	let pending = false;
+	terminalTable.descendants((node) => {
+		pending ||= node.type.name === "tableRow" && isTableRowRevisionAttr(node.attrs["trDel"]) || node.type.name !== "tableRow" && node.marks.some((mark) => mark.type.name === "deletion");
+		return !pending;
+	});
+	return pending;
+};
+/** Resolve the Folio-only receiver Word needs after a terminal deleted table. */
+const resolveTerminalTableReviewCarrier = (tr, mode) => {
+	const carrier = tr.doc.lastChild;
+	if (carrier?.type.name !== "paragraph" || carrier.attrs["reviewCarrier"] !== REVIEW_CARRIERS.TERMINAL_TABLE) return;
+	const position = tr.doc.content.size - carrier.nodeSize;
+	if (mode === "accept") {
+		tr.setNodeAttribute(position, "reviewCarrier", void 0);
+		return;
+	}
+	tr.delete(position, position + carrier.nodeSize);
+};
 const resolveRunPropertyChange = ({ tr, node, from, to, mark, mode, revisionSet, styleResolver }) => {
 	const { changes } = expectRunPropertyChangeMarkAttrs(mark);
 	const matches = changes.filter((change) => revisionSet === null || revisionSet.has(change.info.id));
@@ -401,11 +446,11 @@ function collectTableCellStructuralOps(node, cellPos, mode, revisionSet) {
 		revisionSet
 	});
 	else {
-		const keepsCell = marker.kind === "ins" === (mode === "accept");
+		const view = mode === "accept" ? "final" : "original";
 		operations.push({
 			type: "membership",
 			cellPos,
-			action: keepsCell ? "clear" : "remove"
+			action: isTableCellRetainedInReviewView(marker.kind, view) ? "clear" : "remove"
 		});
 	}
 	if (hasMatchingCollapsedTableCellMerge(node, revisionSet)) operations.push({
@@ -671,6 +716,23 @@ function resolveAllChangesInHeadlessState(state, mode) {
 	return resolvedState;
 }
 /**
+* Resolve through the editor command path when a caller must map a position in
+* the reviewed document back to the tracked source. The bulk resolver is
+* faster, but deliberately replaces inline content without retaining mapping.
+*/
+const resolveAllChangesInHeadlessStateWithMapping = (state, mode) => {
+	let resolvedState = state;
+	let mapping = new Mapping();
+	resolveChange(0, state.doc.content.size, mode)(state, (transaction) => {
+		resolvedState = state.apply(transaction);
+		mapping = transaction.mapping;
+	});
+	return {
+		state: resolvedState,
+		mapping
+	};
+};
+/**
 * Find the document range covered by all revision carriers with any of the
 * given ids. Returns null when none are present (already accepted/rejected, or
 * never existed). A replace operation typically passes two ids; standalone
@@ -1664,4 +1726,4 @@ function findPreviousChange(state, startPos) {
 	return result.value;
 }
 //#endregion
-export { acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState };
+export { acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState, resolveAllChangesInHeadlessStateWithMapping };

package/dist/prosemirror/commands/propertyChangeScope.d.ts

@@ -66,10 +66,16 @@ declare function paragraphRejectOriginalFormatting(previousFormatting: Paragraph
  * Rejected section properties: the stored old sectPr wholesale, preserving
  * the live header/footer references — `EG_HdrFtrReferences` is not part of
  * the `CT_SectPrBase` payload a `w:sectPrChange` stores (ECMA-376
- * §17.13.5.32), so those children survive a reject. The caller re-attaches
- * whatever `propertyChanges` remain unresolved.
+ * §17.13.5.32), so those children survive a native reject. An explicit Folio reference
+ * history replaces that selection, including restoring its absence. The
+ * caller re-attaches whatever `propertyChanges` remain unresolved.
  */
-declare function sectionRejectProperties(live: document_d_exports.SectionProperties, previousProperties: document_d_exports.SectionProperties | undefined): document_d_exports.SectionProperties;
+type SectionRejectPropertiesOptions = {
+  live: document_d_exports.SectionProperties;
+  previousProperties: document_d_exports.SectionProperties | undefined;
+  previousReferences?: document_d_exports.SectionPropertyChange["previousReferences"];
+};
+declare function sectionRejectProperties({ live, previousProperties, previousReferences }: SectionRejectPropertiesOptions): document_d_exports.SectionProperties;
 /**
  * Attr patch for rejecting a `w:tblPrChange`: the stored old tblPr wholesale
  * (`w:tblPrChange` stores the complete previous tblPr, so every tblPr-derived

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -220,19 +220,13 @@ function paragraphRejectOriginalFormatting(previousFormatting, liveOriginal) {
 	if (Object.keys(result).length === 0) return null;
 	return result;
 }
-/**
-* Rejected section properties: the stored old sectPr wholesale, preserving
-* the live header/footer references — `EG_HdrFtrReferences` is not part of
-* the `CT_SectPrBase` payload a `w:sectPrChange` stores (ECMA-376
-* §17.13.5.32), so those children survive a reject. The caller re-attaches
-* whatever `propertyChanges` remain unresolved.
-*/
-function sectionRejectProperties(live, previousProperties) {
+function sectionRejectProperties({ live, previousProperties, previousReferences }) {
 	const restored = { ...previousProperties };
 	delete restored.propertyChanges;
-	if (live.headerReferences) restored.headerReferences = live.headerReferences;
+	const references = previousReferences ?? live;
+	if (references.headerReferences) restored.headerReferences = references.headerReferences;
 	else delete restored.headerReferences;
-	if (live.footerReferences) restored.footerReferences = live.footerReferences;
+	if (references.footerReferences) restored.footerReferences = references.footerReferences;
 	else delete restored.footerReferences;
 	return restored;
 }