@stll/folio-core 0.55.0 → 0.57.0

package/dist/markdown/escape.js

@@ -30,8 +30,15 @@ function escapeInline(text) {
 * line.
 */
 function escapeTableCell(text) {
-	return text.replace(/\|/gu, "&#124;").replace(/\r?\n/gu, "<br>");
+	return inlineBreaksToHtml(text.replace(/\|/gu, "&#124;"));
 }
+/** Single-line Markdown blocks express inline breaks without their two-space syntax. */
+const inlineBreaksToHtml = (text) => text.split(/\r?\n/u).map((line, index, lines) => {
+	if (index === lines.length - 1) return line;
+	let end = line.length;
+	while (end > 0 && line.at(end - 1) === " ") end--;
+	return line.slice(0, end);
+}).join("<br>");
 /**
 * Hyperlink URLs in inline form need parens balanced; we URL-encode the
 * problematic characters rather than escape, so the link still resolves.
@@ -55,4 +62,4 @@ function escapeAltText(text) {
 	return text.replace(/(?<ch>[\\[\]])/gu, "\\$<ch>").replace(/\r?\n/gu, " ");
 }
 //#endregion
-export { escapeAltText, escapeInline, escapeLinkUrl, escapeTableCell };
+export { escapeAltText, escapeInline, escapeLinkUrl, escapeTableCell, inlineBreaksToHtml };

package/dist/markdown/renderBlock.js

@@ -1,6 +1,7 @@
 import { ALT_CHUNK_READER_DIAGNOSTIC, isAltChunkMarkup } from "../docx/altChunk.js";
 import { OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC, isOpaqueNestedRowMarkup, opaqueRevisionCarrierName } from "../docx/opaqueCarrier.js";
-import { cloneParagraphWithoutPropertySource } from "../docx/paragraphPropertySource.js";
+import { projectAcceptedBlocks } from "../internal/acceptedBlockProjection.js";
+import { pushWarning } from "./internals.js";
 import { renderParagraphBlock } from "./renderParagraph.js";
 import { renderTable } from "./renderTable.js";
 import { panic } from "better-result";
@@ -10,130 +11,14 @@ import { panic } from "better-result";
 * markdown for each block, suppressing redundant blank lines between list items
 * of the same list. Ported from eigenpal/docx-editor PR #595.
 */
-/**
-* In `trackedChanges: "clean"` mode every change is accepted, as the editor's
-* accept-all resolves the story (`internal/wholeStoryRevisionResolution.ts`).
-*
-* A paragraph whose mark is pending deletion loses its break on accept and
-* runs on into the paragraph after it, which is the paragraph left: its mark
-* ends the joined text, and a paragraph's properties (style, list) live on its
-* mark. A run of consecutive deletions collapses into that last paragraph.
-*
-* With a table right after it, its words run on into the table's first cell
-* and lead that cell's first paragraph (`prosemirror/tableRunIn.ts`), unless
-* it ends a section, keeps nothing once accepted, or that cell is pending.
-* Otherwise a paragraph that cannot join keeps its place, or goes when it
-* keeps nothing and something follows it.
-*/
-function mergeAcceptedParagraphBreaks(blocks) {
-	const reversed = [];
-	let survivor = null;
-	let tableFollows = false;
-	let followed = false;
-	const flush = () => {
-		if (survivor) reversed.push(survivor);
-		survivor = null;
-	};
-	for (let index = blocks.length - 1; index >= 0; index--) {
-		const block = blocks[index];
-		if (!block) continue;
-		if (block.type !== "paragraph") {
-			flush();
-			reversed.push(block);
-			tableFollows = block.type === "table";
-			followed ||= tableFollows;
-			continue;
-		}
-		const goes = block.pPrMark?.kind === "del" || block.pPrMark?.kind === "moveFrom";
-		if (goes && survivor) {
-			survivor = cloneParagraphWithoutPropertySource(survivor, { content: [...block.content, ...survivor.content] });
-			continue;
-		}
-		const table = reversed.at(-1);
-		if (goes && tableFollows && table?.type === "table") {
-			const ranIn = tableWithParagraphRunIn(table, block);
-			if (ranIn) {
-				reversed[reversed.length - 1] = ranIn;
-				continue;
-			}
-		}
-		flush();
-		tableFollows = false;
-		if (goes && holdsNothingOnAccept(block) && followed && index + reversed.length > 0) continue;
-		survivor = block;
-		followed = true;
-	}
-	flush();
-	return reversed.reverse();
-}
-/**
-* Whether the cell a paragraph's words would run into is itself pending (its
-* row or the cell, through nested tables' first cells), as
-* `prosemirror/tableRunIn.ts` reads it.
-*/
-const runInCellPending = (table) => {
-	const row = table.rows[0];
-	const cell = row?.cells[0];
-	if (!row || !cell) return false;
-	if (row.structuralChange !== void 0 || cell.structuralChange !== void 0) return true;
-	const first = cell.content[0];
-	return first?.type === "table" && runInCellPending(first);
-};
-/**
-* `table` with `paragraph`'s words leading its first cell's first paragraph,
-* descending into nested tables, or null when the paragraph keeps its place.
-*/
-const tableWithParagraphRunIn = (table, paragraph) => {
-	if (paragraph.sectionProperties !== void 0 || holdsNothingOnAccept(paragraph)) return null;
-	if (runInCellPending(table)) return null;
-	const runIn = (current) => {
-		const [row, ...rows] = current.rows;
-		const [cell, ...cells] = row?.cells ?? [];
-		const [first, ...rest] = cell?.content ?? [];
-		if (!row || !cell || !first) return null;
-		let led = null;
-		if (first.type === "paragraph") led = cloneParagraphWithoutPropertySource(first, { content: [...paragraph.content, ...first.content] });
-		else if (first.type === "table") led = runIn(first);
-		if (!led) return null;
-		return {
-			...current,
-			rows: [{
-				...row,
-				cells: [{
-					...cell,
-					content: [led, ...rest]
-				}, ...cells]
-			}, ...rows]
-		};
-	};
-	return runIn(table);
-};
-/** Paragraph content that shows nothing: range boundaries and anchors. */
-const ZERO_WIDTH_CONTENT = /* @__PURE__ */ new Set([
-	"bookmarkStart",
-	"bookmarkEnd",
-	"commentRangeStart",
-	"commentRangeEnd",
-	"commentReference",
-	"moveFromRangeStart",
-	"moveFromRangeEnd",
-	"moveToRangeStart",
-	"moveToRangeEnd"
-]);
-/** Whether an item shows nothing once every change is accepted. */
-const showsNothingOnAccept = (item) => {
-	if (item.type === "deletion" || item.type === "moveFrom" || ZERO_WIDTH_CONTENT.has(item.type)) return true;
-	if (item.type === "insertion" || item.type === "moveTo") return item.content.every(showsNothingOnAccept);
-	return item.type === "run" && item.content.every((content) => content.type === "renderedPageBreak");
-};
-/** Whether a paragraph keeps no visible content once every change is accepted. */
-const holdsNothingOnAccept = (paragraph) => paragraph.content.every(showsNothingOnAccept);
 function renderBlocks(ctx, pkg, blocks) {
 	const outerListIndentWidths = ctx.listIndentWidths;
 	ctx.listIndentWidths = [];
 	const out = [];
 	let prevWasListItem = false;
-	const ordered = ctx.opts.trackedChanges === "clean" ? mergeAcceptedParagraphBreaks(blocks) : blocks;
+	const projection = ctx.opts.trackedChanges === "clean" ? projectAcceptedBlocks(blocks, pkg) : null;
+	if (projection?.completeness === "partial") pushWarning(ctx, "Some tracked structural changes could not be resolved.");
+	const ordered = projection?.blocks ?? blocks;
 	for (const block of ordered) switch (block.type) {
 		case "paragraph": {
 			const { markdown: md, isListItem } = renderParagraphBlock(ctx, pkg, block);

package/dist/markdown/renderParagraph.js

@@ -1,5 +1,6 @@
 import { isQuoteStyle, resolveHeadingLevel } from "../docx/builtInStyles.js";
 import { listLabelAttrsFromRendering } from "../prosemirror/listLabels.js";
+import { inlineBreaksToHtml } from "./escape.js";
 import { renderParagraphInline } from "./renderRuns.js";
 //#region src/markdown/renderParagraph.ts
 /**
@@ -37,13 +38,14 @@ function renderParagraphBlock(ctx, pkg, para) {
 	const headingLevel = markdownHeadingLevel(ctx, para);
 	if (headingLevel !== void 0) {
 		ctx.listIndentWidths = [];
-		if (!inline) return {
+		if (!inline || !inline.trim() && label === void 0) return {
 			markdown: "",
 			isListItem: false
 		};
 		const hashes = "#".repeat(Math.min(MAX_MARKDOWN_HEADING_LEVEL, headingLevel + 1));
+		const headingInline = inlineBreaksToHtml(inline);
 		return {
-			markdown: label ? `${hashes} ${label} ${inline}` : `${hashes} ${inline}`,
+			markdown: label ? `${hashes} ${label} ${headingInline}` : `${hashes} ${headingInline}`,
 			isListItem: false
 		};
 	}

package/dist/markdown/renderRuns.d.ts

@@ -1,6 +1,12 @@
 import { document_d_exports } from "../types/document.js";
 import { RenderContext } from "./types.js";
 //#region src/markdown/renderRuns.d.ts
+/**
+ * Inline marks we recognize. Order matters: we open from outermost to innermost
+ * so the output reads cleanly (`***bold italic***`), not the reverse.
+ */
+type MarkKey = "bold" | "italic" | "code" | "strike";
+declare function applyMarks(text: string, marks: readonly MarkKey[]): string;
 /**
  * The character beside a run's delimiters: `""` at the paragraph's edge,
  * `undefined` when it cannot be told (read as a letter, the strictest case).
@@ -16,4 +22,4 @@ type RunNeighbors = {
  */
 declare function renderParagraphInline(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, content: readonly document_d_exports.ParagraphContent[], paraId: string | undefined, edges?: RunNeighbors): string;
 //#endregion
-export { renderParagraphInline };
+export { applyMarks, renderParagraphInline };

package/dist/markdown/renderRuns.js

@@ -40,22 +40,32 @@ function marksFor(run) {
 	if (ascii && MONOSPACE_FONTS.has(ascii)) out.push("code");
 	return out;
 }
+const splitEdgeWhitespace = (text) => {
+	const start = text.length - text.trimStart().length;
+	const end = text.trimEnd().length;
+	return {
+		leading: text.slice(0, start),
+		core: text.slice(start, Math.max(start, end)),
+		trailing: text.slice(Math.max(start, end))
+	};
+};
 function applyMarks(text, marks) {
-	if (!text) return text;
+	const { leading, core, trailing } = splitEdgeWhitespace(text);
+	if (!core || marks.length === 0) return text;
 	if (marks.includes("code")) {
-		const literal = text.replace(/\\(?<char>[\\`*[\]_<~])/gu, "$<char>");
+		const literal = core.replace(/\\(?<char>[\\`*[\]_<~])/gu, "$<char>");
 		let longestRun = 0;
 		for (const m of literal.matchAll(/`+/gu)) longestRun = Math.max(longestRun, m[0].length);
 		const fence = "`".repeat(longestRun + 1);
 		const pad = literal.startsWith("`") || literal.endsWith("`") ? " " : "";
-		return `${fence}${pad}${literal}${pad}${fence}`;
+		return `${leading}${fence}${pad}${literal}${pad}${fence}${trailing}`;
 	}
-	let out = text;
+	let out = core;
 	for (const m of marks) {
 		const d = MARK_DELIMS[m];
 		out = `${d}${out}${d}`;
 	}
-	return out;
+	return `${leading}${out}${trailing}`;
 }
 const UNKNOWN_NEIGHBORS = {
 	before: void 0,
@@ -250,11 +260,8 @@ function pieceOf(ctx, pkg, run, paraId) {
 		text: inner,
 		marks: new Set(marks)
 	};
-	const leadLen = inner.length - inner.trimStart().length;
-	const trailLen = inner.length - inner.trimEnd().length;
-	const core = inner.slice(leadLen, inner.length - trailLen);
 	return {
-		text: core ? `${inner.slice(0, leadLen)}${applyMarks(core, marks)}${inner.slice(inner.length - trailLen)}` : inner,
+		text: inner.split("\n").map((line) => applyMarks(line, marks)).join("\n"),
 		marks: /* @__PURE__ */ new Set()
 	};
 }
@@ -346,6 +353,8 @@ function renderHyperlink(ctx, pkg, link, paraId) {
 		after: "]"
 	} : UNKNOWN_NEIGHBORS);
 	if (!inner) return "";
+	const { leading, core, trailing } = splitEdgeWhitespace(inner);
+	if (!core) return inner;
 	const href = link.href ?? (link.anchor ? `#${link.anchor}` : "");
 	if (!href) {
 		pushWarning(ctx, "hyperlink missing href and anchor; rendered as plain text");
@@ -357,9 +366,9 @@ function renderHyperlink(ctx, pkg, link, paraId) {
 			href,
 			refNumber
 		});
-		return `[${inner}][${refNumber}]`;
+		return `${leading}[${core}][${refNumber}]${trailing}`;
 	}
-	return `[${inner}](${escapeLinkUrl(href)})`;
+	return `${leading}[${core}](${escapeLinkUrl(href)})${trailing}`;
 }
 function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 	const renderChild = (child) => {
@@ -419,6 +428,16 @@ function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 		default: return wrapMoveTo(ctx, wrapper.info, inner);
 	}
 }
+/** Clean revisions have no inline boundary; group their runs with surrounding runs. */
+const cleanRevisionContent = (content) => content.flatMap((item) => {
+	switch (item.type) {
+		case "insertion":
+		case "moveTo": return cleanRevisionContent(item.content);
+		case "deletion":
+		case "moveFrom": return [];
+		default: return [item];
+	}
+});
 /**
 * Render the full inline content of a paragraph, tracking comment-range
 * boundaries to apply the configured wrapper.
@@ -429,7 +448,7 @@ function renderParagraphInline(ctx, pkg, content, paraId, edges = {
 }) {
 	let out = "";
 	const openComments = [];
-	const items = content.filter((item) => !SILENT_MARKERS.has(item.type) && !(ctx.opts.comments === "strip" && COMMENT_MARKERS.has(item.type)));
+	const items = (ctx.opts.trackedChanges === "clean" ? cleanRevisionContent(content) : content).filter((item) => !SILENT_MARKERS.has(item.type) && !(ctx.opts.comments === "strip" && COMMENT_MARKERS.has(item.type)));
 	const around = (index) => {
 		const next = items[index + 1];
 		return {
@@ -471,17 +490,7 @@ function renderParagraphInline(ctx, pkg, content, paraId, edges = {
 			case "simpleField":
 			case "complexField": {
 				const runs = item.type === "simpleField" ? item.content : item.fieldResult;
-				for (const child of runs) {
-					if (child.type === "run") {
-						out += renderRuns(ctx, pkg, [child], paraId);
-						continue;
-					}
-					if (child.type === "hyperlink") {
-						out += renderHyperlink(ctx, pkg, child, paraId);
-						continue;
-					}
-					out += child.type === "inlineWrapper" ? renderParagraphInline(ctx, pkg, child.content, paraId, UNKNOWN_NEIGHBORS) : child.text;
-				}
+				for (const child of runs) out += child.type === "preservedInline" ? child.text : renderParagraphInline(ctx, pkg, [child], paraId, UNKNOWN_NEIGHBORS);
 				break;
 			}
 			case "inlineSdt":
@@ -557,4 +566,4 @@ function applyCommentWrapping(ctx, slot, current) {
 	}, inner);
 }
 //#endregion
-export { renderParagraphInline };
+export { applyMarks, renderParagraphInline };

package/dist/panel-layout.d.ts

@@ -5,17 +5,17 @@
  *
  * The editor measures the width it has once, and this module decides how
  * each panel is presented. Every track the page shares the row with is
- * counted here, so the page, the outline and the comments cannot overlap:
- * a panel either gets a track of its own or becomes a drawer the user opens
- * on purpose. A drawer takes no track.
+ * counted here, so the page, the outline and the comments cannot overlap.
+ * Explicitly opening the outline gives it a clamped track beside the viewport;
+ * comments keep their existing column-or-drawer behavior.
  *
  * Space goes to the page first, then the outline rail, then the comments
  * column, then the full outline column:
  *
  * - comments: a column when the page, the comments and the outline rail fit;
  *   otherwise a drawer.
- * - outline: a column when it fits beside the page and the comments column;
- *   otherwise a rail of heading ticks when that fits; otherwise a drawer.
+ * - outline: a column when it fits beside the page and comments; otherwise a
+ *   rail of heading ticks when that fits, or a toolbar toggle for the opened track.
  *
  * The tier names the result: `wide` when every panel has its full column,
  * `medium` when the outline is a rail, `narrow` when a panel is a drawer.
@@ -29,6 +29,8 @@ declare const PANEL_METRICS: {
   readonly outlineColumnWidth: 256;
   /** The outline rail in the `medium` tier, border included. */
   readonly outlineRailWidth: 32;
+  /** Minimum width and height of a shared panel control. */
+  readonly controlMinimumSize: 32;
   /** A comment card column. */
   readonly commentsWidth: 280;
   /** Space between the page edge and the comment cards, and after them. */
@@ -41,8 +43,8 @@ declare const PANEL_METRICS: {
 /** Width the comments take beside the page: gap, cards, gap. */
 declare const COMMENTS_TRACK_WIDTH: number;
 type PanelLayoutTier = "wide" | "medium" | "narrow";
-/** How the outline is shown: a column, a rail of ticks, a drawer, or not at all. */
-type OutlinePresentation = "none" | "column" | "rail" | "drawer";
+/** How the outline is shown: a column, tick rail, drawer, or explicitly opened track. */
+type OutlinePresentation = "none" | "column" | "rail" | "drawer" | "expanded";
 /** How the comments are shown: a column beside the page, a drawer, or not at all. */
 type CommentsPresentation = "hidden" | "column" | "drawer";
 type PanelLayoutInput = {
@@ -50,8 +52,8 @@ type PanelLayoutInput = {
   availableWidth: number;
   /** Width of the widest page at the current zoom. */
   pageWidth: number;
-  /** Whether the document has an outline to show. */
-  outline: "absent" | "available";
+  /** Whether the document outline is absent, available, or explicitly opened. */
+  outline: "absent" | "available" | "expanded";
   /** Whether the user (or the auto-open) wants the comments shown. */
   comments: "closed" | "open";
 };

package/dist/panel-layout.js

@@ -5,17 +5,17 @@
 *
 * The editor measures the width it has once, and this module decides how
 * each panel is presented. Every track the page shares the row with is
-* counted here, so the page, the outline and the comments cannot overlap:
-* a panel either gets a track of its own or becomes a drawer the user opens
-* on purpose. A drawer takes no track.
+* counted here, so the page, the outline and the comments cannot overlap.
+* Explicitly opening the outline gives it a clamped track beside the viewport;
+* comments keep their existing column-or-drawer behavior.
 *
 * Space goes to the page first, then the outline rail, then the comments
 * column, then the full outline column:
 *
 * - comments: a column when the page, the comments and the outline rail fit;
 *   otherwise a drawer.
-* - outline: a column when it fits beside the page and the comments column;
-*   otherwise a rail of heading ticks when that fits; otherwise a drawer.
+* - outline: a column when it fits beside the page and comments; otherwise a
+*   rail of heading ticks when that fits, or a toolbar toggle for the opened track.
 *
 * The tier names the result: `wide` when every panel has its full column,
 * `medium` when the outline is a rail, `narrow` when a panel is a drawer.
@@ -29,6 +29,8 @@ const PANEL_METRICS = {
 	outlineColumnWidth: 256,
 	/** The outline rail in the `medium` tier, border included. */
 	outlineRailWidth: 32,
+	/** Minimum width and height of a shared panel control. */
+	controlMinimumSize: 32,
 	/** A comment card column. */
 	commentsWidth: 280,
 	/** Space between the page edge and the comment cards, and after them. */
@@ -49,7 +51,7 @@ const pageTrackWidth = (pageWidth) => pageWidth + 2 * PANEL_METRICS.pageMargin;
 const panelLayoutThresholds = ({ pageWidth, outline, comments }) => {
 	const page = pageTrackWidth(pageWidth);
 	const commentsTrack = comments === "open" ? COMMENTS_TRACK_WIDTH : 0;
-	const hasOutline = outline === "available";
+	const hasOutline = outline !== "absent";
 	return {
 		wide: page + commentsTrack + (hasOutline ? PANEL_METRICS.outlineColumnWidth : 0),
 		medium: page + commentsTrack + (hasOutline ? PANEL_METRICS.outlineRailWidth : 0)
@@ -62,7 +64,7 @@ const OUTLINE_TRACK_WIDTH = {
 	drawer: 0
 };
 const tierFor = (outline, comments) => {
-	if (outline === "drawer" || comments === "drawer") return "narrow";
+	if (outline === "drawer" || outline === "expanded" || comments === "drawer") return "narrow";
 	if (outline === "rail") return "medium";
 	return "wide";
 };
@@ -73,11 +75,13 @@ const computePanelLayout = (input) => {
 	const page = pageTrackWidth(input.pageWidth);
 	const comments = (() => {
 		if (input.comments === "closed") return "hidden";
-		return availableWidth >= thresholds.medium ? "column" : "drawer";
+		const requiredWidth = input.outline === "expanded" ? thresholds.wide : thresholds.medium;
+		return availableWidth >= requiredWidth ? "column" : "drawer";
 	})();
 	const commentsGutter = comments === "column" ? COMMENTS_TRACK_WIDTH : 0;
 	const outline = (() => {
 		if (input.outline === "absent") return "none";
+		if (input.outline === "expanded") return "expanded";
 		const beside = page + commentsGutter;
 		if (availableWidth >= thresholds.wide) return "column";
 		if (availableWidth >= beside + PANEL_METRICS.outlineRailWidth) return "rail";
@@ -87,7 +91,7 @@ const computePanelLayout = (input) => {
 		tier: tierFor(outline, comments),
 		outline,
 		comments,
-		outlineTrackWidth: OUTLINE_TRACK_WIDTH[outline],
+		outlineTrackWidth: outline === "expanded" ? Math.min(PANEL_METRICS.outlineColumnWidth, Math.max(PANEL_METRICS.controlMinimumSize, (availableWidth - commentsGutter) / 2)) : OUTLINE_TRACK_WIDTH[outline],
 		commentsGutter,
 		thresholds
 	};

package/dist/prosemirror/addTrackedDeletionMark.d.ts

@@ -0,0 +1,18 @@
+import { Mark } from "prosemirror-model";
+import { Transform } from "prosemirror-transform";
+//#region src/prosemirror/addTrackedDeletionMark.d.ts
+type AddTrackedDeletionMarkOptions = {
+  tr: Transform;
+  from: number;
+  to: number;
+  mark: Mark;
+  insertionPolicy: "preserve-pending" | "retract-own";
+};
+/**
+ * Already deleted runs keep their revision identity and enclosing insertion path.
+ * An own insertion containing deleted descendants is marked rather than retracted:
+ * removing its carrier would also remove another pending revision.
+ */
+declare const addTrackedDeletionMark: ({ tr, from, to, mark, insertionPolicy }: AddTrackedDeletionMarkOptions) => void;
+//#endregion
+export { addTrackedDeletionMark };

package/dist/prosemirror/addTrackedDeletionMark.js

@@ -0,0 +1,87 @@
+import { expectTrackedChangeMarkAttrs } from "./attrs/index.js";
+import { trackedRevisionLayerOf } from "./trackedRevisionPath.js";
+import { canCarryTrackedRunMark } from "./trackedRunInlineAtoms.js";
+import { panic } from "better-result";
+//#region src/prosemirror/addTrackedDeletionMark.ts
+/**
+* Already deleted runs keep their revision identity and enclosing insertion path.
+* An own insertion containing deleted descendants is marked rather than retracted:
+* removing its carrier would also remove another pending revision.
+*/
+const addTrackedDeletionMark = ({ tr, from, to, mark, insertionPolicy }) => {
+	if (mark.type.name !== "deletion") panic("A tracked deletion requires a deletion mark");
+	const preservedDeletions = [];
+	const protectedCarriers = /* @__PURE__ */ new Set();
+	tr.doc.nodesBetween(from, to, (node, position) => {
+		const existing = node.marks.find(({ type }) => type.name === "deletion");
+		if (node.isInline && existing) {
+			const start = Math.max(from, position);
+			const end = Math.min(to, position + node.nodeSize);
+			if (start < end) preservedDeletions.push({
+				from: start,
+				to: end,
+				mark: existing
+			});
+			const at = tr.doc.resolve(position);
+			for (let depth = 1; depth <= at.depth; depth++) {
+				const ancestor = at.node(depth);
+				if (canCarryTrackedRunMark(ancestor)) protectedCarriers.add(ancestor);
+			}
+		}
+		return true;
+	});
+	const mapFrom = tr.mapping.maps.length;
+	const ranges = [];
+	const descendantDeletions = [];
+	const deletionFor = (node) => {
+		const insertion = node.marks.find(({ type }) => type.name === "insertion");
+		const ancestors = insertion ? expectTrackedChangeMarkAttrs(insertion)._docxRevisionAncestors : null;
+		return insertion && ancestors?.length ? mark.type.create({
+			...mark.attrs,
+			_docxRevisionAncestors: [...ancestors, trackedRevisionLayerOf(insertion, node)]
+		}) : mark;
+	};
+	tr.doc.nodesBetween(from, to, (node, position) => {
+		if (!canCarryTrackedRunMark(node)) return true;
+		if (node.marks.some(({ type }) => type.name === "deletion")) return false;
+		const start = Math.max(from, position);
+		const end = Math.min(to, position + node.nodeSize);
+		if (start >= end) return false;
+		const insertion = node.marks.find(({ type }) => type.name === "insertion");
+		const ownInsertion = insertion !== void 0 && insertion.attrs["author"] === mark.attrs["author"];
+		const deletion = deletionFor(node);
+		const disposition = insertionPolicy === "retract-own" && ownInsertion && !protectedCarriers.has(node) ? "retract" : "mark";
+		const previous = ranges.at(-1);
+		if (previous?.to === start && previous.disposition === disposition && previous.mark.eq(deletion)) previous.to = end;
+		else ranges.push({
+			from: start,
+			to: end,
+			mark: deletion,
+			disposition
+		});
+		if (disposition === "mark") node.descendants((child, offset) => {
+			if (child.marks.some(({ type }) => type.name === "deletion")) return false;
+			const childDeletion = deletionFor(child);
+			if (childDeletion === mark) return true;
+			const childStart = Math.max(from, position + 1 + offset);
+			const childEnd = Math.min(to, position + 1 + offset + child.nodeSize);
+			if (childStart < childEnd) descendantDeletions.push({
+				from: childStart,
+				to: childEnd,
+				mark: childDeletion
+			});
+			return true;
+		});
+		return false;
+	});
+	for (const range of ranges.toReversed()) if (range.disposition === "retract") tr.delete(range.from, range.to);
+	else tr.addMark(range.from, range.to, range.mark);
+	const mapping = tr.mapping.slice(mapFrom);
+	for (const preserved of [...descendantDeletions, ...preservedDeletions]) {
+		const start = mapping.map(preserved.from);
+		const end = mapping.map(preserved.to);
+		if (start < end) tr.addMark(start, end, preserved.mark);
+	}
+};
+//#endregion
+export { addTrackedDeletionMark };

package/dist/prosemirror/attrs/index.js

@@ -8,6 +8,7 @@ import { attrsRecord, attrsResult, expectAttrs, expectCachedNodeAttrs, expectNod
 import { COUNTER_FORMAT_VALUES, EMPHASIS_MARK_VALUES, FIELD_TYPE_VALUES, FONT_HINT_VALUES, FONT_THEME_VALUES, HIGHLIGHT_COLOR_VALUES, IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES, IMAGE_WRAP_TEXT_VALUES, IMAGE_WRAP_TYPE_VALUES, LINE_SPACING_RULE_VALUES, OUTLINE_STYLE_ATTR_VALUES, PARAGRAPH_ALIGNMENT_VALUES, POSITIONAL_TAB_ALIGNMENT_VALUES, POSITIONAL_TAB_LEADER_VALUES, POSITIONAL_TAB_RELATIVE_TO_VALUES, SDT_LOCK_VALUES, SDT_TYPE_VALUES, SHADING_PATTERN_VALUES, TABLE_CELL_VERTICAL_ALIGNMENT_VALUES, TABLE_JUSTIFICATION_VALUES, TABLE_ROW_HEIGHT_RULE_VALUES, TABLE_WIDTH_TYPE_VALUES, TAB_LEADER_VALUES, TAB_STOP_ALIGNMENT_VALUES, TEXT_DIRECTION_VALUES, TEXT_EFFECT_VALUES, UNDERLINE_STYLE_VALUES } from "../../types/documentEnumValues.js";
 import { canonicalJson } from "../../utils/canonicalJson.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
+import { isNoteReferenceOccurrenceId } from "../noteReferenceOccurrenceId.js";
 import { paragraphNumberingFromAttrValue } from "../numberingAttr.js";
 import { outlineLevelFromAttrValue } from "../outlineLevelAttr.js";
 import { isParagraphDirection } from "../paragraphDirection.js";
@@ -953,6 +954,10 @@ const readFootnoteRefMarkAttrs = (mark) => {
 	const issues = [];
 	expectMarkType(mark, "footnoteRef", issues);
 	requiredStringOrNumber(attrs, "id", "footnoteRef.attrs.id", issues);
+	if (!isNoteReferenceOccurrenceId(attrs["occurrenceId"])) issues.push({
+		path: "footnoteRef.attrs.occurrenceId",
+		message: "Expected a nonblank occurrence identity."
+	});
 	optionalOneOf(attrs, "noteType", "footnoteRef.attrs.noteType", issues, NOTE_TYPES);
 	optionalOneOf(attrs, "vertAlign", "footnoteRef.attrs.vertAlign", issues, NOTE_REF_VERT_ALIGNS);
 	optionalBoolean(attrs, "customMarkFollows", "footnoteRef.attrs.customMarkFollows", issues);

package/dist/prosemirror/canonicalCommands.d.ts

@@ -4,6 +4,28 @@ import { ParagraphPropsPatch, RunPropsPatch } from "@stll/docx-core/ops";
 //#region src/prosemirror/canonicalCommands.d.ts
 /** Command meaning before canonical positions are resolved by the session. */
 type CanonicalCommandIntent = {
+  type: "generateTOC";
+  at: number;
+  title: string;
+} | {
+  type: "setHyperlink";
+  from: number;
+  to: number;
+  href: string;
+  tooltip?: string;
+} | {
+  type: "removeHyperlink";
+  from: number;
+  to: number;
+  hyperlinkStyleId?: string;
+} | {
+  type: "insertHyperlink";
+  from: number;
+  to: number;
+  text: string;
+  href: string;
+  tooltip?: string;
+} | {
   type: "formatRun";
   from: number;
   to: number;
@@ -36,9 +58,6 @@ type CanonicalCommandDescriptor = (state: EditorState) => readonly CanonicalComm
 declare const withCanonicalCommand: (command: Command, descriptor: CanonicalCommandDescriptor) => Command;
 declare const getCanonicalCommandIntents: (command: Command, state: EditorState) => readonly CanonicalCommandIntent[] | undefined;
 declare const canonicalRunFormatting: (state: EditorState, patch: RunPropsPatch) => readonly [{
-  readonly type: "formatRun";
-  readonly from: number;
-  readonly to: number;
   readonly patch: import("@stll/docx-core/ops").FormattingPatch<{
     bold?: boolean | undefined;
     boldCs?: boolean | undefined;
@@ -91,7 +110,12 @@ declare const canonicalRunFormatting: (state: EditorState, patch: RunPropsPatch)
     styleId?: string | undefined;
     preserved?: import("@stll/docx-core/model").PreservedMarkup | undefined;
   }>;
+  readonly from: number;
+  readonly to: number;
+  readonly type: "formatRun";
 }];
 declare const withCanonicalParagraphFormatting: (command: Command, patch: ParagraphPropsPatch | ((paragraph: Node) => ParagraphPropsPatch)) => Command;
+/** Commands that read the selection start apply that same patch across selected paragraphs. */
+declare const withCanonicalStartParagraphFormatting: (command: Command, patch: (paragraph: Node) => ParagraphPropsPatch) => Command;
 //#endregion
-export { CanonicalCommandIntent, canonicalRunFormatting, getCanonicalCommandIntents, withCanonicalCommand, withCanonicalParagraphFormatting };
+export { CanonicalCommandIntent, canonicalRunFormatting, getCanonicalCommandIntents, withCanonicalCommand, withCanonicalParagraphFormatting, withCanonicalStartParagraphFormatting };