@stll/folio-core 0.45.0 → 0.47.0

package/dist/prosemirror/commands/paragraph.d.ts

@@ -1,4 +1,5 @@
 import { document_d_exports } from "../../types/document.js";
+import { SectionBreakType } from "../sectionCarrier.js";
 import { GenerateTableOfContentsOptions, ResolvedStyleAttrs, getParagraphAlignment, getParagraphBidi, getParagraphTabs, getStyleId } from "../extensions/core/ParagraphExtension.js";
 import { getListInfo, isInList } from "../extensions/features/ListExtension.js";
 import { Command } from "prosemirror-state";
@@ -26,7 +27,7 @@ declare function setSpaceBefore(twips: number): Command;
 declare function setSpaceAfter(twips: number): Command;
 declare function applyStyle(styleId: string, resolvedAttrs?: ResolvedStyleAttrs): Command;
 declare const clearStyle: Command;
-declare function insertSectionBreak(breakType: "nextPage" | "continuous" | "oddPage" | "evenPage"): Command;
+declare function insertSectionBreak(breakType: SectionBreakType): Command;
 declare const removeSectionBreak: Command;
 declare function addTabStop(position: number, alignment?: document_d_exports.TabStopAlignment, leader?: document_d_exports.TabLeader): Command;
 declare function removeTabStop(position: number): Command;

package/dist/prosemirror/commands/propertyChangeScope.d.ts

