@stll/folio-core 0.52.0 → 0.54.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/documentStyleState.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

@@ -62,14 +62,16 @@ type FolioCommentAnchor = {
 declare const getTrackedChangesFromSnapshot: (snapshot: FolioAIEditSnapshot) => FolioReviewChange[];
 /**
  * The tracked changes present in the body, read from inline marks and
- * structural node attributes. Runs of one inline revision within a block fold
- * into a single entry.
+ * structural node attributes. Adjacent runs sharing a revision wrapper path
+ * fold into one entry; interrupted or differently nested wrappers stay separate.
  *
  * A tracked row insertion or deletion marks the row AND every run in its
  * 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[];
+/** Physical revision ids behind an inline change split by markup. */
+declare const getTrackedChangeGroupIdsFromDoc: (doc: Node, id: number) => number[];
 /** @internal Read revision statistics without paying for an unrelated block projection. */
 declare const getTrackedChangeStatsFromDoc: (doc: Node) => {
   highestId: number;
@@ -78,8 +80,8 @@ 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
-export { FOLIO_REVIEW_CHANGE_KINDS, FolioCommentAnchor, FolioReviewChange, FolioReviewChangeKind, getCommentAnchorsFromDoc, getTrackedChangeStatsFromDoc, getTrackedChangesFromDoc, getTrackedChangesFromSnapshot };
+export { FOLIO_REVIEW_CHANGE_KINDS, FolioCommentAnchor, FolioReviewChange, FolioReviewChangeKind, getCommentAnchorsFromDoc, getTrackedChangeGroupIdsFromDoc, getTrackedChangeStatsFromDoc, getTrackedChangesFromDoc, getTrackedChangesFromSnapshot };

package/dist/ai-edits/read.js

@@ -1,8 +1,10 @@
-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 { enclosingInsertionAncestors, trackedRevisionLayerOf } from "../prosemirror/trackedRevisionPath.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,23 +52,31 @@ 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) => {
+const getTrackedChangeGroupsFromProjectedDoc = (doc, blockStarts) => {
 	const insertionType = doc.type.schema.marks["insertion"];
 	const deletionType = doc.type.schema.marks["deletion"];
 	const grouped = /* @__PURE__ */ new Map();
+	const inlineRanges = /* @__PURE__ */ new Map();
+	const lastInlineGroupByPath = /* @__PURE__ */ new Map();
+	const transparentInlineEnds = /* @__PURE__ */ new Map();
+	const transparentGap = (start, end) => {
+		let pos = start;
+		while (pos < end) {
+			const next = transparentInlineEnds.get(pos);
+			if (next === void 0) return false;
+			pos = next;
+		}
+		return pos === end;
+	};
 	const structuralChangeCellPositions = /* @__PURE__ */ new Map();
 	const rowRevisionScopes = [];
 	const derivedFormattingRepresentationPositions = /* @__PURE__ */ new Set();
+	const noteReferences = collectNoteReferenceLabels(doc);
 	let currentBlockId = null;
 	doc.descendants((node, pos) => {
+		if (node.type.name === "commentReference") transparentInlineEnds.set(pos, pos + node.nodeSize);
 		while (pos >= (rowRevisionScopes.at(-1)?.end ?? Number.POSITIVE_INFINITY)) rowRevisionScopes.pop();
 		const nodeRevisionCarriers = getFolioNodeRevisionCarriers(node, pos);
 		if (nodeRevisionCarriers.length > 0) {
@@ -207,25 +217,50 @@ const getTrackedChangesFromProjectedDoc = (doc, blockStarts) => {
 				}
 			}
 		}
-		const text = node.text ?? "";
-		for (const mark of node.marks) {
-			if (mark.type.name === "runPropertyChange") continue;
-			if (typeof mark.attrs["revisionId"] !== "number") continue;
-			let kind;
-			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 text = readerTextOf(node, noteReferences);
+		const insertionMark = node.marks.find((mark) => mark.type === insertionType);
+		const deletionMark = node.marks.find((mark) => mark.type === deletionType);
+		const mark = deletionMark ?? insertionMark;
+		if (!mark || typeof mark.attrs["revisionId"] !== "number") return;
+		const attrs = expectTrackedChangeMarkAttrs(mark);
+		const pathLayers = [...enclosingInsertionAncestors({
+			insertionMark: deletionMark ? insertionMark : void 0,
+			ancestors: attrs._docxRevisionAncestors ?? [],
+			node
+		}), trackedRevisionLayerOf(mark, node)];
+		const layers = pathLayers.map((layer) => ({
+			kind: layer.type === "insertion" || layer.type === "moveTo" ? "insertion" : "deletion",
+			revision: {
+				id: layer.revisionId,
+				author: layer.author,
+				date: layer.date ?? null
+			}
+		}));
+		for (const [layerIndex, { kind: layerKind, revision }] of layers.entries()) {
 			const rowScope = rowRevisionScopes.at(-1);
-			if (rowScope?.kind === kind && belongsToRowRevision(rowScope, revision)) continue;
-			const key = `${currentBlockId ?? ""}:${kind}:${revisionId}`;
+			if (rowScope?.kind === layerKind && belongsToRowRevision(rowScope, revision)) continue;
+			const path = `${currentBlockId ?? ""}:${JSON.stringify(pathLayers.slice(0, layerIndex + 1))}`;
+			const previousKey = lastInlineGroupByPath.get(path);
+			const previousRange = previousKey === void 0 ? void 0 : inlineRanges.get(previousKey);
+			const key = previousKey !== void 0 && previousRange && transparentGap(previousRange.end, pos) ? previousKey : `${path}:${pos}`;
+			lastInlineGroupByPath.set(path, key);
+			const hyperlink = node.marks.find((candidate) => candidate.type.name === "hyperlink");
+			const commentId = node.marks.find((candidate) => candidate.type.name === "comment")?.attrs["commentId"];
+			const boundary = {
+				hyperlink: hyperlink ? String(hyperlink.attrs["href"] ?? "") : null,
+				comment: typeof commentId === "number" ? commentId : null,
+				revisionParents: JSON.stringify(pathLayers.slice(0, layerIndex))
+			};
+			const range = inlineRanges.get(key);
+			if (range) {
+				range.end = pos + node.nodeSize;
+				range.lastBoundary = boundary;
+			} else inlineRanges.set(key, {
+				start: pos,
+				end: pos + node.nodeSize,
+				firstBoundary: boundary,
+				lastBoundary: boundary
+			});
 			const existing = grouped.get(key);
 			if (existing) {
 				existing.text += text;
@@ -233,71 +268,99 @@ const getTrackedChangesFromProjectedDoc = (doc, blockStarts) => {
 			}
 			grouped.set(key, {
 				...revision,
-				type: kind,
+				type: layerKind,
 				text,
 				blockId: currentBlockId
 			});
 		}
 	});
-	return [...grouped.values()];
+	const groups = [];
+	let previousKey = null;
+	for (const [key, change] of grouped) {
+		const range = inlineRanges.get(key);
+		const previous = groups.at(-1);
+		const previousRange = previousKey === null ? void 0 : inlineRanges.get(previousKey);
+		if (previous && range && previousRange && previousRange.end <= range.start && transparentGap(previousRange.end, range.start) && previousRange.lastBoundary.revisionParents === range.firstBoundary.revisionParents && (previousRange.lastBoundary.hyperlink !== range.firstBoundary.hyperlink || previousRange.lastBoundary.comment !== range.firstBoundary.comment || previousRange.end !== range.start) && (change.type === "insertion" || change.type === "deletion") && previous.change.type === change.type && previous.change.author === change.author && previous.change.date === change.date && previous.change.blockId === change.blockId) {
+			previous.change.text += change.text;
+			previous.ids.push(change.id);
+			previousRange.end = range.end;
+			previousRange.lastBoundary = range.lastBoundary;
+			continue;
+		}
+		groups.push({
+			change: { ...change },
+			ids: [change.id]
+		});
+		previousKey = key;
+	}
+	return groups;
 };
+const getTrackedChangesFromProjectedDoc = (doc, blockStarts) => getTrackedChangeGroupsFromProjectedDoc(doc, blockStarts).map(({ change }) => change);
 /** Read revisions from the exact immutable document that produced a snapshot. */
 const getTrackedChangesFromSnapshot = (snapshot) => getTrackedChangesFromProjectedDoc(sourceDocumentOf(snapshot), blockStartIdsFromSnapshot(snapshot));
 /**
 * The tracked changes present in the body, read from inline marks and
-* structural node attributes. Runs of one inline revision within a block fold
-* into a single entry.
+* structural node attributes. Adjacent runs sharing a revision wrapper path
+* fold into one entry; interrupted or differently nested wrappers stay separate.
 *
 * A tracked row insertion or deletion marks the row AND every run in its
 * 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.
 */
 const getTrackedChangesFromDoc = (doc) => getTrackedChangesFromProjectedDoc(doc, blockStartIdsFromDoc(doc));
+/** Physical revision ids behind an inline change split by markup. */
+const getTrackedChangeGroupIdsFromDoc = (doc, id) => getTrackedChangeGroupsFromProjectedDoc(doc, blockStartIdsFromDoc(doc)).find(({ ids }) => ids.includes(id))?.ids ?? [id];
 /** @internal Read revision statistics without paying for an unrelated block projection. */
 const getTrackedChangeStatsFromDoc = (doc) => {
 	let highestId = 0;
-	const changes = getTrackedChangesFromProjectedDoc(doc, null);
-	for (const change of changes) highestId = Math.max(highestId, change.id);
+	const groups = getTrackedChangeGroupsFromProjectedDoc(doc, null);
+	for (const { ids } of groups) for (const id of ids) highestId = Math.max(highestId, id);
 	return {
 		highestId,
-		present: changes.length > 0
+		present: groups.length > 0
 	};
 };
 /**
 * 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 };
+export { FOLIO_REVIEW_CHANGE_KINDS, getCommentAnchorsFromDoc, getTrackedChangeGroupIdsFromDoc, getTrackedChangeStatsFromDoc, getTrackedChangesFromDoc, getTrackedChangesFromSnapshot };