@stll/folio-core 0.54.2 → 0.56.0

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
 /**
@@ -36,13 +37,15 @@ function renderParagraphBlock(ctx, pkg, para) {
 	const styleId = para.formatting?.styleId;
 	const headingLevel = markdownHeadingLevel(ctx, para);
 	if (headingLevel !== void 0) {
-		if (!inline) return {
+		ctx.listIndentWidths = [];
+		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
 		};
 	}
@@ -50,6 +53,7 @@ function renderParagraphBlock(ctx, pkg, para) {
 		markdown: renderListItem(ctx, para.listRendering, label, inline),
 		isListItem: true
 	};
+	ctx.listIndentWidths = [];
 	if (isQuoteStyle(styleId, ctx.builtInStyles)) return {
 		markdown: inline.split("\n").map((line) => `> ${line}`).join("\n"),
 		isListItem: false
@@ -86,21 +90,12 @@ function escapeLeadingBlockMarker(text) {
 	return text.replace(/^(?<ws>[ \t]*)(?<marker>[#>])/gmu, "$<ws>\\$<marker>").replace(/^(?<ws>[ \t]*)(?<marker>[-+*])(?<after>[ \t])/gmu, "$<ws>\\$<marker>$<after>").replace(/^(?<ws>[ \t]*)(?<num>\d{1,9})(?<marker>[.)])(?<after>[ \t])/gmu, "$<ws>$<num>\\$<marker>$<after>");
 }
 /**
-* A markdown list marker's width when no ancestor at that level has rendered
-* yet (e.g. a DOCX paragraph numbered at a level its list skipped over). Two
-* spaces is the old fixed-indent behaviour, kept as a fallback rather than a
-* guess of zero.
-*/
-const DEFAULT_LIST_INDENT_WIDTH = 2;
-/**
-* The indent a level's item needs: the combined marker width of every
-* shallower level's most recently rendered item (see
-* `RenderContext.listIndentWidths`), so a child sits inside its parent's
-* content column per CommonMark's list-nesting rule, not a fixed guess.
+* Only emitted Markdown ancestors contribute columns. OOXML levels may skip
+* ancestors or resume after prose; inventing those columns creates code blocks.
 */
 function listIndentWidth(ctx, level) {
 	let width = 0;
-	for (let ancestor = 0; ancestor < level; ancestor++) width += ctx.listIndentWidths[ancestor] ?? DEFAULT_LIST_INDENT_WIDTH;
+	for (let ancestor = 0; ancestor < level; ancestor++) width += ctx.listIndentWidths[ancestor] ?? 0;
 	return width;
 }
 /**
@@ -116,9 +111,12 @@ function listIndentWidth(ctx, level) {
 * a following, deeper item can indent correctly under it.
 */
 function renderListItem(ctx, list, label, inline) {
+	const nativeMarker = list.isBullet || /^\d{1,9}[.)]$/u.test(label);
+	if (!nativeMarker) ctx.listIndentWidths = [];
+	ctx.listIndentWidths.length = list.level;
 	const indent = " ".repeat(listIndentWidth(ctx, list.level));
 	const marker = list.isBullet ? "- " : `${label} `;
-	ctx.listIndentWidths[list.level] = marker.length;
+	if (nativeMarker) ctx.listIndentWidths[list.level] = marker.length;
 	return `${indent}${marker}${inline}`.trimEnd();
 }
 //#endregion

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,
@@ -91,8 +101,8 @@ const punctuationFor = (mark) => (ch) => {
 	if (mark !== "strike" && ch === "*") return false;
 	return /[\p{P}\p{S}]/u.test(ch);
 };
