@stll/folio-core 0.37.5 → 0.38.0

package/dist/compare/inline-provenance.js

@@ -0,0 +1,334 @@
+import { sourceDocumentOf, styleResolverOf } from "../ai-edits/snapshot.js";
+import { expectHyperlinkMarkAttrs, expectRunPropertyChangeMarkAttrs, expectTableCellAttrs } from "../prosemirror/attrs/index.js";
+import { getDocumentStyleResolver } from "../prosemirror/plugins/documentStyles.js";
+import { applyMarksToRunFormattingRepresentation, expandRunFormattingCarrier, runFormattingCarrierReviewText } from "../prosemirror/runFormattingInlineCarriers.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
+import { paragraphRunStyleContextAt } from "../prosemirror/runStyleFormatting.js";
+import { isTableCellRetainedInReviewView } from "../prosemirror/tableCellRevisionVisibility.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
+//#region src/compare/inline-provenance.ts
+const isDeleted = (carrier) => carrier.representations.some(({ node }) => node.marks.some(({ type }) => type.name === "deletion"));
+const hyperlinkOf = (node) => node.marks.find(({ type }) => type.name === "hyperlink");
+const hyperlinkIdentity = (node) => {
+	const mark = hyperlinkOf(node);
+	if (!mark) return "null";
+	const { href, tooltip } = expectHyperlinkMarkAttrs(mark);
+	return canonicalJson({
+		href,
+		tooltip
+	});
+};
+const isInserted = (node) => node.marks.some(({ type }) => type.name === "insertion");
+const carrierRepresentations = (carrier) => carrier.representations.map((representation) => ({
+	...representation,
+	from: representation.position,
+	to: representation.position + representation.node.nodeSize
+}));
+const targetBlockIdLookup = (anchors) => {
+	const ordered = Object.values(anchors).toSorted((left, right) => left.from - right.from || left.to - right.to);
+	const active = [];
+	let nextAnchor = 0;
+	return ({ position, nodeSize }) => {
+		while (nextAnchor < ordered.length) {
+			const anchor = ordered.at(nextAnchor);
+			if (!anchor || anchor.from > position) break;
+			active.push(anchor);
+			nextAnchor++;
+		}
+		const end = position + nodeSize;
+		let owner;
+		for (let index = active.length - 1; index >= 0; index--) {
+			const anchor = active[index];
+			if (!anchor) continue;
+			if (anchor.to < end) {
+				active.splice(index, 1);
+				continue;
+			}
+			if (anchor.from <= position && end <= anchor.to && (owner === void 0 || anchor.to - anchor.from < owner.to - owner.from)) owner = anchor;
+		}
+		return owner?.id;
+	};
+};
+const collectCarriers = ({ doc, targetSnapshot }) => {
+	const carriers = [];
+	const targetBlockIdAt = targetSnapshot ? targetBlockIdLookup(targetSnapshot.anchors) : void 0;
+	let unanchoredTargetCarrier = false;
+	doc.descendants((node, position) => {
+		if ((node.type.name === "tableCell" || node.type.name === "tableHeader") && !isTableCellRetainedInReviewView(expectTableCellAttrs(node).cellMarker?.kind, "final")) return false;
+		if (!node.isInline) return true;
+		const carrier = expandRunFormattingCarrier(node, position);
+		if (!carrier) return !node.isAtom;
+		if (isDeleted(carrier)) return false;
+		const targetBlockId = targetBlockIdAt?.({
+			position,
+			nodeSize: node.nodeSize
+		});
+		if (targetSnapshot && targetBlockId === void 0) {
+			unanchoredTargetCarrier = true;
+			return false;
+		}
+		carriers.push({
+			carrier,
+			text: runFormattingCarrierReviewText(carrier),
+			targetBlockId
+		});
+		return false;
+	});
+	return unanchoredTargetCarrier ? null : carriers;
+};
+const sameCarrierShape = (left, right) => {
+	if (left.carrier.disposition !== right.carrier.disposition || left.text !== right.text) return false;
+	const leftRepresentations = left.carrier.representations;
+	const rightRepresentations = right.carrier.representations;
+	return leftRepresentations.length === rightRepresentations.length && leftRepresentations.every((representation, index) => {
+		const target = rightRepresentations.at(index);
+		return target !== void 0 && representation.role === target.role && representation.node.type === target.node.type;
+	});
+};
+/**
+* Match whole formatting carriers while permitting only text runs to be cut at
+* UTF-16 boundaries. Non-text carriers are serialization atoms and therefore
+* must line up exactly on both sides.
+*/
+const matchCarrierStreams = ({ live, target }) => {
+	const matched = [];
+	let liveIndex = 0;
+	let targetIndex = 0;
+	let liveOffset = 0;
+	let targetOffset = 0;
+	while (liveIndex < live.length || targetIndex < target.length) {
+		const liveCarrier = live.at(liveIndex);
+		const targetCarrier = target.at(targetIndex);
+		if (!liveCarrier || !targetCarrier || targetCarrier.targetBlockId === void 0) return null;
+		const liveText = liveCarrier.text.slice(liveOffset);
+		const targetText = targetCarrier.text.slice(targetOffset);
+		const liveIsText = liveCarrier.carrier.disposition === "text-run";
+		const targetIsText = targetCarrier.carrier.disposition === "text-run";
+		if (!liveIsText || !targetIsText) {
+			if (liveOffset !== 0 || targetOffset !== 0 || !sameCarrierShape(liveCarrier, targetCarrier)) return null;
+			const liveRepresentations = carrierRepresentations(liveCarrier.carrier);
+			const targetRepresentations = carrierRepresentations(targetCarrier.carrier);
+			for (const [index, liveRepresentation] of liveRepresentations.entries()) {
+				const targetRepresentation = targetRepresentations.at(index);
+				if (!targetRepresentation) return null;
+				matched.push({
+					live: liveRepresentation,
+					target: targetRepresentation,
+					targetBlockId: targetCarrier.targetBlockId
+				});
+			}
+			liveIndex++;
+			targetIndex++;
+			continue;
+		}
+		const sharedLength = Math.min(liveText.length, targetText.length);
+		if (sharedLength === 0 || liveText.slice(0, sharedLength) !== targetText.slice(0, sharedLength)) return null;
+		const liveRepresentation = carrierRepresentations(liveCarrier.carrier).at(0);
+		const targetRepresentation = carrierRepresentations(targetCarrier.carrier).at(0);
+		if (!liveRepresentation || !targetRepresentation) return null;
+		matched.push({
+			live: {
+				...liveRepresentation,
+				from: liveRepresentation.from + liveOffset,
+				to: liveRepresentation.from + liveOffset + sharedLength
+			},
+			target: {
+				...targetRepresentation,
+				from: targetRepresentation.from + targetOffset,
+				to: targetRepresentation.from + targetOffset + sharedLength
+			},
+			targetBlockId: targetCarrier.targetBlockId
+		});
+		liveOffset += sharedLength;
+		targetOffset += sharedLength;
+		if (liveOffset === liveCarrier.text.length) {
+			liveIndex++;
+			liveOffset = 0;
+		}
+		if (targetOffset === targetCarrier.text.length) {
+			targetIndex++;
+			targetOffset = 0;
+		}
+	}
+	return matched;
+};
+const authoredFormattingAt = ({ doc, representation, styleResolver }) => readAuthoredRunFormatting({
+	context: paragraphRunStyleContextAt({
+		doc,
+		pos: representation.from,
+		styleResolver
+	}),
+	marks: representation.node.marks,
+	styleResolver
+});
+const changeWithCurrentFormatting = ({ change, formatting }) => ({
+	...change,
+	currentFormatting: formatting
+});
+/**
+* Reconcile direct inline run formatting after the comparison plan has aligned
+* text. It deliberately performs all stream, revision-slot, and range-budget
+* checks before creating a transaction step.
+*/
+const matchInlineProvenance = ({ state, targetSnapshot, revisionStamp, originalRevisionIdSeed, author, maxRanges }) => {
+	const targetStyleResolver = styleResolverOf(targetSnapshot);
+	if (!Number.isSafeInteger(maxRanges) || maxRanges < 0) return { status: "budget-exceeded" };
+	const targetDocument = sourceDocumentOf(targetSnapshot);
+	const liveCarriers = collectCarriers({ doc: state.doc });
+	const targetCarriers = collectCarriers({
+		doc: targetDocument,
+		targetSnapshot
+	});
+	if (!liveCarriers || !targetCarriers) return { status: "unalignable" };
+	const matched = matchCarrierStreams({
+		live: liveCarriers,
+		target: targetCarriers
+	});
+	if (!matched) return { status: "unalignable" };
+	const propertyChangeType = state.schema.marks["runPropertyChange"];
+	const liveStyleResolver = getDocumentStyleResolver(state);
+	const planned = [];
+	for (const segment of matched) {
+		const liveFormatting = authoredFormattingAt({
+			doc: state.doc,
+			representation: segment.live,
+			styleResolver: liveStyleResolver
+		});
+		const targetFormatting = authoredFormattingAt({
+			doc: targetDocument,
+			representation: segment.target,
+			styleResolver: targetStyleResolver
+		});
+		const hyperlinkChange = hyperlinkIdentity(segment.live.node) === hyperlinkIdentity(segment.target.node) ? "unchanged" : "replace";
+		if (hyperlinkChange === "replace" && !segment.live.node.isText) return { status: "unalignable" };
+		if (hyperlinkChange === "unchanged" && canonicalJson(liveFormatting) === canonicalJson(targetFormatting)) continue;
+		const existingPropertyChange = propertyChangeType ? segment.live.node.marks.find((mark) => mark.type === propertyChangeType) : void 0;
+		const propertyChange = existingPropertyChange && expectRunPropertyChangeMarkAttrs(existingPropertyChange).changes.length > 0 ? existingPropertyChange : void 0;
+		if (propertyChange && expectRunPropertyChangeMarkAttrs(propertyChange).changes.some(({ info }) => info.id < originalRevisionIdSeed)) return { status: "unalignable" };
+		if (!isInserted(segment.live.node) && !propertyChangeType) return { status: "unalignable" };
+		planned.push({
+			...segment,
+			formatting: targetFormatting,
+			previousFormatting: liveFormatting,
+			inserted: isInserted(segment.live.node),
+			propertyChange,
+			hyperlinkChange
+		});
+	}
+	if (planned.length > maxRanges) return { status: "budget-exceeded" };
+	const transaction = state.tr;
+	let nextRevisionId = revisionStamp.idSeed;
+	const changedTargetBlockIds = /* @__PURE__ */ new Set();
+	for (const change of planned.toReversed()) {
+		const context = paragraphRunStyleContextAt({
+			doc: state.doc,
+			pos: change.live.from,
+			styleResolver: liveStyleResolver
+		});
+		const formattingMarks = reconcileRunFormattingMarks({
+			authoredFormatting: change.formatting,
+			context,
+			node: change.live.node,
+			styleResolver: liveStyleResolver
+		});
+		let marks = formattingMarks;
+		if (change.hyperlinkChange === "replace") {
+			const hyperlinkType = state.schema.marks["hyperlink"];
+			const insertionType = state.schema.marks["insertion"];
+			const deletionType = state.schema.marks["deletion"];
+			if (!hyperlinkType || !insertionType || !deletionType) return { status: "unalignable" };
+			marks = hyperlinkType.removeFromSet(marks);
+			const targetLink = hyperlinkOf(change.target.node);
+			if (targetLink) {
+				const { href, tooltip } = expectHyperlinkMarkAttrs(targetLink);
+				marks = hyperlinkType.create({
+					href,
+					tooltip
+				}).addToSet(marks);
+			}
+			if (!change.inserted) {
+				if (propertyChangeType) marks = propertyChangeType.removeFromSet(marks);
+				marks = insertionType.create({
+					revisionId: nextRevisionId++,
+					author,
+					date: revisionStamp.date
+				}).addToSet(marks);
+				const text = state.doc.textBetween(change.live.from, change.live.to);
+				transaction.addMark(change.live.from, change.live.to, deletionType.create({
+					revisionId: nextRevisionId++,
+					author,
+					date: revisionStamp.date
+				}));
+				transaction.insert(change.live.to, state.schema.text(text, marks));
+				changedTargetBlockIds.add(change.targetBlockId);
+				continue;
+			}
+		}
+		if (!change.inserted && propertyChangeType) if (change.propertyChange) {
+			const attrs = expectRunPropertyChangeMarkAttrs(change.propertyChange);
+			marks = propertyChangeType.create({
+				...change.propertyChange.attrs,
+				changes: attrs.changes.map((entry) => changeWithCurrentFormatting({
+					change: entry,
+					formatting: change.formatting
+				}))
+			}).addToSet(formattingMarks);
+		} else {
+			const propertyChange = {
+				type: "runPropertyChange",
+				info: {
+					id: nextRevisionId++,
+					author,
+					date: revisionStamp.date
+				},
+				...Object.keys(change.previousFormatting).length > 0 ? { previousFormatting: change.previousFormatting } : {}
+			};
+			marks = propertyChangeType.create({ changes: [propertyChange] }).addToSet(formattingMarks);
+		}
+		applyMarksToRunFormattingRepresentation({
+			tr: transaction,
+			representation: change.live,
+			marks
+		});
+		changedTargetBlockIds.add(change.targetBlockId);
+	}
+	return {
+		status: "matched",
+		transaction,
+		nextRevisionId,
+		changedTargetBlockIds: [...changedTargetBlockIds],
+		rangeCount: planned.length
+	};
+};
+/** Compare full authored run-property provenance in two snapshot source documents. */
+const sameAuthoredInlineProvenance = (baseSnapshot, targetSnapshot) => {
+	const baseDocument = sourceDocumentOf(baseSnapshot);
+	const targetDocument = sourceDocumentOf(targetSnapshot);
+	const baseCarriers = collectCarriers({
+		doc: baseDocument,
+		targetSnapshot: baseSnapshot
+	});
+	const targetCarriers = collectCarriers({
+		doc: targetDocument,
+		targetSnapshot
+	});
+	if (!baseCarriers || !targetCarriers) return false;
+	const matched = matchCarrierStreams({
+		live: baseCarriers,
+		target: targetCarriers
+	});
+	if (!matched) return false;
+	const baseStyleResolver = styleResolverOf(baseSnapshot);
+	const targetStyleResolver = styleResolverOf(targetSnapshot);
+	return matched.every(({ live, target }) => hyperlinkIdentity(live.node) === hyperlinkIdentity(target.node) && canonicalJson(authoredFormattingAt({
+		doc: baseDocument,
+		representation: live,
+		styleResolver: baseStyleResolver
+	})) === canonicalJson(authoredFormattingAt({
+		doc: targetDocument,
+		representation: target,
+		styleResolver: targetStyleResolver
+	})));
+};
+//#endregion
+export { matchInlineProvenance, sameAuthoredInlineProvenance };

