@stll/folio-core 0.52.0 → 0.53.0

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

@@ -0,0 +1,79 @@
+import { FolioAIEditAppliedOperation, FolioAIEditApplyResult, FolioAIEditOperation, FolioAIEditSnapshot } from "./types.js";
+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;
+/** A host-owned, JSON-serializable proposal. It is never written into the DOCX. */
+type FolioPendingSuggestionRecord = {
+  version: typeof FOLIO_PENDING_SUGGESTION_VERSION;
+  suggestionId: string;
+  operation: FolioAIEditOperation;
+  story: FolioDocumentStoryHandle;
+  anchor: {
+    blockId: string;
+    paraId: string | null;
+    originalTextHash: string;
+    selectedTextHash?: string;
+    startOffset?: number;
+    endOffset?: number;
+  };
+  author: string;
+  provenance: "suggested";
+  sourceDocumentFingerprint: string;
+  commentId?: number;
+};
+type FolioPendingSuggestionStaleReason = "missingAnchor" | "ambiguousAnchor" | "textChanged" | "unsupportedVersion" | "documentChanged" | "invalidRecord" | "applyFailed";
+type FolioPendingSuggestionLoadResult = {
+  status: "restaged";
+  suggestionId: string;
+} | {
+  status: "stale";
+  suggestionId: string | null;
+  reason: FolioPendingSuggestionStaleReason;
+};
+type RecordAppliedOptions = {
+  snapshot: FolioAIEditSnapshot;
+  story: FolioDocumentStoryHandle;
+  operations: readonly FolioAIEditOperation[];
+  applied: readonly FolioAIEditAppliedOperation[];
+  author: string;
+  activeSuggestionIds: ReadonlySet<string>;
+};
+type ReplaceRestagedStoryOptions = {
+  story: FolioDocumentStoryHandle;
+  restaged: readonly {
+    snapshot: FolioAIEditSnapshot;
+    operation: FolioAIEditOperation;
+    applied: FolioAIEditAppliedOperation;
+    author: string;
+  }[];
+  activeSuggestionIds: ReadonlySet<string>;
+};
+type LoadPendingSuggestionsOptions = {
+  records: readonly unknown[];
+  snapshotForStory: (story: FolioDocumentStoryHandle) => FolioAIEditSnapshot | null;
+  sourceSnapshotForStory: (story: FolioDocumentStoryHandle, commentIds: ReadonlySet<number>) => FolioAIEditSnapshot | null;
+  apply: (record: FolioPendingSuggestionRecord, snapshot: FolioAIEditSnapshot) => FolioAIEditApplyResult;
+  activeSuggestionIds: () => ReadonlySet<string>;
+};
+type ExportPendingSuggestionsOptions = {
+  activeSuggestionIds: ReadonlySet<string>;
+  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;
+/** The saved package's story, with all pending proposals removed. */
+declare const createPendingSuggestionSourceSnapshot: (state: EditorState, commentIds: ReadonlySet<number>) => FolioAIEditSnapshot;
+/** Tracks only operations that successfully staged in `suggested` mode. */
+declare class FolioPendingSuggestionRegistry {
+  private readonly records;
+  private readonly sourceFingerprints;
+  clear(): void;
+  recordApplied({ snapshot, story, operations, applied, author, activeSuggestionIds }: RecordAppliedOptions): void;
+  /** Rebase records after ordinary revisions change their source story. */
+  replaceRestagedStory({ story, restaged, activeSuggestionIds }: ReplaceRestagedStoryOptions): void;
+  exportPendingSuggestions({ activeSuggestionIds, snapshotForStory }: ExportPendingSuggestionsOptions): FolioPendingSuggestionRecord[];
+  loadPendingSuggestions({ records, snapshotForStory, sourceSnapshotForStory, apply, activeSuggestionIds }: LoadPendingSuggestionsOptions): FolioPendingSuggestionLoadResult[];
+}
+//#endregion
+export { FOLIO_PENDING_SUGGESTION_VERSION, FolioPendingSuggestionLoadResult, FolioPendingSuggestionRecord, FolioPendingSuggestionRegistry, FolioPendingSuggestionStaleReason, createPendingSuggestionSourceSnapshot, withoutPendingSuggestionCommentMarks };

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

@@ -0,0 +1,306 @@
+import { parseFolioDocumentOperationBatch } from "../document-operations.js";
+import { rejectAllSuggestions } from "../prosemirror/commands/comments.js";
+import { getDocumentStyleResolver } from "../prosemirror/plugins/documentStyles.js";
+import { getFolioParaIdFromBlockId } from "../types/block-id.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
+import { createFolioAIEditSnapshotWithStyleResolver, hashFolioAIBlockText, sourceDocumentOf } from "./snapshot.js";
+//#region src/ai-edits/pending-suggestions.ts
+const FOLIO_PENDING_SUGGESTION_VERSION = 1;
+/** Drop only comments attached to proposals that have not been accepted. */
+const withoutPendingSuggestionCommentMarks = (state, commentIds) => {
+	if (commentIds.size === 0) return state;
+	let transaction = state.tr;
+	state.doc.descendants((node, position) => {
+		for (const mark of node.marks) if (mark.type.name === "comment" && commentIds.has(mark.attrs["commentId"])) transaction = transaction.removeMark(position, position + node.nodeSize, mark);
+	});
+	return transaction.docChanged ? state.apply(transaction) : state;
+};
+/** The saved package's story, with all pending proposals removed. */
+const createPendingSuggestionSourceSnapshot = (state, commentIds) => {
+	let source = state;
+	rejectAllSuggestions()(state, (transaction) => {
+		source = state.apply(transaction);
+	});
+	source = withoutPendingSuggestionCommentMarks(source, commentIds);
+	return createFolioAIEditSnapshotWithStyleResolver(source.doc, getDocumentStyleResolver(source));
+};
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const operationBlockId = (operation) => {
+	switch (operation.type) {
+		case "replaceRange":
+		case "commentOnRange":
+		case "formatRange": return operation.range.blockId;
+		default: return operation.blockId;
+	}
+};
+const storyFromUnknown = (value) => {
+	if (!isObject(value)) return null;
+	switch (value["type"]) {
+		case "main": return { type: "main" };
+		case "header":
+		case "footer": return typeof value["relationshipId"] === "string" ? {
+			type: value["type"],
+			relationshipId: value["relationshipId"]
+		} : null;
+		case "footnote":
+		case "endnote": return typeof value["noteId"] === "number" && Number.isSafeInteger(value["noteId"]) ? {
+			type: value["type"],
+			noteId: value["noteId"]
+		} : null;
+		default: return null;
+	}
+};
+const fingerprintOf = (snapshot, story) => hashFolioAIBlockText(canonicalJson([story, snapshot.blocks.map((block) => [block, snapshot.anchors[block.id]?.structuralBoundaryHash])]));
+const paraIdCountsOf = (snapshot) => {
+	const counts = /* @__PURE__ */ new Map();
+	sourceDocumentOf(snapshot).descendants((node) => {
+		const paraId = node.attrs["paraId"];
+		if (node.type.name === "paragraph" && typeof paraId === "string") counts.set(paraId, (counts.get(paraId) ?? 0) + 1);
+	});
+	return counts;
+};
+const recordKey = (record) => canonicalJson([
+	record.story,
+	record.suggestionId,
+	record.operation.id
+]);
+const parseRecord = (value) => {
+	if (!isObject(value) || !isObject(value["anchor"])) return null;
+	const story = storyFromUnknown(value["story"]);
+	const anchor = value["anchor"];
+	if (story === null || typeof value["suggestionId"] !== "string" || typeof value["author"] !== "string" || value["provenance"] !== "suggested" || typeof value["sourceDocumentFingerprint"] !== "string" || value["commentId"] !== void 0 && (typeof value["commentId"] !== "number" || !Number.isSafeInteger(value["commentId"])) || typeof anchor["blockId"] !== "string" || anchor["paraId"] !== null && typeof anchor["paraId"] !== "string" || typeof anchor["originalTextHash"] !== "string") return null;
+	let operation;
+	try {
+		const parsed = parseFolioDocumentOperationBatch({
+			version: 1,
+			operations: [value["operation"]],
+			mode: "suggested"
+		}).operations.at(0);
+		if (!parsed) return null;
+		operation = parsed;
+	} catch {
+		return null;
+	}
+	if (operationBlockId(operation) !== anchor["blockId"] || (operation.suggestionId ?? operation.id) !== value["suggestionId"] || getFolioParaIdFromBlockId(anchor["blockId"]) !== anchor["paraId"]) return null;
+	if (operation.type === "replaceRange" || operation.type === "formatRange") {
+		if (anchor["selectedTextHash"] !== operation.range.selectedTextHash || anchor["startOffset"] !== operation.range.startOffset || anchor["endOffset"] !== operation.range.endOffset) return null;
+	}
+	return {
+		version: 1,
+		suggestionId: value["suggestionId"],
+		operation,
+		story,
+		anchor: {
+			blockId: anchor["blockId"],
+			paraId: anchor["paraId"],
+			originalTextHash: anchor["originalTextHash"],
+			...typeof anchor["selectedTextHash"] === "string" && { selectedTextHash: anchor["selectedTextHash"] },
+			...typeof anchor["startOffset"] === "number" && { startOffset: anchor["startOffset"] },
+			...typeof anchor["endOffset"] === "number" && { endOffset: anchor["endOffset"] }
+		},
+		author: value["author"],
+		provenance: "suggested",
+		sourceDocumentFingerprint: value["sourceDocumentFingerprint"],
+		...typeof value["commentId"] === "number" && Number.isSafeInteger(value["commentId"]) && { commentId: value["commentId"] }
+	};
+};
+/** Tracks only operations that successfully staged in `suggested` mode. */
+var FolioPendingSuggestionRegistry = class {
+	records = /* @__PURE__ */ new Map();
+	sourceFingerprints = /* @__PURE__ */ new Map();
+	clear() {
+		this.records.clear();
+		this.sourceFingerprints.clear();
+	}
+	recordApplied({ snapshot, story, operations, applied, author, activeSuggestionIds }) {
+		if (applied.length === 0) return;
+		const storyKey = canonicalJson(story);
+		for (const [key, record] of this.records) if (!activeSuggestionIds.has(record.suggestionId)) this.records.delete(key);
+		if (![...this.records.values()].some((record) => canonicalJson(record.story) === storyKey)) this.sourceFingerprints.delete(storyKey);
+		const fingerprint = this.sourceFingerprints.get(storyKey) ?? fingerprintOf(snapshot, story);
+		this.sourceFingerprints.set(storyKey, fingerprint);
+		const appliedById = new Map(applied.map((entry) => [entry.id, entry]));
+		for (const operation of operations) {
+			const outcome = appliedById.get(operation.id);
+			if (!outcome?.suggestionId) continue;
+			const blockId = operationBlockId(operation);
+			const anchor = snapshot.anchors[blockId];
+			if (!anchor) continue;
+			const range = operation.type === "replaceRange" || operation.type === "formatRange" ? operation.range : null;
+			const record = {
+				version: 1,
+				suggestionId: outcome.suggestionId,
+				operation: structuredClone(operation),
+				story: structuredClone(story),
+				anchor: {
+					blockId,
+					paraId: getFolioParaIdFromBlockId(blockId),
+					originalTextHash: anchor.textHash,
+					...range !== null && {
+						selectedTextHash: range.selectedTextHash,
+						startOffset: range.startOffset,
+						endOffset: range.endOffset
+					}
+				},
+				author,
+				provenance: "suggested",
+				sourceDocumentFingerprint: fingerprint,
+				...outcome.commentId !== void 0 && { commentId: outcome.commentId }
+			};
+			this.records.set(recordKey(record), record);
+		}
+	}
+	/** Rebase records after ordinary revisions change their source story. */
+	replaceRestagedStory({ story, restaged, activeSuggestionIds }) {
+		if (restaged.length === 0) return;
+		const storyKey = canonicalJson(story);
+		for (const [key, record] of this.records) if (canonicalJson(record.story) === storyKey) this.records.delete(key);
+		const first = restaged.at(0);
+		if (!first) return;
+		this.sourceFingerprints.set(storyKey, fingerprintOf(first.snapshot, story));
+		for (const { snapshot, operation, applied, author } of restaged) this.recordApplied({
+			snapshot,
+			story,
+			operations: [operation],
+			applied: [applied],
+			author,
+			activeSuggestionIds
+		});
+	}
+	exportPendingSuggestions({ activeSuggestionIds, snapshotForStory }) {
+		const pending = [];
+		const fingerprints = /* @__PURE__ */ new Map();
+		const commentIdsByStory = /* @__PURE__ */ new Map();
+		for (const record of this.records.values()) {
+			if (!activeSuggestionIds.has(record.suggestionId) || record.commentId === void 0) continue;
+			const storyKey = canonicalJson(record.story);
+			const commentIds = commentIdsByStory.get(storyKey) ?? /* @__PURE__ */ new Set();
+			commentIds.add(record.commentId);
+			commentIdsByStory.set(storyKey, commentIds);
+		}
+		for (const [key, record] of this.records) if (activeSuggestionIds.has(record.suggestionId)) {
+			const storyKey = canonicalJson(record.story);
+			let fingerprint = fingerprints.get(storyKey);
+			if (fingerprint === void 0) {
+				const snapshot = snapshotForStory(record.story, commentIdsByStory.get(storyKey) ?? /* @__PURE__ */ new Set());
+				if (!snapshot) continue;
+				fingerprint = fingerprintOf(snapshot, record.story);
+				fingerprints.set(storyKey, fingerprint);
+			}
+			const current = {
+				...record,
+				sourceDocumentFingerprint: fingerprint
+			};
+			this.records.set(key, current);
+			pending.push(structuredClone(current));
+		} else this.records.delete(key);
+		for (const [storyKey, fingerprint] of fingerprints) this.sourceFingerprints.set(storyKey, fingerprint);
+		if (pending.length === 0) this.sourceFingerprints.clear();
+		return pending;
+	}
+	loadPendingSuggestions({ records, snapshotForStory, sourceSnapshotForStory, apply, activeSuggestionIds }) {
+		const baselines = /* @__PURE__ */ new Map();
+		const changedStories = /* @__PURE__ */ new Set();
+		return records.map((value) => {
+			const suggestionId = isObject(value) && typeof value["suggestionId"] === "string" ? value["suggestionId"] : null;
+			if (!isObject(value) || value["version"] !== 1) return {
+				status: "stale",
+				suggestionId,
+				reason: "unsupportedVersion"
+			};
+			const record = parseRecord(value);
+			if (!record) return {
+				status: "stale",
+				suggestionId,
+				reason: "invalidRecord"
+			};
+			const key = recordKey(record);
+			const existing = this.records.get(key);
+			if (existing && activeSuggestionIds().has(record.suggestionId)) {
+				const { commentId: _existingCommentId, ...existingProposal } = existing;
+				const { commentId: _loadedCommentId, ...loadedProposal } = record;
+				return canonicalJson(existingProposal) === canonicalJson(loadedProposal) ? {
+					status: "restaged",
+					suggestionId: record.suggestionId
+				} : {
+					status: "stale",
+					suggestionId,
+					reason: "invalidRecord"
+				};
+			}
+			const storyKey = canonicalJson(record.story);
+			if (!baselines.has(storyKey)) {
+				const snapshot = snapshotForStory(record.story);
+				const active = activeSuggestionIds();
+				const commentIds = /* @__PURE__ */ new Set();
+				for (const existingRecord of this.records.values()) if (canonicalJson(existingRecord.story) === storyKey && active.has(existingRecord.suggestionId) && existingRecord.commentId !== void 0) commentIds.add(existingRecord.commentId);
+				const source = sourceSnapshotForStory(record.story, commentIds);
+				baselines.set(storyKey, snapshot && source ? {
+					snapshot,
+					fingerprint: fingerprintOf(source, record.story)
+				} : null);
+			}
+			const baseline = baselines.get(storyKey);
+			if (!baseline || record.anchor.paraId === null) return {
+				status: "stale",
+				suggestionId,
+				reason: "missingAnchor"
+			};
+			const snapshot = changedStories.has(storyKey) ? snapshotForStory(record.story) : baseline.snapshot;
+			if (!snapshot) return {
+				status: "stale",
+				suggestionId,
+				reason: "missingAnchor"
+			};
+			const multiplicity = paraIdCountsOf(snapshot).get(record.anchor.paraId) ?? 0;
+			if (multiplicity === 0 || !snapshot.anchors[record.anchor.paraId]) return {
+				status: "stale",
+				suggestionId,
+				reason: "missingAnchor"
+			};
+			if (multiplicity > 1) return {
+				status: "stale",
+				suggestionId,
+				reason: "ambiguousAnchor"
+			};
+			const anchor = snapshot.anchors[record.anchor.paraId];
+			if (!anchor || anchor.textHash !== record.anchor.originalTextHash) return {
+				status: "stale",
+				suggestionId,
+				reason: "textChanged"
+			};
+			const { startOffset, endOffset, selectedTextHash } = record.anchor;
+			if (startOffset !== void 0 && endOffset !== void 0 && selectedTextHash !== void 0 && hashFolioAIBlockText(anchor.text.slice(startOffset, endOffset)) !== selectedTextHash) return {
+				status: "stale",
+				suggestionId,
+				reason: "textChanged"
+			};
+			if (baseline.fingerprint !== record.sourceDocumentFingerprint) return {
+				status: "stale",
+				suggestionId,
+				reason: "documentChanged"
+			};
+			const applied = apply(record, snapshot).applied.find((entry) => entry.id === record.operation.id);
+			if (!applied) return {
+				status: "stale",
+				suggestionId,
+				reason: "applyFailed"
+			};
+			this.sourceFingerprints.set(storyKey, record.sourceDocumentFingerprint);
+			if (!this.records.has(key)) {
+				const { commentId: _oldCommentId, ...rest } = record;
+				this.records.set(key, structuredClone({
+					...rest,
+					...applied.commentId !== void 0 && { commentId: applied.commentId }
+				}));
+			}
+			changedStories.add(storyKey);
+			return {
+				status: "restaged",
+				suggestionId: record.suggestionId
+			};
+		});
+	}
+};
+//#endregion
+export { FOLIO_PENDING_SUGGESTION_VERSION, FolioPendingSuggestionRegistry, createPendingSuggestionSourceSnapshot, withoutPendingSuggestionCommentMarks };

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

@@ -78,7 +78,7 @@ declare const getTrackedChangeStatsFromDoc: (doc: Node) => {
 /**
  * The comment anchors present in the body, read from the `comment` mark the
  * editor renders. Each entry carries the anchored text and containing block id;
- * runs of one comment id within the body fold into a single anchor.
+ * ranges for one comment id within the body fold into a single anchor.
  */
 declare const getCommentAnchorsFromDoc: (doc: Node) => FolioCommentAnchor[];
 //#endregion

package/dist/ai-edits/read.js

@@ -1,8 +1,9 @@
-import { expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { expectRunPropertyChangeMarkAttrs, expectTrackedChangeMarkAttrs } from "../prosemirror/attrs/index.js";
 import { getFolioNodeRevisionCarriers } from "../prosemirror/revisionCarriers.js";
 import { expandRunFormattingCarrier, runFormattingCarrierReviewText, runFormattingInlineAtomDisposition } from "../prosemirror/runFormattingInlineCarriers.js";
 import { getTableCellMergeChange } from "../prosemirror/tableCellMergeRevision.js";
-import { createFolioAIEditSnapshot, sourceDocumentOf } from "./snapshot.js";
+import { readerTextOf } from "./note-references.js";
+import { collectNoteReferenceLabels, createFolioAIEditSnapshot, sourceDocumentOf } from "./snapshot.js";
 //#region src/ai-edits/read.ts
 /**
 * Runtime census of every tracked-change discriminator the reviewer exposes.
@@ -50,12 +51,6 @@ const firstBlockIdWithin = ({ node, nodePos, blockStarts }) => {
 	});
 	return blockId;
 };
-/**
-* Whether a run's revision inside a marked row is that row's own. Folio writes
-* both halves under one revision id; Word mints a fresh `w:id` per element, so
-* an author + timestamp match counts too. A third party's edit inside the row
-* matches neither and keeps its own entry.
-*/
 const belongsToRowRevision = (scope, revision) => revision.id === scope.change.id || revision.author === scope.change.author && revision.date === scope.change.date;
 /** Shared revision interpreter; a null block map omits unrelated block-id projection. */
 const getTrackedChangesFromProjectedDoc = (doc, blockStarts) => {
@@ -65,6 +60,7 @@ const getTrackedChangesFromProjectedDoc = (doc, blockStarts) => {
 	const structuralChangeCellPositions = /* @__PURE__ */ new Map();
 	const rowRevisionScopes = [];
 	const derivedFormattingRepresentationPositions = /* @__PURE__ */ new Set();
+	const noteReferences = collectNoteReferenceLabels(doc);
 	let currentBlockId = null;
 	doc.descendants((node, pos) => {
 		while (pos >= (rowRevisionScopes.at(-1)?.end ?? Number.POSITIVE_INFINITY)) rowRevisionScopes.pop();
@@ -207,7 +203,7 @@ const getTrackedChangesFromProjectedDoc = (doc, blockStarts) => {
 				}
 			}
 		}
-		const text = node.text ?? "";
+		const text = readerTextOf(node, noteReferences);
 		for (const mark of node.marks) {
 			if (mark.type.name === "runPropertyChange") continue;
 			if (typeof mark.attrs["revisionId"] !== "number") continue;
@@ -215,28 +211,39 @@ const getTrackedChangesFromProjectedDoc = (doc, blockStarts) => {
 			if (mark.type === insertionType) kind = "insertion";
 			else if (mark.type === deletionType) kind = "deletion";
 			else continue;
-			const revisionId = mark.attrs["revisionId"];
 			const author = mark.attrs["author"];
 			const date = mark.attrs["date"];
-			const revision = {
-				id: revisionId,
-				author: typeof author === "string" ? author : "",
-				date: typeof date === "string" ? date : null
-			};
-			const rowScope = rowRevisionScopes.at(-1);
-			if (rowScope?.kind === kind && belongsToRowRevision(rowScope, revision)) continue;
-			const key = `${currentBlockId ?? ""}:${kind}:${revisionId}`;
-			const existing = grouped.get(key);
-			if (existing) {
-				existing.text += text;
-				continue;
+			const layers = [...(expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors ?? []).map((ancestor) => ({
+				kind: ancestor.type === "insertion" || ancestor.type === "moveTo" ? "insertion" : "deletion",
+				revision: {
+					id: ancestor.revisionId,
+					author: ancestor.author,
+					date: ancestor.date ?? null
+				}
+			})), {
+				kind,
+				revision: {
+					id: mark.attrs["revisionId"],
+					author: typeof author === "string" ? author : "",
+					date: typeof date === "string" ? date : null
+				}
+			}];
+			for (const { kind: layerKind, revision } of layers) {
+				const rowScope = rowRevisionScopes.at(-1);
+				if (rowScope?.kind === layerKind && belongsToRowRevision(rowScope, revision)) continue;
+				const key = `${currentBlockId ?? ""}:${layerKind}:${revision.id}`;
+				const existing = grouped.get(key);
+				if (existing) {
+					existing.text += text;
+					continue;
+				}
+				grouped.set(key, {
+					...revision,
+					type: layerKind,
+					text,
+					blockId: currentBlockId
+				});
 			}
-			grouped.set(key, {
-				...revision,
-				type: kind,
-				text,
-				blockId: currentBlockId
-			});
 		}
 	});
 	return [...grouped.values()];
@@ -266,38 +273,44 @@ const getTrackedChangeStatsFromDoc = (doc) => {
 /**
 * The comment anchors present in the body, read from the `comment` mark the
 * editor renders. Each entry carries the anchored text and containing block id;
-* runs of one comment id within the body fold into a single anchor.
+* ranges for one comment id within the body fold into a single anchor.
 */
 const getCommentAnchorsFromDoc = (doc) => {
 	const commentType = doc.type.schema.marks["comment"];
 	if (!commentType) return [];
 	const blockStarts = blockStartIdsFromDoc(doc);
-	const anchors = /* @__PURE__ */ new Map();
+	const ranges = /* @__PURE__ */ new Map();
+	const noteReferences = collectNoteReferenceLabels(doc);
 	let currentBlockId = null;
+	let bodyText = "";
 	doc.descendants((node, pos) => {
 		if (node.isTextblock) {
 			currentBlockId = blockStarts.get(pos) ?? null;
 			return true;
 		}
 		if (!node.isInline || node.text === void 0) return;
-		const text = node.text;
+		const text = readerTextOf(node, noteReferences);
+		const end = bodyText.length + text.length;
 		for (const mark of node.marks) {
 			if (mark.type !== commentType || typeof mark.attrs["commentId"] !== "number") continue;
 			const commentId = mark.attrs["commentId"];
-			const existing = anchors.get(commentId);
-			if (!existing) {
-				anchors.set(commentId, {
-					commentId,
-					blockId: currentBlockId,
-					quote: text
-				});
-				continue;
-			}
-			existing.quote += text;
-			existing.blockId ??= currentBlockId;
+			const range = ranges.get(commentId);
+			if (range) {
+				range.end = end;
+				range.blockId ??= currentBlockId;
+			} else ranges.set(commentId, {
+				blockId: currentBlockId,
+				start: bodyText.length,
+				end
+			});
 		}
+		bodyText += text;
 	});
-	return [...anchors.values()];
+	return [...ranges].map(([commentId, { blockId, start, end }]) => ({
+		commentId,
+		blockId,
+		quote: bodyText.slice(start, end)
+	}));
 };
 //#endregion
 export { FOLIO_REVIEW_CHANGE_KINDS, getCommentAnchorsFromDoc, getTrackedChangeStatsFromDoc, getTrackedChangesFromDoc, getTrackedChangesFromSnapshot };

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

@@ -0,0 +1,29 @@
+import { document_d_exports } from "../types/document.js";
+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 = {
+  /**
+   * The document's numbering definitions; `null` when the story states none,
+   * `undefined` when it cannot say (no numbering plugin), which leaves
+   * numbering references unchecked.
+   */
+  numbering: document_d_exports.NumberingDefinitions | null | undefined;
+  /** Comment ids the batch allocated; the host holds the comments themselves. */
+  createdCommentIds: readonly number[];
+  /**
+   * The author the host stamps on those comments, when the batch names one;
+   * the host writes the batch's author, so a blank one fails there too.
+   */
+  commentAuthor?: string;
+};
+/**
+ * The save-validator errors the batch introduced: errors in the changed window
+ * 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 };