-/** One escape pair (`\*`) or one code point of escaped inline text. */
-const INLINE_UNIT = /\\[\s\S]|[\s\S]/gu;
+/** Escape pairs and generated note references are indivisible inline units. */
+const INLINE_UNIT = /\\[\s\S]|\[\^e?\d+\]|[\s\S]/gu;
 /**
 * Wrap `inner` in `mark` so a CommonMark reader reads it back. A delimiter
 * opens only before a character that is not blank, and before punctuation
@@ -213,6 +223,7 @@ function renderRunContent(ctx, pkg, content, paraId) {
 			if (ctx.opts.footnotes === "strip") break;
 			out += numberNoteReference(ctx, item.type === "endnoteRef" ? "endnote" : "footnote", item.id).marker;
 			break;
+		case "noteMarker": break;
 		case "drawing": {
 			const ref = resolveRelationshipIdOfType(pkg?.relationships, item.image.rId, RELATIONSHIP_TYPES.image);
 			const media = ref.status === "resolved" ? pkg?.media?.get(ref.relationship.target) : void 0;
@@ -249,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()
 	};
 }
@@ -345,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");
@@ -356,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) => {
@@ -418,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.
@@ -428,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 {
@@ -556,4 +576,4 @@ function applyCommentWrapping(ctx, slot, current) {
 	}, inner);
 }
 //#endregion
-export { renderParagraphInline };
+export { applyMarks, renderParagraphInline };

package/dist/markdown/renderTable.js

@@ -62,6 +62,7 @@ function renderGfmRow(ctx, pkg, row) {
 	return out;
 }
 function renderGfmCell(ctx, pkg, cell) {
+	ctx.listIndentWidths = [];
 	const blocks = [];
 	const renderBlocks = (content) => {
 		for (const item of content) switch (item.type) {
@@ -278,6 +279,7 @@ function renderHtmlRun(ctx, pkg, run, paraId) {
 			text += `<sup>[${token}]</sup>`;
 			break;
 		}
+		case "noteMarker": break;
 		default: break;
 	}
 	if (!text) return "";

package/dist/markdown/types.d.ts

@@ -141,15 +141,9 @@ type RenderContext = {
   /** The document's styles indexed by the built-in they are; classifies headings and quotes. */
   builtInStyles: BuiltInStyleIndex;
   /**
-   * The rendered width (marker text + one trailing space) of the most
-   * recently emitted list item at each level, indexed by `ListRendering.level`.
-   * A nested item's indent is the sum of every shallower level's width here,
-   * not a fixed two spaces: CommonMark only keeps a child nested under its
-   * parent when the child starts at or past the column where the parent's
-   * content begins, and a marker like `10. ` or `1. ` is wider than `- `.
-   * Document order visits a parent before its children, so by the time a
-   * level-N item renders, levels `0..N-1` already hold the current ancestor
-   * chain's widths.
+   * Active native Markdown ancestor marker widths, indexed by OOXML level.
+   * Missing levels contribute no columns. Prose, headings and container
+   * boundaries clear the chain; a shallower item truncates descendants.
    */
   listIndentWidths: number[];
 };

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,121 @@
+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: "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;
+  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 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;
+  }>;
+  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, withCanonicalStartParagraphFormatting };

package/dist/prosemirror/canonicalCommands.js

@@ -0,0 +1,35 @@
+import { canonicalSelectionRange } from "./canonicalSelectionRange.js";
+//#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",
+	...canonicalSelectionRange(state),
+	patch
+}];
+const canonicalParagraphFormatting = (state, patch) => {
+	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;
+};
+const withCanonicalParagraphFormatting = (command, patch) => withCanonicalCommand(command, (state) => canonicalParagraphFormatting(state, patch));
+/** Commands that read the selection start apply that same patch across selected paragraphs. */
+const withCanonicalStartParagraphFormatting = (command, patch) => withCanonicalCommand(command, (state) => {
+	const paragraph = state.selection.$from.parent;
+	if (paragraph.type.name !== "paragraph") return [];
+	return canonicalParagraphFormatting(state, patch(paragraph));
+});
+//#endregion
+export { canonicalRunFormatting, getCanonicalCommandIntents, withCanonicalCommand, withCanonicalParagraphFormatting, withCanonicalStartParagraphFormatting };

package/dist/prosemirror/canonicalSelectionRange.d.ts

@@ -0,0 +1,9 @@
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/canonicalSelectionRange.d.ts
+/** Whole-document selection addresses paragraph content rather than document edges. */
+declare const canonicalSelectionRange: ({ doc, selection }: EditorState) => {
+  from: number;
+  to: number;
+};
+//#endregion
+export { canonicalSelectionRange };

package/dist/prosemirror/canonicalSelectionRange.js

@@ -0,0 +1,15 @@
+import { AllSelection, Selection } from "prosemirror-state";
+//#region src/prosemirror/canonicalSelectionRange.ts
+/** Whole-document selection addresses paragraph content rather than document edges. */
+const canonicalSelectionRange = ({ doc, selection }) => {
+	if (selection instanceof AllSelection) return {
+		from: Selection.atStart(doc).from,
+		to: Selection.atEnd(doc).to
+	};
+	return {
+		from: selection.from,
+		to: selection.to
+	};
+};
+//#endregion
+export { canonicalSelectionRange };

package/dist/prosemirror/clipboardIntent.d.ts

@@ -0,0 +1,7 @@
+import { Slice } from "prosemirror-model";
+import { EditorView } from "prosemirror-view";
+//#region src/prosemirror/clipboardIntent.d.ts
+declare const registerClipboardIntentHandler: (view: EditorView, handler: (slice: Slice, plain: boolean) => boolean) => void;
+declare const dispatchClipboardIntent: (view: EditorView, slice: Slice) => boolean | undefined;
+//#endregion
+export { dispatchClipboardIntent, registerClipboardIntentHandler };

package/dist/prosemirror/clipboardIntent.js

@@ -0,0 +1,9 @@
+//#region src/prosemirror/clipboardIntent.ts
+/** Async clipboard reads resolve against the current owning session and selection. */
+const handlers = /* @__PURE__ */ new WeakMap();
+const registerClipboardIntentHandler = (view, handler) => {
+	handlers.set(view, handler);
+};
+const dispatchClipboardIntent = (view, slice) => handlers.get(view)?.(slice, true);
+//#endregion
+export { dispatchClipboardIntent, registerClipboardIntentHandler };