@stll/folio-core 0.62.0 → 0.63.0

package/dist/ai-edits/index.js

@@ -6,7 +6,8 @@ import { buildAnnotatedBlockText } from "./clean-text.js";
 import { FOLIO_RESOLVED_REVIEWED_VIEWS, FOLIO_REVIEWED_VIEWS, FolioDocumentStoryNotFoundError, UnsupportedFolioReviewedViewError, isFolioResolvedReviewedView, isFolioReviewedView } from "./headless.js";
 import { FOLIO_PENDING_SUGGESTION_VERSION, FolioPendingSuggestionRegistry, createPendingSuggestionSourceSnapshot } from "./pending-suggestions.js";
 import { getCommentAnchorsFromDoc, getTrackedChangesFromDoc } from "./read.js";
+import { getFolioDocumentOperationRemovedBlockIds } from "./removed-blocks.js";
 import { getFolioDocumentOutline, readFolioDocumentSection } from "./scoped-reading.js";
 import { createFolioAIEditSnapshot, createFolioAIEditSnapshotWithStyleResolver, createFolioAITextRangeHandle, hashFolioAIBlockText, isFolioAIContentBlock, normalizeFolioAIBlockText } from "./snapshot.js";
 import { WORD_DIFF_GRANULARITIES, diffWordSegments } from "./word-diff.js";
-export { FOLIO_DOCUMENT_OPERATION_BATCH_MODES, FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION, FOLIO_DOCUMENT_OPERATION_MODES, FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE, FOLIO_DOCUMENT_OPERATION_PRECONDITIONS, FOLIO_DOCUMENT_OPERATION_STORIES, FOLIO_DOCUMENT_OPERATION_TYPES, FOLIO_LINE_SPACING_RULE_VALUES, FOLIO_PARAGRAPH_ALIGNMENT_VALUES, FOLIO_PENDING_SUGGESTION_VERSION, FOLIO_RESOLVED_REVIEWED_VIEWS, FOLIO_REVIEWED_VIEWS, FolioDocumentStoryNotFoundError, FolioPendingSuggestionRegistry, InvalidFolioDocumentOperationBatchError, UnsupportedFolioDocumentOperationVersionError, UnsupportedFolioReviewedViewError, WORD_DIFF_GRANULARITIES, applyFolioAIEditOperations, applyFolioDocumentOperations, assertSupportedFolioDocumentOperationVersion, buildAnnotatedBlockText, clampRangeToDocSize, createFolioAIEditSnapshot, createFolioAIEditSnapshotWithStyleResolver, createFolioAITextRangeHandle, createPendingSuggestionSourceSnapshot, diffWordSegments, getCommentAnchorsFromDoc, getFolioDocumentOperationCapabilities, getFolioDocumentOperationIssues, getFolioDocumentOperationReceipts, getFolioDocumentOutline, getFolioParaIdFromBlockId, getTrackedChangesFromDoc, hashFolioAIBlockText, isFolioAIContentBlock, isFolioDocumentOperationModeSupported, isFolioResolvedReviewedView, isFolioReviewedView, isSupportedFolioDocumentOperationVersion, normalizeFolioAIBlockText, parseFolioDocumentOperationBatch, readFolioDocumentSection, resolveFolioAIBlockRange, resolveFolioAITextRange, resolvePassageRange };
+export { FOLIO_DOCUMENT_OPERATION_BATCH_MODES, FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION, FOLIO_DOCUMENT_OPERATION_MODES, FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE, FOLIO_DOCUMENT_OPERATION_PRECONDITIONS, FOLIO_DOCUMENT_OPERATION_STORIES, FOLIO_DOCUMENT_OPERATION_TYPES, FOLIO_LINE_SPACING_RULE_VALUES, FOLIO_PARAGRAPH_ALIGNMENT_VALUES, FOLIO_PENDING_SUGGESTION_VERSION, FOLIO_RESOLVED_REVIEWED_VIEWS, FOLIO_REVIEWED_VIEWS, FolioDocumentStoryNotFoundError, FolioPendingSuggestionRegistry, InvalidFolioDocumentOperationBatchError, UnsupportedFolioDocumentOperationVersionError, UnsupportedFolioReviewedViewError, WORD_DIFF_GRANULARITIES, applyFolioAIEditOperations, applyFolioDocumentOperations, assertSupportedFolioDocumentOperationVersion, buildAnnotatedBlockText, clampRangeToDocSize, createFolioAIEditSnapshot, createFolioAIEditSnapshotWithStyleResolver, createFolioAITextRangeHandle, createPendingSuggestionSourceSnapshot, diffWordSegments, getCommentAnchorsFromDoc, getFolioDocumentOperationCapabilities, getFolioDocumentOperationIssues, getFolioDocumentOperationReceipts, getFolioDocumentOperationRemovedBlockIds, getFolioDocumentOutline, getFolioParaIdFromBlockId, getTrackedChangesFromDoc, hashFolioAIBlockText, isFolioAIContentBlock, isFolioDocumentOperationModeSupported, isFolioResolvedReviewedView, isFolioReviewedView, isSupportedFolioDocumentOperationVersion, normalizeFolioAIBlockText, parseFolioDocumentOperationBatch, readFolioDocumentSection, resolveFolioAIBlockRange, resolveFolioAITextRange, resolvePassageRange };

