@stll/folio-core 0.61.0 → 0.63.0

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

package/dist/prosemirror/runFormattingFromMarks.js

@@ -508,7 +508,6 @@ function marksToTextFormatting(marks, options) {
 			characterStyleId = attrs.styleId;
 			break;
 		}
-		default: break;
 	}
 	let authoredFormatting = {};
 	if (runFormattingOverrideMark) {
@@ -531,18 +530,20 @@ function marksToTextFormatting(marks, options) {
 			styleId: characterStyleId
 		};
 	}
+	const runContext = {
+		baseParagraphFormatting: options?.baseParagraphFormatting,
+		paragraphFormatting: options?.inheritedFormatting,
+		paragraphMarkFormatting: options?.paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle: options?.paragraphMarkPrecedesStyle ?? false
+	};
+	const paragraphFormatting = paragraphFormattingForRun({
+		context: runContext,
+		directFormatting: authoredFormatting,
+		marks
+	});
 	const inheritedFormatting = resolveEffectiveRunStyleFormatting({
 		marks,
-		paragraphFormatting: paragraphFormattingForRun({
-			context: {
-				baseParagraphFormatting: options?.baseParagraphFormatting,
-				paragraphFormatting: options?.inheritedFormatting,
-				paragraphMarkFormatting: options?.paragraphMarkFormatting,
-				paragraphMarkPrecedesStyle: options?.paragraphMarkPrecedesStyle ?? false
-			},
-			directFormatting: authoredFormatting,
-			marks
-		}),
+		paragraphFormatting,
 		...options?.styleResolver !== void 0 ? { styleResolver: options.styleResolver } : {}
 	});
 	let reconciled = reconcileAuthoredFormatting({
@@ -553,14 +554,15 @@ function marksToTextFormatting(marks, options) {
 		observedFormatting: formatting
 	});
 	if (runFormattingOverrideMark === void 0 && characterStyleId === void 0 && options?.paragraphMarkFormatting !== void 0) {
+		const suppressedParagraphFormatting = suppressParagraphMarkFormatting({
+			baseFormatting: options.baseParagraphFormatting,
+			directFormatting: authoredFormatting,
+			paragraphMarkFormatting: options.paragraphMarkFormatting,
+			paragraphMarkPrecedesStyle: options.paragraphMarkPrecedesStyle ?? false
+		});
 		const suppressedInheritedFormatting = resolveEffectiveRunStyleFormatting({
 			marks,
-			paragraphFormatting: suppressParagraphMarkFormatting({
-				baseFormatting: options.baseParagraphFormatting,
-				directFormatting: authoredFormatting,
-				paragraphMarkFormatting: options.paragraphMarkFormatting,
-				paragraphMarkPrecedesStyle: options.paragraphMarkPrecedesStyle ?? false
-			}),
+			paragraphFormatting: suppressedParagraphFormatting,
 			...options.styleResolver !== void 0 ? { styleResolver: options.styleResolver } : {}
 		});
 		const suppressed = reconcileAuthoredFormatting({

package/dist/prosemirror/runFormattingInlineCarriers.d.ts

@@ -1,7 +1,7 @@
 import { Mark, Node } from "prosemirror-model";
 import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/runFormattingInlineCarriers.d.ts
-type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "note-marker-run" | "page-break-carrier" | "preserved-xml-run" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
+export type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "note-marker-run" | "page-break-carrier" | "preserved-xml-run" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
 /**
  * How every inline atom maps to a serialized run-formatting carrier.
  *
@@ -10,8 +10,9 @@ type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run
  * marks do not serialize as run properties. The runtime fixed-point test binds
  * this map to the complete schema atom set.
  */
-declare const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS: Readonly<{
+export declare const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly bookmarkBoundary: "not-a-run";
+  readonly commentRangeBoundary: "not-a-run";
   readonly commentReference: "not-a-run";
   readonly field: "field-run";
   readonly hardBreak: "break-run";
@@ -30,7 +31,7 @@ declare const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly text: "text-run";
   readonly textBoxAnchor: "not-a-run";
 }>;
-declare const runFormattingInlineControlCharacter: (node: Node) => string | null;
+export declare const runFormattingInlineControlCharacter: (node: Node) => string | null;
 /**
  * Text an inline atom contributes to a flattened, reader-facing projection.
  *
@@ -40,26 +41,26 @@ declare const runFormattingInlineControlCharacter: (node: Node) => string | null
  * `getFieldVisibleText` paints for the editor is a rendering decision, not
  * document text, and one of its branches is the current date.
  */
-declare const runFormattingInlineAtomCleanText: (node: Node) => string | null;
+export declare const runFormattingInlineAtomCleanText: (node: Node) => string | null;
 /**
  * Document text an inline atom contributes, as opposed to a control character:
  * today a field's authored result.
  */
-declare const runFormattingInlineAtomResultText: (node: Node) => string | null;
-declare const runFormattingInlineControlNodeName: (character: string) => string | null;
-declare const runFormattingInlineAtomDisposition: (node: Node) => RunFormattingInlineAtomDisposition | null;
-type RunFormattingCarrierRepresentation = {
+export declare const runFormattingInlineAtomResultText: (node: Node) => string | null;
+export declare const runFormattingInlineControlNodeName: (character: string) => string | null;
+export declare const runFormattingInlineAtomDisposition: (node: Node) => RunFormattingInlineAtomDisposition | null;
+export type RunFormattingCarrierRepresentation = {
   node: Node;
   position: number;
   role: "owner" | "serialized-result";
 };
-type RunFormattingCarrier = {
+export type RunFormattingCarrier = {
   disposition: Exclude<RunFormattingInlineAtomDisposition, "not-a-run">;
   node: Node;
   position: number;
   representations: readonly RunFormattingCarrierRepresentation[];
 };
-type SelectedRunFormattingCarrierRepresentation = RunFormattingCarrierRepresentation & {
+export type SelectedRunFormattingCarrierRepresentation = RunFormattingCarrierRepresentation & {
   carrierDisposition: RunFormattingCarrier["disposition"];
   from: number;
   to: number;
@@ -73,13 +74,13 @@ type ApplyMarksToRunFormattingRepresentationOptions = {
   marks: readonly Mark[];
 };
 /** Apply a mark set without changing a carrier's text or serialized ownership. */
-declare const applyMarksToRunFormattingRepresentation: ({ tr, representation, marks }: ApplyMarksToRunFormattingRepresentationOptions) => void;
+export declare const applyMarksToRunFormattingRepresentation: ({ tr, representation, marks }: ApplyMarksToRunFormattingRepresentationOptions) => void;
 /**
  * Expand one logical carrier into every editor node that materializes its run
  * properties. A structured field is owned by its outer atom, while its result
  * runs are derived representations needed by the package serializer.
  */
-declare const expandRunFormattingCarrier: (node: Node, position: number) => RunFormattingCarrier | null;
+export declare const expandRunFormattingCarrier: (node: Node, position: number) => RunFormattingCarrier | null;
 type SelectRunFormattingCarrierRepresentationsOptions = {
   doc: Node;
   from: number;
@@ -90,8 +91,8 @@ type SelectRunFormattingCarrierRepresentationsOptions = {
  * properties. The result is shared by every formatting mutation so preflight,
  * direct edits, and tracked edits cannot disagree about ownership.
  */
-declare const selectRunFormattingCarrierRepresentations: ({ doc, from, to }: SelectRunFormattingCarrierRepresentationsOptions) => SelectedRunFormattingCarrierRepresentation[];
+export declare const selectRunFormattingCarrierRepresentations: ({ doc, from, to }: SelectRunFormattingCarrierRepresentationsOptions) => SelectedRunFormattingCarrierRepresentation[];
 /** Deterministic visible text for one logical formatting revision carrier. */
-declare const runFormattingCarrierReviewText: (carrier: RunFormattingCarrier) => string;
+export declare const runFormattingCarrierReviewText: (carrier: RunFormattingCarrier) => string;
 //#endregion
-export { RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS, RunFormattingCarrier, RunFormattingCarrierRepresentation, RunFormattingInlineAtomDisposition, SelectedRunFormattingCarrierRepresentation, applyMarksToRunFormattingRepresentation, expandRunFormattingCarrier, runFormattingCarrierReviewText, runFormattingInlineAtomCleanText, runFormattingInlineAtomDisposition, runFormattingInlineAtomResultText, runFormattingInlineControlCharacter, runFormattingInlineControlNodeName, selectRunFormattingCarrierRepresentations };
+export {};

package/dist/prosemirror/runFormattingInlineCarriers.js

@@ -14,6 +14,7 @@ import { Mark } from "prosemirror-model";
 */
 const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS = Object.freeze({
 	bookmarkBoundary: "not-a-run",
+	commentRangeBoundary: "not-a-run",
 	commentReference: "not-a-run",
 	field: "field-run",
 	hardBreak: "break-run",

package/dist/prosemirror/runFormattingMarkNames.d.ts

@@ -9,6 +9,5 @@
  * it structurally impossible for the two paths to drift and let a formatting
  * mark survive a revert.
  */
-declare const RUN_FORMATTING_MARK_NAMES: Set<string>;
-//#endregion
-export { RUN_FORMATTING_MARK_NAMES };
+export declare const RUN_FORMATTING_MARK_NAMES: Set<string>;
+//#endregion

package/dist/prosemirror/runFormattingProvenance.d.ts

@@ -1,12 +1,11 @@
 import { document_d_exports } from "../types/document.js";
 import { RunFormattingOverrideAttrs } from "./schema/marks.js";
 //#region src/prosemirror/runFormattingProvenance.d.ts
-declare const hasAuthoredRunFormattingProvenance: ({ _authoredOff, _authoredOn, _authoredValues }: RunFormattingOverrideAttrs) => boolean;
+export declare const hasAuthoredRunFormattingProvenance: ({ _authoredOff, _authoredOn, _authoredValues }: RunFormattingOverrideAttrs) => boolean;
 /** Whether an override mark still carries any rendering or authorship signal. */
-declare const hasRunFormattingOverrideAttrs: (attrs: RunFormattingOverrideAttrs) => boolean;
+export declare const hasRunFormattingOverrideAttrs: (attrs: RunFormattingOverrideAttrs) => boolean;
 /** Reconstruct the last imported/reconciled direct baseline; inherited values never enter here. */
-declare const authoredRunFormattingFromAttrs: (attrs: RunFormattingOverrideAttrs) => document_d_exports.TextFormatting | undefined;
+export declare const authoredRunFormattingFromAttrs: (attrs: RunFormattingOverrideAttrs) => document_d_exports.TextFormatting | undefined;
 /** Replace the direct baseline while preserving current rendering attributes. */
-declare const withAuthoredRunFormatting: (attrs: RunFormattingOverrideAttrs, formatting: document_d_exports.TextFormatting | undefined) => RunFormattingOverrideAttrs;
-//#endregion
-export { authoredRunFormattingFromAttrs, hasAuthoredRunFormattingProvenance, hasRunFormattingOverrideAttrs, withAuthoredRunFormatting };
+export declare const withAuthoredRunFormatting: (attrs: RunFormattingOverrideAttrs, formatting: document_d_exports.TextFormatting | undefined) => RunFormattingOverrideAttrs;
+//#endregion

package/dist/prosemirror/runFormattingReconciliation.d.ts

@@ -8,9 +8,9 @@ type ReadAuthoredRunFormattingOptions = {
   styleResolver?: RunStyleResolver | null;
 };
 /** Read authored run properties without confusing inherited visuals for direct formatting. */
-declare const readAuthoredRunFormatting: ({ context, marks, styleResolver }: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting;
+export 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;
+export declare const readAuthoredRunPropertySnapshot: (options: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting | undefined;
 type ReconcileRunFormattingMarksOptions = {
   authoredFormatting: document_d_exports.TextFormatting;
   context: ParagraphRunStyleContext;
@@ -22,6 +22,6 @@ type ReconcileRunFormattingMarksOptions = {
  * current style context. This is the inverse of {@link readAuthoredRunFormatting}:
  * direct provenance stays direct while inherited formatting remains visual only.
  */
-declare const reconcileRunFormattingMarks: ({ authoredFormatting, context, node, styleResolver }: ReconcileRunFormattingMarksOptions) => readonly Mark[];
+export declare const reconcileRunFormattingMarks: ({ authoredFormatting, context, node, styleResolver }: ReconcileRunFormattingMarksOptions) => readonly Mark[];
 //#endregion
-export { readAuthoredRunFormatting, readAuthoredRunPropertySnapshot, reconcileRunFormattingMarks };
+export {};