@stll/folio-core 0.37.5 → 0.38.0

package/dist/compare/content-types.d.ts

@@ -19,7 +19,24 @@ type FolioContentInlineFormatting = Partial<Record<FolioContentInlineBooleanProp
  * An inline-formatting mutation: `false` is an explicit off value, while
  * `null` removes the direct property so its inherited value becomes effective.
  */
-type FolioContentInlineFormattingPatch = Omit<FolioContentInlineFormatting, FolioContentInlineBooleanProperty> & Partial<Record<FolioContentInlineBooleanProperty, boolean | null>>;
+type FolioContentInlineFormattingPatch = { [Property in keyof FolioContentInlineFormatting]?: FolioContentInlineFormatting[Property] | null; };
+/** Presentation differences for one UTF-16 range in a text-aligned block pair. */
+type FolioContentFormatRange = {
+  startOffset: number;
+  endOffset: number;
+  formatting: FolioContentInlineFormattingPatch;
+};
+/** A trusted inline projection or an explicit reason no ranges can be used. */
+type FolioContentInlineComparisonResult = {
+  status: "compared";
+  segments: readonly FolioContentFormatRange[];
+} | {
+  status: "unalignable";
+  side: "base" | "revised" | "both";
+} | {
+  status: "budget-exceeded";
+  maximum: number;
+};
 type FolioContentRun = {
   text: string;
   bold?: boolean;
@@ -61,6 +78,18 @@ type FolioContentTableLocation = {
 type FolioContentParagraphAlignment = "left" | "center" | "right" | "both" | "distribute" | "mediumKashida" | "highKashida" | "lowKashida" | "thaiDistribute";
 /** Line-height interpretation understood by the neutral comparison model. */
 type FolioContentLineSpacingRule = "auto" | "exact" | "atLeast";
+/** The complete modeled attribute set of direct paragraph indentation. */
+type FolioContentParagraphIndentation = {
+  indentLeft?: number;
+  indentRight?: number;
+  indentFirstLine?: number;
+  hangingIndent?: boolean;
+};
+/** A concrete numbering instance and its zero-based level. */
+type FolioContentListReference = {
+  numId: number;
+  level: number;
+};
 /**
  * The complete modeled attribute set of direct paragraph spacing. Optional
  * fields distinguish an absent attribute from an explicit zero or false value.
@@ -87,8 +116,11 @@ type FolioContentBlock<Kind extends string = string> = {
   directAlignment?: FolioContentParagraphAlignment;
   /** Direct paragraph spacing; absent when every spacing value is inherited. */
   directSpacing?: FolioContentParagraphSpacing;
+  /** Direct paragraph indentation; absent when every indentation value is inherited. */
+  directIndentation?: FolioContentParagraphIndentation;
   /** Zero-based list indent level when the block carries numbering. */
   listLevel?: number;
+  listReference?: FolioContentListReference;
   previewRuns?: readonly FolioContentRun[];
   table?: FolioContentTableLocation;
   /** Structural ancestry, ordered from the outermost to the innermost container. */
@@ -99,4 +131,4 @@ type FolioContentSnapshot<Block extends FolioContentBlock = FolioContentBlock> =
   blocks: readonly Block[];
 };
 //#endregion
-export { FolioContentBlock, FolioContentContainerPathEntry, FolioContentIdStability, FolioContentInlineBooleanProperty, FolioContentInlineFormatting, FolioContentInlineFormattingPatch, FolioContentLineSpacingRule, FolioContentParagraphAlignment, FolioContentParagraphKind, FolioContentParagraphSpacing, FolioContentRun, FolioContentSnapshot, FolioContentTableLocation };
+export { FolioContentBlock, FolioContentContainerPathEntry, FolioContentFormatRange, FolioContentIdStability, FolioContentInlineBooleanProperty, FolioContentInlineComparisonResult, FolioContentInlineFormatting, FolioContentInlineFormattingPatch, FolioContentLineSpacingRule, FolioContentListReference, FolioContentParagraphAlignment, FolioContentParagraphIndentation, FolioContentParagraphKind, FolioContentParagraphSpacing, FolioContentRun, FolioContentSnapshot, FolioContentTableLocation };

package/dist/compare/content.d.ts

@@ -1,4 +1,4 @@
-import { FolioContentBlock, FolioContentIdStability, FolioContentInlineFormattingPatch, FolioContentParagraphSpacing, FolioContentSnapshot } from "./content-types.js";
+import { FolioContentBlock, FolioContentFormatRange, FolioContentIdStability, FolioContentListReference, FolioContentParagraphIndentation, FolioContentParagraphSpacing, FolioContentSnapshot } from "./content-types.js";
 import { WordDiffGranularity, createWordDiffSession } from "../ai-edits/word-diff.js";
 import { FolioContentAlignmentStep, FolioContentAlignmentWorkSession } from "./content-alignment.js";
 import { Result } from "better-result";
@@ -34,8 +34,15 @@ declare class FolioContentComparisonLimitError extends FolioContentComparisonLim
   blockIndex?: number;
   field?: string;
 }> {}
