@stll/folio-core 0.53.0 → 0.54.0

package/dist/ai-edits/batch-claims.d.ts

@@ -54,10 +54,6 @@ type BatchClaim = InlineClaim |
    * any other does — see `followedByInsertion`.
    */
   keepsParagraph: boolean;
-  /** The node leaves the document while the batch is still applying. */
-  removesNode: boolean;
-  /** Applied directly rather than tracked. */
-  direct: boolean;
 } |
 /**
  * Joins `block` with the block starting at `next`, where `block` ends.
@@ -88,11 +84,20 @@ type BatchClaim = InlineClaim |
   axis: "row" | "column" | "table";
   ranges: readonly PositionRange[];
 } |
-/** Any other change to a table's grid: rows or columns added, cells merged or split. */
+/**
+ * Any other change to a table's grid: rows or columns added, cells merged or
+ * split. A merge also names the blank cells it folds into its first one
+ * (`folded`, empty for every other change). Tracked, a merge folds only
+ * blank cells, since the record moves no content; applied directly, it
+ * moves whatever they hold. Another operation of the batch writing into one
+ * would let the merge apply in one mode and not the other, so nothing else
+ * may claim them.
+ */
 {
   type: "tableStructure";
   table: number;
   axis: "row" | "column" | "cell";
+  folded: readonly PositionRange[];
 } | {
   type: "unclaimed";
 };