package/dist/compare/plan.d.ts

@@ -1,8 +1,9 @@
 import { FolioAIEditOperation, FolioAIEditSnapshot } from "../ai-edits/types.js";
 import { TableGeometryPairing } from "../ai-edits/table-geometry.js";
 import { FolioDocumentStoryHandle } from "../ai-edits/headless.js";
-import { FolioContentComparisonWorkSession } from "./content.js";
+import { CompareVerificationFailure } from "./verification.js";
 import { CompareChange } from "./types.js";
+import { FolioContentComparisonWorkSession } from "./content.js";
 //#region src/compare/plan.d.ts
 /**
  * A table the target document already holds, which the operation naming it
@@ -23,6 +24,8 @@ type CompareTableTemplateRequest = {
 type CompareStoryPlan = {
   changes: CompareChange[];
   operations: FolioAIEditOperation[];
+  /** Differences the operation grammar cannot safely project. */
+  verificationFailures: CompareVerificationFailure[];
   /**
    * Where an operation's table comes from. Kept beside the operations rather
    * than inside them because a table node is not JSON, and the serialized

package/dist/compare/plan.js

@@ -221,8 +221,10 @@ const shareAContainer = (left, right) => {
 const toFolioAIBlockParagraphProperties = (properties) => ({
 	...properties.styleId !== void 0 && { styleId: properties.styleId },
 	...properties.listLevel !== void 0 && { listLevel: properties.listLevel },
+	...properties.listReference !== void 0 && { numbering: properties.listReference },
 	...properties.alignment !== void 0 && { alignment: properties.alignment },
-	...properties.spacing !== void 0 && { spacing: properties.spacing }
+	...properties.spacing !== void 0 && { spacing: properties.spacing },
+	...properties.indentation !== void 0 && { indentation: properties.indentation }
 });
 /**
 * For each step, the id of the next base block at or after it — the anchor a
@@ -484,6 +486,10 @@ const withTrailingDeletionRules = ({ baseSnapshot, targetSnapshot, operations, t
 					...insert.moveId !== void 0 && { moveId: insert.moveId },
 					styleId: insert.styleId ?? null,
 					listLevel: insert.listLevel ?? null,
+					numbering: insert.numbering ?? null,
+					indentation: insert.indentation ?? null,
+					...insert.lineBreakMode !== void 0 && { lineBreakMode: insert.lineBreakMode },
+					...insert.hardPageBreak !== void 0 && { hardPageBreak: insert.hardPageBreak },
 					alignment: insert.alignment ?? null,
 					spacing: insert.spacing ?? null
 				};
@@ -557,6 +563,7 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations,
 	const anchorIds = nextBaseBlockIdByStep(steps);
 	const changes = [];
 	const operations = [];
+	const verificationFailures = [];
 	const tableTemplates = [];
 	/**
 	* The anchor everything past the base document's content hangs from: its
@@ -582,13 +589,19 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations,
 	const moveIdOf = (baseBlockId) => `move-${baseBlockId}`;
 	const pushInsertOperation = (block, anchorId) => {
 		const moveSourceId = moveSourceByTargetBlockId.get(block.id);
+		const structuralBoundary = block.structuralBoundaries?.at(0);
+		const hardPageBreak = block.text.length === 0 && block.structuralBoundaries?.length === 1 && structuralBoundary?.type === "pageBreak" && structuralBoundary.offset === 0 ? { ...structuralBoundary.clear !== void 0 && { clear: structuralBoundary.clear } } : void 0;
 		const shared = {
 			text: block.text,
+			...(block.text.includes("	") || block.text.includes("\n")) && { lineBreakMode: "inline" },
 			...moveSourceId !== void 0 && { moveId: moveIdOf(moveSourceId) },
+			...hardPageBreak !== void 0 && { hardPageBreak },
 			styleId: block.styleId ?? null,
 			listLevel: block.listLevel ?? null,
+			numbering: block.listReference ?? null,
 			alignment: block.directAlignment ?? null,
-			spacing: block.directSpacing ?? null
+			spacing: block.directSpacing ?? null,
+			indentation: block.directIndentation ?? null
 		};
 		if (anchorId !== null) {
 			operations.push({
@@ -712,12 +725,26 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations,
 					});
 					break;
 				}
-				const segments = inlineFormattingSegments({
+				const formattingComparison = inlineFormattingSegments({
 					baseBlock,
 					targetBlock,
 					maxSegments: maxOperations
 				});
-				if (segments === null) return null;
+				switch (formattingComparison.status) {
+					case "compared": break;
+					case "budget-exceeded": return null;
+					case "unalignable":
+						verificationFailures.push({
+							invariant: "accept-reproduces-target",
+							cause: "inline-formatting",
+							story,
+							detail: `supported inline formatting could not be aligned (${formattingComparison.side})`
+						});
+						break;
+					default: panic("Unhandled inline formatting comparison result", { result: formattingComparison });
+				}
+				if (formattingComparison.status !== "compared") break;
+				const { segments } = formattingComparison;
 				if (segments.length === 0) break;
 				changes.push({
 					kind: "format",
@@ -935,6 +962,7 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations,
 	return planned.length > maxOperations ? null : {
 		changes,
 		operations: planned,
+		verificationFailures,
 		tableTemplates,
 		tableGeometryPairings: tableGeometryPairingsOf(steps)
 	};

package/dist/compare/scenario.d.ts

@@ -1,4 +1,5 @@
-import { FolioAIEditOperation, FolioAIInlineFormattingPatch } from "../ai-edits/types.js";
+import { FolioContentFormatRange } from "./content-types.js";
+import { FolioAIEditOperation } from "../ai-edits/types.js";
 import { CompareDocxParseError, CompareDocxSerializeError } from "./types.js";
 import { Result } from "better-result";
 //#region src/compare/scenario.d.ts
@@ -45,13 +46,10 @@ type EditScriptStep = {
 {
   type: "mergeParagraphs";
   blockIndex: number;
-} | {
+} | ({
   type: "formatRange";
   blockIndex: number;
-  startOffset: number;
-  endOffset: number;
-  formatting: FolioAIInlineFormattingPatch;
-} | {
+} & FolioContentFormatRange) | {
   type: "insertTableRow";
   blockIndex: number;
   position?: TableRowPosition;

package/dist/compare/section-boundary-properties.d.ts

@@ -0,0 +1,63 @@
+import { document_d_exports } from "../types/document.js";
+import { Node } from "prosemirror-model";
+//#region src/compare/section-boundary-properties.d.ts
+type SectionBoundaryPropertyChange = {
+  position: number;
+  current: document_d_exports.SectionProperties;
+  target: document_d_exports.SectionProperties;
+};
+type SectionBoundaryPropertiesComparison = {
+  status: "matched";
+  changes: readonly SectionBoundaryPropertyChange[];
+} | {
+  status: "unalignable";
+  detail: string;
+};
+/**
+ * Compare section properties attached to retained top-level paragraph endpoints.
+ * A section endpoint cannot be added to or removed from a retained paragraph
+ * with `sectPrChange`: its previous payload is still a section endpoint.
+ */
+declare const compareSectionBoundaryProperties: ({ current, target, mapTargetProperties }: {
+  current: Node;
+  target: Node;
+  mapTargetProperties?: (properties: document_d_exports.SectionProperties) => document_d_exports.SectionProperties | null;
+}) => SectionBoundaryPropertiesComparison;
+type MappedSectionBoundaryProperties = {
+  kind: "inserted";
+  target: document_d_exports.SectionProperties;
+} | {
+  kind: "retained";
+  previous: document_d_exports.SectionProperties;
+  target: document_d_exports.SectionProperties;
+};
+type StageSectionBoundaryPropertiesResult = {
+  status: "matched";
+  transaction: import("prosemirror-state").Transaction;
+  nextRevisionId: number;
+  rangeCount: number;
+} | {
+  status: "unalignable";
+  detail: string;
+} | {
+  status: "budget-exceeded";
+};
+/** Stage section deltas after document operations, against the accepted projection. */
+declare const stageSectionBoundaryProperties: ({ state, target, originalRevisionIdSeed, revisionStamp, author, maxRanges, mapTargetProperties }: {
+  state: import("prosemirror-state").EditorState;
+  target: Node;
+  originalRevisionIdSeed: number;
+  revisionStamp: {
+    idSeed: number;
+    date: string;
+  };
+  author: string;
+  maxRanges: number;
+  mapTargetProperties: (args: {
+    kind: "inserted" | "retained";
+    current: document_d_exports.SectionProperties | undefined;
+    target: document_d_exports.SectionProperties;
+  }) => MappedSectionBoundaryProperties | null;
+}) => StageSectionBoundaryPropertiesResult;
+//#endregion
+export { SectionBoundaryPropertiesComparison, SectionBoundaryPropertyChange, StageSectionBoundaryPropertiesResult, compareSectionBoundaryProperties, stageSectionBoundaryProperties };