+declare const FolioContentInlinePresentationProjectionError_base: import("better-result").TaggedErrorClass<"FolioContentInlinePresentationProjectionError">;
+declare class FolioContentInlinePresentationProjectionError extends FolioContentInlinePresentationProjectionError_base<{
+  message: string;
+  side: "base" | "revised" | "both";
+  baseBlockId: string;
+  revisedBlockId: string;
+}> {}
 /** Errors returned by {@link compareContent}. */
-type FolioContentComparisonError = InvalidFolioContentComparisonError | FolioContentComparisonLimitError;
+type FolioContentComparisonError = InvalidFolioContentComparisonError | FolioContentComparisonLimitError | FolioContentInlinePresentationProjectionError;
 /** One Folio word-diff segment with JavaScript-slice-compatible offsets. */
 type FolioContentTextSegment = {
   type: "equal" | "del" | "ins";
@@ -49,14 +56,10 @@ type FolioContentTextSegment = {
 type FolioContentParagraphFormattingPatch = {
   styleId?: string | null;
   listLevel?: number | null;
+  listReference?: FolioContentListReference | null;
   alignment?: FolioContentBlock["directAlignment"] | null;
   spacing?: FolioContentParagraphSpacing | null;
-};
-/** Presentation differences for one text-aligned block pair. */
-type FolioContentFormatRange = {
-  startOffset: number;
-  endOffset: number;
-  formatting: FolioContentInlineFormattingPatch;
+  indentation?: FolioContentParagraphIndentation | null;
 };
 /** Presentation differences for one text-aligned block pair. */
 type FolioContentFormattingChange = {
@@ -202,8 +205,8 @@ type CompareAlignedContentOptions<Block extends FolioContentBlock> = {
   maxChanges: number;
   idStability?: (block: Block) => FolioContentIdStability;
 };
-declare const compareAlignedFolioContent: <Block extends FolioContentBlock>({ baseBlocks, revisedBlocks, steps, workSession, maxChanges, idStability }: CompareAlignedContentOptions<Block>) => Result<FolioContentComparison<Block>, FolioContentComparisonLimitError>;
+declare const compareAlignedFolioContent: <Block extends FolioContentBlock>({ baseBlocks, revisedBlocks, steps, workSession, maxChanges, idStability }: CompareAlignedContentOptions<Block>) => Result<FolioContentComparison<Block>, FolioContentComparisonLimitError | FolioContentInlinePresentationProjectionError>;
 /** Compare two representation-neutral ordered content snapshots. */
 declare const compareContent: <Block extends FolioContentBlock = FolioContentBlock>(options: CompareContentOptions<Block>) => Result<FolioContentComparison<Block>, FolioContentComparisonError>;
 //#endregion
-export { CompareContentOptions, FOLIO_CONTENT_COMPARISON_LIMITS, FolioContentBlockProperty, FolioContentComparison, FolioContentComparisonError, FolioContentComparisonEvent, FolioContentComparisonLimit, FolioContentComparisonLimitError, FolioContentComparisonWorkSession, FolioContentFormatRange, FolioContentFormattingChange, FolioContentParagraphFormattingPatch, FolioContentStructuralChange, FolioContentTextSegment, InvalidFolioContentComparisonError, changedFolioContentParagraphFormatting, compareAlignedFolioContent, compareContent, createContentComparisonWorkSession, detectFolioContentMoves, detectFolioContentParagraphMarkPlans };
+export { CompareContentOptions, FOLIO_CONTENT_COMPARISON_LIMITS, FolioContentBlockProperty, FolioContentComparison, FolioContentComparisonError, FolioContentComparisonEvent, FolioContentComparisonLimit, FolioContentComparisonLimitError, FolioContentComparisonWorkSession, type FolioContentFormatRange, FolioContentFormattingChange, FolioContentInlinePresentationProjectionError, FolioContentParagraphFormattingPatch, FolioContentStructuralChange, FolioContentTextSegment, InvalidFolioContentComparisonError, changedFolioContentParagraphFormatting, compareAlignedFolioContent, compareContent, createContentComparisonWorkSession, detectFolioContentMoves, detectFolioContentParagraphMarkPlans };

package/dist/compare/content.js

@@ -1,4 +1,5 @@
 import { WORD_DIFF_GRANULARITIES, createWordDiffSession } from "../ai-edits/word-diff.js";
+import { paragraphIndentationEqual } from "../prosemirror/paragraphIndentation.js";
 import { alignFolioContentStructure, contentBlocksShareContainer, createFolioContentAlignmentWorkSession } from "./content-alignment.js";
 import { inlineFormattingSegments } from "./formatting.js";
 import { Result, TaggedError, panic } from "better-result";
@@ -40,6 +41,7 @@ const MAX_MOVE_PROFILE_TOKENS = 16384;
 const MAX_MOVE_PROFILE_CODE_UNITS = 1048576;
 var InvalidFolioContentComparisonError = class extends TaggedError("InvalidFolioContentComparisonError") {};
 var FolioContentComparisonLimitError = class extends TaggedError("FolioContentComparisonLimitError") {};
+var FolioContentInlinePresentationProjectionError = class extends TaggedError("FolioContentInlinePresentationProjectionError") {};
 const createContentComparisonWorkSession = (granularity) => ({
 	alignment: createFolioContentAlignmentWorkSession(),
 	remainingMoveComparisons: MAX_MOVE_SIMILARITY_COMPARISONS,
@@ -416,9 +418,13 @@ const paragraphSpacingEqual = (base, revised) => base?.spaceBefore === revised?.
 const changedFolioContentParagraphFormatting = (base, revised) => {
 	const patch = {};
 	if ((base.styleId ?? null) !== (revised.styleId ?? null)) patch.styleId = revised.styleId ?? null;
-	if (base.listLevel !== revised.listLevel) patch.listLevel = revised.listLevel ?? null;
+	const listReferenceChanged = base.listReference?.numId !== revised.listReference?.numId;
+	const targetOmitsLevelOnChangedReference = listReferenceChanged && revised.listReference !== void 0 && revised.listLevel === void 0;
+	if (base.listLevel !== revised.listLevel || targetOmitsLevelOnChangedReference) patch.listLevel = revised.listLevel ?? null;
+	if (listReferenceChanged || base.listLevel !== revised.listLevel && revised.listLevel === void 0 && revised.listReference !== void 0) patch.listReference = revised.listReference ?? null;
 	if (base.directAlignment !== revised.directAlignment) patch.alignment = revised.directAlignment ?? null;
 	if (!paragraphSpacingEqual(base.directSpacing, revised.directSpacing)) patch.spacing = revised.directSpacing ?? null;
+	if (!paragraphIndentationEqual(base.directIndentation, revised.directIndentation)) patch.indentation = revised.directIndentation ?? null;
 	return Object.keys(patch).length > 0 ? patch : null;
 };
 const changedBlockProperties = (base, revised) => {
@@ -640,16 +646,37 @@ const structuralChangeForStep = (step, id) => {
 };
 const formattingChange = (base, revised, maxRanges) => {
 	const paragraph = changedFolioContentParagraphFormatting(base, revised);
-	const ranges = base.text === revised.text ? inlineFormattingSegments({
+	const inlineComparison = base.text === revised.text ? inlineFormattingSegments({
 		baseBlock: base,
 		targetBlock: revised,
 		maxSegments: maxRanges
-	}) : [];
-	if (ranges === null) return "limit";
-	return paragraph || ranges.length > 0 ? {
-		...paragraph && { paragraph },
-		ranges
-	} : null;
+	}) : {
+		status: "compared",
+		segments: []
+	};
+	switch (inlineComparison.status) {
+		case "compared": {
+			const { segments: ranges } = inlineComparison;
+			return {
+				status: "compared",
+				formatting: paragraph || ranges.length > 0 ? {
+					...paragraph && { paragraph },
+					ranges
+				} : null
+			};
+		}
+		case "budget-exceeded": return { status: "budget-exceeded" };
+		case "unalignable": return {
+			status: "unalignable",
+			error: new FolioContentInlinePresentationProjectionError({
+				message: "Inline formatting runs cannot be aligned to their block text.",
+				side: inlineComparison.side,
+				baseBlockId: base.id,
+				revisedBlockId: revised.id
+			})
+		};
+		default: return panic("Unhandled inline formatting comparison result", { result: inlineComparison });
+	}
 };
 const compareAlignedFolioContent = ({ baseBlocks, revisedBlocks, steps, workSession, maxChanges, idStability }) => {
 	const paragraphPlans = detectFolioContentParagraphMarkPlans(steps);
@@ -733,13 +760,21 @@ const compareAlignedFolioContent = ({ baseBlocks, revisedBlocks, steps, workSess
 			const base = step.baseBlock;
 			const revised = step.revisedBlock;
 			const properties = changedBlockProperties(base, revised);
-			const formatting = formattingChange(base, revised, remainingFormattingRanges);
-			if (formatting === "limit") return Result.err(limitExceeded({
-				input: "result",
-				limit: "changes",
-				maximum: maxChanges,
-				actual: maxChanges + 1
-			}));
+			const formattingResult = formattingChange(base, revised, remainingFormattingRanges);
+			let formatting;
+			switch (formattingResult.status) {
+				case "compared":
+					formatting = formattingResult.formatting;
+					break;
+				case "budget-exceeded": return Result.err(limitExceeded({
+					input: "result",
+					limit: "changes",
+					maximum: maxChanges,
+					actual: maxChanges + 1
+				}));
+				case "unalignable": return Result.err(formattingResult.error);
+				default: return panic("Unhandled formatting comparison result", { result: formattingResult });
+			}
 			remainingFormattingRanges -= formatting?.ranges.length ?? 0;
 			let event;
 			if (base.text !== revised.text || properties.length > 0) event = {
@@ -780,13 +815,24 @@ const compareAlignedFolioContent = ({ baseBlocks, revisedBlocks, steps, workSess
 		}
 		if (step.type === "revisedOnly") {
 			const move = moveByRevisedId.get(step.block.id);
-			const moveFormatting = move ? formattingChange(move.baseBlock, step.block, remainingFormattingRanges) : null;
-			if (moveFormatting === "limit") return Result.err(limitExceeded({
-				input: "result",
-				limit: "changes",
-				maximum: maxChanges,
-				actual: maxChanges + 1
-			}));
+			const moveFormattingResult = move ? formattingChange(move.baseBlock, step.block, remainingFormattingRanges) : {
+				status: "compared",
+				formatting: null
+			};
+			let moveFormatting;
+			switch (moveFormattingResult.status) {
+				case "compared":
+					moveFormatting = moveFormattingResult.formatting;
+					break;
+				case "budget-exceeded": return Result.err(limitExceeded({
+					input: "result",
+					limit: "changes",
+					maximum: maxChanges,
+					actual: maxChanges + 1
+				}));
+				case "unalignable": return Result.err(moveFormattingResult.error);
+				default: return panic("Unhandled formatting comparison result", { result: moveFormattingResult });
+			}
 			remainingFormattingRanges -= moveFormatting?.ranges.length ?? 0;
 			const moveProperties = move ? changedBlockProperties(move.baseBlock, step.block) : [];
 			if (!addRelation(move ? {
@@ -882,4 +928,4 @@ const compareContent = (options) => {
 	});
 };
 //#endregion
-export { FOLIO_CONTENT_COMPARISON_LIMITS, FolioContentComparisonLimitError, InvalidFolioContentComparisonError, changedFolioContentParagraphFormatting, compareAlignedFolioContent, compareContent, createContentComparisonWorkSession, detectFolioContentMoves, detectFolioContentParagraphMarkPlans };
+export { FOLIO_CONTENT_COMPARISON_LIMITS, FolioContentComparisonLimitError, FolioContentInlinePresentationProjectionError, InvalidFolioContentComparisonError, changedFolioContentParagraphFormatting, compareAlignedFolioContent, compareContent, createContentComparisonWorkSession, detectFolioContentMoves, detectFolioContentParagraphMarkPlans };

package/dist/compare/formatting.d.ts

@@ -1,29 +1,11 @@
-import { FolioContentBlock, FolioContentInlineFormattingPatch } from "./content-types.js";
+import { FolioContentBlock, FolioContentInlineComparisonResult } from "./content-types.js";
 //#region src/compare/formatting.d.ts
-/** One run of characters whose supported inline formatting differs. */
-type InlineFormattingSegment = {
-  /** Zero-based UTF-16 offset into the block's visible text. */
-  startOffset: number;
-  endOffset: number;
-  /** Differing properties set to the target value; null removes a direct property. */
-  formatting: FolioContentInlineFormattingPatch;
-};
 type InlineFormattingSegmentsOptions = {
   baseBlock: FolioContentBlock;
   targetBlock: FolioContentBlock;
-  /** Refuse (return `null`) rather than build more segments than this. */
   maxSegments: number;
 };
-/**
- * Segments where `targetBlock`'s supported run formatting differs from
- * `baseBlock`'s, for two blocks that carry the same text. Returns `null` only
- * when the diff would exceed `maxSegments`.
- *
- * A block whose runs cannot be aligned to its text reports no segments rather
- * than guessing: attributing formatting to the wrong characters is worse than
- * missing a formatting-only change, and the caller has no offset it could
- * trust instead.
- */
-declare const inlineFormattingSegments: ({ baseBlock, targetBlock, maxSegments }: InlineFormattingSegmentsOptions) => InlineFormattingSegment[] | null;
+/** Malformed run streams take precedence over the output budget. */
+declare const inlineFormattingSegments: ({ baseBlock, targetBlock, maxSegments }: InlineFormattingSegmentsOptions) => FolioContentInlineComparisonResult;
 //#endregion
-export { InlineFormattingSegment, inlineFormattingSegments };
+export { inlineFormattingSegments };

package/dist/compare/formatting.js

@@ -1,115 +1,11 @@
+import { canonicalInlinePresentationSegments } from "../internal/compare/inline-presentation.js";
 //#region src/compare/formatting.ts
-const HEX_COLOR = /^#?(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/u;
-const normalizeInlineFormattingColor = (color) => HEX_COLOR.test(color) ? color.replace(/^#/u, "").toUpperCase() : color;
-const normalizeEffectiveInlineFormattingColor = (color) => color === void 0 ? void 0 : normalizeInlineFormattingColor(color);
-const normalizeDirectInlineFormattingColor = (color) => color === null || color === void 0 ? color : normalizeInlineFormattingColor(color);
-const changedStringValue = (baseEffective, targetEffective, baseAuthored, targetAuthored) => {
-	if (baseAuthored !== targetAuthored) return targetAuthored ?? null;
-	return baseEffective === targetEffective ? void 0 : targetEffective ?? null;
-};
-const changedNumberValue = (baseEffective, targetEffective, baseAuthored, targetAuthored) => {
-	if (baseAuthored !== targetAuthored) return targetAuthored ?? null;
-	return baseEffective === targetEffective ? void 0 : targetEffective ?? null;
-};
-const changedSupportedFormatting = (base, target) => {
-	const baseDirect = base.directFormatting ?? {};
-	const targetDirect = target.directFormatting ?? {};
-	const formatting = {};
-	const changedBoolean = (property) => {
-		if (baseDirect[property] !== targetDirect[property]) return targetDirect[property] ?? null;
-		return Boolean(base[property]) === Boolean(target[property]) ? void 0 : Boolean(target[property]);
-	};
-	for (const property of [
-		"bold",
-		"italic",
-		"underline",
-		"strike"
-	]) {
-		const changed = changedBoolean(property);
-		if (changed !== void 0) formatting[property] = changed;
-	}
-	const fontFamily = changedStringValue(base.fontFamily, target.fontFamily, baseDirect.fontFamily, targetDirect.fontFamily);
-	if (fontFamily !== void 0) formatting.fontFamily = fontFamily;
-	const fontSizePt = changedNumberValue(base.fontSizePt, target.fontSizePt, baseDirect.fontSizePt, targetDirect.fontSizePt);
-	if (fontSizePt !== void 0) formatting.fontSizePt = fontSizePt;
-	const color = changedStringValue(normalizeEffectiveInlineFormattingColor(base.color), normalizeEffectiveInlineFormattingColor(target.color), normalizeDirectInlineFormattingColor(baseDirect.color), normalizeDirectInlineFormattingColor(targetDirect.color));
-	if (color !== void 0) formatting.color = color;
-	return formatting;
-};
-const sameInlineFormatting = (left, right) => left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strike === right.strike && left.fontFamily === right.fontFamily && left.fontSizePt === right.fontSizePt && left.color === right.color;
-const hasInlineFormatting = (formatting) => formatting.bold !== void 0 || formatting.italic !== void 0 || formatting.underline !== void 0 || formatting.strike !== void 0 || formatting.fontFamily !== void 0 || formatting.fontSizePt !== void 0 || formatting.color !== void 0;
-/**
-* A block's runs, or `null` when they cannot describe the block's text.
-* Non-text inline content (a field, an image) leaves the concatenated run text
-* shorter than the block text; attributing formatting by offset would then
-* point at the wrong characters, so the caller must back off instead.
-*/
-const previewRunsForBlock = (block) => {
-	const runs = block.previewRuns ?? [{ text: block.text }];
-	return runs.map(({ text }) => text).join("") === block.text ? runs : null;
-};
-/**
-* Segments where `targetBlock`'s supported run formatting differs from
-* `baseBlock`'s, for two blocks that carry the same text. Returns `null` only
-* when the diff would exceed `maxSegments`.
-*
-* A block whose runs cannot be aligned to its text reports no segments rather
-* than guessing: attributing formatting to the wrong characters is worse than
-* missing a formatting-only change, and the caller has no offset it could
-* trust instead.
-*/
-const inlineFormattingSegments = ({ baseBlock, targetBlock, maxSegments }) => {
-	const baseRuns = previewRunsForBlock(baseBlock);
-	const targetRuns = previewRunsForBlock(targetBlock);
-	if (!baseRuns || !targetRuns || baseBlock.text.length === 0) return [];
-	const segments = [];
-	let baseRunIndex = 0;
-	let targetRunIndex = 0;
-	let baseRunOffset = 0;
-	let targetRunOffset = 0;
-	let textOffset = 0;
-	while (baseRunIndex < baseRuns.length && targetRunIndex < targetRuns.length) {
-		const baseRun = baseRuns[baseRunIndex];
-		const targetRun = targetRuns[targetRunIndex];
-		if (!baseRun || !targetRun) break;
-		const length = Math.min(baseRun.text.length - baseRunOffset, targetRun.text.length - targetRunOffset);
-		if (length <= 0) {
-			if (baseRunOffset >= baseRun.text.length) {
-				baseRunIndex++;
-				baseRunOffset = 0;
-			}
-			if (targetRunOffset >= targetRun.text.length) {
-				targetRunIndex++;
-				targetRunOffset = 0;
-			}
-			continue;
-		}
-		const formatting = changedSupportedFormatting(baseRun, targetRun);
-		if (hasInlineFormatting(formatting)) {
-			const previous = segments.at(-1);
-			if (previous && previous.endOffset === textOffset && sameInlineFormatting(previous.formatting, formatting)) previous.endOffset += length;
-			else {
-				if (segments.length >= maxSegments) return null;
-				segments.push({
-					startOffset: textOffset,
-					endOffset: textOffset + length,
-					formatting
-				});
-			}
-		}
-		textOffset += length;
-		baseRunOffset += length;
-		targetRunOffset += length;
-		if (baseRunOffset >= baseRun.text.length) {
-			baseRunIndex++;
-			baseRunOffset = 0;
-		}
-		if (targetRunOffset >= targetRun.text.length) {
-			targetRunIndex++;
-			targetRunOffset = 0;
-		}
-	}
-	return segments;
-};
+/** Character-aligned inline-formatting comparison of two text-equal blocks. */
+/** Malformed run streams take precedence over the output budget. */
+const inlineFormattingSegments = ({ baseBlock, targetBlock, maxSegments }) => canonicalInlinePresentationSegments({
+	baseBlock,
+	revisedBlock: targetBlock,
+	maxSegments
+});
 //#endregion
 export { inlineFormattingSegments };

package/dist/compare/inline-atom-resources.d.ts

@@ -0,0 +1,6 @@
+import { Node } from "prosemirror-model";
+//#region src/compare/inline-atom-resources.d.ts
+/** Detach supported atoms from the source package; save allocates the receiving media relationship. */
+declare const prepareTargetInlineAtom: (node: Node) => Node | null;
+//#endregion
+export { prepareTargetInlineAtom };

package/dist/compare/inline-atom-resources.js

@@ -0,0 +1,26 @@
+import { rebindDrawingImageRelationship } from "../docx/drawingRelationships.js";
+import { expectImageAttrs } from "../prosemirror/attrs/index.js";
+//#region src/compare/inline-atom-resources.ts
+/** Detach supported atoms from the source package; save allocates the receiving media relationship. */
+const prepareTargetInlineAtom = (node) => {
+	if (node.type.name === "field") return node;
+	if (node.type.name === "pageBreakRun") return node;
+	if (node.type.name !== "image") return null;
+	const attrs = expectImageAttrs(node);
+	if (!attrs.src.startsWith("data:") || attrs.hlinkRId || attrs.hlinkHref) return null;
+	const rId = "rId_img_compare";
+	const rawXml = attrs._docxRawXml;
+	const reboundXml = rawXml ? rebindDrawingImageRelationship({
+		xml: rawXml,
+		previousId: attrs.rId ?? "",
+		nextId: rId
+	}) : void 0;
+	if (reboundXml === null) return null;
+	return node.type.create({
+		...node.attrs,
+		rId,
+		...reboundXml !== void 0 && { _docxRawXml: reboundXml }
+	}, node.content, node.marks);
+};
+//#endregion
+export { prepareTargetInlineAtom };

package/dist/compare/inline-atoms.d.ts

@@ -0,0 +1,35 @@
+import { FolioAIEditSnapshot } from "../ai-edits/types.js";
+import { FolioRevisionStamp } from "../ai-edits/apply.js";
+import { EditorState, Transaction } from "prosemirror-state";
+import { Node } from "prosemirror-model";
+//#region src/compare/inline-atoms.d.ts
+type MatchInlineAtomsOptions = {
+  state: EditorState;
+  targetSnapshot: FolioAIEditSnapshot;
+  revisionStamp: FolioRevisionStamp;
+  /** First id reserved for this comparison, before planned operations allocated ids. */
+  originalRevisionIdSeed: number;
+  author: string;
+  maxRanges: number;
+};
+type MatchInlineAtomsResult = {
+  status: "matched";
+  transaction: Transaction;
+  nextRevisionId: number;
+  changedTargetBlockIds: readonly string[];
+  rangeCount: number;
+} | {
+  status: "unalignable";
+} | {
+  status: "budget-exceeded";
+};
+/**
+ * Restore field, image, and page-break atoms omitted by text-only comparison operations.
+ * Positions come from the legacy review resolver's mapping, never a guessed
+ * paragraph correspondence: paragraph-mark deletions can merge paragraphs.
+ */
+declare const matchInlineAtoms: ({ state, targetSnapshot, revisionStamp, originalRevisionIdSeed, author, maxRanges }: MatchInlineAtomsOptions) => MatchInlineAtomsResult;
+/** Compare supported inline atom identity after accept or reject projection. */
+declare const sameInlineAtoms: (leftDocument: Node, rightDocument: Node) => boolean;
+//#endregion
+export { MatchInlineAtomsOptions, MatchInlineAtomsResult, matchInlineAtoms, sameInlineAtoms };