@@ -106,10 +111,12 @@ declare class BatchClaims {
   private readonly insertions;
   private readonly joins;
   private readonly removals;
+  /** Accepted merges' folded cells; see the `tableStructure` claim. */
+  private readonly folds;
   private readonly tables;
   private readonly rowInsertions;
   private readonly columnInsertions;
-  /** Accepted deletions that keep their paragraph, by where the paragraph ends. */
+  /** Accepted deletions that keep their paragraph, by where the paragraph starts and ends. */
   private readonly keptParagraphs;
   /** `claim`'s roles, given the insertions accepted so far. */
   private rolesOf;
@@ -124,6 +131,14 @@ declare class BatchClaims {
    * conflicts with none.
    */
   conflictOf(claim: BatchClaim): string | null;
+  /** The accepted merge whose folded cells hold `position`. */
+  private foldAt;
+  /**
+   * An accepted operation that claims anything inside `ranges`, the blank
+   * cells a merge folds. A block insertion anchored in a cell lands beside its
+   * table, so only the cell's own paragraph can be claimed there.
+   */
+  private claimedInside;
   add(operationId: string, claim: BatchClaim): void;
 }
 //#endregion

package/dist/ai-edits/batch-claims.js

@@ -19,9 +19,7 @@ const blockRolesOf = (claim) => {
 			block: claim.block,
 			role: {
 				kind: "deleteBlock",
-				keepsParagraph: claim.keepsParagraph,
-				removesNode: claim.removesNode,
-				direct: claim.direct
+				keepsParagraph: claim.keepsParagraph
 			}
 		}];
 		case "merge": return [{
@@ -42,14 +40,16 @@ const blockRolesOf = (claim) => {
 };
 /**
 * A deletion of the paragraph that ends its container, once the batch inserts
-* a block after it: the insertion lands first, the paragraph then ends
-* nothing, and it goes as any other — tracked, its mark is deleted into the
-* inserted block and its properties with it; directly, the node goes.
+* a block next to it. After it, the insertion lands first, the paragraph then
+* ends nothing, and it goes as any other — tracked, its mark is deleted into
+* the inserted block and its properties with it; directly, the node goes.
+* Before it, the paragraph the deletion retires the mark of is the inserted
+* one, a pending insertion, so retiring it joins the two and this paragraph
+* does not stay either.
 */
 const followedByInsertion = (role) => ({
 	...role,
-	keepsParagraph: false,
-	removesNode: role.direct
+	keepsParagraph: false
 });
 const isPoint = ({ from, to }) => from === to;
 /**
@@ -80,7 +80,7 @@ const rolesConflict = (left, right) => {
 	switch (left.kind) {
 		case "deleteBlock": switch (right.kind) {
 			case "paragraphProperties": return !left.keepsParagraph;
-			case "mergeNext": return left.removesNode;
+			case "mergeNext": return false;
 			default: return true;
 		}
 		case "rewriteBlock": switch (right.kind) {
@@ -122,14 +122,16 @@ var BatchClaims = class {
 	insertions = /* @__PURE__ */ new Map();
 	joins = /* @__PURE__ */ new Map();
 	removals = [];
+	/** Accepted merges' folded cells; see the `tableStructure` claim. */
+	folds = [];
 	tables = /* @__PURE__ */ new Map();
 	rowInsertions = /* @__PURE__ */ new Map();
 	columnInsertions = /* @__PURE__ */ new Map();
-	/** Accepted deletions that keep their paragraph, by where the paragraph ends. */
+	/** Accepted deletions that keep their paragraph, by where the paragraph starts and ends. */
 	keptParagraphs = /* @__PURE__ */ new Map();
 	/** `claim`'s roles, given the insertions accepted so far. */
 	rolesOf(claim) {
-		return blockRolesOf(claim).map(({ block, role }) => role.kind === "deleteBlock" && role.keepsParagraph && claim.type === "deleteBlock" && this.insertions.has(claim.end) ? {
+		return blockRolesOf(claim).map(({ block, role }) => role.kind === "deleteBlock" && role.keepsParagraph && claim.type === "deleteBlock" && (this.insertions.has(claim.end) || this.insertions.has(claim.block)) ? {
 			block,
 			role: followedByInsertion(role)
 		} : {
@@ -158,6 +160,8 @@ var BatchClaims = class {
 	conflictOf(claim) {
 		for (const { block, role } of this.rolesOf(claim)) {
 			for (const entry of this.blocks.get(block) ?? []) if (rolesConflict(entry.role, role)) return entry.operationId;
+			const fold = this.foldAt(block);
+			if (fold !== null) return fold;
 			if (role.kind === "deleteBlock") continue;
 			for (const removal of this.removals) if (insideAny(removal.claim.ranges, block)) return removal.operationId;
 		}
@@ -170,7 +174,7 @@ var BatchClaims = class {
 				if (following !== null) return following;
 				return this.removals.find(({ claim: removed }) => strictlyInsideAny(removed.ranges, claim.at))?.operationId ?? null;
 			}
-			case "tableStructure": return this.removals.find(({ claim: removed }) => insideAny(removed.ranges, claim.table) || removed.table === claim.table && removed.axis !== claim.axis && (removed.axis === "row" || removed.axis === "column"))?.operationId ?? this.removals.find(({ claim: removed }) => removed.wholeTable && removed.table === claim.table)?.operationId ?? null;
+			case "tableStructure": return this.claimedInside(claim.folded) ?? this.removals.find(({ claim: removed }) => insideAny(removed.ranges, claim.table) || removed.table === claim.table && removed.axis !== claim.axis && (removed.axis === "row" || removed.axis === "column"))?.operationId ?? this.removals.find(({ claim: removed }) => removed.wholeTable && removed.table === claim.table)?.operationId ?? null;
 			case "tableRemoval":
 				if (claim.axis === "row") {
 					const columnInsertion = this.columnInsertions.get(claim.table);
@@ -195,6 +199,23 @@ var BatchClaims = class {
 			default: return null;
 		}
 	}
+	/** The accepted merge whose folded cells hold `position`. */
+	foldAt(position) {
+		return this.folds.find(({ ranges }) => insideAny(ranges, position))?.operationId ?? null;
+	}
+	/**
+	* An accepted operation that claims anything inside `ranges`, the blank
+	* cells a merge folds. A block insertion anchored in a cell lands beside its
+	* table, so only the cell's own paragraph can be claimed there.
+	*/
+	claimedInside(ranges) {
+		if (ranges.length === 0) return null;
+		for (const [block, entries] of this.blocks) {
+			const entry = entries[0];
+			if (entry !== void 0 && insideAny(ranges, block)) return entry.operationId;
+		}
+		return null;
+	}
 	add(operationId, claim) {
 		for (const { block, role } of this.rolesOf(claim)) {
 			const entries = this.blocks.get(block);
@@ -206,10 +227,16 @@ var BatchClaims = class {
 				operationId,
 				role
 			}]);
-			if (claim.type === "deleteBlock" && role.kind === "deleteBlock" && role.keepsParagraph) this.keptParagraphs.set(claim.end, {
-				block,
-				operationId
-			});
+			if (claim.type === "deleteBlock" && role.kind === "deleteBlock" && role.keepsParagraph) {
+				this.keptParagraphs.set(claim.end, {
+					block,
+					operationId
+				});
+				this.keptParagraphs.set(claim.block, {
+					block,
+					operationId
+				});
+			}
 		}
 		switch (claim.type) {
 			case "merge":
@@ -225,6 +252,10 @@ var BatchClaims = class {
 				break;
 			}
 			case "tableStructure":
+				if (claim.folded.length > 0) this.folds.push({
+					operationId,
+					ranges: claim.folded
+				});
 				if (!this.tables.has(claim.table)) this.tables.set(claim.table, operationId);
 				if (claim.axis === "row" && !this.rowInsertions.has(claim.table)) this.rowInsertions.set(claim.table, operationId);
 				if (claim.axis === "column" && !this.columnInsertions.has(claim.table)) this.columnInsertions.set(claim.table, operationId);

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

@@ -341,6 +341,8 @@ declare class FolioDocxReviewer {
   private state;
   private readonly secondaryStoryStates;
   private readonly removedHeaderFooterStories;
+  /** Notes whose reference a resolution removed: a note exists only through its reference. */
+  private readonly removedNoteStories;
   private readonly sectionReferenceRemovals;
   private importedStyles;
   private readonly importedMedia;
@@ -445,7 +447,9 @@ declare class FolioDocxReviewer {
   applyDocumentOperations(batch: FolioDocumentOperationBatch, options?: FolioApplyDocumentOperationsOptions): FolioDocumentOperationResult;
   /** Apply a versioned operation batch to one editable document story. */
   applyDocumentOperationsToStory({ story, batch, snapshot, revisionStamp, wordDiff, tableTemplates, replacementBackground, undefinedStyles }: FolioApplyDocumentOperationsToStoryOptions): FolioDocumentOperationResult;
+  /** Apply a batch; the notes whose references it deletes or removes follow them. */
   private applyDocumentOperationsInternal;
+  private applyDocumentOperationsToStoryState;
   /** Undo the latest unchanged document-operation batch and its created comments. */
   undoDocumentOperations(undoHandle: FolioDocumentOperationUndoHandle): FolioDocumentOperationUndoResult;
   /**
@@ -569,6 +573,22 @@ declare class FolioDocxReviewer {
   private resolveWithSectionReferenceHistory;
   private resolveEveryFinalSectionChange;
   private resolveEveryStory;
+  /**
+   * Change the body the way a note follows its reference: a note whose
+   * reference goes, goes too, as a note no text refers to does; a note whose
+   * reference an edit deletes as a tracked change has its text deleted with
+   * it; a note whose reference's deletion is rejected gets back the text that
+   * deletion took.
+   */
+  private withNotesFollowingReferences;
+  /** Delete the text of each note whose reference went from live to a tracked deletion. */
+  private deleteNotesWithTheirReferences;
+  /**
+   * The notes a story other than the body refers to (a header, a footer, a
+   * comment, another note), leaving out references inside the `skipped` notes.
+   */
+  private noteKeysReferencedOutsideBody;
+  private resolveEveryStoryOnce;
   private acceptOrdinaryChangesWithSuggestions;
   /** The current document model with edits merged back in. */
   toDocument(): document_d_exports.Document;

package/dist/ai-edits/headless.js

@@ -17,7 +17,7 @@ import { attemptSelectiveSave } from "../docx/selectiveSave.js";
 import { pluginsForHeadlessRevisionResolution } from "../internal/headlessRevisionResolutionGuard.js";
 import { withTrackedSectionEndpointRemoval } from "../internal/sectionEndpointResolution.js";
 import { captureSectionReferenceInventory, resolvedSectionReferenceLosses, withSectionReferenceResolution } from "../internal/sectionReferenceResolution.js";
-import { expectCharacterStyleMarkAttrs } from "../prosemirror/attrs/index.js";
+import { expectCharacterStyleMarkAttrs, expectFootnoteRefMarkAttrs } from "../prosemirror/attrs/index.js";
 import { acceptAIEditRevision, acceptSuggestion, getSuggestions, rejectAIEditRevision, rejectAllSuggestions, rejectSuggestion, resolveAllChangesInHeadlessState, suggestionIdOfRevision } from "../prosemirror/commands/comments.js";
 import { sectionRejectProperties } from "../prosemirror/commands/propertyChangeScope.js";
 import { proseDocToBlocks, updateDocumentContent } from "../prosemirror/conversion/fromProseDoc.js";
@@ -26,8 +26,10 @@ import { ensureBaseDirectionInState } from "../prosemirror/extensions/features/A
 import { getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
 import { completeNumberingForDoc } from "../prosemirror/listInstanceReferences.js";
 import "../prosemirror/listMarker.js";
+import { deleteNoteWithReference, noteDeletionRevisions, noteKeysReferencedIn, noteReferenceStates, noteReferencesRestored, referenceDeletions, referencedNotes } from "../prosemirror/noteReferenceReview.js";
 import { createDocumentNumberingPlugin, withDocumentNumbering } from "../prosemirror/plugins/documentNumbering.js";
-import { createDocumentStylesPlugin, getDocumentStyleResolver, withDocumentStyles } from "../prosemirror/plugins/documentStyles.js";
+import { getDocumentStyleResolver } from "../prosemirror/plugins/documentStyleState.js";
+import { createDocumentStylesPlugin, withDocumentStyles } from "../prosemirror/plugins/documentStyles.js";
 import { schema, singletonManager } from "../prosemirror/schema/index.js";
 import { sectionPropertiesOf } from "../prosemirror/sectionCarrier.js";
 import { storyListNumbering } from "../prosemirror/storyListNumbering.js";
@@ -35,8 +37,9 @@ import { canonicalJson } from "../utils/canonicalJson.js";
 import { deterministicHexId } from "../utils/hexId.js";
 import { buildAnnotatedBlockTextWithNoteReferences } from "./clean-text.js";
 import { anchoredCommentIdsInBlocks, anchoredCommentIdsInProseDoc, withoutLostCommentThreads } from "./comment-lifecycle.js";
+import { noteReferenceEditsAllowed } from "./note-references.js";
 import { FolioPendingSuggestionRegistry, createPendingSuggestionSourceSnapshot, withoutPendingSuggestionCommentMarks } from "./pending-suggestions.js";
-import { getCommentAnchorsFromDoc, getTrackedChangeStatsFromDoc, getTrackedChangesFromDoc, getTrackedChangesFromSnapshot } from "./read.js";
+import { getCommentAnchorsFromDoc, getTrackedChangeGroupIdsFromDoc, getTrackedChangeStatsFromDoc, getTrackedChangesFromDoc, getTrackedChangesFromSnapshot } from "./read.js";
 import { collectNoteReferenceLabels, createFolioAIEditSnapshotWithStyleResolver, detachFolioAIEditSnapshotExternalHyperlinks, folioStoryTables, isFolioAIContentBlock, normalizeFolioAIBlockText, sourceDocumentOf } from "./snapshot.js";
 import { matchTableGeometry } from "./table-geometry.js";
 import { tableTemplateCanCrossPackageLosslessly } from "./table-template.js";
@@ -254,6 +257,28 @@ const comparisonAccessByReviewer = /* @__PURE__ */ new WeakMap();
 const MAIN_STORY = Object.freeze({ type: "main" });
 const headerFooterStoryKey = ({ type, relationshipId }) => `${type}:${relationshipId}`;
 const noteStoryKey = ({ type, noteId }) => `${type}:${noteId}`;
+/** The note story a {@link noteStoryKey} key names. */
+const noteStoryHandleOf = (key) => {
+	const [type, noteId] = key.split(":");
+	return (type === "footnote" || type === "endnote") && noteId !== void 0 ? {
+		type,
+		noteId: Number(noteId)
+	} : null;
+};
+/** The notes a story's text refers to, keyed as {@link noteStoryKey} keys them. */
+const referencedNoteKeys = (doc) => {
+	const keys = /* @__PURE__ */ new Set();
+	doc.descendants((node) => {
+		if (!node.isText) return true;
+		for (const mark of node.marks) {
+			if (mark.type.name !== "footnoteRef") continue;
+			const { id, noteType } = expectFootnoteRefMarkAttrs(mark);
+			keys.add(`${noteType === "endnote" ? "endnote" : "footnote"}:${String(id)}`);
+		}
+		return false;
+	});
+	return keys;
+};
 /**
 * A part's roles as a reader label: `first`, or, in a document with several
 * sections, `first (sections 1, 3), default (section 2)`.
@@ -365,6 +390,8 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	state;
 	secondaryStoryStates = /* @__PURE__ */ new Map();
 	removedHeaderFooterStories = /* @__PURE__ */ new Map();
+	/** Notes whose reference a resolution removed: a note exists only through its reference. */
+	removedNoteStories = /* @__PURE__ */ new Map();
 	sectionReferenceRemovals = [];
 	importedStyles;
 	importedMedia = /* @__PURE__ */ new Map();
@@ -905,7 +932,12 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			createUndoEntry: true
 		});
 	}
-	applyDocumentOperationsInternal({ story, batch, author, snapshot, revisionStamp, wordDiff, tableTemplates, replacementBackground, undefinedStyles, createUndoEntry }) {
+	/** Apply a batch; the notes whose references it deletes or removes follow them. */
+	applyDocumentOperationsInternal(options) {
+		if (noteReferenceEditsAllowed()) return this.applyDocumentOperationsToStoryState(options);
+		return this.withNotesFollowingReferences(() => this.applyDocumentOperationsToStoryState(options));
+	}
+	applyDocumentOperationsToStoryState({ story, batch, author, snapshot, revisionStamp, wordDiff, tableTemplates, replacementBackground, undefinedStyles, createUndoEntry }) {
 		const beforeState = this.requireEditableStoryState(story);
 		const operationAuthor = author ?? this.author;
 		const sourceSnapshot = snapshot ?? createStateSnapshot(beforeState);
@@ -993,7 +1025,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			undoHandle,
 			reason: "documentChanged"
 		};
-		this.setEditableStoryState(entry.story, entry.beforeState);
+		this.withNotesFollowingReferences(() => this.setEditableStoryState(entry.story, entry.beforeState));
 		this.createdComments.length = entry.createdCommentsLengthBefore;
 		this.documentOperationUndoEntries.pop();
 		return {
@@ -1100,7 +1132,10 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			type: "endnote",
 			noteId: endnote.id
 		});
-		return handles.filter((handle) => handle.type !== "header" && handle.type !== "footer" || !this.removedHeaderFooterStories.has(headerFooterStoryKey(handle)));
+		return handles.filter((handle) => {
+			if (handle.type === "header" || handle.type === "footer") return !this.removedHeaderFooterStories.has(headerFooterStoryKey(handle));
+			return handle.type !== "footnote" && handle.type !== "endnote" || !this.removedNoteStories.has(noteStoryKey(handle));
+		});
 	}
 	/** Discover every readable document story through a typed, serializable handle. */
 	listStories() {
@@ -1373,13 +1408,15 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	* revision is no longer present (already resolved, or never existed).
 	*/
 	acceptChange(target) {
-		return this.resolveWithSectionReferenceHistory(() => this.acceptChangeInternal(target));
+		return this.resolveWithSectionReferenceHistory(() => this.withNotesFollowingReferences(() => this.acceptChangeInternal(target)));
 	}
 	acceptChangeInternal(target) {
 		const id = revisionIdOf(target);
+		const ids = getTrackedChangeGroupIdsFromDoc(this.state.doc, id);
 		const suggestionId = suggestionIdOfRevision(this.state, id);
 		if (suggestionId !== null) this.runCommand(acceptSuggestion(suggestionId, { author: this.author }));
-		const bodyChanged = this.runCommand(acceptAIEditRevision(id));
+		let bodyChanged = false;
+		for (const memberId of ids) bodyChanged = this.runCommand(acceptAIEditRevision(memberId)) || bodyChanged;
 		const sectionChanged = this.resolveFinalSectionProperties("accept", id) > 0;
 		return bodyChanged || sectionChanged;
 	}
@@ -1388,13 +1425,15 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	* deletion's text is restored. See {@link acceptChange} for targeting.
 	*/
 	rejectChange(target) {
-		return this.resolveWithSectionReferenceHistory(() => this.rejectChangeInternal(target));
+		return this.resolveWithSectionReferenceHistory(() => this.withNotesFollowingReferences(() => this.rejectChangeInternal(target)));
 	}
 	rejectChangeInternal(target) {
 		const id = revisionIdOf(target);
+		const ids = getTrackedChangeGroupIdsFromDoc(this.state.doc, id);
 		const suggestionId = suggestionIdOfRevision(this.state, id);
 		if (suggestionId !== null && this.runCommand(rejectSuggestion(suggestionId))) return true;
-		const bodyChanged = this.runCommand(rejectAIEditRevision(id));
+		let bodyChanged = false;
+		for (const memberId of ids) bodyChanged = this.runCommand(rejectAIEditRevision(memberId)) || bodyChanged;
 		const sectionChanged = this.resolveFinalSectionProperties("reject", id) > 0;
 		return bodyChanged || sectionChanged;
 	}
@@ -1473,6 +1512,77 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		return propertyChanges?.length ?? 0;
 	}
 	resolveEveryStory(mode) {
+		return this.withNotesFollowingReferences(() => this.resolveEveryStoryOnce(mode));
+	}
+	/**
+	* Change the body the way a note follows its reference: a note whose
+	* reference goes, goes too, as a note no text refers to does; a note whose
+	* reference an edit deletes as a tracked change has its text deleted with
+	* it; a note whose reference's deletion is rejected gets back the text that
+	* deletion took.
+	*/
+	withNotesFollowingReferences(change) {
+		const before = this.state.doc;
+		const result = change();
+		const after = this.state.doc;
+		const referencedAfter = referencedNoteKeys(after);
+		for (const key of referencedAfter) this.removedNoteStories.delete(key);
+		const unreferenced = new Set([...referencedNoteKeys(before)].filter((key) => !referencedAfter.has(key)));
+		const referencedElsewhere = unreferenced.size > 0 ? this.noteKeysReferencedOutsideBody(unreferenced) : /* @__PURE__ */ new Set();
+		for (const key of unreferenced) {
+			if (referencedElsewhere.has(key)) continue;
+			const handle = noteStoryHandleOf(key);
+			if (handle) this.removedNoteStories.set(noteStoryKey(handle), handle);
+		}
+		const rejectedDeletions = referenceDeletions(before);
+		for (const key of noteReferencesRestored(before, after)) {
+			const handle = noteStoryHandleOf(key);
+			const state = handle ? this.getEditableStoryState(handle) : null;
+			const reference = rejectedDeletions.get(key);
+			const revisions = state && reference ? noteDeletionRevisions(state.doc, reference) : [];
+			if (handle && revisions.length > 0) this.runStoryCommand(rejectAIEditRevision(revisions), handle);
+		}
+		this.deleteNotesWithTheirReferences(before, after);
+		return result;
+	}
+	/** Delete the text of each note whose reference went from live to a tracked deletion. */
+	deleteNotesWithTheirReferences(before, after) {
+		const was = noteReferenceStates(before);
+		const deletions = referenceDeletions(after);
+		for (const [key, state] of noteReferenceStates(after)) {
+			if (state !== "deleted" || was.get(key) !== "live") continue;
+			const reference = deletions.get(key);
+			if (!reference || reference.attrs["provenance"] === "suggested" || reference.attrs["moveKind"] != null) continue;
+			const handle = noteStoryHandleOf(key);
+			if (!handle || this.removedNoteStories.has(noteStoryKey(handle))) continue;
+			this.runStoryCommand((storyState, dispatch) => {
+				const transaction = deleteNoteWithReference(storyState.tr, reference);
+				if (!transaction.docChanged) return false;
+				dispatch?.(transaction);
+				return true;
+			}, handle);
+		}
+	}
+	/**
+	* The notes a story other than the body refers to (a header, a footer, a
+	* comment, another note), leaving out references inside the `skipped` notes.
+	*/
+	noteKeysReferencedOutsideBody(skipped) {
+		const keys = new Set(noteKeysReferencedIn(this.baseDocument.package.document.comments ?? []));
+		for (const handle of this.listStoryHandlesInternal()) {
+			if (handle.type === "main") continue;
+			let source;
+			if (handle.type === "footnote" || handle.type === "endnote") {
+				if (skipped.has(noteStoryKey(handle))) continue;
+				source = this.getNoteStory(handle);
+			} else source = this.getHeaderFooterStory(handle);
+			const state = this.secondaryStoryStates.get(secondaryStoryKey(handle))?.state;
+			const found = state ? referencedNoteKeys(state.doc) : noteKeysReferencedIn(source?.content ?? []);
+			for (const key of found) keys.add(key);
+		}
+		return keys;
+	}
+	resolveEveryStoryOnce(mode) {
 		let count = 0;
 		const resolvedStories = [];
 		const refreshes = [];
@@ -1571,6 +1681,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			secondaryStoryStates,
 			sectionReferenceRemovals: [...this.sectionReferenceRemovals],
 			removedHeaderFooterStories: [...this.removedHeaderFooterStories.values()],
+			removedNoteStories: [...this.removedNoteStories.values()],
 			importedStyles: this.importedStyles,
 			importedMedia: new Map(this.importedMedia),
 			importedHeaders: new Map(this.importedHeaders),
@@ -1601,6 +1712,20 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			document.package.footers.delete(handle.relationshipId);
 		}
 		this.mergeEditedSecondaryStories(document, snapshot.secondaryStoryStates);
+		if (snapshot.removedNoteStories.length > 0) {
+			const candidates = new Set(snapshot.removedNoteStories.map(noteStoryKey));
+			const referenced = referencedNotes(document, candidates);
+			const removed = new Set([...candidates].filter((key) => !referenced.has(key)));
+			const { footnotes, endnotes } = document.package;
+			if (footnotes) document.package.footnotes = footnotes.filter((note) => !removed.has(noteStoryKey({
+				type: "footnote",
+				noteId: note.id
+			})));
+			if (endnotes) document.package.endnotes = endnotes.filter((note) => !removed.has(noteStoryKey({
+				type: "endnote",
+				noteId: note.id
+			})));
+		}
 		const definitions = [...document.package.document.comments ?? [], ...snapshot.createdComments];
 		const kept = this.keptCommentThreads(definitions, snapshot.mainState, snapshot.secondaryStoryStates);
 		if (kept.length !== definitions.length || snapshot.createdComments.length > 0 || snapshot.resolvedOverrides.size > 0) document.package.document.comments = this.withResolvedOverrides(kept, snapshot.resolvedOverrides);
@@ -1610,7 +1735,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		const snapshot = this.captureReviewerState();
 		const pendingCommentIds = new Set(this.exportPendingSuggestions().flatMap(({ commentId }) => commentId === void 0 ? [] : [commentId]));
 		const changedParaIds = new Set(getChangedParagraphIds(snapshot.mainState));
-		let structuralChange = hasStructuralChanges(snapshot.mainState) || snapshot.finalSectionPropertiesOverride !== void 0 || snapshot.importedStyles !== void 0 || snapshot.importedHeaders.size > 0 || snapshot.importedFooters.size > 0;
+		let structuralChange = hasStructuralChanges(snapshot.mainState) || snapshot.finalSectionPropertiesOverride !== void 0 || snapshot.importedStyles !== void 0 || snapshot.importedHeaders.size > 0 || snapshot.importedFooters.size > 0 || snapshot.removedNoteStories.length > 0;
 		let untrackedChanges = hasUntrackedChanges(snapshot.mainState);
 		const changedNoteParaIds = /* @__PURE__ */ new Set();
 		for (const entry of snapshot.secondaryStoryStates) {
@@ -2032,6 +2157,10 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			}
 			addAll(anchoredNow, anchoredCommentIdsInBlocks((handle.type === "header" || handle.type === "footer" ? this.getHeaderFooterStory(handle) : this.getNoteStory(handle))?.content ?? []));
 		}
+		for (const handle of this.removedNoteStories.values()) {
+			const entry = loaded.get(secondaryStoryKey(handle));
+			addAll(anchoredBefore, entry ? anchoredCommentIdsInProseDoc(entry.initialState.doc) : anchoredCommentIdsInBlocks(this.getNoteStory(handle)?.content ?? []));
+		}
 		return withoutLostCommentThreads(comments, {
 			anchoredBefore,
 			anchoredNow

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

@@ -1,6 +1,6 @@
 import { parseFolioDocumentOperationBatch } from "../document-operations.js";
 import { rejectAllSuggestions } from "../prosemirror/commands/comments.js";
-import { getDocumentStyleResolver } from "../prosemirror/plugins/documentStyles.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";

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;
@@ -82,4 +84,4 @@ declare const getTrackedChangeStatsFromDoc: (doc: Node) => {
  */
 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 };