@stll/folio-core 0.60.0 → 0.62.0

package/dist/prosemirror/extensions/nodes/CommentReferenceExtension.js

@@ -1,3 +1,4 @@
+import { isCommentRangeInertAtom } from "../../commentRangeInlineAtoms.js";
 import { readCommentReferenceAttrs } from "../../commentReferenceAttrs.js";
 import { planCommentReferenceRepairs } from "../../commentReferenceIntegrity.js";
 import { readRangeAnchorAttrs } from "../../rangeAnchorAttrs.js";
@@ -10,7 +11,16 @@ const COMMENT_REFERENCE_NODE_NAME = "commentReference";
 const surveyCommentReferences = (doc) => {
 	const references = [];
 	const markEnds = /* @__PURE__ */ new Map();
+	const unanchoredMarks = [];
 	doc.descendants((node, position) => {
+		const inert = isCommentRangeInertAtom(node);
+		if (inert) {
+			for (const mark of node.marks) if (mark.type.name === "comment") unanchoredMarks.push({
+				position,
+				size: node.nodeSize,
+				mark
+			});
+		}
 		if (node.type.name === "commentReference") {
 			const attrs = readCommentReferenceAttrs(node);
 			references.push(attrs.ok ? {
@@ -33,6 +43,7 @@ const surveyCommentReferences = (doc) => {
 			}
 			return false;
 		}
+		if (inert) return false;
 		if (!node.isInline) return true;
 		for (const mark of node.marks) {
 			if (mark.type.name !== "comment") continue;
@@ -44,6 +55,7 @@ const surveyCommentReferences = (doc) => {
 	});
 	return {
 		references,
+		unanchoredMarks,
 		markExtents: [...markEnds].map(([commentId, end]) => ({
 			commentId,
 			end
@@ -84,9 +96,11 @@ const CommentReferenceExtension = createNodeExtension({
 		if (!transactions.some(({ docChanged }) => docChanged)) return null;
 		const referenceType = newState.schema.nodes[COMMENT_REFERENCE_NODE_NAME];
 		if (!referenceType) return null;
-		const repairs = planCommentReferenceRepairs(surveyCommentReferences(newState.doc));
-		if (repairs.length === 0) return null;
+		const survey = surveyCommentReferences(newState.doc);
+		const repairs = planCommentReferenceRepairs(survey);
+		if (repairs.length === 0 && survey.unanchoredMarks.length === 0) return null;
 		const transaction = newState.tr;
+		for (const { position, size, mark } of survey.unanchoredMarks) transaction.removeMark(position, position + size, mark);
 		for (const repair of repairs) {
 			if (repair.type === "delete") {
 				transaction.delete(repair.position, repair.position + repair.size);

package/dist/prosemirror/fieldRepresentation.js

@@ -1,15 +1,17 @@
 import "./extensions/marks/InlineWrapperExtension.js";
+import { getInlineDisplayText } from "./inlineDisplayText.js";
 //#region src/prosemirror/fieldRepresentation.ts
 /** Current children alone decide whether a field needs editable structural content. */
 const fieldRequiresStructuredContent = (children) => children.some((child) => !child.isText || child.marks.some((mark) => mark.type.name === "hyperlink" || mark.type.name === "inlineWrapper" || mark.type.name === "insertion" || mark.type.name === "deletion"));
 /** Resolution returns text-only fields to the same atom representation as initial conversion. */
 const canonicalFieldNode = (node) => {
 	if (node.type.name !== "structuredField") return node;
+	const displayText = getInlineDisplayText(node);
 	const attrs = {
 		...node.attrs,
-		displayText: node.textContent
+		displayText
 	};
-	if (fieldRequiresStructuredContent(node.content.content)) return node.attrs["displayText"] === node.textContent ? node : node.type.create(attrs, node.content, node.marks);
+	if (fieldRequiresStructuredContent(node.content.content)) return node.attrs["displayText"] === displayText ? node : node.type.create(attrs, node.content, node.marks);
 	let marks = node.marks;
 	for (const mark of node.firstChild?.marks ?? []) marks = mark.addToSet(marks);
 	return node.type.schema.node("field", attrs, void 0, marks);

package/dist/prosemirror/findReplaceSelection.d.ts

@@ -1,5 +1,8 @@
-import { FindOptions } from "../utils/findReplace.js";
+import { document_d_exports } from "../types/document.js";
+import { DisplayMode } from "../managers/EditorModeManager.js";
+import { FindMatch, FindOptions, FindSearchContext } from "../utils/findReplace.js";
 import { Node } from "prosemirror-model";
+import { EditorState } from "prosemirror-state";
 //#region src/prosemirror/findReplaceSelection.d.ts
 /**
  * Positional fields of a document search match that the range resolver needs.
@@ -20,11 +23,54 @@ type FindMatchPosition = {
 type FindMatchRange = {
   from: number;
   to: number;
+  /** Navigation anchors inside a logical match are excluded from decorations. */
+  excludedRanges?: {
+    from: number;
+    to: number;
+  }[];
+  /** Character subranges inside source atoms, whose text exceeds their PM size. */
+  atomicTextRanges?: {
+    from: number;
+    to: number;
+    startOffset: number;
+    endOffset: number;
+  }[];
 };
 type ProseMirrorFindMatch = FindMatchPosition & FindMatchRange & {
   text: string;
 };
 declare function resolveFindMatchRange(doc: Node, match: FindMatchPosition): FindMatchRange | null;
+/** Resolve a result set in one paragraph traversal, preserving result order. */
+declare const resolveFindMatchRanges: (doc: Node, matches: readonly FindMatchPosition[]) => (FindMatchRange | null)[];
 declare function findInProseMirrorDocument(doc: Node, searchText: string, options: FindOptions): ProseMirrorFindMatch[];
+type FindInMarkupViewOptions = {
+  state: EditorState;
+  markupView: DisplayMode;
+  searchText: string;
+  options: FindOptions;
+};
+/** Search the displayed story; returned ranges address the authored editor document. */
+declare const findInMarkupView: ({ state, markupView, searchText, options }: FindInMarkupViewOptions) => ProseMirrorFindMatch[];
+type FindInDisplayedDocumentOptions = {
+  document: document_d_exports.Document;
+  /**
+   * Live body editor state. A review view reads its body from this state's
+   * projection, so null defers that search until the body editor mounts.
+   * Hosts without an editor state omit it and search the package model.
+   */
+  state?: EditorState | null | undefined;
+  searchText: string;
+  options: FindOptions;
+  context?: FindSearchContext | undefined;
+};
+/**
+ * Search every story a display mode shows. All Markup searches the package
+ * stories. A resolved review view searches its body through the projection the
+ * layout paints, so body ranges address the authored editor document; anchored
+ * shapes, headers, footers, notes and comments keep the package search owner
+ * with the same display mode. Returns null while a review view has no body
+ * editor state to project.
+ */
+declare const findInDisplayedDocument: ({ document, state, searchText, options, context }: FindInDisplayedDocumentOptions) => FindMatch[] | null;
 //#endregion
-export { FindMatchPosition, FindMatchRange, ProseMirrorFindMatch, findInProseMirrorDocument, resolveFindMatchRange };
+export { FindMatchPosition, FindMatchRange, ProseMirrorFindMatch, findInDisplayedDocument, findInMarkupView, findInProseMirrorDocument, resolveFindMatchRange, resolveFindMatchRanges };

package/dist/prosemirror/findReplaceSelection.js

@@ -1,6 +1,7 @@
-import { findAllMatches } from "../utils/findReplace.js";
-import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
-import { expectSymbolAttrs } from "./attrs/index.js";
+import { findAllMatches, findInDocument, isPageDependentSearchField } from "../utils/findReplace.js";
+import { expectFieldAttrs } from "./attrs/index.js";
+import { getInlineDisplayText, getInlineDisplayToken, isNoteReferenceText } from "./inlineDisplayText.js";
+import { projectMarkupView } from "./markupViewProjection.js";
 //#region src/prosemirror/findReplaceSelection.ts
 function resolveFindMatchRange(doc, match) {
 	let resolved = null;
@@ -16,11 +17,29 @@ function resolveFindMatchRange(doc, match) {
 	});
 	return resolved;
 }
+/** Resolve a result set in one paragraph traversal, preserving result order. */
+const resolveFindMatchRanges = (doc, matches) => {
+	const paragraphs = /* @__PURE__ */ new Map();
+	forEachSearchParagraph(doc, (paragraph, paragraphPos, paragraphIndex) => {
+		paragraphs.set(paragraphIndex, {
+			paragraph,
+			paragraphPos
+		});
+		return true;
+	});
+	return matches.map((match) => {
+		const paragraph = paragraphs.get(match.paragraphIndex);
+		return paragraph ? resolveTextRangeInParagraph({
+			...paragraph,
+			...match
+		}) : null;
+	});
+};
 function findInProseMirrorDocument(doc, searchText, options) {
 	if (!searchText) return [];
 	const matches = [];
 	forEachSearchParagraph(doc, (paragraph, paragraphPos, paragraphIndex) => {
-		const text = getSearchableParagraphText(paragraph);
+		const text = getInlineDisplayText(paragraph);
 		for (const { start, end } of findAllMatches(text, searchText, options)) {
 			const range = resolveTextRangeInParagraph({
 				paragraph,
@@ -40,6 +59,100 @@ function findInProseMirrorDocument(doc, searchText, options) {
 	});
 	return matches;
 }
+/** Search the displayed story; returned ranges address the authored editor document. */
+const findInMarkupView = ({ state, markupView, searchText, options }) => {
+	const projection = projectMarkupView(state, markupView);
+	if (projection.type === "authored") return findInProseMirrorDocument(state.doc, searchText, options);
+	return findInProseMirrorDocument(projection.doc, searchText, options).map((match) => toAuthoredFindMatch(projection, match));
+};
+/** Every view-document position a match carries, mapped to the authored editor document. */
+const toAuthoredFindMatch = (projection, match) => {
+	const toEditorRange = ({ from, to }) => ({
+		from: projection.toEditor(from, 1),
+		to: projection.toEditor(to, -1)
+	});
+	return {
+		paragraphIndex: match.paragraphIndex,
+		startOffset: match.startOffset,
+		endOffset: match.endOffset,
+		text: match.text,
+		...toEditorRange(match),
+		...match.excludedRanges && { excludedRanges: match.excludedRanges.map(toEditorRange) },
+		...match.atomicTextRanges && { atomicTextRanges: match.atomicTextRanges.map((atom) => ({
+			...toEditorRange(atom),
+			startOffset: atom.startOffset,
+			endOffset: atom.endOffset
+		})) }
+	};
+};
+/** Replacement policy for a projected body match, in the shared eligibility vocabulary. */
+const projectedReplacement = (state, viewMatch, authored) => {
+	const atom = authored.atomicTextRanges?.at(0);
+	if (atom) return {
+		status: "blocked",
+		reason: state.doc.nodeAt(atom.from)?.type.name === "field" ? "field-result" : "atomic-content"
+	};
+	return authored.to - authored.from === viewMatch.to - viewMatch.from ? { status: "allowed" } : {
+		status: "blocked",
+		reason: "hidden-content"
+	};
+};
+/**
+* Search every story a display mode shows. All Markup searches the package
+* stories. A resolved review view searches its body through the projection the
+* layout paints, so body ranges address the authored editor document; anchored
+* shapes, headers, footers, notes and comments keep the package search owner
+* with the same display mode. Returns null while a review view has no body
+* editor state to project.
+*/
+const findInDisplayedDocument = ({ document, state, searchText, options, context }) => {
+	const displayMode = options.displayMode ?? "all-markup";
+	if (displayMode === "all-markup" || state === void 0) return findInDocument(document, searchText, options, context);
+	if (state === null) return null;
+	const packageMatches = findInDocument(document, searchText, options, context);
+	const projection = projectMarkupView(state, displayMode);
+	if (projection.type === "authored" || !searchText) return packageMatches;
+	const bodyMatches = findInProseMirrorDocument(projection.doc, searchText, options).map((viewMatch) => {
+		const authored = toAuthoredFindMatch(projection, viewMatch);
+		const { from, to, excludedRanges, atomicTextRanges } = authored;
+		return {
+			paragraphIndex: authored.paragraphIndex,
+			contentIndex: 0,
+			startOffset: authored.startOffset,
+			endOffset: authored.endOffset,
+			text: authored.text,
+			story: "main",
+			replacement: projectedReplacement(state, viewMatch, authored),
+			authoredRange: {
+				from,
+				to,
+				...excludedRanges && { excludedRanges },
+				...atomicTextRanges && { atomicTextRanges }
+			}
+		};
+	});
+	const anchorEnds = [];
+	forEachSearchParagraph(state.doc, (paragraph, paragraphPos, paragraphIndex) => {
+		anchorEnds[paragraphIndex] = paragraphPos + paragraph.nodeSize;
+		return true;
+	});
+	const bodyShapeMatches = packageMatches.filter((match) => match.story === "main" && match.textBoxIndex !== void 0);
+	const orderedBody = [];
+	let shapeIndex = 0;
+	const shapeAnchorEnd = (match) => match.anchorParagraphIndex !== void 0 && anchorEnds[match.anchorParagraphIndex] || Number.POSITIVE_INFINITY;
+	for (const bodyMatch of bodyMatches) {
+		const from = bodyMatch.authoredRange?.from ?? 0;
+		while (shapeIndex < bodyShapeMatches.length) {
+			const shapeMatch = bodyShapeMatches[shapeIndex];
+			if (!shapeMatch || shapeAnchorEnd(shapeMatch) > from) break;
+			orderedBody.push(shapeMatch);
+			shapeIndex++;
+		}
+		orderedBody.push(bodyMatch);
+	}
+	orderedBody.push(...bodyShapeMatches.slice(shapeIndex));
+	return [...orderedBody, ...packageMatches.filter((match) => match.story !== "main" || match.textBoxIndex === void 0 && match.commentId !== void 0)];
+};
 function forEachSearchParagraph(doc, visit) {
 	let paragraphIndex = 0;
 	const walkBlocks = (container, contentStart) => {
@@ -89,54 +202,56 @@ function resolveTextRangeInParagraph({ paragraph, paragraphPos, startOffset, end
 		to: null
 	};
 	const pageBreakOffsets = [];
+	const excludedTextRanges = [];
+	const excludedRanges = [];
+	const atomicTextRanges = [];
 	paragraph.descendants((node, pos) => {
+		if ((node.type.name === "field" || node.type.name === "structuredField") && isPageDependentSearchField(expectFieldAttrs(node).instruction)) {
+			const length = node.type.name === "field" ? expectFieldAttrs(node).displayText.length : getInlineDisplayText(node).length;
+			excludedTextRanges.push({
+				start: textOffset,
+				end: textOffset + length
+			});
+		}
 		if (node.type.name === "pageBreakRun") {
 			pageBreakOffsets.push(textOffset);
 			return false;
 		}
+		if (isNoteReferenceText(node)) {
+			const from = paragraphPos + 1 + pos;
+			excludedRanges.push({
+				from,
+				to: from + node.nodeSize
+			});
+		}
 		const tokenLength = getSearchTextTokenLength(node);
 		if (tokenLength === 0) return true;
 		const textStart = textOffset;
 		const textEnd = textStart + tokenLength;
 		const nodeStart = paragraphPos + 1 + pos;
-		if (range.from === null && startOffset >= textStart && startOffset < textEnd) range.from = nodeStart + Math.min(startOffset - textStart, node.nodeSize);
-		if (range.to === null && endOffset > textStart && endOffset <= textEnd) range.to = nodeStart + Math.min(endOffset - textStart, node.nodeSize);
+		const atomic = node.type.name === "field" || node.type.name === "preservedXml";
+		if (atomic && textStart < endOffset && textEnd > startOffset) atomicTextRanges.push({
+			from: nodeStart,
+			to: nodeStart + node.nodeSize,
+			startOffset: Math.max(0, startOffset - textStart),
+			endOffset: Math.min(tokenLength, endOffset - textStart)
+		});
+		if (range.from === null && startOffset >= textStart && startOffset < textEnd) range.from = atomic ? nodeStart : nodeStart + Math.min(startOffset - textStart, node.nodeSize);
+		if (range.to === null && endOffset > textStart && endOffset <= textEnd) range.to = atomic ? nodeStart + node.nodeSize : nodeStart + Math.min(endOffset - textStart, node.nodeSize);
 		textOffset = textEnd;
 		return range.to === null;
 	});
-	if (range.from === null || range.to === null || range.from >= range.to || pageBreakOffsets.some((offset) => offset > startOffset && offset < endOffset)) return null;
+	if (range.from === null || range.to === null || range.from >= range.to || pageBreakOffsets.some((offset) => offset > startOffset && offset < endOffset) || excludedTextRanges.some(({ start, end }) => start < endOffset && end > startOffset)) return null;
+	const from = range.from;
+	const to = range.to;
+	const visibleExcludedRanges = excludedRanges.filter((anchor) => anchor.from < to && anchor.to > from);
 	return {
-		from: range.from,
-		to: range.to
+		from,
+		to,
+		...atomicTextRanges.length > 0 && { atomicTextRanges },
+		...visibleExcludedRanges.length > 0 && { excludedRanges: visibleExcludedRanges }
 	};
 }
-function getSearchTextTokenLength(node) {
-	if (node.isText) return node.text?.length ?? 0;
-	if (node.type.name === "tab" || node.type.name === "hardBreak" || node.type.name === "symbol") return 1;
-	return 0;
-}
-function getSearchableParagraphText(paragraph) {
-	let text = "";
-	paragraph.descendants((node) => {
-		if (node.isText) {
-			text += node.text ?? "";
-			return false;
-		}
-		if (node.type.name === "tab") {
-			text += "	";
-			return false;
-		}
-		if (node.type.name === "hardBreak") {
-			text += "\n";
-			return false;
-		}
-		if (node.type.name === "symbol") {
-			text += decodeOoxmlSymbolCharacter(expectSymbolAttrs(node).char) ?? "";
-			return false;
-		}
-		return true;
-	});
-	return text;
-}
+const getSearchTextTokenLength = (node) => getInlineDisplayToken(node)?.length ?? 0;
 //#endregion
-export { findInProseMirrorDocument, resolveFindMatchRange };
+export { findInDisplayedDocument, findInMarkupView, findInProseMirrorDocument, resolveFindMatchRange, resolveFindMatchRanges };

package/dist/prosemirror/inlineDisplayText.d.ts

@@ -0,0 +1,10 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/inlineDisplayText.d.ts
+/** Native note-reference labels are navigation anchors, outside searchable text. */
+declare const isNoteReferenceText: (node: Node) => boolean;
+/** A leaf's logical text; null means a transparent container to descend into. */
+declare const getInlineDisplayToken: (node: Node) => string | null;
+/** Visible inline text, including cached source atoms and native run tokens. */
+declare const getInlineDisplayText: (paragraph: Node) => string;
+//#endregion
+export { getInlineDisplayText, getInlineDisplayToken, isNoteReferenceText };

package/dist/prosemirror/inlineDisplayText.js

@@ -0,0 +1,29 @@
+import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
+import { expectFieldAttrs, expectPreservedXmlAttrs, expectSymbolAttrs } from "./attrs/index.js";
+//#region src/prosemirror/inlineDisplayText.ts
+/** Native note-reference labels are navigation anchors, outside searchable text. */
+const isNoteReferenceText = (node) => node.isText && node.marks.some((mark) => mark.type.name === "footnoteRef");
+/** A leaf's logical text; null means a transparent container to descend into. */
+const getInlineDisplayToken = (node) => {
+	if (isNoteReferenceText(node)) return "";
+	if (node.type.name === "field") return expectFieldAttrs(node).displayText;
+	if (node.type.name === "preservedXml") return expectPreservedXmlAttrs(node).text;
+	if (node.isText) return node.text ?? "";
+	if (node.type.name === "tab") return "	";
+	if (node.type.name === "hardBreak") return "\n";
+	if (node.type.name === "symbol") return decodeOoxmlSymbolCharacter(expectSymbolAttrs(node).char) ?? "";
+	return null;
+};
+/** Visible inline text, including cached source atoms and native run tokens. */
+const getInlineDisplayText = (paragraph) => {
+	let text = "";
+	paragraph.descendants((node) => {
+		const token = getInlineDisplayToken(node);
+		if (token === null) return true;
+		text += token;
+		return false;
+	});
+	return text;
+};
+//#endregion
+export { getInlineDisplayText, getInlineDisplayToken, isNoteReferenceText };

package/dist/prosemirror/markupViewProjection.d.ts

@@ -1,3 +1,4 @@
+import { document_d_exports } from "../types/document.js";
 import { DisplayMode } from "../managers/EditorModeManager.js";
 import { RemovedSectionReference } from "../internal/sectionEndpointResolution.js";
 import { indexedPositionMap } from "../internal/indexedPositionMap.js";
@@ -93,5 +94,13 @@ declare const projectMarkupView: (state: EditorState, view: DisplayMode) => Mark
  * of text it cannot enter.
  */
 declare const visibleCaretPosition: (projection: MarkupViewProjection, position: number) => number;
+type ProjectStoryMarkupViewOptions = {
+  doc: Node;
+  markupView: DisplayMode;
+  styles?: document_d_exports.StyleDefinitions | null | undefined;
+  numbering?: document_d_exports.NumberingDefinitions | undefined;
+};
+/** Detached stories use the same state-aware projection owner as the body. */
+declare const projectStoryMarkupView: ({ doc, markupView, styles, numbering }: ProjectStoryMarkupViewOptions) => MarkupViewProjection;
 //#endregion
-export { MarkupViewProjection, markupViewResolutionMode, projectMarkupView, resolveStateStory, visibleCaretPosition };
+export { MarkupViewProjection, markupViewResolutionMode, projectMarkupView, projectStoryMarkupView, resolveStateStory, visibleCaretPosition };

package/dist/prosemirror/markupViewProjection.js

@@ -1,9 +1,10 @@
 import { indexedPositionMap } from "../internal/indexedPositionMap.js";
 import { finalRevisionParagraphRanges } from "../internal/revisionResolutionTracking.js";
 import { resolveWholeStory } from "../internal/wholeStoryRevisionResolution.js";
-import { getDocumentNumbering } from "./plugins/documentNumbering.js";
+import { createDocumentNumberingPlugin, getDocumentNumbering } from "./plugins/documentNumbering.js";
 import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
-import { Selection } from "prosemirror-state";
+import { createDocumentStyleContextPlugin } from "./plugins/documentStyles.js";
+import { EditorState, Selection } from "prosemirror-state";
 //#region src/prosemirror/markupViewProjection.ts
 /** Resolve every revision in the state's story with the state's own styles and numbering. */
 const resolveStateStory = (state, mode) => resolveWholeStory({
@@ -84,5 +85,22 @@ const visibleCaretPosition = (projection, position) => {
 	const near = Selection.near(projection.doc.resolve(bounded), -1);
 	return projection.toEditor(near.head, -1);
 };
+const storyProjectionStates = /* @__PURE__ */ new WeakMap();
+/** Detached stories use the same state-aware projection owner as the body. */
+const projectStoryMarkupView = ({ doc, markupView, styles, numbering }) => {
+	if (markupView === "all-markup") return AUTHORED;
+	const cached = storyProjectionStates.get(doc);
+	if (cached && cached.styles === styles && cached.numbering === numbering) return projectMarkupView(cached.state, markupView);
+	const state = EditorState.create({
+		doc,
+		plugins: [createDocumentStyleContextPlugin(styles), createDocumentNumberingPlugin(numbering)]
+	});
+	storyProjectionStates.set(doc, {
+		styles,
+		numbering,
+		state
+	});
+	return projectMarkupView(state, markupView);
+};
 //#endregion
-export { markupViewResolutionMode, projectMarkupView, resolveStateStory, visibleCaretPosition };
+export { markupViewResolutionMode, projectMarkupView, projectStoryMarkupView, resolveStateStory, visibleCaretPosition };

package/dist/prosemirror/plugins/transactionInvariants.js

@@ -1,3 +1,4 @@
+import { sliceText } from "../../utils/sliceText.js";
 import { expectParagraphAttrs } from "../attrs/index.js";
 import { effectiveParagraphNumberingReference, paragraphNumberingSourcesFromBoundary } from "../numberingAttr.js";
 import { createPluginKeyOwner } from "../pluginKeyOwner.js";
@@ -30,7 +31,11 @@ const MAX_REPORTED_STEPS_LENGTH = 4e3;
 const describeSteps = (transactions) => {
 	const steps = transactions.flatMap((transaction) => transaction.steps.map((step) => step.toJSON()));
 	const json = JSON.stringify(steps);
-	return json.length > MAX_REPORTED_STEPS_LENGTH ? `${json.slice(0, MAX_REPORTED_STEPS_LENGTH)}… (${json.length} characters)` : json;
+	return json.length > MAX_REPORTED_STEPS_LENGTH ? `${sliceText({
+		text: json,
+		units: "codeUnits",
+		end: MAX_REPORTED_STEPS_LENGTH
+	})}… (${json.length} characters)` : json;
 };
 var TransactionInvariantError = class extends Error {
 	issues;

package/dist/prosemirror/replacedAnnotations.d.ts

@@ -19,6 +19,20 @@ declare const NON_INCLUSIVE_MARK_DISPOSITION: {
 };
 /** The mark names in the schema that a replacement must not silently drop. */
 declare const nonInclusiveMarkNames: (schema: Schema) => string[];
+/** One typed point for a comment whose aligned coverage has no content left. */
+declare const commentPoint: (schema: Schema, id: number) => Node;
+type ResolvedCommentPointsOptions = {
+  doc: Node;
+  removes: (node: Node, position: number) => boolean;
+  retiresStructure: (node: Node, position: number) => boolean;
+};
+/** The same collector serves standalone commands and the existing bulk walk. */
+declare const createResolvedCommentPointCollector: ({ removes, retiresStructure }: Omit<ResolvedCommentPointsOptions, "doc">) => {
+  visit: (node: Node, position: number, previous?: Node) => boolean;
+  finish: () => Map<number, number>;
+};
+/** Point fallback excludes comments belonging to retired blocks and table cells. */
+declare const resolvedCommentPoints: ({ doc, removes, retiresStructure }: ResolvedCommentPointsOptions) => Map<number, number>;
 type ReplacedAnnotations = {
   /** Marks the replacement must carry, in document order. */
   carried: readonly Mark[];
@@ -88,4 +102,4 @@ declare const annotatedReplacement: ({ annotations: { carried, leading, trailing
  */
 declare const inheritedReplacementMarks: (doc: Node, from: number, to: number) => readonly Mark[];
 //#endregion
-export { NON_INCLUSIVE_MARK_DISPOSITION, ReplacedAnnotations, addCarriedMarks, annotatedReplacement, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, surveyReplacedAnnotations };
+export { NON_INCLUSIVE_MARK_DISPOSITION, ReplacedAnnotations, addCarriedMarks, annotatedReplacement, commentPoint, commentsAcrossBlockBoundary, commentsForTrackedInsertion, createResolvedCommentPointCollector, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, resolvedCommentPoints, surveyReplacedAnnotations };

package/dist/prosemirror/replacedAnnotations.js

@@ -1,9 +1,11 @@
+import { expectParagraphAttrs, expectTableCellAttrs, expectTableRowAttrs } from "./attrs/index.js";
 import { BOOKMARK_BOUNDARY_NODE_NAME } from "./extensions/nodes/BookmarkBoundaryExtension.js";
 import { COMMENT_REFERENCE_NODE_NAME } from "./extensions/nodes/CommentReferenceExtension.js";
 import { MOVE_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/MoveRangeBoundaryExtension.js";
 import { RANGE_ANCHOR_NODE_NAME } from "./extensions/nodes/RangeAnchorExtension.js";
 import { TEXT_BOX_ANCHOR_NODE_NAME } from "./extensions/nodes/TextBoxAnchorExtension.js";
 import { readMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
+import { readRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
 import { isZeroWidthAnchor } from "./zeroWidthAnchors.js";
 import { Fragment, Mark } from "prosemirror-model";
 //#region src/prosemirror/replacedAnnotations.ts
@@ -21,15 +23,12 @@ import { Fragment, Mark } from "prosemirror-model";
 * hyperlink simply stops being a link. Zero-width anchors fare worse still: a
 * plain replace deletes them outright.
 *
-* Word moves a range start that sits inside a replaced span to the beginning
-* of the replacement and lets the range keep covering the new text; it keeps
-* a link across a replacement of its display text. A range wholly inside the
-* span collapses onto the replacement, and disappears only when every
-* character it covered is gone. One rule per marker kind, and that is the
-* whole contract:
+* Text replacement preserves a comment's aligned coverage. Unchanged text
+* keeps its ranges; inserted text takes the comments of the replaced aligned
+* span. A range with no remaining content becomes a point at the replacement
+* start. The applier decides alignment once for direct and tracked edits.
 *
-* - `comment` mark: the replacement carries every comment the span covered, so
-*   a range that started inside it starts at the replacement instead.
+* - `comment` mark: carried over its aligned replacement span.
 * - `hyperlink` mark: the replacement carries the first link the span held, so
 *   replacing a link's display text leaves the link on the new text. A span
 *   crossing two links keeps the one it opens in, because the mark excludes
@@ -66,9 +65,8 @@ import { Fragment, Mark } from "prosemirror-model";
 * - every other mark: formatting, and left to boundary inheritance, which
 *   already gives the replacement the formatting of the text it replaces.
 *
-* Deleting the whole of a comment's span leaves it no mark anywhere, so
-* `CommentReferenceExtension` drops the orphan reference and the save drops
-* the comment: the one case where a range is meant to disappear.
+* Removing the owning block removes its comment. Replacing its last covered
+* text within a surviving block retains a point rather than dropping it.
 */
 /**
 * What a replacement does with each mark the schema declares
@@ -90,6 +88,67 @@ const NON_INCLUSIVE_MARK_DISPOSITION = {
 /** The mark names in the schema that a replacement must not silently drop. */
 const nonInclusiveMarkNames = (schema) => Object.entries(schema.marks).filter(([, type]) => type.spec.inclusive === false).map(([name]) => name);
 const isCarried = (mark) => NON_INCLUSIVE_MARK_DISPOSITION[mark.type.name] === "carry";
+/** One typed point for a comment whose aligned coverage has no content left. */
+const commentPoint = (schema, id) => schema.node(RANGE_ANCHOR_NODE_NAME, {
+	start: {
+		type: "commentRangeStart",
+		id
+	},
+	end: {
+		type: "commentRangeEnd",
+		id
+	}
+});
+/** The same collector serves standalone commands and the existing bulk walk. */
+const createResolvedCommentPointCollector = ({ removes, retiresStructure }) => {
+	const points = /* @__PURE__ */ new Map();
+	const retained = /* @__PURE__ */ new Set();
+	const visit = (node, position, previous) => {
+		if (node.type.name === "paragraph") {
+			const mark = expectParagraphAttrs(node).pPrMark;
+			const precedingMark = previous?.type.name === "paragraph" ? expectParagraphAttrs(previous).pPrMark : null;
+			if ((mark?.kind === "del" || mark?.kind === "moveFrom") && retiresStructure(node, position) || (precedingMark?.kind === "del" || precedingMark?.kind === "moveFrom") && previous !== void 0 && retiresStructure(previous, position - previous.nodeSize)) {
+				let survivingContent = false;
+				node.descendants((inline, offset) => {
+					if (inline.isInline && !isZeroWidthAnchor(inline) && !removes(inline, position + 1 + offset)) survivingContent = true;
+					return !survivingContent;
+				});
+				if (!survivingContent) return false;
+			}
+		}
+		if (node.type.name === "tableRow" && expectTableRowAttrs(node).trDel && retiresStructure(node, position)) return false;
+		if ((node.type.name === "tableCell" || node.type.name === "tableHeader") && expectTableCellAttrs(node).cellMarker?.kind === "del" && retiresStructure(node, position)) return false;
+		if (node.type.name === "rangeAnchor") {
+			const attrs = readRangeAnchorAttrs(node);
+			if (attrs.ok && attrs.value.start.type === "commentRangeStart") retained.add(attrs.value.start.id);
+		}
+		if (!node.isInline || isZeroWidthAnchor(node)) return true;
+		for (const mark of node.marks) {
+			if (mark.type.name !== "comment") continue;
+			const id = mark.attrs["commentId"];
+			if (!removes(node, position)) retained.add(id);
+			else if (!points.has(id)) points.set(id, position);
+		}
+		return true;
+	};
+	const finish = () => {
+		for (const id of retained) points.delete(id);
+		return points;
+	};
+	return {
+		visit,
+		finish
+	};
+};
+/** Point fallback excludes comments belonging to retired blocks and table cells. */
+const resolvedCommentPoints = ({ doc, removes, retiresStructure }) => {
+	const collector = createResolvedCommentPointCollector({
+		removes,
+		retiresStructure
+	});
+	doc.descendants((node, position, parent, index) => collector.visit(node, position, index > 0 ? parent?.maybeChild(index - 1) ?? void 0 : void 0));
+	return collector.finish();
+};
 /** Anchors an edit must put back, and where relative to the replacement. */
 const ANCHOR_PLACEMENT = {
 	[COMMENT_REFERENCE_NODE_NAME]: "after",
@@ -349,4 +408,4 @@ const inheritedReplacementMarks = (doc, from, to) => {
 	return (to === from ? $from.marks() : $from.marksAcross(doc.resolve(to))) ?? Mark.none;
 };
 //#endregion
-export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, surveyReplacedAnnotations };
+export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, commentPoint, commentsAcrossBlockBoundary, commentsForTrackedInsertion, createResolvedCommentPointCollector, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, resolvedCommentPoints, surveyReplacedAnnotations };

package/dist/prosemirror/runFormattingReconciliation.d.ts

@@ -9,6 +9,8 @@ type ReadAuthoredRunFormattingOptions = {
 };
 /** Read authored run properties without confusing inherited visuals for direct formatting. */
 declare const readAuthoredRunFormatting: ({ context, marks, styleResolver }: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting;
+/** Preserve the authored distinction between an absent and empty property set in revisions. */
+declare const readAuthoredRunPropertySnapshot: (options: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting | undefined;
 type ReconcileRunFormattingMarksOptions = {
   authoredFormatting: document_d_exports.TextFormatting;
   context: ParagraphRunStyleContext;
@@ -22,4 +24,4 @@ type ReconcileRunFormattingMarksOptions = {
  */
 declare const reconcileRunFormattingMarks: ({ authoredFormatting, context, node, styleResolver }: ReconcileRunFormattingMarksOptions) => readonly Mark[];
 //#endregion
-export { readAuthoredRunFormatting, reconcileRunFormattingMarks };
+export { readAuthoredRunFormatting, readAuthoredRunPropertySnapshot, reconcileRunFormattingMarks };