@stll/folio-core 0.54.1 → 0.55.0

package/dist/paged-layout/scrollToPmPosition.js

@@ -1,6 +1,7 @@
 import { findBodyPmAnchor, findBodyPmAnchors } from "../layout-bridge/dom/findBodyPmSpans.js";
 import { findPageShellForPmPos } from "../layout-painter/renderPage.js";
-import { isValidPmScrollPosition, prefersReducedMotionBehavior } from "./scrollNavigation.js";
+import { getEditorScrollRoot, scrollEditorElementIntoView } from "./editorScrollRoot.js";
+import { isValidPmScrollPosition } from "./scrollNavigation.js";
 //#region src/paged-layout/scrollToPmPosition.ts
 /** Class on the pages container `PagedEditor` paints into. */
 const PAGES_CONTAINER_CLASS = "paged-editor__pages";
@@ -9,10 +10,7 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 	if (!isValidPmScrollPosition(pmPos)) return;
 	const exact = findBodyPmAnchor(pageContainer, pmPos);
 	if (exact) {
-		exact.scrollIntoView({
-			behavior: prefersReducedMotionBehavior(),
-			block: "center"
-		});
+		scrollEditorElementIntoView(exact);
 		return;
 	}
 	let runMatch = null;
@@ -27,28 +25,19 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 		}
 	}
 	if (runMatch) {
-		runMatch.scrollIntoView({
-			behavior: prefersReducedMotionBehavior(),
-			block: "center"
-		});
+		scrollEditorElementIntoView(runMatch);
 		return;
 	}
 	const shellHit = findPageShellForPmPos(pageContainer, pmPos);
 	if (!shellHit) return;
 	const { element: shell } = shellHit;
-	shell.scrollIntoView({
-		behavior: prefersReducedMotionBehavior(),
-		block: "center"
-	});
+	scrollEditorElementIntoView(shell);
 	let attempts = 0;
 	const refine = () => {
 		attempts++;
 		const exactInShell = findBodyPmAnchor(shell, pmPos);
 		if (exactInShell) {
-			exactInShell.scrollIntoView({
-				behavior: prefersReducedMotionBehavior(),
-				block: "center"
-			});
+			scrollEditorElementIntoView(exactInShell);
 			return;
 		}
 		let bestEl = null;
@@ -68,10 +57,7 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 			}
 		}
 		if (bestEl) {
-			bestEl.scrollIntoView({
-				behavior: prefersReducedMotionBehavior(),
-				block: "center"
-			});
+			scrollEditorElementIntoView(bestEl);
 			return;
 		}
 		if (attempts < 20) requestAnimationFrame(refine);
