@stll/folio-core 0.55.0 → 0.56.0

package/dist/docx/tableParser.js

@@ -1406,33 +1406,6 @@ function isCellHorizontallyMerged(cell) {
 	return (cell.formatting?.gridSpan ?? 1) > 1;
 }
 /**
-* Get the plain text content of a table
-*
-* @param table - The table to extract text from
-* @returns Plain text content
-*/
-function getTableText(table) {
-	const rows = [];
-	for (const row of table.rows) {
-		const cells = [];
-		for (const cell of row.cells) {
-			const cellText = cell.content.filter((c) => c.type === "paragraph").map((p) => getParagraphText(p)).join("\n");
-			cells.push(cellText);
-		}
-		rows.push(cells.join("	"));
-	}
-	return rows.join("\n");
-}
-/**
-* Helper to get paragraph text (simplified)
-*/
-function getParagraphText(para) {
-	return para.content.filter((c) => "content" in c).flatMap((run) => {
-		if (!("content" in run) || !Array.isArray(run.content)) return [];
-		return run.content.filter((c) => typeof c === "object" && c !== null && "type" in c && c.type === "text" && "text" in c).map((c) => c.text);
-	}).join("");
-}
-/**
 * Check if table has header row
 *
 * @param table - The table to check
@@ -1461,4 +1434,4 @@ function isFloatingTable(table) {
 	return table.formatting?.floating !== void 0;
 }
 //#endregion
-export { CELL_CONTENT_HANDLERS, MAX_TABLE_COLUMNS, ROW_CONTENT_HANDLERS, TABLE_CONTENT_HANDLERS, getHeaderRows, getTableColumnCount, getTableRowCount, getTableText, hasHeaderRow, isCellHorizontallyMerged, isCellMergeContinuation, isCellMergeStart, isFloatingTable, isTableCellMergeRevisionContinuation, isTableCellMergeRevisionValue, parseCellMargins, parseConditionalFormatStyle, parseFloatingTableProperties, parseTable, parseTableBorders, parseTableCell, parseTableCellProperties, parseTableGrid, parseTableLook, parseTableMeasurement, parseTableProperties, parseTablePropertyExceptions, parseTableRow, parseTableRowProperties };
+export { CELL_CONTENT_HANDLERS, MAX_TABLE_COLUMNS, ROW_CONTENT_HANDLERS, TABLE_CONTENT_HANDLERS, getHeaderRows, getTableColumnCount, getTableRowCount, hasHeaderRow, isCellHorizontallyMerged, isCellMergeContinuation, isCellMergeStart, isFloatingTable, isTableCellMergeRevisionContinuation, isTableCellMergeRevisionValue, parseCellMargins, parseConditionalFormatStyle, parseFloatingTableProperties, parseTable, parseTableBorders, parseTableCell, parseTableCellProperties, parseTableGrid, parseTableLook, parseTableMeasurement, parseTableProperties, parseTablePropertyExceptions, parseTableRow, parseTableRowProperties };

package/dist/docx/textBoxParser.d.ts

@@ -103,10 +103,6 @@ declare function hasTextBoxOutline(textBox: document_d_exports.TextBox): boolean
  * Check if text box has content
  */
 declare function hasTextBoxContent(textBox: document_d_exports.TextBox): boolean;
-/**
- * Get plain text from text box (helper for search/indexing)
- */
-declare function getTextBoxText(textBox: document_d_exports.TextBox): string;
 /**
  * Resolve fill color to CSS color string
  */
@@ -151,4 +147,4 @@ type ScanRunForTextBoxDrawingsOptions = {
 };
 declare const scanRunForTextBoxDrawings: ({ xmlRun, claimedByRunParser }: ScanRunForTextBoxDrawingsOptions) => TextBoxRunScan;
 //#endregion
-export { ParagraphParserFn, ScanRunForTextBoxDrawingsOptions, TableParserFn, TextBoxDrawing, TextBoxRunScan, extractTextBoxContentElements, getTextBoxContentElement, getTextBoxDimensionsPx, getTextBoxHeightPx, getTextBoxMarginsPx, getTextBoxOutlineWidthPx, getTextBoxText, getTextBoxWidthPx, hasTextBoxContent, hasTextBoxFill, hasTextBoxOutline, isFloatingTextBox, isShapeTextBox, isTextBoxDrawing, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, resolveTextBoxFillColor, resolveTextBoxOutlineColor, scanRunForTextBoxDrawings };
+export { ParagraphParserFn, ScanRunForTextBoxDrawingsOptions, TableParserFn, TextBoxDrawing, TextBoxRunScan, extractTextBoxContentElements, getTextBoxContentElement, getTextBoxDimensionsPx, getTextBoxHeightPx, getTextBoxMarginsPx, getTextBoxOutlineWidthPx, getTextBoxWidthPx, hasTextBoxContent, hasTextBoxFill, hasTextBoxOutline, isFloatingTextBox, isShapeTextBox, isTextBoxDrawing, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, resolveTextBoxFillColor, resolveTextBoxOutlineColor, scanRunForTextBoxDrawings };

