@stll/folio-core 0.9.0 → 0.11.0

package/dist/prosemirror/conversion/toProseDoc.js

@@ -7,10 +7,9 @@ import { assertValidProseMirrorDocument } from "../validation.js";
 import { shadingToRunShadingAttrs } from "./runShadingMark.js";
 import { marksToTextFormatting } from "./fromProseDoc.js";
 import { createStyleEngine } from "../../style-engine/styleEngine.js";
-import { resolveColor } from "../../utils/colorResolver.js";
-import { resolveShadingFill } from "../../utils/formatToStyle.js";
 import { buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
 import { schema } from "../schema/index.js";
+import { resolveEffectiveTableCellFormatting } from "./effectiveTableCellFormatting.js";
 //#region src/prosemirror/conversion/toProseDoc.ts
 const TOC_STYLE_ID = /^TOC\d*$/iu;
 /**
@@ -725,88 +724,60 @@ function convertTableRow(row, styleResolver, context, isHeaderRow, columnWidths,
 		if (cellIsFirstRow && cellIsLastCol && (tableLook?.firstRow || rowCnf?.firstRow || cellCnf?.firstRow) && (tableLook?.lastColumn || rowCnf?.lastColumn || cellCnf?.lastColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.neCell);
 		if (cellIsLastRow && cellIsFirstCol && (tableLook?.lastRow || rowCnf?.lastRow || cellCnf?.lastRow) && (tableLook?.firstColumn || rowCnf?.firstColumn || cellCnf?.firstColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.swCell);
 		if (cellIsLastRow && cellIsLastCol && (tableLook?.lastRow || rowCnf?.lastRow || cellCnf?.lastRow) && (tableLook?.lastColumn || rowCnf?.lastColumn || cellCnf?.lastColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.seCell);
-		cells.push(convertTableCell(cell, styleResolver, context, isHeaderRow, gridWidth, cellConditionalStyle, tableBorders, isFirstRow, isLastRow, isFirstCol, isLastCol, calculatedRowSpan, preserveVMergeRestart, rowSpanInfo?.continuationCells, defaultCellMargins));
+		cells.push(convertTableCell({
+			cell,
+			styleResolver,
+			context,
+			isHeader: isHeaderRow,
+			gridWidthPercent: gridWidth,
+			conditionalStyle: cellConditionalStyle,
+			tableBorders,
+			position: {
+				isFirstRow,
+				isLastRow,
+				isFirstColumn: isFirstCol,
+				isLastColumn: isLastCol
+			},
+			calculatedRowSpan,
+			preserveVMergeRestart,
+			vMergeContinuationCells: rowSpanInfo?.continuationCells,
+			defaultCellMargins
+		}));
 	}
 	return schema.node("tableRow", attrs, cells);
 }
-const TABLE_BORDER_SIDES = [
-	"top",
-	"bottom",
-	"left",
-	"right",
-	"insideH",
-	"insideV",
-	"topLeftToBottomRight",
-	"topRightToBottomLeft"
-];
-function resolveThemedBorderColors(borders, theme) {
-	if (!borders || !theme?.colorScheme) return borders;
-	let resolved;
-	for (const side of TABLE_BORDER_SIDES) {
-		const border = borders[side];
-		if (!border?.color?.themeColor || border.color.auto) continue;
-		resolved ??= { ...borders };
-		resolved[side] = {
-			...border,
-			color: { rgb: resolveColor(border.color, theme).replace(/^#/u, "") }
-		};
-	}
-	return resolved ?? borders;
-}
 /**
 * Convert a TableCell to a ProseMirror table cell node
 */
-function convertTableCell(cell, styleResolver, context, isHeader, gridWidthPercent, conditionalStyle, tableBorders, isFirstRow, isLastRow, isFirstCol, isLastCol, calculatedRowSpan, preserveVMergeRestart, vMergeContinuationCells, defaultCellMargins) {
-	const { theme } = context;
+function convertTableCell({ cell, styleResolver, context, isHeader, gridWidthPercent, conditionalStyle, tableBorders, position, calculatedRowSpan, preserveVMergeRestart, vMergeContinuationCells, defaultCellMargins }) {
 	const formatting = cell.formatting;
 	const rowspan = calculatedRowSpan ?? 1;
-	let width = formatting?.width?.value;
-	let widthType = formatting?.width?.type;
-	if (width === void 0 && gridWidthPercent !== void 0) {
-		width = gridWidthPercent;
-		widthType = "pct";
-	}
-	const backgroundColor = resolveShadingFill(formatting?.shading ?? conditionalStyle?.tcPr?.shading, theme).replace(/^#/u, "");
-	const baseBorders = (() => {
-		if (tableBorders) return {
-			top: isFirstRow ? tableBorders.top : tableBorders.insideH,
-			bottom: isLastRow ? tableBorders.bottom : tableBorders.insideH,
-			left: isFirstCol ? tableBorders.left : tableBorders.insideV,
-			right: isLastCol ? tableBorders.right : tableBorders.insideV
-		};
-	})();
-	const conditionalBorders = conditionalStyle?.tcPr?.borders;
-	const cellBorders = formatting?.borders;
-	const borders = resolveThemedBorderColors(baseBorders || conditionalBorders || cellBorders ? {
-		...baseBorders,
-		...conditionalBorders,
-		...cellBorders
-	} : void 0, theme);
-	const buildMarginsAttr = (src) => {
-		const m = {};
-		if (src.top?.value !== void 0) m.top = src.top.value;
-		if (src.bottom?.value !== void 0) m.bottom = src.bottom.value;
-		if (src.left?.value !== void 0) m.left = src.left.value;
-		if (src.right?.value !== void 0) m.right = src.right.value;
-		return m;
-	};
+	const effectiveFormatting = resolveEffectiveTableCellFormatting({
+		directFormatting: formatting,
+		styleFormatting: conditionalStyle?.tcPr,
+		tableBorders,
+		position,
+		gridWidthPercent,
+		defaultMargins: defaultCellMargins,
+		theme: context.theme
+	});
 	const attrs = {
 		colspan: formatting?.gridSpan ?? 1,
 		rowspan
 	};
-	if (width !== void 0) attrs.width = width;
-	if (widthType) attrs.widthType = widthType;
+	if (effectiveFormatting.width.type === "value") {
+		attrs.width = effectiveFormatting.width.value;
+		if (effectiveFormatting.width.widthType) attrs.widthType = effectiveFormatting.width.widthType;
+	}
 	if (formatting?.verticalAlign) attrs.verticalAlign = formatting.verticalAlign;
-	if (backgroundColor) {
-		attrs.backgroundColor = backgroundColor;
-		attrs._resolvedBackgroundColor = backgroundColor;
+	if (effectiveFormatting.background.type === "color") {
+		attrs.backgroundColor = effectiveFormatting.background.rgb;
+		attrs._resolvedBackgroundColor = effectiveFormatting.background.rgb;
 	}
 	if (formatting?.textDirection) attrs.textDirection = formatting.textDirection;
 	if (formatting?.noWrap !== void 0) attrs.noWrap = formatting.noWrap;
-	if (borders) attrs.borders = borders;
-	if (formatting?.margins) attrs.margins = buildMarginsAttr(formatting.margins);
-	else if (conditionalStyle?.tcPr?.margins) attrs.margins = buildMarginsAttr(conditionalStyle.tcPr.margins);
-	else if (defaultCellMargins) attrs.margins = defaultCellMargins;
+	if (effectiveFormatting.borders) attrs.borders = effectiveFormatting.borders;
+	if (effectiveFormatting.margins) attrs.margins = effectiveFormatting.margins;
 	if (formatting) attrs._originalFormatting = formatting;
 	if (cell.propertyChanges && cell.propertyChanges.length > 0) attrs.tcPrChange = [...cell.propertyChanges];
 	if (preserveVMergeRestart) attrs._preserveVMergeRestart = true;
@@ -1072,6 +1043,7 @@ function convertImage(image, rawXml) {
 		cropBottom: image.crop?.bottom,
 		cropLeft: image.crop?.left,
 		position,
+		layoutInCell: image.layoutInCell,
 		borderWidth,
 		borderColor,
 		borderStyle,

package/dist/prosemirror/extensions/core/ParagraphExtension.js

@@ -1,8 +1,8 @@
 import { autospacingMatchesBase } from "../../autospacingBase.js";
 import { directionIsRtl } from "../../paragraphDirection.js";
 import { expectParagraphAttrs } from "../../attrs/index.js";
-import { paragraphToStyle } from "../../../utils/formatToStyle.js";
 import { createNodeExtension } from "../create.js";
+import { paragraphToStyle } from "../../../utils/formatToStyle.js";
 import { collectHeadings } from "../../../utils/headingCollector.js";
 import { listAttrsFromResolvedStyle, paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs.js";
 import { Fragment } from "prosemirror-model";

package/dist/prosemirror/extensions/marks/HighlightExtension.js

@@ -1,7 +1,7 @@
 import { HIGHLIGHT_COLOR_VALUES } from "../../../types/documentEnumValues.js";
 import { expectHighlightMarkAttrs } from "../../attrs/index.js";
-import { resolveHighlightToCss } from "../../../utils/colorResolver.js";
 import { createMarkExtension } from "../create.js";
+import { resolveHighlightToCss } from "../../../utils/colorResolver.js";
 import { removeMark, setMark } from "./markUtils.js";
 import { panic } from "better-result";
 //#region src/prosemirror/extensions/marks/HighlightExtension.ts

package/dist/prosemirror/extensions/marks/RunShadingExtension.js

@@ -1,6 +1,6 @@
 import { expectRunShadingMarkAttrs } from "../../attrs/index.js";
-import { ensureHexPrefix } from "../../../utils/colorResolver.js";
 import { createMarkExtension } from "../create.js";
+import { ensureHexPrefix } from "../../../utils/colorResolver.js";
 import { normalizeCssColorKey, parseDOMHighlightColor } from "./HighlightExtension.js";
 //#region src/prosemirror/extensions/marks/RunShadingExtension.ts
 const RunShadingExtension = createMarkExtension({

package/dist/prosemirror/extensions/marks/TextColorExtension.js

@@ -1,6 +1,6 @@
 import { expectTextColorMarkAttrs } from "../../attrs/index.js";
-import { textToStyle } from "../../../utils/formatToStyle.js";
 import { createMarkExtension } from "../create.js";
+import { textToStyle } from "../../../utils/formatToStyle.js";
 import { removeMark, setMark } from "./markUtils.js";
 import { panic } from "better-result";
 //#region src/prosemirror/extensions/marks/TextColorExtension.ts

package/dist/prosemirror/extensions/nodes/ImageExtension.js

@@ -33,6 +33,7 @@ const ImageExtension = createNodeExtension({
 			cropBottom: { default: null },
 			cropLeft: { default: null },
 			position: { default: null },
+			layoutInCell: { default: null },
 			borderWidth: { default: null },
 			borderColor: { default: null },
 			borderStyle: { default: null },

package/dist/prosemirror/extensions/nodes/TableExtension.js

@@ -1,7 +1,7 @@
 import { TABLE_CELL_TEXT_DIRECTION_VALUES, TABLE_WIDTH_TYPE_VALUES } from "../../../types/documentEnumValues.js";
 import { expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs } from "../../attrs/index.js";
-import { resolveColor } from "../../../utils/colorResolver.js";
 import { createExtension, createNodeExtension } from "../create.js";
+import { resolveColor } from "../../../utils/colorResolver.js";
 import { panic } from "better-result";
 import { Plugin, PluginKey, Selection, TextSelection } from "prosemirror-state";
 import { CellSelection, TableMap, columnResizing, mergeCells, removeRow, selectedRect, splitCell, tableEditing } from "prosemirror-tables";

package/dist/prosemirror/findReplaceSelection.d.ts

@@ -1,3 +1,4 @@
+import { FindOptions } from "../utils/findReplace.js";
 import { Node } from "prosemirror-model";
 
 //#region src/prosemirror/findReplaceSelection.d.ts
@@ -18,6 +19,10 @@ type FindMatchRange = {
   from: number;
   to: number;
 };
+type ProseMirrorFindMatch = FindMatchPosition & FindMatchRange & {
+  text: string;
+};
 declare function resolveFindMatchRange(doc: Node, match: FindMatchPosition): FindMatchRange | null;
+declare function findInProseMirrorDocument(doc: Node, searchText: string, options: FindOptions): ProseMirrorFindMatch[];
 //#endregion
-export { FindMatchPosition, FindMatchRange, resolveFindMatchRange };
+export { FindMatchPosition, FindMatchRange, ProseMirrorFindMatch, findInProseMirrorDocument, resolveFindMatchRange };

package/dist/prosemirror/findReplaceSelection.js

@@ -1,29 +1,55 @@
+import { findAllMatches } from "../utils/findReplace.js";
 //#region src/prosemirror/findReplaceSelection.ts
 function resolveFindMatchRange(doc, match) {
-	let paragraphIndex = 0;
 	let resolved = null;
-	const visitParagraph = (node, pos) => {
-		if (resolved) return false;
-		if (paragraphIndex !== match.paragraphIndex) {
-			paragraphIndex++;
-			return true;
-		}
+	forEachSearchParagraph(doc, (paragraph, paragraphPos, paragraphIndex) => {
+		if (paragraphIndex !== match.paragraphIndex) return true;
 		resolved = resolveTextRangeInParagraph({
-			paragraph: node,
-			paragraphPos: pos,
+			paragraph,
+			paragraphPos,
 			startOffset: match.startOffset,
 			endOffset: match.endOffset
 		});
 		return false;
-	};
+	});
+	return resolved;
+}
+function findInProseMirrorDocument(doc, searchText, options) {
+	if (!searchText) return [];
+	const matches = [];
+	forEachSearchParagraph(doc, (paragraph, paragraphPos, paragraphIndex) => {
+		const text = getSearchableParagraphText(paragraph);
+		for (const { start, end } of findAllMatches(text, searchText, options)) {
+			const range = resolveTextRangeInParagraph({
+				paragraph,
+				paragraphPos,
+				startOffset: start,
+				endOffset: end
+			});
+			if (range) matches.push({
+				paragraphIndex,
+				startOffset: start,
+				endOffset: end,
+				text: text.slice(start, end),
+				...range
+			});
+		}
+		return true;
+	});
+	return matches;
+}
+function forEachSearchParagraph(doc, visit) {
+	let paragraphIndex = 0;
 	const walkBlocks = (container, contentStart) => {
 		let offset = 0;
 		for (let childIndex = 0; childIndex < container.childCount; childIndex++) {
 			const child = container.child(childIndex);
 			const childPos = contentStart + offset;
 			if (child.type.name === "paragraph") {
-				if (!visitParagraph(child, childPos)) return false;
+				if (!visit(child, childPos, paragraphIndex)) return false;
+				paragraphIndex++;
 			} else if (child.type.name === "table" && !walkTable(child, childPos)) return false;
+			else if (child.type.name === "blockSdt" && !walkBlocks(child, childPos + 1)) return false;
 			offset += child.nodeSize;
 		}
 		return true;
@@ -53,7 +79,6 @@ function resolveFindMatchRange(doc, match) {
 		return true;
 	};
 	walkBlocks(doc, 0);
-	return resolved;
 }
 function resolveTextRangeInParagraph({ paragraph, paragraphPos, startOffset, endOffset }) {
 	let textOffset = 0;
@@ -83,5 +108,24 @@ function getSearchTextTokenLength(node) {
 	if (node.type.name === "tab" || node.type.name === "hardBreak") return 1;
 	return 0;
 }
+function getSearchableParagraphText(paragraph) {
+	let text = "";
+	paragraph.descendants((node) => {
+		if (node.isText) {
+			text += node.text ?? "";
+			return false;
+		}
+		if (node.type.name === "tab") {
+			text += "	";
+			return false;
+		}
+		if (node.type.name === "hardBreak") {
+			text += "\n";
+			return false;
+		}
+		return true;
+	});
+	return text;
+}
 //#endregion
-export { resolveFindMatchRange };
+export { findInProseMirrorDocument, resolveFindMatchRange };

package/dist/prosemirror/schema/nodes.d.ts

@@ -197,7 +197,8 @@ type ImageAttrs = {
   cropRight?: number;
   cropBottom?: number;
   cropLeft?: number; /** Position for floating images (horizontal and vertical alignment) */
-  position?: ImagePositionAttrs; /** Border width in pixels */
+  position?: ImagePositionAttrs; /** Use the containing table cell as the anchor's positioning scope (the OOXML default). */
+  layoutInCell?: boolean; /** Border width in pixels */
   borderWidth?: number; /** Border color as CSS color string */
   borderColor?: string; /** Border style (CSS border-style value) */
   borderStyle?: string; /** Wrap text setting from DOCX (left, right, bothSides, largest) for round-trip */

package/dist/redline.d.ts

@@ -1,20 +1,35 @@
-import { FolioAIEditApplyResult } from "./ai-edits/types.js";
+import { FolioAIEditAppliedOperation, FolioAIEditSkippedOperation } from "./ai-edits/types.js";
+import { FolioDocumentStoryHandle, FolioResolvedReviewedView } from "./ai-edits/headless.js";
+import { FolioDocumentPrivacyOptions, FolioDocumentPrivacyReport } from "./docx/metadataPrivacy.js";
 
 //#region src/redline.d.ts
 /** Options for {@link generateRedlineDocx}. */
 type GenerateRedlineDocxOptions = {
-  /** Author recorded on the generated tracked changes. (default: `"folio compare"`) */author?: string;
+  /** Author recorded on the generated tracked changes. (default: `"folio compare"`) */author?: string; /** Resolved base input state. (default: `"final"`) */
+  baseView?: FolioResolvedReviewedView; /** Resolved revised input state. (default: `"final"`) */
+  revisedView?: FolioResolvedReviewedView; /** Optional output-only package-metadata privacy transforms. */
+  privacy?: FolioDocumentPrivacyOptions;
+};
+declare const InvalidGenerateRedlineDocxOptionsError_base: import("better-result").TaggedErrorClass<"InvalidGenerateRedlineDocxOptionsError", {
+  message: string;
+  option: "baseView" | "revisedView";
+  receivedValue: unknown;
+}>;
+declare class InvalidGenerateRedlineDocxOptionsError extends InvalidGenerateRedlineDocxOptionsError_base {}
+type GenerateRedlineUnprocessedStory = {
+  baseStory: FolioDocumentStoryHandle | null;
+  revisedStory: FolioDocumentStoryHandle | null;
+  reason: "missing-base-story" | "missing-revised-story";
 };
 /** Result of {@link generateRedlineDocx}. */
-type GenerateRedlineDocxResult = FolioAIEditApplyResult & {
-  /** The redline `.docx`: the base document with base → revised tracked changes. */buffer: ArrayBuffer;
+type GenerateRedlineDocxResult = {
+  /** The base package with generated tracked changes. */buffer: ArrayBuffer; /** Operations applied across every matched story. */
+  applied: FolioAIEditAppliedOperation[]; /** Block operations that could not be applied. */
+  skipped: FolioAIEditSkippedOperation[]; /** Package parts that could not be represented as story-scoped text edits. */
+  unprocessedStories: GenerateRedlineUnprocessedStory[]; /** Privacy transforms applied to the generated package. */
+  privacyReport: FolioDocumentPrivacyReport;
 };
-/**
- * Compare `base` and `revised` and return the base document with every
- * difference recorded as a tracked change. See the module doc comment for
- * semantics and limitations; `skipped` reports any block the generator could
- * not redline (e.g. additions with no anchor in an empty base document).
- */
+/** Compare two buffers and return tracked changes for every matched editable story. */
 declare const generateRedlineDocx: (base: ArrayBuffer, revised: ArrayBuffer, options?: GenerateRedlineDocxOptions) => Promise<GenerateRedlineDocxResult>;
 //#endregion
-export { GenerateRedlineDocxOptions, GenerateRedlineDocxResult, generateRedlineDocx };
+export { GenerateRedlineDocxOptions, GenerateRedlineDocxResult, GenerateRedlineUnprocessedStory, InvalidGenerateRedlineDocxOptionsError, generateRedlineDocx };

package/dist/redline.js

@@ -1,75 +1,35 @@
-import { FolioDocxReviewer } from "./ai-edits/headless.js";
+import "./document-operations.js";
+import { pairFolioDocumentStories } from "./document-stories.js";
+import { FolioDocxReviewer, isFolioResolvedReviewedView } from "./ai-edits/headless.js";
+import { resolveFolioDocumentPrivacyTransforms, rewriteDocxMetadataPrivacy } from "./docx/metadataPrivacy.js";
 import { alignFolioBlocks } from "./version-comparison.js";
+import { TaggedError, panic } from "better-result";
 //#region src/redline.ts
 /**
-* Redline generator: compare two `.docx` buffers and produce a THIRD `.docx`
-* whose differences are recorded as real Word tracked changes (`w:ins` /
-* `w:del`), ready for review in Word or the folio editor — the
-* document-producing counterpart to {@link compareDocxVersions}'s structured
-* diff.
+* Compare two `.docx` buffers and produce a third buffer whose text
+* differences are represented as tracked changes.
 *
-* The pipeline is a composition of existing machinery, not a new engine:
-* the base buffer is opened in a headless {@link FolioDocxReviewer}, the two
-* snapshots are aligned with {@link alignFolioBlocks} (the same three-pass
-* alignment the comparer uses), each alignment event maps onto a
-* tracked-changes {@link FolioAIEditOperation}, and the reviewer's shared
-* apply path records them as redlines. Word-level minimality comes free:
-* the apply engine word-diffs a `replaceBlock` and only marks the divergent
-* tokens.
-*
-* ## Semantics and limitations
-*
-* - **As-accepted inputs.** Pending tracked changes in either input count as
-*   applied before comparison (mirroring {@link compareDocxVersions}): the
-*   base's own pending redlines are accepted in the output, so the tracked
-*   changes it carries are exactly base → revised. This is intentionally
-*   lossy about the inputs' own revision history and authorship.
-* - **Text redlines only.** Format-only changes and relocated blocks are
-*   redlined as plain edits (a move becomes a delete + insert, like Word
-*   compare with move detection off); block-level formatting is carried via
-*   the revised block's `styleId` on inserted blocks.
-* - **Anchoring.** Insertions anchor `before` the next surviving base block
-*   so consecutive additions keep their order; additions past the last base
-*   block anchor `after` it. A base document with no content blocks offers
-*   no anchor at all — such additions surface in `skipped` rather than
-*   silently vanishing.
-*/
-/**
-* For each event index, the base block id the next `revisedOnly` event
-* should anchor before: the base side of the nearest later `pair` or
-* `baseOnly` event, or `null` when only additions remain until the end of
-* the document. One backward pass, so a long run of trailing additions
-* (huge revised document vs. a small base) stays linear instead of
-* re-scanning the tail per added block.
+* Each matched editable story is processed independently through the shared
+* block alignment and document-operation paths. Package parts that exist on
+* only one side are reported because creating or removing those parts is a
+* distinct package-level operation.
 */
+var InvalidGenerateRedlineDocxOptionsError = class extends TaggedError("InvalidGenerateRedlineDocxOptionsError")() {};
 const nextBaseBlockIdByIndex = (events) => {
 	const nextIds = Array.from({ length: events.length });
 	let nextId = null;
-	for (let i = events.length - 1; i >= 0; i--) {
-		nextIds[i] = nextId;
-		const event = events[i];
+	for (let index = events.length - 1; index >= 0; index--) {
+		nextIds[index] = nextId;
+		const event = events[index];
 		if (event?.type === "pair") nextId = event.baseBlock.id;
 		else if (event?.type === "baseOnly") nextId = event.block.id;
 	}
 	return nextIds;
 };
-/**
-* Compare `base` and `revised` and return the base document with every
-* difference recorded as a tracked change. See the module doc comment for
-* semantics and limitations; `skipped` reports any block the generator could
-* not redline (e.g. additions with no anchor in an empty base document).
-*/
-const generateRedlineDocx = async (base, revised, options = {}) => {
-	const [baseReviewer, revisedReviewer] = await Promise.all([FolioDocxReviewer.fromBuffer(base, { author: options.author ?? "folio compare" }), FolioDocxReviewer.fromBuffer(revised)]);
-	baseReviewer.acceptAll();
-	const baseSnapshot = baseReviewer.snapshot();
-	const revisedBlocks = revisedReviewer.snapshot().blocks;
+const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }) => {
 	const events = alignFolioBlocks(baseSnapshot.blocks, revisedBlocks);
 	const anchorIds = nextBaseBlockIdByIndex(events);
 	const operations = [];
-	let operationSeq = 0;
-	const nextOperationId = () => `redline-${++operationSeq}`;
-	/** Additions past the last base block, kept in revised-document order. */
 	const trailingAdditions = [];
 	const lastBaseBlockId = baseSnapshot.blocks.at(-1)?.id ?? null;
 	events.forEach((event, eventIndex) => {
@@ -123,15 +83,88 @@ const generateRedlineDocx = async (base, revised, options = {}) => {
 		text: addition.text,
 		...addition.styleId !== void 0 && { styleId: addition.styleId }
 	});
-	const { applied, skipped } = baseReviewer.applyOperations(operations, {
-		mode: "tracked-changes",
-		snapshot: baseSnapshot
+	return operations;
+};
+const resolveInputView = (value, option) => {
+	if (value === void 0) return "final";
+	if (!isFolioResolvedReviewedView(value)) throw new InvalidGenerateRedlineDocxOptionsError({
+		message: `${option} must be original or final.`,
+		option,
+		receivedValue: value
 	});
+	return value;
+};
+/** Compare two buffers and return tracked changes for every matched editable story. */
+const generateRedlineDocx = async (base, revised, options = {}) => {
+	const baseView = resolveInputView(options.baseView, "baseView");
+	const revisedView = resolveInputView(options.revisedView, "revisedView");
+	const privacyTransforms = resolveFolioDocumentPrivacyTransforms(options.privacy?.transforms ?? []);
+	const [baseReviewer, revisedReviewer] = await Promise.all([FolioDocxReviewer.fromBuffer(base, { author: options.author ?? "folio compare" }), FolioDocxReviewer.fromBuffer(revised)]);
+	const baseStories = baseReviewer.listStories().map(({ handle }) => handle);
+	const revisedStories = revisedReviewer.listStories().map(({ handle }) => handle);
+	for (const story of baseStories) if (!baseReviewer.resolveReviewedStory({
+		story,
+		view: baseView
+	})) panic("A listed base story could not be resolved");
+	const applied = [];
+	const skipped = [];
+	const unprocessedStories = [];
+	let operationSequence = 0;
+	const nextOperationId = () => `redline-${++operationSequence}`;
+	for (const pair of pairFolioDocumentStories(baseStories, revisedStories)) {
+		if (!pair.baseStory) {
+			unprocessedStories.push({
+				...pair,
+				reason: "missing-base-story"
+			});
+			continue;
+		}
+		if (!pair.revisedStory) {
+			unprocessedStories.push({
+				...pair,
+				reason: "missing-revised-story"
+			});
+			continue;
+		}
+		const baseSnapshot = baseReviewer.snapshotStory(pair.baseStory);
+		const revisedSnapshot = revisedReviewer.readReviewedStory({
+			story: pair.revisedStory,
+			view: revisedView
+		})?.snapshot;
+		if (!baseSnapshot || !revisedSnapshot) panic("A matched document story could not be read");
+		const operations = buildRedlineOperations({
+			baseSnapshot,
+			revisedBlocks: revisedSnapshot.blocks,
+			nextOperationId
+		});
+		if (operations.length === 0) continue;
+		const result = baseReviewer.applyDocumentOperationsToStory({
+			story: pair.baseStory,
+			snapshot: baseSnapshot,
+			batch: {
+				version: 1,
+				mode: "tracked-changes",
+				operations
+			}
+		});
+		applied.push(...result.applied);
+		skipped.push(...result.skipped);
+	}
+	const redlineBuffer = await baseReviewer.toBuffer();
+	const privacyResult = privacyTransforms.length === 0 ? {
+		buffer: redlineBuffer,
+		privacyReport: {
+			appliedTransforms: [],
+			removedMetadataProperties: []
+		}
+	} : await rewriteDocxMetadataPrivacy(redlineBuffer, { transforms: privacyTransforms });
 	return {
-		buffer: await baseReviewer.toBuffer(),
+		buffer: privacyResult.buffer,
 		applied,
-		skipped
+		skipped,
+		unprocessedStories,
+		privacyReport: privacyResult.privacyReport
 	};
 };
 //#endregion
-export { generateRedlineDocx };
+export { InvalidGenerateRedlineDocxOptionsError, generateRedlineDocx };

package/dist/render-dom/BodySelectionOverlay.d.ts

@@ -0,0 +1,31 @@
+import { EditorState } from "prosemirror-state";
+
+//#region src/render-dom/BodySelectionOverlay.d.ts
+type BodySelectionOverlayResult = {
+  type: "text";
+} | {
+  type: "image";
+  element: HTMLElement;
+  pmPos: number;
+};
+type SyncBodySelectionOverlayOptions = {
+  pagesContainer: HTMLElement;
+  state: EditorState;
+  zoom: number;
+  zIndex?: number;
+  caretColor?: string;
+  selectionColor?: string;
+};
+declare class BodySelectionOverlay {
+  clear(pagesContainer: HTMLElement): void;
+  sync({
+    pagesContainer,
+    state,
+    zoom,
+    zIndex,
+    caretColor,
+    selectionColor
+  }: SyncBodySelectionOverlayOptions): BodySelectionOverlayResult;
+}
+//#endregion
+export { BodySelectionOverlay, BodySelectionOverlayResult, SyncBodySelectionOverlayOptions };