@stll/folio-core 0.62.0 → 0.63.1

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 {};

package/dist/ai-edits/removed-blocks.js

@@ -0,0 +1,69 @@
+//#region src/ai-edits/removed-blocks.ts
+const blockContainerKey = ({ table }) => table === void 0 ? "body" : `${String(table.tableIndex)}:${String(table.rowIndex)}:${String(table.cellIndex)}`;
+const isContainerCarrier = (blocks, anchorIndex) => {
+	const anchor = blocks[anchorIndex];
+	if (anchor === void 0) return false;
+	const containerKey = blockContainerKey(anchor);
+	return blocks.slice(anchorIndex + 1).every((block) => blockContainerKey(block) !== containerKey);
+};
+/**
+* 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.
+*/
+const removedBlockIds = (blocks, operation) => {
+	const removed = /* @__PURE__ */ new Set();
+	const blockId = "range" in operation ? operation.range.blockId : operation.blockId;
+	const anchorIndex = blocks.findIndex(({ id }) => id === blockId);
+	const anchor = blocks[anchorIndex];
+	switch (operation.type) {
+		case "deleteBlock":
+			removed.add(operation.blockId);
+			break;
+		case "mergeBlockWithNext": {
+			const next = anchorIndex < 0 ? void 0 : blocks[anchorIndex + 1];
+			if (next !== void 0) removed.add(next.id);
+			break;
+		}
+		case "deleteTable":
+			if (anchor?.table !== void 0) {
+				for (const block of blocks) if (block.table?.tableIndex === anchor.table.tableIndex) removed.add(block.id);
+			}
+			break;
+		case "deleteTableRow":
+			if (anchor?.table !== void 0) {
+				for (const block of blocks) if (block.table?.tableIndex === anchor.table.tableIndex && block.table.rowIndex === anchor.table.rowIndex) removed.add(block.id);
+			}
+			break;
+		case "deleteTableColumn": if (anchor?.table !== void 0) for (const block of blocks) {
+			const table = block.table;
+			if (table?.tableIndex === anchor.table.tableIndex && table.gridColumnIndex === anchor.table.gridColumnIndex && table.columnSpan === 1) removed.add(block.id);
+		}
+	}
+	return removed;
+};
+/**
+* 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.
+*/
+const getFolioDocumentOperationRemovedBlockIds = (blocks, operation) => removedBlockIds(blocks, operation);
+const getTrackedFolioDocumentOperationRemovedBlockIds = (blocks, operation) => operation.type === "mergeBlockWithNext" ? /* @__PURE__ */ new Set() : removedBlockIds(blocks, operation);
+const getTrackedFolioDocumentOperationCarrierBlockId = (blocks, operation, previouslyRemovedBlockIds) => {
+	if (operation.type !== "mergeBlockWithNext") return void 0;
+	const anchorIndex = blocks.findIndex(({ id }) => id === operation.blockId);
+	const anchor = blocks[anchorIndex];
+	if (anchor === void 0) return void 0;
+	const containerKey = blockContainerKey(anchor);
+	let carrierIndex = anchorIndex + 1;
+	while (blocks[carrierIndex + 1] !== void 0 && blockContainerKey(blocks[carrierIndex + 1]) === containerKey) carrierIndex++;
+	const carrier = blocks[carrierIndex];
+	if (carrier === void 0 || !isContainerCarrier(blocks, carrierIndex)) return void 0;
+	return blocks.slice(anchorIndex + 1, carrierIndex + 1).every(({ id }) => previouslyRemovedBlockIds.has(id)) ? carrier.id : void 0;
+};
+//#endregion
+export { getFolioDocumentOperationRemovedBlockIds, getTrackedFolioDocumentOperationCarrierBlockId, getTrackedFolioDocumentOperationRemovedBlockIds };

package/dist/ai-edits/result-validation.d.ts

@@ -3,7 +3,7 @@ import { Node } from "prosemirror-model";
 import { ValidateDocumentModelIssue } from "@stll/docx-core";
 //#region src/ai-edits/result-validation.d.ts
 /** What the story's package knows that the story itself does not. */