package/dist/docx/textBoxParser.js

@@ -285,25 +285,6 @@ function hasTextBoxContent(textBox) {
 	return textBox.content.length > 0;
 }
 /**
-* Get plain text from text box (helper for search/indexing)
-*/
-function getTextBoxText(textBox) {
-	return textBox.content.map(getTextBoxBlockText).join("\n");
-}
-const getTextBoxBlockText = (block) => {
-	if (block.type === "paragraph") {
-		const runTexts = [];
-		for (const item of block.content) {
-			if (item.type !== "run") continue;
-			for (const content of item.content) if (content.type === "text") runTexts.push(content.text);
-		}
-		return runTexts.join("");
-	}
-	if (block.type === "table") return block.rows.map((row) => row.cells.map((cell) => cell.content.map(getTextBoxBlockText).join("\n")).join("	")).join("\n");
-	if (block.type !== "blockSdt" && block.type !== "blockCustomXml") return "";
-	return block.content.map(getTextBoxBlockText).join("\n");
-};
-/**
 * Resolve fill color to CSS color string
 */
 function resolveTextBoxFillColor(textBox) {
@@ -380,4 +361,4 @@ const scanRunForTextBoxDrawings = ({ xmlRun, claimedByRunParser }) => {
 	};
 };
 //#endregion
-export { extractTextBoxContentElements, getTextBoxContentElement, getTextBoxDimensionsPx, getTextBoxHeightPx, getTextBoxMarginsPx, getTextBoxOutlineWidthPx, getTextBoxText, getTextBoxWidthPx, hasTextBoxContent, hasTextBoxFill, hasTextBoxOutline, isFloatingTextBox, isShapeTextBox, isTextBoxDrawing, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, resolveTextBoxFillColor, resolveTextBoxOutlineColor, scanRunForTextBoxDrawings };
+export { extractTextBoxContentElements, getTextBoxContentElement, getTextBoxDimensionsPx, getTextBoxHeightPx, getTextBoxMarginsPx, getTextBoxOutlineWidthPx, getTextBoxWidthPx, hasTextBoxContent, hasTextBoxFill, hasTextBoxOutline, isFloatingTextBox, isShapeTextBox, isTextBoxDrawing, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, resolveTextBoxFillColor, resolveTextBoxOutlineColor, scanRunForTextBoxDrawings };

package/dist/docx/unzip.js

@@ -5,6 +5,7 @@ import { openDocxBuffer } from "./encryption/openEncryptedDocx.js";
 import { RASTER_MIME_TYPES, detectRasterMimeType } from "./rasterMime.js";
 import { decodeXmlBytes } from "./xmlEncoding.js";
 import { FOLIO_XML_RESOURCE_LIMITS, assertXmlResourceLimits, createXmlPackageBudget } from "./xmlResourceLimits.js";
+import { writeZipPart } from "@stll/docx-core/zip";
 import JSZip from "jszip";
 //#region src/docx/unzip.ts
 /**
@@ -282,7 +283,11 @@ const replaceRawDocxXmlParts = async (content, parts) => {
 			lowerPath: path.toLowerCase(),
 			content: xmlContent
 		});
-		content.originalZip.file(path, xmlContent);
+		writeZipPart({
+			zip: content.originalZip,
+			path,
+			data: xmlContent
+		});
 		identitiesChanged = true;
 	}
 	if (identitiesChanged) content.originalBuffer = await content.originalZip.generateAsync({

package/dist/internal/acceptedBlockProjection.d.ts

@@ -0,0 +1,12 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/internal/acceptedBlockProjection.d.ts
+/**
+ * Read a model story through the same structural resolver as Accept All and
+ * the editor's No Markup view. The authored model is never changed.
+ */
+declare const projectAcceptedBlocks: (blocks: readonly document_d_exports.BlockContent[], pkg: document_d_exports.DocxPackage | undefined) => {
+  blocks: readonly document_d_exports.BlockContent[];
+  completeness: string;
+} | null;
+//#endregion
+export { projectAcceptedBlocks };

package/dist/internal/acceptedBlockProjection.js