@@ -86,7 +72,7 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 * callers can fall back to coordinate-based scrolling.
 */
 const scrollFolioPositionIntoView = (view, pmPos) => {
-	const pageContainer = view.dom.closest("[data-folio-scroll]")?.querySelector(`.paged-editor__pages`) ?? null;
+	const pageContainer = getEditorScrollRoot(view.dom)?.querySelector(`.paged-editor__pages`) ?? null;
 	if (!pageContainer) return false;
 	scrollPagesToPmPosition(pageContainer, pmPos);
 	return true;

package/dist/prosemirror/attrs/index.d.ts

@@ -1,19 +1,9 @@
 import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperLayer, LanguageAttrs, RunFormattingOverrideAttrs, RunIdentityMarkAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedRevisionAncestor, UnderlineAttrs } from "../schema/marks.js";
 import { BlockCustomXmlAttrs, BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, PreservedBlockAttrs, PreservedXmlAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "../schema/nodes.js";
 import "../schema/index.js";
+import { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult } from "../../internal/prosemirrorAttrBoundary.js";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/attrs/index.d.ts
-type ProseMirrorAttrIssue = {
-  readonly path: string;
-  readonly message: string;
-};
-type ReadProseMirrorAttrsResult<T> = {
-  ok: true;
-  value: T;
-} | {
-  ok: false;
-  issues: readonly ProseMirrorAttrIssue[];
-};
 declare const readParagraphAttrs: (node: Node) => ReadProseMirrorAttrsResult<Readonly<ParagraphAttrs>>;
 declare const expectParagraphAttrs: (node: Node) => Readonly<ParagraphAttrs>;
 declare const readHardBreakAttrs: (node: Node) => ReadProseMirrorAttrsResult<HardBreakAttrs>;
@@ -123,4 +113,4 @@ declare const mergeTableRowAttrs: (node: Node, patch: NodeAttrPatch<TableRowAttr
  */
 declare const mergeTableCellAttrs: (node: Node, patch: NodeAttrPatch<TableCellAttrs>) => TableCellAttrs;
 //#endregion
-export { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult, expectBlockCustomXmlAttrs, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, isValidEmptyFieldResultRuns, isValidFieldCode, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockCustomXmlAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };
+export { type ProseMirrorAttrIssue, type ReadProseMirrorAttrsResult, expectBlockCustomXmlAttrs, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, isValidEmptyFieldResultRuns, isValidFieldCode, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockCustomXmlAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };

package/dist/prosemirror/attrs/index.js

@@ -1,7 +1,10 @@
 import { isSerializablePreservedAttribute } from "../../docx/attributeRemainder.js";
 import { DRAWING_ANCHOR_FLAG_KEYS } from "../../docx/drawingAnchor.js";
+import { isFoldedListNumber } from "../../docx/foldedListNumberFields.js";
 import { GRAPHIC_FRAME_LOCK_KEYS } from "../../docx/graphicFrameLocks.js";
 import { allowsDirectDrawingEdit, isDrawingRawXmlMode } from "../../docx/imageRawXml.js";
+import { isParagraphMarkResolutionJoin, isResolutionJoins } from "../../docx/reviewResolutionProvenance.js";
+import { attrsRecord, attrsResult, expectAttrs, expectCachedNodeAttrs, expectNodeType, isRecord } from "../../internal/prosemirrorAttrBoundary.js";
 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";
@@ -10,7 +13,6 @@ import { outlineLevelFromAttrValue } from "../outlineLevelAttr.js";
 import { isParagraphDirection } from "../paragraphDirection.js";
 import { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS, RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_VALUE_PROPERTIES, TRACKED_CHANGE_PROVENANCE_VALUES } from "../schema/marks.js";
 import { PRESERVED_XML_LEVELS, TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES } from "../schema/nodes.js";
-import { panic } from "better-result";
 import { DRAWING_RAW_XML_MODES, THEME_COLORS, isOoxmlSymbolCharacter } from "@stll/docx-core/model";
 import { isSafePreservedChildXml, isWithinPreservedMarkupBudget } from "@stll/docx-core/schema";
 //#region src/prosemirror/attrs/index.ts
@@ -216,6 +218,11 @@ const readParagraphAttrsUncached = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
 	expectNodeType(node, "paragraph", issues);
+	const paragraphMark = attrs["pPrMark"];
+	if (isRecord(paragraphMark) && paragraphMark["resolutionJoin"] !== void 0 && !isParagraphMarkResolutionJoin(paragraphMark["resolutionJoin"])) issues.push({
+		path: "paragraph.attrs.pPrMark.resolutionJoin",
+		message: "Expected a non-negative bounded paragraph cut depth."
+	});
 	optionalString(attrs, "paraId", "paragraph.attrs.paraId", issues);
 	optionalString(attrs, "_docxParagraphSourceToken", "paragraph.attrs._docxParagraphSourceToken", issues);
 	optionalString(attrs, "textId", "paragraph.attrs.textId", issues);
@@ -243,6 +250,7 @@ const readParagraphAttrsUncached = (node) => {
 	optionalBoolean(attrs, "listIsLegal", "paragraph.attrs.listIsLegal", issues);
 	optionalString(attrs, "listMarker", "paragraph.attrs.listMarker", issues);
 	optionalString(attrs, "listMarkerTemplate", "paragraph.attrs.listMarkerTemplate", issues);
+	optionalString(attrs, "listFoldedMarkerSuffix", "paragraph.attrs.listFoldedMarkerSuffix", issues);
 	optionalBoolean(attrs, "listMarkerHidden", "paragraph.attrs.listMarkerHidden", issues);
 	optionalTextFormatting(attrs, "listMarkerFormatting", "paragraph.attrs.listMarkerFormatting", issues);
 	optionalOneOf(attrs, "listMarkerAlignment", "paragraph.attrs.listMarkerAlignment", issues, [
@@ -362,6 +370,11 @@ const readPreservedXmlAttrs = (node) => {
 	expectNodeType(node, "preservedXml", issues);
 	requiredString(attrs, "xml", "preservedXml.attrs.xml", issues);
 	requiredString(attrs, "text", "preservedXml.attrs.text", issues);
+	const folded = attrs["foldedListNumber"];
+	if (folded !== void 0 && folded !== null && !isFoldedListNumber(folded)) issues.push({
+		path: "preservedXml.attrs.foldedListNumber",
+		message: "Expected a folded list-number field or tab."
+	});
 	if (!PRESERVED_XML_LEVEL_VALUES.has(attrs["level"])) issues.push({
 		path: "preservedXml.attrs.level",
 		message: `Expected one of ${[...PRESERVED_XML_LEVEL_VALUES].join(", ")}.`
@@ -580,6 +593,7 @@ const isFieldCodeContent = (value) => {
 		case "symbol": return typeof value["font"] === "string" && typeof value["char"] === "string";
 		case "footnoteRef":
 		case "endnoteRef": return typeof value["id"] === "number";
+		case "noteMarker": return value["kind"] === "footnote" || value["kind"] === "endnote";
 		case "drawing": return isRecord(value["image"]);
 		case "shape": return isRecord(value["shape"]);
 		case "tab":
@@ -953,7 +967,7 @@ const readCommentMarkAttrs = (mark) => {
 	return attrsResult(attrs, issues);
 };
 const expectCommentMarkAttrs = (mark) => expectCachedMarkAttrs(mark, commentAttrsCache, readCommentMarkAttrs, "comment attrs");
-const isTrackedRevisionAncestorArray = (value) => Array.isArray(value) && value.length > 0 && value.every((ancestor) => isRecord(ancestor) && TRACKED_REVISION_ANCESTOR_TYPES.some((type) => type === ancestor["type"]) && typeof ancestor["revisionId"] === "number" && Number.isSafeInteger(ancestor["revisionId"]) && ancestor["revisionId"] >= 0 && typeof ancestor["author"] === "string" && (ancestor["date"] === void 0 || typeof ancestor["date"] === "string") && (ancestor["utcDate"] === void 0 || typeof ancestor["utcDate"] === "string") && (ancestor["initials"] === void 0 || typeof ancestor["initials"] === "string") && typeof ancestor["outerWrapperCount"] === "number" && Number.isSafeInteger(ancestor["outerWrapperCount"]) && ancestor["outerWrapperCount"] >= 0);
+const isTrackedRevisionAncestorArray = (value) => Array.isArray(value) && value.length > 0 && value.every((ancestor) => isRecord(ancestor) && TRACKED_REVISION_ANCESTOR_TYPES.some((type) => type === ancestor["type"]) && typeof ancestor["revisionId"] === "number" && Number.isSafeInteger(ancestor["revisionId"]) && ancestor["revisionId"] >= 0 && typeof ancestor["author"] === "string" && (ancestor["date"] === void 0 || typeof ancestor["date"] === "string") && (ancestor["utcDate"] === void 0 || typeof ancestor["utcDate"] === "string") && (ancestor["initials"] === void 0 || typeof ancestor["initials"] === "string") && typeof ancestor["outerWrapperCount"] === "number" && Number.isSafeInteger(ancestor["outerWrapperCount"]) && ancestor["outerWrapperCount"] >= 0 && (ancestor["resolutionJoins"] === void 0 || isResolutionJoins(ancestor["resolutionJoins"])));
 const readTrackedChangeMarkAttrs = (mark) => {
 	const attrs = attrsRecord(mark.attrs);
 	const issues = [];
@@ -969,6 +983,11 @@ const readTrackedChangeMarkAttrs = (mark) => {
 		message: "Expected a non-negative safe integer."
 	});
 	const ancestors = attrs["_docxRevisionAncestors"];
+	const resolutionJoins = attrs["_docxResolutionJoins"];
+	if (resolutionJoins !== void 0 && resolutionJoins !== null && !isResolutionJoins(resolutionJoins)) issues.push({
+		path: `${mark.type.name}.attrs._docxResolutionJoins`,
+		message: "Expected valid tracked-resolution provenance."
+	});
 	if (ancestors !== void 0 && ancestors !== null && !isTrackedRevisionAncestorArray(ancestors)) issues.push({
 		path: `${mark.type.name}.attrs._docxRevisionAncestors`,
 		message: "Expected a non-empty array of valid revision ancestors."
@@ -1310,46 +1329,6 @@ const mergeTableCellAttrs = (node, patch) => {
 		}
 	};
 };
-const attrsRecord = (attrs) => {
-	if (isRecord(attrs)) return attrs;
-	return {};
-};
-const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-const attrsResult = (attrs, issues) => {
-	if (issues.length > 0) return {
-		ok: false,
-		issues
-	};
-	let normalizedAttrs;
-	return {
-		ok: true,
-		get value() {
-			if (normalizedAttrs !== void 0) return normalizedAttrs;
-			const presentAttrs = {};
-			for (const key in attrs) {
-				if (!Object.hasOwn(attrs, key)) continue;
-				const value = attrs[key];
-				if (value !== null) presentAttrs[key] = value;
-			}
-			normalizedAttrs = presentAttrs;
-			return normalizedAttrs;
-		},
-		set value(value) {
-			normalizedAttrs = value;
-		}
-	};
-};
-const expectAttrs = (result, label) => {
-	if (result.ok) return result.value;
-	panic(`Invalid ProseMirror ${label}:\n${result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n")}`);
-};
-function expectCachedNodeAttrs(node, cache, reader, label) {
-	const cached = cache.get(node);
-	if (cached) return cached;
-	const value = expectAttrs(reader(node), label);
-	cache.set(node, value);
-	return value;
-}
 function expectCachedMarkAttrs(mark, cache, reader, label) {
 	const cached = cache.get(mark);
 	if (cached) return cached;
@@ -1357,12 +1336,6 @@ function expectCachedMarkAttrs(mark, cache, reader, label) {
 	cache.set(mark, value);
 	return value;
 }
-const expectNodeType = (node, expected, issues) => {
-	if (node.type.name !== expected) issues.push({
-		path: "node.type.name",
-		message: `Expected ${expected}, got ${node.type.name}.`
-	});
-};
 const expectNodeTypeOneOf = (node, expected, issues) => {
 	if (!expected.includes(node.type.name)) issues.push({
 		path: "node.type.name",
@@ -2408,6 +2381,7 @@ const validateParagraphFormatting = (value, path, issues) => {
 	optionalOneOf(value, "listNumFmt", `${path}.listNumFmt`, issues, COUNTER_FORMAT_VALUES);
 	optionalString(value, "listMarker", `${path}.listMarker`, issues);
 	optionalString(value, "listMarkerTemplate", `${path}.listMarkerTemplate`, issues);
+	optionalString(value, "listFoldedMarkerSuffix", `${path}.listFoldedMarkerSuffix`, issues);
 	optionalTextFormatting(value, "listMarkerFormatting", `${path}.listMarkerFormatting`, issues);
 	optionalOneOf(value, "listMarkerAlignment", `${path}.listMarkerAlignment`, issues, [
 		"left",

package/dist/prosemirror/bookmarkBoundaryAttrs.d.ts

@@ -1,6 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 import { BookmarkBoundaryAttrs } from "./schema/nodes.js";
-import { ReadProseMirrorAttrsResult } from "./attrs/index.js";
+import { ReadProseMirrorAttrsResult } from "../internal/prosemirrorAttrBoundary.js";
+import "./attrs/index.js";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/bookmarkBoundaryAttrs.d.ts
 declare const isDisplacedByCustomXml: (value: unknown) => value is document_d_exports.DisplacedByCustomXml;

package/dist/prosemirror/canonicalCommands.d.ts

@@ -0,0 +1,97 @@
+import { Node } from "prosemirror-model";
+import { Command, EditorState } from "prosemirror-state";
+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: "formatRun";
+  from: number;
+  to: number;
+  patch: RunPropsPatch;
+} | {
+  type: "formatParagraph";
+  at: number;
+  patch: ParagraphPropsPatch;
+} | {
+  type: "toggleList";
+  kind: "bullet" | "decimal";
+} | {
+  type: "changeListLevel";
+  direction: "increase" | "decrease";
+} | {
+  type: "removeList";
+} | {
+  type: "restartNumbering";
+  start?: number;
+} | {
+  type: "continueNumbering";
+} | {
+  type: "insertBreak";
+  from: number;
+  to: number;
+  breakType: "page" | "textWrapping";
+};
+type CanonicalCommandDescriptor = (state: EditorState) => readonly CanonicalCommandIntent[];
+/** Registration leaves execution and side-effect-free command probes unchanged. */
+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;
+    italic?: boolean | undefined;
+    italicCs?: boolean | undefined;
+    underline?: {
+      style: import("@stll/docx-core/model").UnderlineStyle;
+      color?: import("@stll/docx-core/model").ColorValue;
+    } | undefined;
+    strike?: boolean | undefined;
+    doubleStrike?: boolean | undefined;
+    vertAlign?: "baseline" | "superscript" | "subscript" | undefined;
+    smallCaps?: boolean | undefined;
+    allCaps?: boolean | undefined;
+    hidden?: boolean | undefined;
+    noProof?: boolean | undefined;
+    color?: import("@stll/docx-core/model").ColorValue | undefined;
+    highlight?: "black" | "blue" | "cyan" | "darkBlue" | "darkCyan" | "darkGray" | "darkGreen" | "darkMagenta" | "darkRed" | "darkYellow" | "green" | "lightGray" | "magenta" | "none" | "red" | "white" | "yellow" | undefined;
+    shading?: import("@stll/docx-core/model").ShadingProperties | undefined;
+    fontSize?: number | undefined;
+    fontSizeCs?: number | undefined;
+    fontFamily?: {
+      ascii?: string;
+      hAnsi?: string;
+      eastAsia?: string;
+      cs?: string;
+      hint?: "default" | "eastAsia" | "cs";
+      asciiTheme?: "majorAscii" | "majorHAnsi" | "majorEastAsia" | "majorBidi" | "minorAscii" | "minorHAnsi" | "minorEastAsia" | "minorBidi";
+      hAnsiTheme?: string;
+      eastAsiaTheme?: string;
+      csTheme?: string;
+    } | undefined;
+    language?: {
+      val?: string;
+      eastAsia?: string;
+      bidi?: string;
+    } | undefined;
+    spacing?: number | undefined;
+    position?: number | undefined;
+    scale?: number | undefined;
+    kerning?: number | undefined;
+    effect?: import("@stll/docx-core/model").TextEffect | undefined;
+    emphasisMark?: import("@stll/docx-core/model").EmphasisMark | undefined;
+    emboss?: boolean | undefined;
+    imprint?: boolean | undefined;
+    outline?: boolean | undefined;
+    shadow?: boolean | undefined;
+    rtl?: boolean | undefined;
+    cs?: boolean | undefined;
+    styleId?: string | undefined;
+    preserved?: import("@stll/docx-core/model").PreservedMarkup | undefined;
+  }>;
+}];
+declare const withCanonicalParagraphFormatting: (command: Command, patch: ParagraphPropsPatch | ((paragraph: Node) => ParagraphPropsPatch)) => Command;
+//#endregion
+export { CanonicalCommandIntent, canonicalRunFormatting, getCanonicalCommandIntents, withCanonicalCommand, withCanonicalParagraphFormatting };

package/dist/prosemirror/canonicalCommands.js

@@ -0,0 +1,28 @@
+//#region src/prosemirror/canonicalCommands.ts
+const descriptors = /* @__PURE__ */ new WeakMap();
+/** Registration leaves execution and side-effect-free command probes unchanged. */
+const withCanonicalCommand = (command, descriptor) => {
+	descriptors.set(command, descriptor);
+	return command;
+};
+const getCanonicalCommandIntents = (command, state) => descriptors.get(command)?.(state);
+const canonicalRunFormatting = (state, patch) => [{
+	type: "formatRun",
+	from: state.selection.from,
+	to: state.selection.to,
+	patch
+}];
+const withCanonicalParagraphFormatting = (command, patch) => withCanonicalCommand(command, (state) => {
+	const intents = [];
+	state.doc.nodesBetween(state.selection.from, state.selection.to, (node, position) => {
+		if (node.type.name !== "paragraph") return;
+		intents.push({
+			type: "formatParagraph",
+			at: position + 1,
+			patch: typeof patch === "function" ? patch(node) : patch
+		});
+	});
+	return intents;
+});
+//#endregion
+export { canonicalRunFormatting, getCanonicalCommandIntents, withCanonicalCommand, withCanonicalParagraphFormatting };

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

@@ -0,0 +1,6 @@
+import { Command } from "prosemirror-state";
+//#region src/prosemirror/commands/clearParagraphIndent.d.ts
+/** Clear indentation at paragraph start before Backspace joins paragraphs. */
+declare const clearIndentOnBackspace: Command;
+//#endregion
+export { clearIndentOnBackspace };

package/dist/prosemirror/commands/clearParagraphIndent.js

@@ -0,0 +1,25 @@
+import { expectParagraphAttrs } from "../attrs/index.js";
+import { TextSelection } from "prosemirror-state";
+//#region src/prosemirror/commands/clearParagraphIndent.ts
+/** Clear indentation at paragraph start before Backspace joins paragraphs. */
+const clearIndentOnBackspace = (state, dispatch) => {
+	if (!(state.selection instanceof TextSelection)) return false;
+	const { $cursor } = state.selection;
+	if (!$cursor || $cursor.parentOffset !== 0 || $cursor.parent.type.name !== "paragraph") return false;
+	const attrs = expectParagraphAttrs($cursor.parent);
+	const hasFirstLine = typeof attrs.indentFirstLine === "number" && attrs.indentFirstLine > 0;
+	const hasIndentLeft = typeof attrs.indentLeft === "number" && attrs.indentLeft > 0;
+	if (!hasFirstLine && !attrs.hangingIndent && !hasIndentLeft) return false;
+	if (dispatch) {
+		const position = $cursor.before();
+		dispatch(state.tr.setNodeMarkup(position, void 0, {
+			...attrs,
+			indentFirstLine: null,
+			hangingIndent: null,
+			indentLeft: null
+		}).scrollIntoView());
+	}
+	return true;
+};
+//#endregion
+export { clearIndentOnBackspace };

package/dist/prosemirror/commands/pageBreak.js

@@ -1,3 +1,4 @@
+import { withCanonicalCommand } from "../canonicalCommands.js";
 import { pageBreakRunParagraphProjectionDisposition } from "../pageBreakRunProjection.js";
 //#region src/prosemirror/commands/pageBreak.ts
 const UNSUPPORTED_PAGE_BREAK_RUN_ANCESTORS = /* @__PURE__ */ new Set([
@@ -23,7 +24,7 @@ const hasTextBoxAnchorAtOrAfter = (paragraph, contentStart, position) => {
 * position among neighbouring run content. Block-level `pageBreak` remains a
 * legacy input boundary and is never emitted by this command.
 */
-const insertPageBreak = (state, dispatch) => {
+const insertPageBreakCommand = (state, dispatch) => {
 	const { schema } = state;
 	const pageBreakRunType = schema.nodes["pageBreakRun"];
 	const { $from } = state.selection;
@@ -36,5 +37,18 @@ const insertPageBreak = (state, dispatch) => {
 	}
 	return true;
 };
+/**
+* Insert a page-break run at the current text cursor.
+*
+* Keeping the atom inline preserves its authored run, revision marks, and exact
+* position among neighbouring run content. Block-level `pageBreak` remains a
+* legacy input boundary and is never emitted by this command.
+*/
+const insertPageBreak = withCanonicalCommand(insertPageBreakCommand, (state) => insertPageBreakCommand(state) ? [{
+	type: "insertBreak",
+	from: state.selection.from,
+	to: state.selection.to,
+	breakType: "page"
+}] : []);
 //#endregion
 export { insertPageBreak };

package/dist/prosemirror/commentIdAllocator.d.ts

@@ -3,30 +3,23 @@ import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/commentIdAllocator.d.ts
 /** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
 declare const PENDING_COMMENT_ID = -1;
+declare const CommentIdSpaceExhaustedError_base: import("better-result").TaggedErrorClass<"CommentIdSpaceExhaustedError">;
+declare class CommentIdSpaceExhaustedError extends CommentIdSpaceExhaustedError_base<{
+  message: string;
+}> {}
+/** Allocate a valid, unused comment ID in this realm. */
+declare function allocateCommentId(): number;
+/** Reserve a loaded ID and advance past it when the upper bound permits. */
+declare function seedCommentIdAbove(id: number): void;
 type CommentIdAllocator = {
-  /** Allocate the next ID and advance the counter. */
+  /** Allocate the next unused ID. */
   next(): number;
-  /**
-   * On document load, bump the counter above the highest ID found in the
-   * loaded comments and tracked-change marks so subsequent allocations don't
-   * collide with already-present IDs.
-   */
-  seedAbove(maxId: number): void;
+  /** Reserve a loaded ID and seed above it when possible. */
+  seedAbove(id: number): void;
 };
-/**
- * Create an instance-scoped monotonic comment/revision ID allocator. IDs are
- * never reused (deleting a comment does not free its ID), and the counter is
- * private to this allocator — multiple editors get independent ID spaces.
- */
+/** Every handle uses the same counter, including separate editor instances. */
 declare function createCommentIdAllocator(): CommentIdAllocator;
-/**
- * Seed an allocator above every comment/revision ID currently in the document
- * — comment objects (including replies, which carry no mark) plus
- * tracked-change `revisionId` marks. Because `seedAbove` only ever raises the
- * counter, this is safe to call on load (React) or before each allocation
- * (Vue): new IDs never collide with or reuse an existing one, and the comment
- * and revision ID spaces stay unified.
- */
-declare function seedCommentAllocator(allocator: CommentIdAllocator, comments: Comment[] | undefined, view: EditorView | null): void;
+/** Seed from comments, replies, and the document's conservative annotation maximum. */
+declare function seedCommentAllocator(allocator: CommentIdAllocator, comments: Comment[] | undefined, view: Pick<EditorView, "state"> | null): void;
 //#endregion
-export { CommentIdAllocator, PENDING_COMMENT_ID, createCommentIdAllocator, seedCommentAllocator };
+export { CommentIdAllocator, CommentIdSpaceExhaustedError, PENDING_COMMENT_ID, allocateCommentId, createCommentIdAllocator, seedCommentAllocator, seedCommentIdAbove };

package/dist/prosemirror/commentIdAllocator.js

@@ -1,40 +1,65 @@
 import { maxAnnotationIdInDoc, seedRevisionIdsAbove } from "./plugins/revisionIds.js";
+import { readRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
+import { TaggedError } from "better-result";
 import { MAX_REVISION_ID } from "@stll/docx-core/model";
 //#region src/prosemirror/commentIdAllocator.ts
-/** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
-const PENDING_COMMENT_ID = -1;
 /**
-* Create an instance-scoped monotonic comment/revision ID allocator. IDs are
-* never reused (deleting a comment does not free its ID), and the counter is
-* private to this allocator — multiple editors get independent ID spaces.
+* Realm-wide comment ID allocation, shared by live editors and headless reviewers.
+* Loaded and issued IDs stay reserved even when a comment is deleted.
 */
+/** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
+const PENDING_COMMENT_ID = -1;
+var CommentIdSpaceExhaustedError = class extends TaggedError("CommentIdSpaceExhaustedError") {};
+let nextId = 1;
+const reservedIds = /* @__PURE__ */ new Set();
+/** Allocate a valid, unused comment ID in this realm. */
+function allocateCommentId() {
+	if (reservedIds.size >= MAX_REVISION_ID) throw new CommentIdSpaceExhaustedError({ message: "The OOXML comment ID space is exhausted." });
+	while (reservedIds.has(nextId)) nextId = nextId === MAX_REVISION_ID ? 1 : nextId + 1;
+	const id = nextId;
+	reservedIds.add(id);
+	nextId = id === MAX_REVISION_ID ? 1 : id + 1;
+	return id;
+}
+/** Reserve a loaded ID and advance past it when the upper bound permits. */
+function seedCommentIdAbove(id) {
+	if (!Number.isInteger(id) || id < 0 || id > MAX_REVISION_ID) return;
+	if (id > 0) reservedIds.add(id);
+	if (id >= nextId) nextId = id === MAX_REVISION_ID ? 1 : id + 1;
+}
+/** Every handle uses the same counter, including separate editor instances. */
 function createCommentIdAllocator() {
-	let nextId = 1;
 	return {
-		next: () => {
-			if (nextId > MAX_REVISION_ID) nextId = 1;
-			return nextId++;
-		},
-		seedAbove(maxId) {
-			if (!Number.isInteger(maxId) || maxId < 0 || maxId >= MAX_REVISION_ID) return;
-			if (maxId >= nextId) nextId = maxId + 1;
-		}
+		next: allocateCommentId,
+		seedAbove: seedCommentIdAbove
 	};
 }
-/**
-* Seed an allocator above every comment/revision ID currently in the document
-* — comment objects (including replies, which carry no mark) plus
-* tracked-change `revisionId` marks. Because `seedAbove` only ever raises the
-* counter, this is safe to call on load (React) or before each allocation
-* (Vue): new IDs never collide with or reuse an existing one, and the comment
-* and revision ID spaces stay unified.
-*/
+/** Seed from comments, replies, and the document's conservative annotation maximum. */
 function seedCommentAllocator(allocator, comments, view) {
 	let max = 0;
-	for (const comment of comments ?? []) if (Number.isInteger(comment.id) && comment.id > max && comment.id <= MAX_REVISION_ID) max = comment.id;
-	if (view) max = Math.max(max, maxAnnotationIdInDoc(view.state.doc));
+	for (const comment of comments ?? []) {
+		allocator.seedAbove(comment.id);
+		if (Number.isInteger(comment.id) && comment.id > max && comment.id <= MAX_REVISION_ID) max = comment.id;
+	}
+	if (view) {
+		view.state.doc.descendants((node) => {
+			for (const mark of node.marks) {
+				const id = mark.attrs["commentId"];
+				if (typeof id === "number") allocator.seedAbove(id);
+			}
+			if (node.type.name === "commentReference") {
+				const id = node.attrs["commentId"];
+				if (typeof id === "number") allocator.seedAbove(id);
+			}
+			if (node.type.name === "rangeAnchor") {
+				const attrs = readRangeAnchorAttrs(node);
+				if (attrs.ok && attrs.value.start.type === "commentRangeStart") allocator.seedAbove(attrs.value.start.id);
+			}
+		});
+		max = Math.max(max, maxAnnotationIdInDoc(view.state.doc));
+	}
 	allocator.seedAbove(max);
 	seedRevisionIdsAbove(max);
 }
 //#endregion
-export { PENDING_COMMENT_ID, createCommentIdAllocator, seedCommentAllocator };
+export { CommentIdSpaceExhaustedError, PENDING_COMMENT_ID, allocateCommentId, createCommentIdAllocator, seedCommentAllocator, seedCommentIdAbove };

package/dist/prosemirror/commentReferenceAttrs.d.ts

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