package/dist/ai-edits/inline-emphasis.d.ts

@@ -17,15 +17,15 @@
  * Backslashes are ordinary characters (no markdown escapes), so Windows paths
  * and regex survive intact.
  */
-type InlineEmphasisRun = {
+export type InlineEmphasisRun = {
   text: string;
   bold: boolean;
   italic: boolean;
 };
-declare const parseInlineEmphasisRuns: (input: string) => InlineEmphasisRun[];
+export declare const parseInlineEmphasisRuns: (input: string) => InlineEmphasisRun[];
 /** True when `input` contains at least one bold / italic span worth promoting
  *  to real marks; lets callers skip the run rebuild for plain text. */
-declare const hasInlineEmphasis: (input: string) => boolean;
+export declare const hasInlineEmphasis: (input: string) => boolean;
 /**
  * Drop emphasis markers without reconstructing formatting. Used on the
  * tracked-changes replace path, where the word-diff redline cannot carry inline
@@ -33,6 +33,5 @@ declare const hasInlineEmphasis: (input: string) => boolean;
  * input verbatim when no real span is present, so plain prose (and stray
  * single `*` / escaped `\*`) is never reshaped.
  */
-declare const stripInlineEmphasisMarkers: (input: string) => string;
-//#endregion
-export { InlineEmphasisRun, hasInlineEmphasis, parseInlineEmphasisRuns, stripInlineEmphasisMarkers };
+export declare const stripInlineEmphasisMarkers: (input: string) => string;
+//#endregion

package/dist/ai-edits/minimal-replacement.d.ts

@@ -1,26 +1,26 @@
 import { WordDiffSegment } from "./word-diff.js";
 //#region src/ai-edits/minimal-replacement.d.ts
 /** Replace `source.slice(start, end)` with `text`; offsets index the source span. */
-type TextChange = {
+export type TextChange = {
   start: number;
   end: number;
   text: string;
 };
 /** A clean-text span that can only be replaced whole (a field result). */
-type AtomicTextSpan = {
+export type AtomicTextSpan = {
   offset: number;
   length: number;
 };
 /** Common prefix length that never ends between the halves of a surrogate pair. */
-declare const commonPrefixLength: (a: string, b: string) => number;
+export declare const commonPrefixLength: (a: string, b: string) => number;
 /** Common suffix length that never starts between the halves of a surrogate pair. */
-declare const commonSuffixLength: (a: string, b: string) => number;
+export declare const commonSuffixLength: (a: string, b: string) => number;
 /**
  * Edits beyond which a replacement is treated as one rewrite. Bounds the diff
  * at O((N + M) * D) time and O(D^2) memory; a rewrite that large keeps
  * nothing of its source worth aligning to anyway.
  */
-declare const MAX_TOKEN_EDITS = 1024;
+export declare const MAX_TOKEN_EDITS = 1024;
 /**
  * The shortest edit script between two token sequences (Myers, 1986), as
  * segments of joined token text, or `null` past `maxEdits` edits.
@@ -30,7 +30,7 @@ declare const MAX_TOKEN_EDITS = 1024;
  * edit applied directly has no reader to serve, and every token it gives up is
  * text rewritten with someone else's formatting.
  */
-declare const shortestTokenDiff: (before: readonly string[], after: readonly string[], maxEdits?: number) => WordDiffSegment[] | null;
+export declare const shortestTokenDiff: (before: readonly string[], after: readonly string[], maxEdits?: number) => WordDiffSegment[] | null;
 /**
  * The changes from `source` to `replacement`, in source order and disjoint.
  *
@@ -44,14 +44,14 @@ declare const shortestTokenDiff: (before: readonly string[], after: readonly str
  * diff that does not reconstruct both strings exactly (it never should), is
  * one change over the whole span, trimmed the same way.
  */
-declare const planTextChanges: (source: string, replacement: string) => TextChange[];
+export declare const planTextChanges: (source: string, replacement: string) => TextChange[];
 /**
  * The changes a diff's segments describe, in source order and disjoint: each
  * run of `del` and `ins` segments between two `equal` ones is one change,
  * exactly as wide as the segments say. A redline's segments come cut to the
  * granularity its reader asked for, so they are not trimmed further.
  */
-declare const changesFromSegments: (segments: readonly WordDiffSegment[]) => TextChange[];
+export declare const changesFromSegments: (segments: readonly WordDiffSegment[]) => TextChange[];
 /**
  * `changes` widened so none cuts into an atomic span, then merged where the
  * widening made two overlap. A widened change re-emits the source text it
@@ -59,7 +59,7 @@ declare const changesFromSegments: (segments: readonly WordDiffSegment[]) => Tex
  *
  * `spans` are in the same coordinates as the changes (the source span's).
  */
-declare const widenChangesToAtomicSpans: (source: string, changes: readonly TextChange[], spans: readonly AtomicTextSpan[]) => TextChange[];
+export declare const widenChangesToAtomicSpans: (source: string, changes: readonly TextChange[], spans: readonly AtomicTextSpan[]) => TextChange[];
 /**
  * `changes` cut around every atomic span (a field result) that `kept`, another
  * plan of the same replacement, leaves untouched.
@@ -72,8 +72,7 @@ declare const widenChangesToAtomicSpans: (source: string, changes: readonly Text
  * the field's text does not stand in the change's new text exactly where
  * `kept` puts it, the change is left whole.
  */
-declare const keepAtomicSpans: (source: string, replacement: string, changes: readonly TextChange[], kept: readonly TextChange[], spans: readonly AtomicTextSpan[]) => TextChange[];
+export declare const keepAtomicSpans: (source: string, replacement: string, changes: readonly TextChange[], kept: readonly TextChange[], spans: readonly AtomicTextSpan[]) => TextChange[];
 /** `source` with `changes` applied; the invariant the planner owes. */
-declare const applyTextChanges: (source: string, changes: readonly TextChange[]) => string;
-//#endregion
-export { AtomicTextSpan, MAX_TOKEN_EDITS, TextChange, applyTextChanges, changesFromSegments, commonPrefixLength, commonSuffixLength, keepAtomicSpans, planTextChanges, shortestTokenDiff, widenChangesToAtomicSpans };
+export declare const applyTextChanges: (source: string, changes: readonly TextChange[]) => string;
+//#endregion

package/dist/ai-edits/newListNumbering.d.ts

@@ -1,17 +1,30 @@
+import { FolioContentStatedNumbering } from "../compare/content-types.js";
+import { ListKind } from "../docx/listNumberingInstances.js";
 import { FolioAIEditOperation, FolioAIListNumbering, FolioAINewListReference, FolioAIResolvedEditOperation } from "./types.js";
 import { NumberingMap } from "../docx/numberingParser.js";
 //#region src/ai-edits/newListNumbering.d.ts
 /** Whether `numbering` asks for a new list rather than naming an instance. */
-declare const isFolioAINewListReference: (numbering: FolioAIListNumbering) => numbering is FolioAINewListReference;
+export declare const isFolioAINewListReference: (numbering: FolioAIListNumbering) => numbering is FolioAINewListReference;
 type ResolvedNewLists = {
   operations: FolioAIResolvedEditOperation[];
   numbering: NumberingMap | null;
 };
+type DeferredNewListReference = {
+  kind: "deferredNewList";
+  allocation: {
+    format: ListKind;
+  };
+  level: number;
+};
+export type FolioAIStagedEditOperation = FolioAIEditOperation<FolioContentStatedNumbering | DeferredNewListReference>;
+export declare function assertNewListsAllocated(operation: FolioAIStagedEditOperation): asserts operation is FolioAIResolvedEditOperation;
+/** Make requests structurally plannable without allocating document resources. */
+export declare const stageNewListOperations: (operations: readonly FolioAIEditOperation[]) => FolioAIStagedEditOperation[];
 /**
  * Replace every new-list request with a reference to an instance minted for
  * its operation: one instance per operation and kind. `numbering` is the map
  * the batch applies against; the result's map adds the minted instances.
  */
-declare const resolveNewListOperations: (operations: readonly FolioAIEditOperation[], numbering: NumberingMap | null) => ResolvedNewLists;
+export declare const resolveNewListOperations: (operations: readonly FolioAIStagedEditOperation[], numbering: NumberingMap | null) => ResolvedNewLists;
 //#endregion
-export { isFolioAINewListReference, resolveNewListOperations };
+export {};

package/dist/ai-edits/newListNumbering.js

@@ -1,44 +1,38 @@
 import { mintListInstance } from "../docx/listNumberingInstances.js";
 import { createNumberingMap } from "../docx/numberingParser.js";
 import { paragraphNumberingReference } from "../docx/numberingReference.js";
+import { panic } from "better-result";
 //#region src/ai-edits/newListNumbering.ts
-/**
-* Operations that start a new list (`numbering: { kind: "newList", format }`)
-* resolved to the numbering instance each one defines.
-*
-* The instance is minted against the document's numbering (the package's
-* definitions plus every instance its paragraphs already define), so its id
-* collides with nothing, and against the instances earlier operations in the
-* batch minted, so two operations start two lists. The paragraphs the
-* operation numbers then carry the instance's rendering, which is what
-* defines it in the saved package (see `docx/listNumberingInstances.ts`).
-*/
 /** Whether `numbering` asks for a new list rather than naming an instance. */
 const isFolioAINewListReference = (numbering) => numbering.kind === "newList";
-/**
-* Replace every new-list request with a reference to an instance minted for
-* its operation: one instance per operation and kind. `numbering` is the map
-* the batch applies against; the result's map adds the minted instances.
-*/
-const resolveNewListOperations = (operations, numbering) => {
-	let definitions = numbering?.definitions;
-	let minted = false;
-	const resolveOperation = (operation) => {
-		const instances = /* @__PURE__ */ new Map();
+const operationNumbering = (operation) => {
+	switch (operation.type) {
+		case "insertAfterBlock":
+		case "insertBeforeBlock": return [operation.numbering];
+		case "setBlockParagraphProperties": return [operation.properties.numbering];
+		case "splitBlock": return [operation.firstParagraphProperties?.numbering, operation.secondParagraphProperties?.numbering];
+		case "mergeBlockWithNext": return [operation.mergedParagraphProperties?.numbering];
+		default: return [];
+	}
+};
+function assertNewListsAllocated(operation) {
+	if (operationNumbering(operation).some((numbering) => numbering?.kind === "deferredNewList")) panic("A deferred new-list request reached execution", { operationId: operation.id });
+}
+const deferNewListRequests = (operations) => {
+	const deferOperation = (operation) => {
+		const allocations = /* @__PURE__ */ new Map();
 		const resolve = (value) => {
 			if (value === void 0 || !isFolioAINewListReference(value)) return value;
-			let numId = instances.get(value.format);
-			if (numId === void 0) {
-				const instance = mintListInstance(definitions, { kind: value.format });
-				definitions = instance.definitions;
-				numId = instance.numId;
-				instances.set(value.format, numId);
-				minted = true;
+			let allocation = allocations.get(value.format);
+			if (allocation === void 0) {
+				allocation = { format: value.format };
+				allocations.set(value.format, allocation);
 			}
-			return paragraphNumberingReference({
-				numId,
-				ilvl: value.level ?? 0
-			});
+			return {
+				kind: "deferredNewList",
+				allocation,
+				level: value.level ?? 0
+			};
 		};
 		const resolveProperties = (properties) => {
 			const { numbering: request, ...rest } = properties;
@@ -80,10 +74,79 @@ const resolveNewListOperations = (operations, numbering) => {
 			default: return operation;
 		}
 	};
+	return operations.map(deferOperation);
+};
+/** Make requests structurally plannable without allocating document resources. */
+const stageNewListOperations = (operations) => deferNewListRequests(operations);
+/**
+* Replace every new-list request with a reference to an instance minted for
+* its operation: one instance per operation and kind. `numbering` is the map
+* the batch applies against; the result's map adds the minted instances.
+*/
+const resolveNewListOperations = (operations, numbering) => {
+	let definitions = numbering?.definitions;
+	let minted = false;
 	return {
-		operations: operations.map(resolveOperation),
+		operations: operations.map((operation) => {
+			const instances = /* @__PURE__ */ new Map();
+			const resolve = (value) => {
+				if (value === void 0) return value;
+				if (value.kind !== "deferredNewList") return value;
+				let numId = instances.get(value.allocation);
+				if (numId === void 0) {
+					const instance = mintListInstance(definitions, { kind: value.allocation.format });
+					definitions = instance.definitions;
+					minted = true;
+					numId = instance.numId;
+					instances.set(value.allocation, numId);
+				}
+				return paragraphNumberingReference({
+					numId,
+					ilvl: value.level
+				});
+			};
+			const resolveProperties = (properties) => {
+				const { numbering: request, ...rest } = properties;
+				const resolvedNumbering = resolve(request);
+				return {
+					...rest,
+					...resolvedNumbering !== void 0 && { numbering: resolvedNumbering }
+				};
+			};
+			switch (operation.type) {
+				case "insertAfterBlock":
+				case "insertBeforeBlock": {
+					const { numbering: request, ...rest } = operation;
+					const resolvedNumbering = resolve(request);
+					return {
+						...rest,
+						...resolvedNumbering !== void 0 && { numbering: resolvedNumbering }
+					};
+				}
+				case "setBlockParagraphProperties": return {
+					...operation,
+					properties: resolveProperties(operation.properties)
+				};
+				case "splitBlock": {
+					const { firstParagraphProperties, secondParagraphProperties, ...rest } = operation;
+					return {
+						...rest,
+						...firstParagraphProperties !== void 0 && { firstParagraphProperties: resolveProperties(firstParagraphProperties) },
+						...secondParagraphProperties !== void 0 && { secondParagraphProperties: resolveProperties(secondParagraphProperties) }
+					};
+				}
+				case "mergeBlockWithNext": {
+					const { mergedParagraphProperties, ...rest } = operation;
+					return {
+						...rest,
+						...mergedParagraphProperties !== void 0 && { mergedParagraphProperties: resolveProperties(mergedParagraphProperties) }
+					};
+				}
+				default: return operation;
+			}
+		}),
 		numbering: minted && definitions ? createNumberingMap(definitions) : numbering
 	};
 };
 //#endregion
-export { isFolioAINewListReference, resolveNewListOperations };
+export { assertNewListsAllocated, isFolioAINewListReference, resolveNewListOperations, stageNewListOperations };

package/dist/ai-edits/note-references.d.ts

@@ -4,23 +4,23 @@ import { CleanBlockText } from "./clean-text.js";
 import { Node } from "prosemirror-model";
 //#region src/ai-edits/note-references.d.ts
 /** Which note a reference names: its kind and its package id. */
-type NoteReferenceIdentity = {
+export type NoteReferenceIdentity = {
   noteType: NoteReferenceKind;
   noteId: string;
 };
 /** The reference a text node carries, or `null` for ordinary text. */
-declare const noteReferenceOf: (node: Node) => NoteReferenceIdentity | null;
+export declare const noteReferenceOf: (node: Node) => NoteReferenceIdentity | null;
 /**
  * The marker each reference of a story shows, keyed by note: numbered once
  * for a whole story so every block reads the same number the Markdown export
  * gives it, and so an edit elsewhere in one batch cannot renumber a block the
  * batch resolved earlier.
  */
-type NoteReferenceLabels = {
+export type NoteReferenceLabels = {
   labelOf: (reference: NoteReferenceIdentity) => string | undefined;
 };
 /** Labels that grow as the blocks of a story are numbered, in reading order. */
-type NoteReferenceLabeler = NoteReferenceLabels & {
+export type NoteReferenceLabeler = NoteReferenceLabels & {
   /**
    * Number the references of one block. A reference the clean view omits
    * (tracked-deleted, hidden) takes no number, exactly as its characters take
@@ -33,23 +33,23 @@ type NoteReferenceLabeler = NoteReferenceLabels & {
  * block by block inside its own walk; `collectNoteReferenceLabels` (with the
  * snapshot, so both skip what the snapshot skips) numbers a whole story.
  */
-declare const createNoteReferenceLabeler: () => NoteReferenceLabeler;
+export declare const createNoteReferenceLabeler: () => NoteReferenceLabeler;
 /**
  * The text a reader shows for an inline text node: a note reference's marker
  * instead of its package id. A reference the clean view omits (a tracked
  * deletion) has no number there, and reads as an unnumbered marker.
  */
-declare const readerTextOf: (node: Node, labels: NoteReferenceLabels) => string;
+export declare const readerTextOf: (node: Node, labels: NoteReferenceLabels) => string;
 /** A note reference's marker inside a span of clean text, relative to the span. */
-type NoteReferenceSpan = {
+export type NoteReferenceSpan = {
   offset: number;
   length: number;
 };
 type StructuralBoundaries = Pick<CleanBlockText, "structuralBoundaries">;
 /** The markers lying wholly inside clean text `[start, end)`, relative to `start`. */
-declare const noteReferenceSpansWithin: ({ structuralBoundaries }: StructuralBoundaries, start: number, end: number) => NoteReferenceSpan[];
+export declare const noteReferenceSpansWithin: ({ structuralBoundaries }: StructuralBoundaries, start: number, end: number) => NoteReferenceSpan[];
 /** Whether clean text `[start, end)` starts or ends inside a reference's marker. */
-declare const cutsIntoNoteReference: ({ structuralBoundaries }: StructuralBoundaries, start: number, end: number) => boolean;
+export declare const cutsIntoNoteReference: ({ structuralBoundaries }: StructuralBoundaries, start: number, end: number) => boolean;
 /**
  * @internal Run `apply` with its text operations free to remove note
  * references and to write marker text in place of new ones.
@@ -61,9 +61,9 @@ declare const cutsIntoNoteReference: ({ structuralBoundaries }: StructuralBounda
  * removed reference is a tracked deletion of the reference itself. Every other
  * caller keeps the protection. The scope is synchronous, like the applier.
  */
-declare const withComparisonNoteReferenceEdits: <T>(apply: () => T) => T;
+export declare const withComparisonNoteReferenceEdits: <T>(apply: () => T) => T;
 /** @internal Whether the running apply belongs to a comparison (see above). */
-declare const noteReferenceEditsAllowed: () => boolean;
+export declare const noteReferenceEditsAllowed: () => boolean;
 /** The pieces of a replacement between the markers it has to keep. */
 type NoteReferenceSegments = {
   /** The source text between markers, with its offset in the source. */
@@ -85,12 +85,12 @@ type NoteReferenceSegments = {
  * `null`: the edit is refused rather than deleting a reference, or leaving
  * text behind that claims to be one.
  */
-declare const segmentsAroundNoteReferences: (source: string, replacement: string, spans: readonly NoteReferenceSpan[]) => NoteReferenceSegments | null;
+export declare const segmentsAroundNoteReferences: (source: string, replacement: string, spans: readonly NoteReferenceSpan[]) => NoteReferenceSegments | null;
 /**
  * Plan a replacement's changes piece by piece between the markers it keeps, so
  * no change ever touches a reference. `null` when the replacement does not
  * keep them (see {@link segmentsAroundNoteReferences}).
  */
-declare const planChangesAroundNoteReferences: (source: string, replacement: string, spans: readonly NoteReferenceSpan[], planChanges: (source: string, replacement: string) => readonly TextChange[]) => TextChange[] | null;
+export declare const planChangesAroundNoteReferences: (source: string, replacement: string, spans: readonly NoteReferenceSpan[], planChanges: (source: string, replacement: string) => readonly TextChange[]) => TextChange[] | null;
 //#endregion
-export { NoteReferenceIdentity, NoteReferenceLabeler, NoteReferenceLabels, NoteReferenceSpan, createNoteReferenceLabeler, cutsIntoNoteReference, noteReferenceEditsAllowed, noteReferenceOf, noteReferenceSpansWithin, planChangesAroundNoteReferences, readerTextOf, segmentsAroundNoteReferences, withComparisonNoteReferenceEdits };
+export {};

package/dist/ai-edits/note-story-inventory.d.ts

@@ -2,6 +2,6 @@ import { document_d_exports } from "../types/document.js";
 //#region src/ai-edits/note-story-inventory.d.ts
 type NoteStories = Pick<document_d_exports.Document["package"], "footnotes" | "endnotes">;
 /** The note collections visible to a reviewer or its captured save state. */
-declare const noteStoryInventory: (source: NoteStories, removed: Pick<ReadonlySet<string>, "has" | "size">) => NoteStories;
+export declare const noteStoryInventory: (source: NoteStories, removed: Pick<ReadonlySet<string>, "has" | "size">) => NoteStories;
 //#endregion
-export { noteStoryInventory };
+export {};

package/dist/ai-edits/pending-suggestions.d.ts

@@ -2,9 +2,9 @@ import { FolioAIEditAppliedOperation, FolioAIEditApplyResult, FolioAIEditOperati
 import { FolioDocumentStoryHandle } from "./headless.js";
 import { EditorState } from "prosemirror-state";
 //#region src/ai-edits/pending-suggestions.d.ts
-declare const FOLIO_PENDING_SUGGESTION_VERSION: 1;
+export declare const FOLIO_PENDING_SUGGESTION_VERSION: 1;
 /** A host-owned, JSON-serializable proposal. It is never written into the DOCX. */
-type FolioPendingSuggestionRecord = {
+export type FolioPendingSuggestionRecord = {
   version: typeof FOLIO_PENDING_SUGGESTION_VERSION;
   suggestionId: string;
   operation: FolioAIEditOperation;
@@ -22,8 +22,8 @@ type FolioPendingSuggestionRecord = {
   sourceDocumentFingerprint: string;
   commentId?: number;
 };
-type FolioPendingSuggestionStaleReason = "missingAnchor" | "ambiguousAnchor" | "textChanged" | "unsupportedVersion" | "documentChanged" | "invalidRecord" | "applyFailed";
-type FolioPendingSuggestionLoadResult = {
+export type FolioPendingSuggestionStaleReason = "missingAnchor" | "ambiguousAnchor" | "textChanged" | "unsupportedVersion" | "documentChanged" | "invalidRecord" | "applyFailed";
+export type FolioPendingSuggestionLoadResult = {
   status: "restaged";
   suggestionId: string;
 } | {
@@ -61,11 +61,11 @@ type ExportPendingSuggestionsOptions = {
   snapshotForStory: (story: FolioDocumentStoryHandle, commentIds: ReadonlySet<number>) => FolioAIEditSnapshot | null;
 };
 /** Drop only comments attached to proposals that have not been accepted. */
-declare const withoutPendingSuggestionCommentMarks: (state: EditorState, commentIds: ReadonlySet<number>) => EditorState;
+export declare const withoutPendingSuggestionCommentMarks: (state: EditorState, commentIds: ReadonlySet<number>) => EditorState;
 /** The saved package's story, with all pending proposals removed. */
-declare const createPendingSuggestionSourceSnapshot: (state: EditorState, commentIds: ReadonlySet<number>) => FolioAIEditSnapshot;
+export declare const createPendingSuggestionSourceSnapshot: (state: EditorState, commentIds: ReadonlySet<number>) => FolioAIEditSnapshot;
 /** Tracks only operations that successfully staged in `suggested` mode. */
-declare class FolioPendingSuggestionRegistry {
+export declare class FolioPendingSuggestionRegistry {
   private readonly records;
   private readonly sourceFingerprints;
   clear(): void;
@@ -76,4 +76,4 @@ declare class FolioPendingSuggestionRegistry {
   loadPendingSuggestions({ records, snapshotForStory, sourceSnapshotForStory, apply, activeSuggestionIds }: LoadPendingSuggestionsOptions): FolioPendingSuggestionLoadResult[];
 }
 //#endregion
-export { FOLIO_PENDING_SUGGESTION_VERSION, FolioPendingSuggestionLoadResult, FolioPendingSuggestionRecord, FolioPendingSuggestionRegistry, FolioPendingSuggestionStaleReason, createPendingSuggestionSourceSnapshot, withoutPendingSuggestionCommentMarks };
+export {};

package/dist/ai-edits/pending-suggestions.js

@@ -127,10 +127,14 @@ var FolioPendingSuggestionRegistry = class {
 			const anchor = snapshot.anchors[blockId];
 			if (!anchor) continue;
 			const range = operation.type === "replaceRange" || operation.type === "formatRange" ? operation.range : null;
+			const recorded = outcome.suggestionId === (operation.suggestionId ?? operation.id) ? operation : {
+				...operation,
+				suggestionId: outcome.suggestionId
+			};
 			const record = {
 				version: 1,
 				suggestionId: outcome.suggestionId,
-				operation: structuredClone(operation),
+				operation: structuredClone(recorded),
 				story: structuredClone(story),
 				anchor: {
 					blockId,

package/dist/ai-edits/read.d.ts

@@ -2,7 +2,7 @@ import { FolioAIEditSnapshot } from "./types.js";
 import { FolioNodeRevisionKind } from "../prosemirror/revisionCarriers.js";
 import { Node } from "prosemirror-model";
 //#region src/ai-edits/read.d.ts
-type FolioReviewChangeKind = "insertion" | "deletion" | "formatting" | "rowInserted" | "rowDeleted" | "cellInserted" | "cellDeleted" | "cellMerged" | FolioNodeRevisionKind;
+export type FolioReviewChangeKind = "insertion" | "deletion" | "formatting" | "rowInserted" | "rowDeleted" | "cellInserted" | "cellDeleted" | "cellMerged" | FolioNodeRevisionKind;
 /**
  * Runtime census of every tracked-change discriminator the reviewer exposes.
  *
@@ -11,7 +11,7 @@ type FolioReviewChangeKind = "insertion" | "deletion" | "formatting" | "rowInser
  * this census, so a newly modeled revision cannot silently miss the resolver
  * and serialization matrix.
  */
-declare const FOLIO_REVIEW_CHANGE_KINDS: Readonly<{
+export declare const FOLIO_REVIEW_CHANGE_KINDS: Readonly<{
   readonly insertion: "insertion";
   readonly deletion: "deletion";
   readonly formatting: "formatting";
@@ -30,7 +30,7 @@ declare const FOLIO_REVIEW_CHANGE_KINDS: Readonly<{
   readonly cellPropertiesChanged: "cellPropertiesChanged";
 }>;
 /** A tracked change discovered in the document body. */
-type FolioReviewChange = {
+export type FolioReviewChange = {
   /**
    * The tracked-change revision id — the OOXML `w:id` carried on the
    * revision marker. A text replacement produces two changes (a deletion side
@@ -51,7 +51,7 @@ type FolioReviewChange = {
   blockId: string | null;
 };
 /** A comment anchor (the ranged text a comment marks) discovered in the body. */
-type FolioCommentAnchor = {
+export type FolioCommentAnchor = {
   commentId: number;
   /** Stable id of the anchored body block, or `null` when the anchor is absent. */
   blockId: string | null;
@@ -59,7 +59,7 @@ type FolioCommentAnchor = {
   quote: string;
 };
 /** Read revisions from the exact immutable document that produced a snapshot. */
-declare const getTrackedChangesFromSnapshot: (snapshot: FolioAIEditSnapshot) => FolioReviewChange[];
+export declare const getTrackedChangesFromSnapshot: (snapshot: FolioAIEditSnapshot) => FolioReviewChange[];
 /**
  * The tracked changes present in the body, read from inline marks and
  * structural node attributes. Adjacent runs sharing a revision wrapper path
@@ -69,11 +69,11 @@ declare const getTrackedChangesFromSnapshot: (snapshot: FolioAIEditSnapshot) =>
  * cells, the way Word writes it. Both halves are one change, so the run marks
  * fold into the row's entry rather than reporting a second time.
  */
-declare const getTrackedChangesFromDoc: (doc: Node) => FolioReviewChange[];
+export declare const getTrackedChangesFromDoc: (doc: Node) => FolioReviewChange[];
 /** Physical revision ids behind an inline change split by markup. */
-declare const getTrackedChangeGroupIdsFromDoc: (doc: Node, id: number) => number[];
+export declare const getTrackedChangeGroupIdsFromDoc: (doc: Node, id: number) => number[];
 /** @internal Read revision statistics without paying for an unrelated block projection. */
-declare const getTrackedChangeStatsFromDoc: (doc: Node) => {
+export declare const getTrackedChangeStatsFromDoc: (doc: Node) => {
   highestId: number;
   present: boolean;
   ids: readonly number[];
@@ -83,6 +83,5 @@ declare const getTrackedChangeStatsFromDoc: (doc: Node) => {
  * editor renders. Each entry carries the anchored text and containing block id;
  * ranges for one comment id within the body fold into a single anchor.
  */
-declare const getCommentAnchorsFromDoc: (doc: Node) => FolioCommentAnchor[];
-//#endregion
-export { FOLIO_REVIEW_CHANGE_KINDS, FolioCommentAnchor, FolioReviewChange, FolioReviewChangeKind, getCommentAnchorsFromDoc, getTrackedChangeGroupIdsFromDoc, getTrackedChangeStatsFromDoc, getTrackedChangesFromDoc, getTrackedChangesFromSnapshot };
+export declare const getCommentAnchorsFromDoc: (doc: Node) => FolioCommentAnchor[];
+//#endregion

package/dist/ai-edits/read.js

@@ -3,6 +3,7 @@ import { getFolioNodeRevisionCarriers } from "../prosemirror/revisionCarriers.js
 import { expandRunFormattingCarrier, runFormattingCarrierReviewText, runFormattingInlineAtomDisposition } from "../prosemirror/runFormattingInlineCarriers.js";
 import { getTableCellMergeChange } from "../prosemirror/tableCellMergeRevision.js";
 import { enclosingInsertionAncestors, trackedRevisionLayerOf } from "../prosemirror/trackedRevisionPath.js";
+import { commentAnchorIdsForNode } from "./comment-lifecycle.js";
 import { readerTextOf } from "./note-references.js";
 import { collectNoteReferenceLabels, createFolioAIEditSnapshot, sourceDocumentOf } from "./snapshot.js";
 //#region src/ai-edits/read.ts
@@ -350,6 +351,11 @@ const getCommentAnchorsFromDoc = (doc) => {
 			currentBlockId = blockStarts.get(pos) ?? null;
 			return true;
 		}
+		for (const commentId of commentAnchorIdsForNode(node)) if (!ranges.has(commentId)) ranges.set(commentId, {
+			blockId: currentBlockId,
+			start: bodyText.length,
+			end: bodyText.length
+		});
 		if (!node.isInline || node.text === void 0) return;
 		const text = readerTextOf(node, noteReferences);
 		const end = bodyText.length + text.length;

package/dist/ai-edits/referenceClassification.d.ts

@@ -17,6 +17,6 @@ declare const REFERENCE_DISPOSITIONS: {
 };
 type ReferenceDisposition = (typeof REFERENCE_DISPOSITIONS)[keyof typeof REFERENCE_DISPOSITIONS];
 /** A missing source reference may stay dangling, but cannot acquire destination meaning. */
-declare const classifyResourceReference: (reference: ResourceReferenceClassificationOptions) => ReferenceDisposition;
+export declare const classifyResourceReference: (reference: ResourceReferenceClassificationOptions) => ReferenceDisposition;
 //#endregion
-export { classifyResourceReference };
+export {};

package/dist/ai-edits/removed-blocks.d.ts

@@ -0,0 +1,20 @@
+import { FolioAIBlock } from "./types.js";
+import { FolioDocumentOperation } from "../document-operations.js";
+//#region src/ai-edits/removed-blocks.d.ts
+type BlockIdentity = Pick<FolioAIBlock, "id"> & {
+  table?: FolioAIBlock["table"];
+};
+/**
+ * The pre-batch block identities an operation removes from the accepted result.
+ *
+ * Batch operations all address this same block list. Keeping removal in block-id
+ * coordinates prevents a structural operation from moving a later operation's
+ * numeric position onto a different block.
+ */
+export declare const getFolioDocumentOperationRemovedBlockIds: (blocks: readonly BlockIdentity[], operation: FolioDocumentOperation) => ReadonlySet<string>;
+export declare const getTrackedFolioDocumentOperationRemovedBlockIds: (blocks: readonly BlockIdentity[], operation: FolioDocumentOperation) => ReadonlySet<string>;
+export declare const getTrackedFolioDocumentOperationCarrierBlockId: (blocks: readonly BlockIdentity[], operation: FolioDocumentOperation, previouslyRemovedBlockIds: {
+  has(blockId: string): boolean;
+}) => string | undefined;
+//#endregion
+export {};