@@ -0,0 +1,45 @@
+import { getCachedNumberingMap } from "../docx/numberingParser.js";
+import { proseDocToBlocks } from "../prosemirror/conversion/fromProseDoc.js";
+import { headerFooterToProseDoc } from "../prosemirror/conversion/toProseDoc.js";
+import { createStyleEngine } from "../style-engine/styleEngine.js";
+import { resolveWholeStory } from "./wholeStoryRevisionResolution.js";
+import { panic } from "better-result";
+//#region src/internal/acceptedBlockProjection.ts
+/** Inline revisions alone are already handled by the Markdown run renderer. */
+const hasBlockRevision = (blocks) => blocks.some((block) => {
+	switch (block.type) {
+		case "paragraph": return block.pPrMark !== void 0;
+		case "table": return block.rows.some((row) => row.structuralChange !== void 0 || row.cells.some((cell) => cell.structuralChange !== void 0 || hasBlockRevision(cell.content)));
+		case "blockSdt":
+		case "blockCustomXml": return hasBlockRevision(block.content);
+		case "preservedBlock":
+		case "bookmarkStart":
+		case "bookmarkEnd": return false;
+		default: return panic("Unsupported block in accepted projection", { unsupported: block });
+	}
+});
+/**
+* Read a model story through the same structural resolver as Accept All and
+* the editor's No Markup view. The authored model is never changed.
+*/
+const projectAcceptedBlocks = (blocks, pkg) => {
+	if (!hasBlockRevision(blocks)) return null;
+	const options = {
+		...pkg?.styles !== void 0 && { styles: pkg.styles },
+		...pkg?.theme !== void 0 && { theme: pkg.theme },
+		...pkg?.numbering !== void 0 && { numbering: pkg.numbering }
+	};
+	const doc = headerFooterToProseDoc([...blocks], options);
+	const result = resolveWholeStory({
+		doc,
+		mode: "accept",
+		styleResolver: createStyleEngine(pkg?.styles),
+		numbering: pkg?.numbering ? getCachedNumberingMap(pkg.numbering) : null
+	});
+	return {
+		blocks: result.resolved.eq(doc) ? blocks : proseDocToBlocks(result.resolved, [...blocks], pkg?.styles),
+		completeness: result.failed ? "partial" : "complete"
+	};
+};
+//#endregion
+export { projectAcceptedBlocks };

package/dist/managers/DocumentLoaderManager.js

@@ -2,6 +2,7 @@ import { prepareCanonicalDocxInput } from "../docx/canonicalSessionInput.js";
 import { inspectDocxCompatibility } from "../docx/compatibility.js";
 import { parseDocx } from "../docx/parser.js";
 import { recordDocumentLoadPhase } from "../layout-engine/layoutInstrumentation.js";
+import { CANONICAL_GAP, usesCanonicalSession } from "../types/canonicalCapabilities.js";
 import { resetAuthorColors } from "../utils/authorColors.js";
 import { loadFontsWithMapping } from "../utils/fontLoader.js";
 //#region src/managers/DocumentLoaderManager.ts
@@ -62,7 +63,7 @@ var DocumentLoaderManager = class {
 			let doc;
 			try {
 				let input = buffer;
-				if (this.callbacks.getExperimentalSession?.() === "canonical") {
+				if (usesCanonicalSession(this.callbacks.getExperimentalSession?.(), CANONICAL_GAP.authorityRouting)) {
 					const prepared = await prepareCanonicalDocxInput(buffer);
 					if (prepared.isErr()) throw prepared.error;
 					input = prepared.value;

package/dist/markdown/escape.d.ts

@@ -25,6 +25,8 @@ declare function escapeInline(text: string): string;
  * line.
  */
 declare function escapeTableCell(text: string): string;
+/** Single-line Markdown blocks express inline breaks without their two-space syntax. */
+declare const inlineBreaksToHtml: (text: string) => string;
 declare function escapeLinkUrl(url: string): string;
 /**
  * Alt text inside `![alt](url)`. Raw (un-escaped) text, so escape the backslash
@@ -33,4 +35,4 @@ declare function escapeLinkUrl(url: string): string;
  */
 declare function escapeAltText(text: string): string;
 //#endregion
-export { escapeAltText, escapeInline, escapeLinkUrl, escapeTableCell };
+export { escapeAltText, escapeInline, escapeLinkUrl, escapeTableCell, inlineBreaksToHtml };

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 {
@@ -557,4 +576,4 @@ function applyCommentWrapping(ctx, slot, current) {
 	}, inner);
 }
 //#endregion
-export { renderParagraphInline };
+export { applyMarks, renderParagraphInline };

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 };

package/dist/prosemirror/canonicalCommands.js

@@ -1,3 +1,4 @@
+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. */
@@ -8,11 +9,10 @@ const withCanonicalCommand = (command, descriptor) => {
 const getCanonicalCommandIntents = (command, state) => descriptors.get(command)?.(state);
 const canonicalRunFormatting = (state, patch) => [{
 	type: "formatRun",
-	from: state.selection.from,
-	to: state.selection.to,
+	...canonicalSelectionRange(state),
 	patch
 }];
-const withCanonicalParagraphFormatting = (command, patch) => withCanonicalCommand(command, (state) => {
+const canonicalParagraphFormatting = (state, patch) => {
 	const intents = [];
 	state.doc.nodesBetween(state.selection.from, state.selection.to, (node, position) => {
 		if (node.type.name !== "paragraph") return;
@@ -23,6 +23,13 @@ const withCanonicalParagraphFormatting = (command, patch) => withCanonicalComman
 		});
 	});
 	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 };
+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 };