-type FolioOperationResultValidationContext = {
+export type FolioOperationResultValidationContext = {
   /**
    * The document's numbering definitions; `null` when the story states none,
    * `undefined` when it cannot say (no numbering plugin), which leaves
@@ -23,7 +23,6 @@ type FolioOperationResultValidationContext = {
  * of `after` that the same window of `before` did not already report. Empty
  * when the result is as saveable as the story it started from.
  */
-declare const findIntroducedModelErrors: (before: Node, after: Node, context: FolioOperationResultValidationContext) => ValidateDocumentModelIssue[];
-declare const describeModelError: ({ path, message }: ValidateDocumentModelIssue) => string;
-//#endregion
-export { FolioOperationResultValidationContext, describeModelError, findIntroducedModelErrors };
+export declare const findIntroducedModelErrors: (before: Node, after: Node, context: FolioOperationResultValidationContext) => ValidateDocumentModelIssue[];
+export declare const describeModelError: ({ path, message }: ValidateDocumentModelIssue) => string;
+//#endregion

package/dist/ai-edits/result-validation.js

@@ -1,7 +1,7 @@
-import { validateFolioDocumentModel } from "../docx/modelValidation.js";
 import { proseDocToBlocks } from "../prosemirror/conversion/fromProseDoc.js";
 import { sectionPropertiesOf } from "../prosemirror/sectionCarrier.js";
 import { anchoredCommentIdsInProseDoc } from "./comment-lifecycle.js";
+import { validateDocumentModel } from "@stll/docx-core";
 import { Fragment } from "prosemirror-model";
 //#region src/ai-edits/result-validation.ts
 /**
@@ -97,7 +97,7 @@ const windowErrors = ({ doc, from, to, context, knownParts, knownCommentIds }) =
 			severity: "error"
 		}];
 	}
-	return validateFolioDocumentModel({ package: {
+	const document = { package: {
 		document: {
 			content,
 			comments: [...[...knownCommentIds ?? []].map((id) => syntheticComment(id, "")), ...context.createdCommentIds.filter((id) => !knownCommentIds?.has(id)).map((id) => syntheticComment(id, context.commentAuthor ?? ""))]
@@ -107,7 +107,8 @@ const windowErrors = ({ doc, from, to, context, knownParts, knownCommentIds }) =
 			headers: knownParts.headers,
 			footers: knownParts.footers
 		}
-	} }).issues.filter((issue) => issue.severity === "error" && !(context.numbering === void 0 && issue.path.endsWith(".numPr.numId"))).map(({ path, message, severity }) => ({
+	} };
+	return validateDocumentModel(document).issues.filter((issue) => issue.severity === "error" && !(context.numbering === void 0 && issue.path.endsWith(".numPr.numId"))).map(({ path, message, severity }) => ({
 		path: rebasePath(path, from),
 		message,
 		severity

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

@@ -4,7 +4,7 @@ type SeparateRevisionStretchesOptions = {
   tr: Transaction;
   revisionSeed: number;
 };
-type SeparatedRevisionStretches = {
+export type SeparatedRevisionStretches = {
   nextRevisionId: number;
   /** Each fresh id, with the revision whose stretch it now names. */
   minted: {
@@ -12,6 +12,6 @@ type SeparatedRevisionStretches = {
     from: number;
   }[];
 };
-declare const separateRevisionStretches: ({ tr, revisionSeed }: SeparateRevisionStretchesOptions) => SeparatedRevisionStretches;
+export declare const separateRevisionStretches: ({ tr, revisionSeed }: SeparateRevisionStretchesOptions) => SeparatedRevisionStretches;
 //#endregion
-export { SeparatedRevisionStretches, separateRevisionStretches };
+export {};

package/dist/ai-edits/revisionStretches.js

@@ -2,6 +2,23 @@ import { expectRunPropertyChangeMarkAttrs, expectTrackedChangeMarkAttrs } from "
 import { applyMarksToRunFormattingRepresentation, expandRunFormattingCarrier } from "../prosemirror/runFormattingInlineCarriers.js";
 import { panic } from "better-result";
 //#region src/ai-edits/revisionStretches.ts
+/**
+* One id per stretch of an inline revision.
+*
+* An edit inside a pending insertion (or a replacement whose words differ in
+* several places) leaves one revision in stretches with other content between
+* them. A saved package writes each stretch as a wrapper of its own, and
+* `w:id` is unique per wrapper, so the save would give every stretch after the
+* first a fresh id: once reopened they are separate changes, each accepted or
+* rejected alone. The batch gives them those ids when it makes them, so the
+* reviewer lists, resolves, saves and reopens the same changes.
+*
+* A stretch is what the reader lists as one change: the revision's content in
+* one paragraph, uninterrupted but for comment references.
+* A formatting revision instead belongs to one serialized run carrier. A
+* later edit can split that carrier without changing its property mark, so
+* each resulting carrier gets its own id through the same allocator.
+*/
 const INLINE_REVISION_MARKS = /* @__PURE__ */ new Set(["insertion", "deletion"]);
 const separateRevisionStretches = ({ tr, revisionSeed }) => {
 	let nextRevisionId = revisionSeed;

package/dist/ai-edits/scoped-reading.d.ts

@@ -1,8 +1,7 @@
 import { FolioAIEditSnapshot, FolioDocumentOutline, FolioDocumentSectionHandle, FolioDocumentSectionReadResult } from "./types.js";
 //#region src/ai-edits/scoped-reading.d.ts
 /** Build a flat, ordered outline with stable handles and explicit parents. */
-declare const getFolioDocumentOutline: (snapshot: FolioAIEditSnapshot) => FolioDocumentOutline;
+export declare const getFolioDocumentOutline: (snapshot: FolioAIEditSnapshot) => FolioDocumentOutline;
 /** Resolve one heading section against a fresh snapshot without guessing. */
-declare const readFolioDocumentSection: (snapshot: FolioAIEditSnapshot, handle: FolioDocumentSectionHandle) => FolioDocumentSectionReadResult;
-//#endregion
-export { getFolioDocumentOutline, readFolioDocumentSection };
+export declare const readFolioDocumentSection: (snapshot: FolioAIEditSnapshot, handle: FolioDocumentSectionHandle) => FolioDocumentSectionReadResult;
+//#endregion