@stll/folio-core 0.62.0 → 0.63.0

package/dist/prosemirror/queries.d.ts

@@ -2,7 +2,7 @@ import { Node } from "prosemirror-model";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/queries.d.ts
 /** A resolved PM position range — half-open `[from, to)` in PM coordinates. */
-type PmRange = {
+export type PmRange = {
   from: number;
   to: number;
 };
@@ -14,7 +14,7 @@ type PmRange = {
  * `RangeError`. Both adapters' `highlightRange` route raw caller positions
  * through this so the no-op contract holds identically.
  */
-declare function clampRangeToDoc(doc: Node, from: number, to: number): PmRange | null;
+export declare function clampRangeToDoc(doc: Node, from: number, to: number): PmRange | null;
 /**
  * Resolve a `commentId` to the PM position range its `comment` mark
  * spans. Walks every inline node carrying a `comment` mark with the
@@ -26,7 +26,7 @@ declare function clampRangeToDoc(doc: Node, from: number, to: number): PmRange |
  *
  * Pure read over `view.state`; no dispatch.
  */
-declare function findCommentRange(view: EditorView | null, commentId: number): PmRange | null;
+export declare function findCommentRange(view: EditorView | null, commentId: number): PmRange | null;
 /**
  * Resolve a tracked-change `revisionId` to the PM position range of its
  * first site. Delegates to {@link extractTrackedChanges} so a coalesced
@@ -40,6 +40,5 @@ declare function findCommentRange(view: EditorView | null, commentId: number): P
  *
  * Pure read over `view.state`; no dispatch.
  */
-declare function findChangeRange(view: EditorView | null, revisionId: number): PmRange | null;
-//#endregion
-export { PmRange, clampRangeToDoc, findChangeRange, findCommentRange };
+export declare function findChangeRange(view: EditorView | null, revisionId: number): PmRange | null;
+//#endregion

package/dist/prosemirror/rangeAnchorAttrs.d.ts

@@ -4,12 +4,11 @@ import { RangeAnchorAttrs } from "./emptyRangeAnchor.js";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/rangeAnchorAttrs.d.ts
 /** The two marker values, checked for every field the DOCX serializer reads. */
-declare const readRangeAnchorValues: (start: unknown, end: unknown) => ReadProseMirrorAttrsResult<RangeAnchorAttrs>;
+export declare const readRangeAnchorValues: (start: unknown, end: unknown) => ReadProseMirrorAttrsResult<RangeAnchorAttrs>;
 /**
  * The anchor's attrs, checked before a save can call string methods or emit
  * invalid range-marker XML.
  */
-declare const readRangeAnchorAttrs: (node: Node) => ReadProseMirrorAttrsResult<RangeAnchorAttrs>;
-declare const expectRangeAnchorAttrs: (node: Node) => RangeAnchorAttrs;
-//#endregion
-export { expectRangeAnchorAttrs, readRangeAnchorAttrs, readRangeAnchorValues };
+export declare const readRangeAnchorAttrs: (node: Node) => ReadProseMirrorAttrsResult<RangeAnchorAttrs>;
+export declare const expectRangeAnchorAttrs: (node: Node) => RangeAnchorAttrs;
+//#endregion

package/dist/prosemirror/rangeAnchorAttrs.js

@@ -93,7 +93,10 @@ const expectRangeAnchorAttrs = (node) => {
 	const cached = attrsCache.get(node);
 	if (cached) return cached;
 	const result = readRangeAnchorAttrs(node);
-	if (!result.ok) panic(`Invalid ProseMirror range anchor attrs:\n${result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n")}`);
+	if (!result.ok) {
+		const details = result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n");
+		panic(`Invalid ProseMirror range anchor attrs:\n${details}`);
+	}
 	attrsCache.set(node, result.value);
 	return result.value;
 };

package/dist/prosemirror/rebaseParagraphRunFormatting.d.ts

@@ -28,11 +28,11 @@ type RebaseParagraphRunsOptions<T extends Transform> = {
  * paragraph's current style context: direct formatting stays direct, and what
  * the old context lent the runs goes with it.
  */
-declare const rebaseParagraphRuns: <T extends Transform>({ previousContext, paragraphPosition, range, shouldRebase, styleResolver, tr }: RebaseParagraphRunsOptions<T>) => T;
+export declare const rebaseParagraphRuns: <T extends Transform>({ previousContext, paragraphPosition, range, shouldRebase, styleResolver, tr }: RebaseParagraphRunsOptions<T>) => T;
 /**
  * Change paragraph attrs and re-resolve inherited run marks in the new style
  * context without turning the old rendered style into direct run formatting.
  */
-declare const setParagraphAttrsWithRebasedRunFormatting: ({ nextAttrs, paragraphPosition, shouldRebase, styleResolver, tr }: RebaseParagraphRunFormattingOptions) => Transaction;
+export declare const setParagraphAttrsWithRebasedRunFormatting: ({ nextAttrs, paragraphPosition, shouldRebase, styleResolver, tr }: RebaseParagraphRunFormattingOptions) => Transaction;
 //#endregion
-export { rebaseParagraphRuns, setParagraphAttrsWithRebasedRunFormatting };
+export {};

package/dist/prosemirror/rebaseParagraphRunFormatting.js

@@ -26,12 +26,13 @@ const rebaseParagraphRuns = ({ previousContext, paragraphPosition, range, should
 	const changes = [];
 	const collectRebasedRepresentation = ({ node, position }) => {
 		if (shouldRebase && !shouldRebase(node)) return;
+		const authoredFormatting = readAuthoredRunFormatting({
+			context: previousContext,
+			marks: node.marks,
+			styleResolver
+		});
 		const nextMarks = reconcileRunFormattingMarks({
-			authoredFormatting: readAuthoredRunFormatting({
-				context: previousContext,
-				marks: node.marks,
-				styleResolver
-			}),
+			authoredFormatting,
 			context: nextContext,
 			node,
 			styleResolver

package/dist/prosemirror/rebaseParagraphRuns.d.ts

@@ -3,7 +3,7 @@ import { Fragment, Mark, Node } from "prosemirror-model";
 import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/rebaseParagraphRuns.d.ts
 /** Two contexts that lend runs the same formatting: rebasing between them changes nothing. */
-declare const sameRunStyleContext: (source: ParagraphRunStyleContext, target: ParagraphRunStyleContext) => boolean;
+export declare const sameRunStyleContext: (source: ParagraphRunStyleContext, target: ParagraphRunStyleContext) => boolean;
 type RebaseParagraphRunsOptions = {
   tr: Transaction;
   position: number;
@@ -17,7 +17,7 @@ type RebaseParagraphRunsOptions = {
   storedMarks?: readonly Mark[] | null;
 };
 /** Rebuild rendered marks after the paragraph's style cascade changes. */
-declare const rebaseParagraphRuns: ({ tr, position, previous, target, styleResolver, range, storedMarks: initialStoredMarks }: RebaseParagraphRunsOptions) => Transaction;
+export declare const rebaseParagraphRuns: ({ tr, position, previous, target, styleResolver, range, storedMarks: initialStoredMarks }: RebaseParagraphRunsOptions) => Transaction;
 type RebasedRunFormatting = {
   before: Node;
   after: Node;
@@ -31,6 +31,6 @@ type RebaseParagraphRunContentOptions = {
   onRebased: (resolution: RebasedRunFormatting) => void;
 };
 /** Rebase an immutable paragraph chunk once, before assembling a resolved join chain. */
-declare const rebaseParagraphRunContent: ({ paragraph, target, position, styleResolver, onRebased }: RebaseParagraphRunContentOptions) => Fragment;
+export declare const rebaseParagraphRunContent: ({ paragraph, target, position, styleResolver, onRebased }: RebaseParagraphRunContentOptions) => Fragment;
 //#endregion
-export { rebaseParagraphRunContent, rebaseParagraphRuns, sameRunStyleContext };
+export {};

package/dist/prosemirror/rebaseParagraphRuns.js

@@ -20,20 +20,24 @@ const rebaseParagraphRuns = ({ tr, position, previous, target, styleResolver, ra
 		from: range?.from ?? position + 1,
 		to: range?.to ?? position + paragraph.nodeSize - 1
 	});
-	for (const representation of representations) applyMarksToRunFormattingRepresentation({
-		tr,
-		representation,
-		marks: reconcileRunFormattingMarks({
-			authoredFormatting: readAuthoredRunFormatting({
-				context: sourceContext,
-				marks: representation.node.marks,
-				styleResolver
-			}),
+	for (const representation of representations) {
+		const authoredFormatting = readAuthoredRunFormatting({
+			context: sourceContext,
+			marks: representation.node.marks,
+			styleResolver
+		});
+		const marks = reconcileRunFormattingMarks({
+			authoredFormatting,
 			context: targetContext,
 			node: representation.node,
 			styleResolver
-		})
-	});
+		});
+		applyMarksToRunFormattingRepresentation({
+			tr,
+			representation,
+			marks
+		});
+	}
 	if (target === void 0 && range === void 0 && tr.selection.empty && tr.selection.from > position && tr.selection.from < position + paragraph.nodeSize) {
 		const node = paragraph.type.schema.text(" ", storedMarks);
 		tr.setStoredMarks(sameCascade ? storedMarks : reconcileRunFormattingMarks({

package/dist/prosemirror/rejoinRunCarriers.d.ts

@@ -14,7 +14,7 @@ type ContinuedRunMarksOptions = {
  * already share their marks or write different runs: another mark differs,
  * or the formatting they state does.
  */
-declare const continuedRunMarks: ({ left, right, context, styleResolver }: ContinuedRunMarksOptions) => readonly Mark[] | null;
+export declare const continuedRunMarks: ({ left, right, context, styleResolver }: ContinuedRunMarksOptions) => readonly Mark[] | null;
 type RejoinRunsAtOptions = {
   tr: Transaction;
   /** Positions in `tr.doc` where resolved content began or ended. */
@@ -22,6 +22,6 @@ type RejoinRunsAtOptions = {
   styleResolver: RunStyleResolver | null;
 };
 /** Rejoin the runs meeting at each of `boundaries`, left to right. */
-declare const rejoinRunsAt: ({ tr, boundaries, styleResolver }: RejoinRunsAtOptions) => void;
+export declare const rejoinRunsAt: ({ tr, boundaries, styleResolver }: RejoinRunsAtOptions) => void;
 //#endregion
-export { continuedRunMarks, rejoinRunsAt };
+export {};

package/dist/prosemirror/replacedAnnotations.d.ts

@@ -1,4 +1,5 @@
 import { Fragment, Mark, Node, Schema } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/replacedAnnotations.d.ts
 /**
  * What a replacement does with each mark the schema declares
@@ -7,7 +8,7 @@ import { Fragment, Mark, Node, Schema } from "prosemirror-model";
  * non-inclusive mark that is missing from it fails
  * `replacedAnnotations.test.ts` rather than silently following the text.
  */
-declare const NON_INCLUSIVE_MARK_DISPOSITION: {
+export declare const NON_INCLUSIVE_MARK_DISPOSITION: {
   readonly comment: "carry";
   readonly hyperlink: "carry";
   readonly footnoteRef: "followsTheText";
@@ -18,22 +19,22 @@ declare const NON_INCLUSIVE_MARK_DISPOSITION: {
   readonly inlineWrapper: "followsTheText";
 };
 /** 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;
+export declare const nonInclusiveMarkNames: (schema: Schema) => string[];
+/** One typed anchor for a comment authored as a point. */
+export 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">) => {
+export 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 = {
+/** Ranged comments whose covered non-carrier content is removed by a resolution. */
+export declare const resolvedCommentPoints: ({ doc, removes, retiresStructure }: ResolvedCommentPointsOptions) => Map<number, number>;
+export type ReplacedAnnotations = {
   /** Marks the replacement must carry, in document order. */
   carried: readonly Mark[];
   /** Anchors restored before the replacement, in their original order. */
@@ -41,13 +42,13 @@ type ReplacedAnnotations = {
   /** Anchors restored after the replacement, in their original order. */
   trailing: readonly Node[];
 };
-declare const hasReplacedAnnotations: ({ carried, leading, trailing }: ReplacedAnnotations) => boolean;
+export declare const hasReplacedAnnotations: ({ carried, leading, trailing }: ReplacedAnnotations) => boolean;
 /**
  * The annotations carried by `[from, to)`. An anchor counts only when the
  * range covers it whole: a partially covered atom is not deleted by the
  * replacement either.
  */
-declare const surveyReplacedAnnotations: (doc: Node, from: number, to: number) => ReplacedAnnotations;
+export declare const surveyReplacedAnnotations: (doc: Node, from: number, to: number) => ReplacedAnnotations;
 type AnnotatedReplacementOptions = {
   annotations: ReplacedAnnotations;
   /** The replacement's own inline content, already carrying its formatting. */
@@ -61,7 +62,7 @@ type AnnotatedReplacement = {
   contentSize: number;
 };
 /** `marks` with the carried marks added, each type's exclusions respected. */
-declare const addCarriedMarks: (marks: readonly Mark[], carried: readonly Mark[]) => readonly Mark[];
+export declare const addCarriedMarks: (marks: readonly Mark[], carried: readonly Mark[]) => readonly Mark[];
 /**
  * The mark sets of a run of text a TRACKED edit inserts at `at` (one set per
  * piece, in order), with the comments that keep every comment one stretch.
@@ -73,7 +74,7 @@ declare const addCarriedMarks: (marks: readonly Mark[], carried: readonly Mark[]
  * pieces that have a comment (the neighbours included), every piece takes
  * it, or the run would split it in two.
  */
-declare const commentsForTrackedInsertion: (doc: Node, at: number, pieces: readonly (readonly Mark[])[]) => (readonly Mark[])[];
+export declare const commentsForTrackedInsertion: (doc: Node, at: number, pieces: readonly (readonly Mark[])[]) => (readonly Mark[])[];
 /**
  * Where, within the text a tracked replacement removes (`from` to `to`), each
  * piece of its new text goes, one position per piece and never decreasing.
@@ -85,7 +86,20 @@ declare const commentsForTrackedInsertion: (doc: Node, at: number, pieces: reado
  * after it follow it. So each comment stays one stretch, holding the removed
  * text it held and exactly the new text given it.
  */
-declare const placeTrackedInsertion: (doc: Node, from: number, to: number, pieces: readonly (readonly Mark[])[]) => number[];
+export declare const placeTrackedInsertion: (doc: Node, from: number, to: number, pieces: readonly (readonly Mark[])[]) => number[];
+/**
+ * `tr` with every comment in the paragraph at `at` covering one stretch.
+ *
+ * A comment is saved as two points, `w:commentRangeStart` and
+ * `w:commentRangeEnd`, so it covers everything between its first and last
+ * covered character. A tracked replacement over separate comments gives its
+ * new text all of them, as the direct edit does, but the new text sits next
+ * to only one of their removed stretches: the others then skip the removed
+ * text between. The saved package cannot hold that gap and covers it, so the
+ * live document covers it too. Otherwise rejecting the replacement before and
+ * after a save gives different comment ranges.
+ */
+export declare const joinCommentStretches: (tr: Transaction, at: number) => Transaction;
 /**
  * The comments content inserted at the block boundary `at` must carry: those
  * covering the content on both sides of it. A comment range is two points in
@@ -93,13 +107,13 @@ declare const placeTrackedInsertion: (doc: Node, from: number, to: number, piece
  * crosses paragraphs, empty paragraphs or a table edge, and the saved package
  * reopens exactly so. A merge's separator lands on such a boundary too.
  */
-declare const commentsAcrossBlockBoundary: (doc: Node, at: number) => Mark[];
+export declare const commentsAcrossBlockBoundary: (doc: Node, at: number) => Mark[];
 /** `content` with the surveyed marks on it and the surveyed anchors around it. */
-declare const annotatedReplacement: ({ annotations: { carried, leading, trailing }, content }: AnnotatedReplacementOptions) => AnnotatedReplacement;
+export declare const annotatedReplacement: ({ annotations: { carried, leading, trailing }, content }: AnnotatedReplacementOptions) => AnnotatedReplacement;
 /**
  * The marks a replacement inherits at `[from, to)`, exactly as
  * `Transaction.insertText` would compute them.
  */
-declare const inheritedReplacementMarks: (doc: Node, from: number, to: number) => readonly Mark[];
+export declare const inheritedReplacementMarks: (doc: Node, from: number, to: number) => readonly Mark[];
 //#endregion
-export { NON_INCLUSIVE_MARK_DISPOSITION, ReplacedAnnotations, addCarriedMarks, annotatedReplacement, commentPoint, commentsAcrossBlockBoundary, commentsForTrackedInsertion, createResolvedCommentPointCollector, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, resolvedCommentPoints, surveyReplacedAnnotations };
+export {};

package/dist/prosemirror/replacedAnnotations.js

@@ -1,6 +1,9 @@
+import { isCommentAnchorCarrier } from "../ai-edits/comment-lifecycle.js";
 import { expectParagraphAttrs, expectTableCellAttrs, expectTableRowAttrs } from "./attrs/index.js";
+import { expectCommentRangeBoundaryAttrs } from "./commentRangeBoundaryAttrs.js";
+import { COMMENT_REFERENCE_NODE_NAME } from "./commentReferenceIntegrity.js";
 import { BOOKMARK_BOUNDARY_NODE_NAME } from "./extensions/nodes/BookmarkBoundaryExtension.js";
-import { COMMENT_REFERENCE_NODE_NAME } from "./extensions/nodes/CommentReferenceExtension.js";
+import { COMMENT_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/CommentRangeBoundaryExtension.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";
@@ -8,6 +11,7 @@ import { readMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
 import { readRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
 import { isZeroWidthAnchor } from "./zeroWidthAnchors.js";
 import { Fragment, Mark } from "prosemirror-model";
+import { isCommentExhausted } from "@stll/docx-core/ops";
 //#region src/prosemirror/replacedAnnotations.ts
 /**
 * What survives when an edit replaces a span of inline content.
@@ -88,7 +92,7 @@ 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. */
+/** One typed anchor for a comment authored as a point. */
 const commentPoint = (schema, id) => schema.node(RANGE_ANCHOR_NODE_NAME, {
 	start: {
 		type: "commentRangeStart",
@@ -103,6 +107,7 @@ const commentPoint = (schema, id) => schema.node(RANGE_ANCHOR_NODE_NAME, {
 const createResolvedCommentPointCollector = ({ removes, retiresStructure }) => {
 	const points = /* @__PURE__ */ new Map();
 	const retained = /* @__PURE__ */ new Set();
+	const removedStructures = [];
 	const visit = (node, position, previous) => {
 		if (node.type.name === "paragraph") {
 			const mark = expectParagraphAttrs(node).pPrMark;
@@ -110,29 +115,49 @@ const createResolvedCommentPointCollector = ({ removes, retiresStructure }) => {
 			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;
+					if (inline.isInline && !isCommentAnchorCarrier(inline) && !removes(inline, position + 1 + offset)) survivingContent = true;
 					return !survivingContent;
 				});
-				if (!survivingContent) return false;
+				if (!survivingContent) removedStructures.push({
+					from: position,
+					to: position + node.nodeSize
+				});
 			}
 		}
-		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 === "tableRow" && expectTableRowAttrs(node).trDel && retiresStructure(node, position)) {
+			removedStructures.push({
+				from: position,
+				to: position + node.nodeSize
+			});
+			return true;
+		}
+		if ((node.type.name === "tableCell" || node.type.name === "tableHeader") && expectTableCellAttrs(node).cellMarker?.kind === "del" && retiresStructure(node, position)) {
+			removedStructures.push({
+				from: position,
+				to: position + node.nodeSize
+			});
+			return true;
+		}
 		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;
+		if (!node.isInline || isCommentAnchorCarrier(node)) return true;
+		const removedWithStructure = removedStructures.some(({ from, to }) => position > from && position < to);
 		for (const mark of node.marks) {
 			if (mark.type.name !== "comment") continue;
 			const id = mark.attrs["commentId"];
-			if (!removes(node, position)) retained.add(id);
+			if (!removedWithStructure && !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);
+		for (const id of points.keys()) if (!isCommentExhausted({
+			type: "coverage",
+			anchorKind: "range",
+			survivingNonCarrierContent: retained.has(id)
+		})) points.delete(id);
 		return points;
 	};
 	return {
@@ -140,7 +165,7 @@ const createResolvedCommentPointCollector = ({ removes, retiresStructure }) => {
 		finish
 	};
 };
-/** Point fallback excludes comments belonging to retired blocks and table cells. */
+/** Ranged comments whose covered non-carrier content is removed by a resolution. */
 const resolvedCommentPoints = ({ doc, removes, retiresStructure }) => {
 	const collector = createResolvedCommentPointCollector({
 		removes,
@@ -152,6 +177,7 @@ const resolvedCommentPoints = ({ doc, removes, retiresStructure }) => {
 /** Anchors an edit must put back, and where relative to the replacement. */
 const ANCHOR_PLACEMENT = {
 	[COMMENT_REFERENCE_NODE_NAME]: "after",
+	[COMMENT_RANGE_BOUNDARY_NODE_NAME]: "byCommentRangeBoundaryType",
 	[RANGE_ANCHOR_NODE_NAME]: "after",
 	[TEXT_BOX_ANCHOR_NODE_NAME]: "after",
 	[BOOKMARK_BOUNDARY_NODE_NAME]: "byBoundaryType",
@@ -160,6 +186,7 @@ const ANCHOR_PLACEMENT = {
 const anchorPlacement = (node) => ANCHOR_PLACEMENT[node.type.name];
 const opensRange = (node, placement) => {
 	if (placement === "byBoundaryType") return node.attrs["type"] === "start";
+	if (placement === "byCommentRangeBoundaryType") return expectCommentRangeBoundaryAttrs(node).marker.type === "commentRangeStart";
 	if (placement !== "byMoveBoundaryType") return false;
 	const marker = readMoveRangeBoundaryAttrs(node);
 	return marker.ok && marker.value.type.endsWith("Start");
@@ -373,6 +400,48 @@ const placeTrackedInsertion = (doc, from, to, pieces) => {
 	return positions;
 };
 /**
+* `tr` with every comment in the paragraph at `at` covering one stretch.
+*
+* A comment is saved as two points, `w:commentRangeStart` and
+* `w:commentRangeEnd`, so it covers everything between its first and last
+* covered character. A tracked replacement over separate comments gives its
+* new text all of them, as the direct edit does, but the new text sits next
+* to only one of their removed stretches: the others then skip the removed
+* text between. The saved package cannot hold that gap and covers it, so the
+* live document covers it too. Otherwise rejecting the replacement before and
+* after a save gives different comment ranges.
+*/
+const joinCommentStretches = (tr, at) => {
+	const $at = tr.doc.resolve(at);
+	if (!$at.parent.inlineContent) return tr;
+	const from = $at.start();
+	const to = $at.end();
+	const leaves = [];
+	tr.doc.nodesBetween(from, to, (node, position) => {
+		if (!node.isLeaf) return true;
+		if (!isZeroWidthAnchor(node)) leaves.push({
+			node,
+			position
+		});
+		return false;
+	});
+	const comments = [];
+	for (const { node } of leaves) for (const mark of node.marks) if (mark.type.name === "comment" && !mark.isInSet(comments)) comments.push(mark);
+	let next = tr;
+	for (const comment of comments) {
+		const covered = leaves.flatMap(({ node }, index) => comment.isInSet(node.marks) ? [index] : []);
+		const first = covered[0];
+		const last = covered.at(-1);
+		if (first === void 0 || last === void 0) continue;
+		for (let index = first + 1; index < last; index++) {
+			const leaf = leaves[index];
+			if (leaf === void 0 || comment.isInSet(leaf.node.marks)) continue;
+			next = next.addMark(leaf.position, leaf.position + leaf.node.nodeSize, comment);
+		}
+	}
+	return next;
+};
+/**
 * The comments content inserted at the block boundary `at` must carry: those
 * covering the content on both sides of it. A comment range is two points in
 * document order, so what lands between them is covered whether the range
@@ -408,4 +477,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, commentPoint, commentsAcrossBlockBoundary, commentsForTrackedInsertion, createResolvedCommentPointCollector, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, resolvedCommentPoints, surveyReplacedAnnotations };
+export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, commentPoint, commentsAcrossBlockBoundary, commentsForTrackedInsertion, createResolvedCommentPointCollector, hasReplacedAnnotations, inheritedReplacementMarks, joinCommentStretches, nonInclusiveMarkNames, placeTrackedInsertion, resolvedCommentPoints, surveyReplacedAnnotations };

package/dist/prosemirror/revisionCarriers.d.ts

@@ -1,7 +1,7 @@
 import { Node } from "prosemirror-model";
 import { PropertyRevisionKind } from "@stll/docx-core/model";
 //#region src/prosemirror/revisionCarriers.d.ts
-declare const PROPERTY_REVISION_SITES: {
+export declare const PROPERTY_REVISION_SITES: {
   readonly runPropertyChange: {
     readonly kind: "runPropertyChange";
     readonly resolution: "inline-mark";
@@ -57,21 +57,21 @@ declare const PROPERTY_REVISION_SITES: {
 };
 type SiteOf<TKind extends PropertyRevisionKind> = (typeof PROPERTY_REVISION_SITES)[TKind];
 /** One property revision carried on a node's attrs rather than on a mark. */
-type NodePropertyRevisionSite = Extract<SiteOf<PropertyRevisionKind>, {
+export type NodePropertyRevisionSite = Extract<SiteOf<PropertyRevisionKind>, {
   carrier: string;
 }>;
 /** The sites the shared node-attr pass resolves, and therefore must patch. */
-type NodeAttrsPropertyRevisionSite = Extract<NodePropertyRevisionSite, {
+export type NodeAttrsPropertyRevisionSite = Extract<NodePropertyRevisionSite, {
   resolution: "node-attrs";
 }>;
 /** The kinds that pass resolves. */
-type NodeAttrsPropertyRevisionKind = NodeAttrsPropertyRevisionSite["kind"];
+export type NodeAttrsPropertyRevisionKind = NodeAttrsPropertyRevisionSite["kind"];
 /** The reviewer-facing name of a property revision carried on a node. */
-type PropertyRevisionCarrier = NodePropertyRevisionSite["carrier"];
-type FolioNodeRevisionKind = "paragraphMarkInserted" | "paragraphMarkDeleted" | PropertyRevisionCarrier;
+export type PropertyRevisionCarrier = NodePropertyRevisionSite["carrier"];
+export type FolioNodeRevisionKind = "paragraphMarkInserted" | "paragraphMarkDeleted" | PropertyRevisionCarrier;
 /** The property revisions a PM node of this type can carry, in element order. */
-declare const nodePropertyRevisionSites: (nodeTypeName: string) => NodePropertyRevisionSite[];
-type FolioNodeRevisionCarrier = {
+export declare const nodePropertyRevisionSites: (nodeTypeName: string) => NodePropertyRevisionSite[];
+export type FolioNodeRevisionCarrier = {
   id: number;
   type: FolioNodeRevisionKind;
   author: string;
@@ -82,22 +82,22 @@ type FolioNodeRevisionCarrier = {
 };
 type RevisionMetadata = Pick<FolioNodeRevisionCarrier, "id" | "author" | "date">;
 /** The `w:id`, author and date a stored revision's `info` carries, or null. */
-declare const propertyRevisionMetadata: (value: unknown) => RevisionMetadata | null;
+export declare const propertyRevisionMetadata: (value: unknown) => RevisionMetadata | null;
 /**
  * A stored property-revision record as ProseMirror attrs carry it. The
  * previous property set is whatever the site's own element stores, which the
  * reject patch filed under that kind narrows.
  */
-type StoredPropertyRevision = {
+export type StoredPropertyRevision = {
   info?: unknown;
   previousFormatting?: unknown;
 };
 /** The record array a site names, walked from a node's attrs. */
-declare const propertyRevisionRecords: (node: Node, site: NodePropertyRevisionSite) => StoredPropertyRevision[];
+export declare const propertyRevisionRecords: (node: Node, site: NodePropertyRevisionSite) => StoredPropertyRevision[];
 /**
  * Read revision records stored on ProseMirror node attributes and return the
  * exact range the shared accept/reject command requires for each carrier.
  */
-declare const getFolioNodeRevisionCarriers: (node: Node, nodePos: number) => FolioNodeRevisionCarrier[];
+export declare const getFolioNodeRevisionCarriers: (node: Node, nodePos: number) => FolioNodeRevisionCarrier[];
 //#endregion
-export { FolioNodeRevisionCarrier, FolioNodeRevisionKind, NodeAttrsPropertyRevisionKind, NodeAttrsPropertyRevisionSite, NodePropertyRevisionSite, PROPERTY_REVISION_SITES, PropertyRevisionCarrier, StoredPropertyRevision, getFolioNodeRevisionCarriers, nodePropertyRevisionSites, propertyRevisionMetadata, propertyRevisionRecords };
+export {};

package/dist/prosemirror/runContentProjection.d.ts

@@ -0,0 +1,6 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/prosemirror/runContentProjection.d.ts
+export declare const RUN_CONTENT_INLINE_NODE_NAMES: readonly string[];
+export declare const isRunContentInlineNodeName: (name: string) => boolean;
+export declare const isRunContentProjectionNode: (sourceType: document_d_exports.RunContent["type"], nodeName: string) => boolean;
+//#endregion

package/dist/prosemirror/runContentProjection.js

@@ -0,0 +1,24 @@
+//#region src/prosemirror/runContentProjection.ts
+/** RunContent cases and the inline nodes their projection may emit. */
+const RUN_CONTENT_PROJECTION = {
+	text: ["text"],
+	tab: ["tab"],
+	break: ["hardBreak", "pageBreakRun"],
+	symbol: ["symbol"],
+	footnoteRef: ["text"],
+	endnoteRef: ["text"],
+	noteMarker: ["noteMarker"],
+	fieldChar: [],
+	instrText: [],
+	softHyphen: ["text"],
+	noBreakHyphen: ["text"],
+	renderedPageBreak: ["renderedPageBreak"],
+	preservedXml: ["preservedXml"],
+	drawing: ["image"],
+	shape: ["shape", "textBoxAnchor"]
+};
+const RUN_CONTENT_INLINE_NODE_NAMES = [...new Set(Object.values(RUN_CONTENT_PROJECTION).flat())];
+const isRunContentInlineNodeName = (name) => RUN_CONTENT_INLINE_NODE_NAMES.some((candidate) => candidate === name);
+const isRunContentProjectionNode = (sourceType, nodeName) => RUN_CONTENT_PROJECTION[sourceType].some((name) => name === nodeName);
+//#endregion
+export { RUN_CONTENT_INLINE_NODE_NAMES, isRunContentInlineNodeName, isRunContentProjectionNode };

package/dist/prosemirror/runFormattingFromMarks.d.ts

@@ -6,7 +6,7 @@ import { RunPropsPatch } from "@stll/docx-core/ops";
 /**
  * Convert ProseMirror marks to TextFormatting
  */
-type MarksToTextFormattingOptions = {
+export type MarksToTextFormattingOptions = {
   baseParagraphFormatting?: document_d_exports.TextFormatting | undefined;
   inheritedFormatting?: document_d_exports.TextFormatting | undefined;
   paragraphMarkFormatting?: document_d_exports.TextFormatting | undefined;
@@ -14,8 +14,7 @@ type MarksToTextFormattingOptions = {
   styleResolver?: RunStyleResolver | null | undefined;
 };
 /** Overlay only changed visual marks; private authored properties stay with the run. */
-declare const runFormattingPatchFromMarks: (beforeMarks: readonly Mark[], afterMarks: readonly Mark[]) => RunPropsPatch;
-declare const sameFormattingValue: (left: unknown, right: unknown) => boolean;
-declare function marksToTextFormatting(marks: readonly Mark[], options?: MarksToTextFormattingOptions): document_d_exports.TextFormatting;
-//#endregion
-export { MarksToTextFormattingOptions, marksToTextFormatting, runFormattingPatchFromMarks, sameFormattingValue };
+export declare const runFormattingPatchFromMarks: (beforeMarks: readonly Mark[], afterMarks: readonly Mark[]) => RunPropsPatch;
+export declare const sameFormattingValue: (left: unknown, right: unknown) => boolean;
+export declare function marksToTextFormatting(marks: readonly Mark[], options?: MarksToTextFormattingOptions): document_d_exports.TextFormatting;
+//#endregion