@@ -32,9 +32,9 @@ declare const removeParagraphPropertyChanges: (changes: readonly ParagraphProper
  * stored record resets to the schema default (`null`).
  *
  * Deliberately OUT of scope (preserved across a reject):
- * - identity/structure: `paraId`, `textId`, `sectionBreakType`,
- *   `_sectionProperties`, `_propertyChanges`, `pPrMark`, `bookmarks`,
- *   `_emptyHyperlinks`, `renderedPageBreakBefore`
+ * - identity/structure: `paraId`, `textId`, `_sectionProperties`,
+ *   `_propertyChanges`, `pPrMark`, `bookmarks`, `_emptyHyperlinks`,
+ *   `renderedPageBreakBefore`
  * - paragraph-mark run properties — `pPr/rPr` is CT_PPr-only, not part of the
  *   CT_PPrBase payload a pPrChange stores: `defaultTextFormatting`,
  *   `runInWithNext` (`w:specVanish` lives in that rPr)
@@ -83,6 +83,14 @@ declare function sectionRejectProperties({ live, previousProperties, previousRef
  * and is untouched.
  */
 declare function tableRejectAttrPatch(previousFormatting: document_d_exports.TableFormatting | undefined): AttrPatch;
+/**
+ * Attr patch for rejecting a `w:tblPrExChange`: the stored old `w:tblPrEx`
+ * wholesale. The exceptions ride the row node whole rather than as attrs (the
+ * editor surfaces none of the nine properties), so restoring the previous set
+ * is restoring that one attr — and a record with no stored set says the row
+ * overrode nothing, which is the element's absence, not an empty one.
+ */
+declare function tablePropertyExceptionsRejectAttrPatch(previousFormatting: document_d_exports.TablePropertyExceptionFormatting | undefined): AttrPatch;
 /** Attr patch for rejecting a `w:trPrChange`: the stored old trPr wholesale. */
 declare function tableRowRejectAttrPatch(previousFormatting: document_d_exports.TableRowFormatting | undefined): AttrPatch;
 /**
@@ -96,4 +104,4 @@ declare function tableRowRejectAttrPatch(previousFormatting: document_d_exports.
  */
 declare function tableCellRejectAttrPatch(previousFormatting: document_d_exports.TableCellFormatting | undefined, liveOriginalFormatting: document_d_exports.TableCellFormatting | null | undefined): AttrPatch;
 //#endregion
-export { PPR_CHANGE_SCOPED_ATTR_KEYS, ParagraphPropertyChangeRemoval, hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };
+export { PPR_CHANGE_SCOPED_ATTR_KEYS, ParagraphPropertyChangeRemoval, hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tablePropertyExceptionsRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -1,4 +1,5 @@
 import { expectParagraphAttrs } from "../attrs/index.js";
+import { readParagraphNumberingAttr } from "../numberingAttr.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
 import { directionFromBidi } from "../paragraphDirection.js";
 import { directParagraphSpacing, paragraphSpacingAttrPatch, paragraphSpacingFromFormatting } from "../paragraphSpacing.js";
@@ -56,9 +57,9 @@ const removeParagraphPropertyChanges = (changes, shouldRemove) => {
 * stored record resets to the schema default (`null`).
 *
 * Deliberately OUT of scope (preserved across a reject):
-* - identity/structure: `paraId`, `textId`, `sectionBreakType`,
-*   `_sectionProperties`, `_propertyChanges`, `pPrMark`, `bookmarks`,
-*   `_emptyHyperlinks`, `renderedPageBreakBefore`
+* - identity/structure: `paraId`, `textId`, `_sectionProperties`,
+*   `_propertyChanges`, `pPrMark`, `bookmarks`, `_emptyHyperlinks`,
+*   `renderedPageBreakBefore`
 * - paragraph-mark run properties — `pPr/rPr` is CT_PPr-only, not part of the
 *   CT_PPrBase payload a pPrChange stores: `defaultTextFormatting`,
 *   `runInWithNext` (`w:specVanish` lives in that rPr)
@@ -214,6 +215,9 @@ function paragraphRejectOriginalFormatting(previousFormatting, liveOriginal) {
 		const value = Object.hasOwn(prev, key) ? prev[key] : void 0;
 		if (value != null) Object.assign(result, { [key]: value });
 	}
+	const numbering = readParagraphNumberingAttr(prev.numPr);
+	if (numbering === null) Reflect.deleteProperty(result, "numPr");
+	else result.numPr = numbering;
 	const live = isRecord(liveOriginal) ? liveOriginal : {};
 	if (live["runProperties"] != null) Object.assign(result, { runProperties: live["runProperties"] });
 	if (live["runInWithNext"] != null) Object.assign(result, { runInWithNext: live["runInWithNext"] });
@@ -249,6 +253,16 @@ function tableRejectAttrPatch(previousFormatting) {
 		_originalFormatting: previousFormatting ?? null
 	};
 }
+/**
+* Attr patch for rejecting a `w:tblPrExChange`: the stored old `w:tblPrEx`
+* wholesale. The exceptions ride the row node whole rather than as attrs (the
+* editor surfaces none of the nine properties), so restoring the previous set
+* is restoring that one attr — and a record with no stored set says the row
+* overrode nothing, which is the element's absence, not an empty one.
+*/
+function tablePropertyExceptionsRejectAttrPatch(previousFormatting) {
+	return { _tablePropertyExceptions: previousFormatting ?? null };
+}
 /** Attr patch for rejecting a `w:trPrChange`: the stored old trPr wholesale. */
 function tableRowRejectAttrPatch(previousFormatting) {
 	return {
@@ -277,6 +291,10 @@ function tableCellRejectAttrPatch(previousFormatting, liveOriginalFormatting) {
 	return {
 		width: previousFormatting?.width?.value ?? null,
 		widthType: previousFormatting?.width?.type ?? null,
+		_authoredWidth: previousFormatting?.width ? {
+			value: previousFormatting.width.value,
+			type: previousFormatting.width.type
+		} : null,
 		verticalAlign: previousFormatting?.verticalAlign ?? null,
 		backgroundColor: previousFormatting?.shading?.fill?.rgb ?? null,
 		textDirection: previousFormatting?.textDirection ?? null,
@@ -306,4 +324,4 @@ function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
-export { PPR_CHANGE_SCOPED_ATTR_KEYS, hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };
+export { PPR_CHANGE_SCOPED_ATTR_KEYS, hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tablePropertyExceptionsRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };

package/dist/prosemirror/commands/sectionBreak.d.ts

@@ -1,5 +1,37 @@
+import { SectionBreakType } from "../sectionCarrier.js";
 import { Command } from "prosemirror-state";
 //#region src/prosemirror/commands/sectionBreak.d.ts
+/**
+ * Run a command, keeping every section break on the paragraph whose mark
+ * survived it.
+ *
+ * A section break is a property of a paragraph *mark*. The transfer is keyed on
+ * the mark's position surviving the transaction, not on which command ran, so
+ * deleting a section-ending paragraph outright still removes its section: that
+ * mark is gone, and nothing inherits it.
+ */
+declare const keepSectionBreaksOnSurvivingMarks: (command: Command) => Command;
+/**
+ * End the selection's sections with `breakType`.
+ *
+ * A paragraph that already ends a section keeps its page size, margins,
+ * columns and header references and changes only `w:type` (§17.6.22), which is
+ * the one field the type names; a paragraph that ends none mints a record
+ * stating that type alone, and inherits the rest from the section that follows
+ * it.
+ */
+declare const setSectionBreakType: (breakType: SectionBreakType) => Command;
+/**
+ * Remove the section break the selection's paragraphs carry.
+ *
+ * The record goes, and with it the section boundary: the paragraphs it
+ * governed become part of the section that follows, whose `w:sectPr` governs
+ * them from then on. That is Word's own rule for deleting a section break, and
+ * it is what §17.6.18 says a paragraph with no `w:sectPr` means — nothing has
+ * to be merged into the following record, because the following record already
+ * states the whole of the section it heads.
+ */
+declare const removeSectionBreakAtSelection: Command;
 /**
  * Insert a "next page" section break at the cursor — starts a new section on a
  * new page.
@@ -11,4 +43,4 @@ declare const insertSectionBreakNextPage: Command;
  */
 declare const insertSectionBreakContinuous: Command;
 //#endregion
-export { insertSectionBreakContinuous, insertSectionBreakNextPage };
+export { insertSectionBreakContinuous, insertSectionBreakNextPage, keepSectionBreaksOnSurvivingMarks, removeSectionBreakAtSelection, setSectionBreakType };

package/dist/prosemirror/commands/sectionBreak.js

@@ -1,14 +1,192 @@
+import { mintSectionProperties, sectionPropertiesOf } from "../sectionCarrier.js";
 import { TextSelection } from "prosemirror-state";
 //#region src/prosemirror/commands/sectionBreak.ts
+const sectionEndingMarks = (doc) => {
+	const marks = [];
+	doc.descendants((node, position) => {
+		if (node.type.name !== "paragraph") return true;
+		const properties = sectionPropertiesOf(node);
+		if (properties) marks.push({
+			markPosition: position + node.nodeSize - 1,
+			properties
+		});
+		return false;
+	});
+	return marks;
+};
+const withSectionProperties = (attrs, properties) => {
+	const next = { ...attrs };
+	if (properties === null) {
+		delete next["_sectionProperties"];
+		return next;
+	}
+	next["_sectionProperties"] = properties;
+	return next;
+};
+/**
+* Restate, over the whole document, which paragraph marks end a section.
+*
+* The rule is total in both directions, because a join is: it consumes one
+* paragraph mark and keeps the other, so exactly the marks that survived the
+* transaction still end the sections they ended before. ProseMirror keeps the
+* *first* node's attrs when it joins, which gets both halves of the rule wrong
+* on its own — the mark that survived a backward join loses a break it still
+* owns, and the node that absorbed a section-ending predecessor keeps a break
+* whose mark is gone.
+*
+* Word deletes the section break in the second case: with the caret at the
+* start of the paragraph *after* a break, Backspace removes the break, and the
+* paragraphs it governed join the following section, whose `w:sectPr` then
+* governs them (ECMA-376 Part 1 §17.6.18: a paragraph's `w:sectPr` states the
+* properties of the section ending at that paragraph, so content with no
+* `w:sectPr` before it belongs to the next one).
+*/
+const reconcileSectionEndingMarks = (transaction, marks) => {
+	const survivors = /* @__PURE__ */ new Map();
+	for (const { markPosition, properties } of marks) {
+		const mapped = transaction.mapping.mapResult(markPosition, 1);
+		if (!mapped.deleted) survivors.set(mapped.pos, properties);
+	}
+	const corrections = [];
+	transaction.doc.descendants((node, position) => {
+		if (node.type.name !== "paragraph") return true;
+		const survived = survivors.get(position + node.nodeSize - 1) ?? null;
+		if (survived !== sectionPropertiesOf(node)) corrections.push({
+			position,
+			properties: survived
+		});
+		return false;
+	});
+	for (const { position, properties } of corrections) {
+		const paragraph = transaction.doc.nodeAt(position);
+		if (paragraph) transaction.setNodeMarkup(position, void 0, withSectionProperties(paragraph.attrs, properties));
+	}
+};
+/**
+* Run a command, keeping every section break on the paragraph whose mark
+* survived it.
+*
+* A section break is a property of a paragraph *mark*. The transfer is keyed on
+* the mark's position surviving the transaction, not on which command ran, so
+* deleting a section-ending paragraph outright still removes its section: that
+* mark is gone, and nothing inherits it.
+*/
+const keepSectionBreaksOnSurvivingMarks = (command) => (state, dispatch, view) => {
+	if (!dispatch) return command(state, void 0, view);
+	const marks = sectionEndingMarks(state.doc);
+	if (marks.length === 0) return command(state, dispatch, view);
+	let captured = null;
+	const capture = (transaction) => {
+		captured = transaction;
+	};
+	if (!command(state, capture, view)) return false;
+	const transaction = captured;
+	if (transaction === null) return true;
+	reconcileSectionEndingMarks(transaction, marks);
+	dispatch(transaction);
+	return true;
+};
+const selectedParagraphs = (state) => {
+	const paragraphs = [];
+	const { $from, $to } = state.selection;
+	state.doc.nodesBetween($from.pos, $to.pos, (node, position) => {
+		if (node.type.name !== "paragraph") return true;
+		paragraphs.push({
+			position,
+			node
+		});
+		return false;
+	});
+	return paragraphs;
+};
+/**
+* Rewrite the section record of every paragraph the selection touches.
+*
+* A record is rewritten once and the replacement applied to every paragraph
+* holding it, wherever in the document it sits. A split leaves two halves over
+* one object until the save leg decides which of them ends the section;
+* rewriting them apart would turn that one section into two, and leaving a
+* sharer outside the selection behind would do the same.
+*
+* A paragraph that holds no record is asked on its own, so two break-less
+* paragraphs in one selection author two sections rather than share one.
+*/
+const rewriteSelectedSectionRecords = (rewrite) => (state, dispatch) => {
+	const selected = selectedParagraphs(state);
+	if (selected.length === 0) return false;
+	const replacements = /* @__PURE__ */ new Map();
+	for (const { node } of selected) {
+		const current = sectionPropertiesOf(node);
+		if (current !== null && !replacements.has(current)) replacements.set(current, rewrite(current));
+	}
+	const selectedPositions = new Set(selected.map(({ position }) => position));
+	const corrections = [];
+	state.doc.descendants((node, position) => {
+		if (node.type.name !== "paragraph") return true;
+		const current = sectionPropertiesOf(node);
+		if (current === null) {
+			if (selectedPositions.has(position)) {
+				const minted = rewrite(null);
+				if (minted !== null) corrections.push({
+					position,
+					properties: minted
+				});
+			}
+			return false;
+		}
+		if (replacements.has(current)) {
+			const replacement = replacements.get(current) ?? null;
+			if (replacement !== current) corrections.push({
+				position,
+				properties: replacement
+			});
+		}
+		return false;
+	});
+	if (corrections.length === 0) return false;
+	if (dispatch) {
+		const transaction = state.tr;
+		for (const { position, properties } of corrections) {
+			const paragraph = transaction.doc.nodeAt(position);
+			if (paragraph) transaction.setNodeMarkup(position, void 0, withSectionProperties(paragraph.attrs, properties));
+		}
+		dispatch(transaction.scrollIntoView());
+	}
+	return true;
+};
+/**
+* End the selection's sections with `breakType`.
+*
+* A paragraph that already ends a section keeps its page size, margins,
+* columns and header references and changes only `w:type` (§17.6.22), which is
+* the one field the type names; a paragraph that ends none mints a record
+* stating that type alone, and inherits the rest from the section that follows
+* it.
+*/
+const setSectionBreakType = (breakType) => rewriteSelectedSectionRecords((current) => current === null ? mintSectionProperties(breakType) : {
+	...current,
+	sectionStart: breakType
+});
+/**
+* Remove the section break the selection's paragraphs carry.
+*
+* The record goes, and with it the section boundary: the paragraphs it
+* governed become part of the section that follows, whose `w:sectPr` governs
+* them from then on. That is Word's own rule for deleting a section break, and
+* it is what §17.6.18 says a paragraph with no `w:sectPr` means — nothing has
+* to be merged into the following record, because the following record already
+* states the whole of the section it heads.
+*/
+const removeSectionBreakAtSelection = rewriteSelectedSectionRecords(() => null);
 /**
 * Insert a section break at the current cursor position.
 *
 * In OOXML a section break is the `sectPr` carried by the *last* paragraph of a
-* section. So we split the current paragraph at the cursor, mark the first half
-* with `sectionBreakType` (it becomes the section end), and leave the cursor in
-* the second half (the first paragraph of the new section). Content after the
-* cursor therefore flows into the new section — onto a new page for `nextPage`,
-* or in place for `continuous`.
+* section (§17.6.18). So we split the current paragraph at the cursor, give the
+* first half the one record this insertion mints (it becomes the section end),
+* and leave the cursor in the second half (the first paragraph of the new
+* section). Content after the cursor therefore flows into the new section —
+* onto a new page for `nextPage`, or in place for `continuous`.
 */
 function insertSectionBreakAtCursor(breakType) {
 	return (state, dispatch) => {
@@ -19,19 +197,17 @@ function insertSectionBreakAtCursor(breakType) {
 		if (!($from.parent.isTextblock ? state.doc.resolve($from.before()).depth === 0 : $from.depth === 0)) return false;
 		if (dispatch) {
 			const tr = state.tr;
+			const sectionProperties = mintSectionProperties(breakType);
 			let cursorPos;
 			if ($from.parent.isTextblock) {
 				const paraPos = $from.before();
 				tr.split($from.pos);
 				const firstPara = tr.doc.nodeAt(paraPos);
-				if (firstPara) tr.setNodeMarkup(paraPos, void 0, {
-					...firstPara.attrs,
-					sectionBreakType: breakType
-				});
+				if (firstPara) tr.setNodeMarkup(paraPos, void 0, withSectionProperties(firstPara.attrs, sectionProperties));
 				cursorPos = tr.mapping.map($from.pos);
 			} else {
 				const pos = $from.pos;
-				tr.insert(pos, paragraphType.create({ sectionBreakType: breakType }));
+				tr.insert(pos, paragraphType.create({ _sectionProperties: sectionProperties }));
 				cursorPos = pos + 1;
 			}
 			tr.setSelection(TextSelection.create(tr.doc, cursorPos));
@@ -51,4 +227,4 @@ const insertSectionBreakNextPage = insertSectionBreakAtCursor("nextPage");
 */
 const insertSectionBreakContinuous = insertSectionBreakAtCursor("continuous");
 //#endregion
-export { insertSectionBreakContinuous, insertSectionBreakNextPage };
+export { insertSectionBreakContinuous, insertSectionBreakNextPage, keepSectionBreaksOnSurvivingMarks, removeSectionBreakAtSelection, setSectionBreakType };

package/dist/prosemirror/commentReferenceAttrs.d.ts

@@ -0,0 +1,8 @@
+import { CommentReferenceAttrs } from "./schema/nodes.js";
+import { ReadProseMirrorAttrsResult } from "./attrs/index.js";
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/commentReferenceAttrs.d.ts
+declare const readCommentReferenceAttrs: (node: Node) => ReadProseMirrorAttrsResult<CommentReferenceAttrs>;
+declare const expectCommentReferenceAttrs: (node: Node) => CommentReferenceAttrs;
+//#endregion
+export { expectCommentReferenceAttrs, readCommentReferenceAttrs };

package/dist/prosemirror/commentReferenceAttrs.js

@@ -0,0 +1,33 @@
+import { panic } from "better-result";
+//#region src/prosemirror/commentReferenceAttrs.ts
+const attrsCache = /* @__PURE__ */ new WeakMap();
+const readCommentReferenceAttrs = (node) => {
+	const issues = [];
+	if (node.type.name !== "commentReference") issues.push({
+		path: "commentReference.type.name",
+		message: `Expected commentReference, got ${node.type.name}.`
+	});
+	const commentId = node.attrs["commentId"];
+	if (typeof commentId !== "number" || !Number.isInteger(commentId) || commentId < 0) issues.push({
+		path: "commentReference.attrs.commentId",
+		message: "Expected a non-negative integer."
+	});
+	if (issues.length > 0 || typeof commentId !== "number") return {
+		ok: false,
+		issues
+	};
+	return {
+		ok: true,
+		value: { commentId }
+	};
+};
+const expectCommentReferenceAttrs = (node) => {
+	const cached = attrsCache.get(node);
+	if (cached) return cached;
+	const result = readCommentReferenceAttrs(node);
+	if (!result.ok) panic(`Invalid ProseMirror comment reference attrs:\n${result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n")}`);
+	attrsCache.set(node, result.value);
+	return result.value;
+};
+//#endregion
+export { expectCommentReferenceAttrs, readCommentReferenceAttrs };

package/dist/prosemirror/commentReferenceIntegrity.d.ts

@@ -0,0 +1,47 @@
+//#region src/prosemirror/commentReferenceIntegrity.d.ts
+/**
+ * What a document must hold for every comment: exactly one `commentReference`
+ * node, after the last position its `comment` mark covers.
+ *
+ * The reference is the run Word paints the visible comment mark with, so a
+ * comment without one is invisible in Word and a duplicate paints the mark
+ * twice. Editing cannot be trusted to keep that true — a paste duplicates a
+ * reference, deleting the commented text orphans one, and a command that adds
+ * a comment mark creates none — so the repair is computed here and applied by
+ * the extension's `appendTransaction`, rather than left to each call site.
+ */
+type CommentReferenceOccurrence = {
+  commentId: number;
+  position: number;
+  /** Node size, so a caller can delete the node without re-reading it. */
+  size: number;
+  malformed: boolean;
+};
+/** Where a comment's mark last covers content, and how far that content runs. */
+type CommentMarkExtent = {
+  commentId: number;
+  /** Document position just past the last inline node carrying the mark. */
+  end: number;
+};
+type CommentReferenceRepair = {
+  type: "delete";
+  position: number;
+  size: number;
+} | {
+  type: "insert";
+  position: number;
+  commentId: number;
+};
+type CommentReferenceRepairInput = {
+  references: readonly CommentReferenceOccurrence[];
+  markExtents: readonly CommentMarkExtent[];
+};
+/**
+ * The repairs that make a document total, as positions in the document they
+ * were read from. Deletions come first, last-first, so they apply in sequence
+ * without mapping; the insertions that follow still carry pre-repair positions
+ * and the applier maps them through the transaction.
+ */
+declare const planCommentReferenceRepairs: ({ references, markExtents }: CommentReferenceRepairInput) => readonly CommentReferenceRepair[];
+//#endregion
+export { CommentMarkExtent, CommentReferenceOccurrence, CommentReferenceRepair, planCommentReferenceRepairs };

package/dist/prosemirror/commentReferenceIntegrity.js

@@ -0,0 +1,43 @@
+//#region src/prosemirror/commentReferenceIntegrity.ts
+/**
+* The repairs that make a document total, as positions in the document they
+* were read from. Deletions come first, last-first, so they apply in sequence
+* without mapping; the insertions that follow still carry pre-repair positions
+* and the applier maps them through the transaction.
+*/
+const planCommentReferenceRepairs = ({ references, markExtents }) => {
+	const markedIds = new Set(markExtents.map(({ commentId }) => commentId));
+	const deletions = [];
+	const keptIds = /* @__PURE__ */ new Set();
+	for (const reference of references) {
+		if (reference.malformed || !markedIds.has(reference.commentId)) {
+			deletions.push({
+				type: "delete",
+				position: reference.position,
+				size: reference.size
+			});
+			continue;
+		}
+		if (keptIds.has(reference.commentId)) {
+			deletions.push({
+				type: "delete",
+				position: reference.position,
+				size: reference.size
+			});
+			continue;
+		}
+		keptIds.add(reference.commentId);
+	}
+	const insertions = [];
+	for (const { commentId, end } of markExtents) {
+		if (keptIds.has(commentId)) continue;
+		insertions.push({
+			type: "insert",
+			position: end,
+			commentId
+		});
+	}
+	return [...deletions.toSorted((first, second) => second.position - first.position), ...insertions.toSorted((first, second) => second.position - first.position)];
+};
+//#endregion
+export { planCommentReferenceRepairs };

package/dist/prosemirror/conversion/fromProseDoc.d.ts

@@ -3,16 +3,24 @@ import { TableAttrs, TableCellAttrs, TableRowAttrs } from "../schema/nodes.js";
 import { RunStyleResolver } from "../runStyleFormatting.js";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/conversion/fromProseDoc.d.ts
-/** Convert a ProseMirror document to the document model. */
-declare function fromProseDoc(pmDoc: Node, baseDocument?: document_d_exports.Document): document_d_exports.Document;
 /**
- * What a field carrying no stored result reports.
+ * Whether a record the editor did not change may come back from the base
+ * document by reference.
  *
- * `serializerFallback` writes the visible page number a save has always given a
- * result-less PAGE/NUMPAGES field; `authored` reports the result the document
- * actually holds, so a text read of a story reads the same loaded and unloaded.
+ * `"none"` rebuilds every record out of ProseMirror, which is what folio does
+ * today. `"matched"` is the merge against a matched base record; it is declared
+ * here because the measurement that tells the two apart has to exist before the
+ * merge does, and it panics until it is implemented. An accepted-but-inert
+ * value would let a caller believe it had asked for a merge and get a rebuild.
  */
-type EmptyFieldResultMode = "serializerFallback" | "authored";
+type ProjectionReuse = "none" | "matched";
+/** How the conversion treats records the editor did not change. */
+type FromProseDocOptions = {
+  /** Defaults to `"none"`, the only value implemented. */
+  reuse?: ProjectionReuse;
+};
+/** Convert a ProseMirror document to the document model. */
+declare function fromProseDoc(pmDoc: Node, baseDocument?: document_d_exports.Document, { reuse }?: FromProseDocOptions): document_d_exports.Document;
 /**
  * Convert ProseMirror marks to TextFormatting
  */
@@ -36,9 +44,6 @@ declare function tableCellAttrsToFormatting(attrs: TableCellAttrs): document_d_e
  * Preserves all non-content parts of the original document
  */
 declare function updateDocumentContent(originalDocument: document_d_exports.Document, pmDoc: Node): document_d_exports.Document;
-type ProseDocToBlocksOptions = {
-  emptyFieldResult?: EmptyFieldResultMode;
-};
 /**
  * Convert a ProseMirror document back to an array of `BlockContent` blocks
  * (paragraphs, tables, and block-level content controls).
@@ -46,6 +51,6 @@ type ProseDocToBlocksOptions = {
  * Used for converting edited header/footer PM content back to the document
  * model.
  */
-declare function proseDocToBlocks(pmDoc: Node, baseContent?: document_d_exports.BlockContent[], styles?: NonNullable<document_d_exports.Document["package"]>["styles"], options?: ProseDocToBlocksOptions): document_d_exports.BlockContent[];
+declare function proseDocToBlocks(pmDoc: Node, baseContent?: document_d_exports.BlockContent[], styles?: NonNullable<document_d_exports.Document["package"]>["styles"]): document_d_exports.BlockContent[];
 //#endregion
-export { EmptyFieldResultMode, ProseDocToBlocksOptions, fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, tableAttrsToFormatting, tableCellAttrsToFormatting, tableRowAttrsToFormatting, updateDocumentContent };
+export { FromProseDocOptions, ProjectionReuse, fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, tableAttrsToFormatting, tableCellAttrsToFormatting, tableRowAttrsToFormatting, updateDocumentContent };