@stll/folio-core 0.11.0 → 0.13.0

package/dist/layout-engine/measure/measureProvider.js

@@ -1,3 +1,4 @@
+import { toPaintedText } from "./textMeasurementPolicy.js";
 import { panic } from "better-result";
 //#region src/layout-engine/measure/measureProvider.ts
 /**
@@ -28,8 +29,8 @@ const resetMeasureProvider = () => {
 	activeMeasureProvider = throwingMeasureProvider;
 };
 const getFontMetrics = (style) => activeMeasureProvider.getFontMetrics(style);
-const measureTextWidth = (text, style) => activeMeasureProvider.measureTextWidth(text, style);
-const measureText = (text, style) => activeMeasureProvider.measureText(text, style);
-const measureRun = (text, style) => activeMeasureProvider.measureRun(text, style);
+const measureTextWidth = (text, style) => activeMeasureProvider.measureTextWidth(toPaintedText(text), style);
+const measureText = (text, style) => activeMeasureProvider.measureText(toPaintedText(text), style);
+const measureRun = (text, style) => activeMeasureProvider.measureRun(toPaintedText(text), style);
 //#endregion
 export { getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider };

package/dist/layout-engine/measure/tableCellFlow.js

@@ -1,6 +1,6 @@
 import { measuredLineRangeHeight } from "../lineFlow.js";
 import { isFloatingTextBoxBlock } from "../types.js";
-import { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph } from "../paragraphSpacing.js";
+import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph } from "../paragraphSpacing.js";
 //#region src/layout-engine/measure/tableCellFlow.ts
 const createTableCellFlowState = () => ({
 	height: 0,
@@ -57,7 +57,10 @@ const placeTableCellBlock = (state, block, measure) => {
 	}
 	const spacing = paragraphSpacing(block, measure);
 	const empty = isEmptyParagraph(block);
-	const leadingSpacing = empty && state.previousParagraphWasEmpty ? spacing.before + state.trailingSpacing : Math.max(spacing.before, state.trailingSpacing);
+	const leadingSpacing = empty && state.previousParagraphWasEmpty ? spacing.before + state.trailingSpacing : collapseParagraphSpacing({
+		before: spacing.before,
+		after: state.trailingSpacing
+	});
 	const contentTop = top + leadingSpacing;
 	state.height = contentTop + contentHeight;
 	state.previousParagraphWasEmpty = empty;

package/dist/layout-engine/measure/textBoxParagraphLayout.d.ts

@@ -1,18 +1,20 @@
-import { ParagraphBlock, ParagraphMeasure } from "../types.js";
+import { ParagraphBlock, ParagraphMeasure, TableBlock, TableMeasure } from "../types.js";
 
 //#region src/layout-engine/measure/textBoxParagraphLayout.d.ts
-type TextBoxParagraphPlacement = {
+type TextBoxContentPlacement = {
   leadingSpacing: number;
   contentHeight: number;
 };
-type TextBoxParagraphLayout = {
-  placements: TextBoxParagraphPlacement[];
+type TextBoxContentLayout = {
+  placements: TextBoxContentPlacement[];
   totalHeight: number;
 };
+type TextBoxContentBlock = ParagraphBlock | TableBlock;
+type TextBoxContentMeasure = ParagraphMeasure | TableMeasure;
 /**
- * Lay out a text box's paragraph story as one unpaginated flow. Adjacent
+ * Lay out a text box's block story as one unpaginated flow. Adjacent paragraph
  * before/after spacing collapses to the larger value, matching body flow.
  */
-declare function layoutTextBoxParagraphs(blocks: readonly ParagraphBlock[], measures: readonly ParagraphMeasure[]): TextBoxParagraphLayout;
+declare function layoutTextBoxContent(blocks: readonly TextBoxContentBlock[], measures: readonly TextBoxContentMeasure[]): TextBoxContentLayout;
 //#endregion
-export { TextBoxParagraphLayout, TextBoxParagraphPlacement, layoutTextBoxParagraphs };
+export { TextBoxContentLayout, TextBoxContentPlacement, layoutTextBoxContent };

package/dist/layout-engine/measure/textBoxParagraphLayout.js

@@ -1,20 +1,36 @@
 import { measuredLineRangeHeight } from "../lineFlow.js";
-import { getParagraphSpacingAfter, getParagraphSpacingBefore } from "../paragraphSpacing.js";
+import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore } from "../paragraphSpacing.js";
 import { panic } from "better-result";
 //#region src/layout-engine/measure/textBoxParagraphLayout.ts
 /**
-* Lay out a text box's paragraph story as one unpaginated flow. Adjacent
+* Lay out a text box's block story as one unpaginated flow. Adjacent paragraph
 * before/after spacing collapses to the larger value, matching body flow.
 */
-function layoutTextBoxParagraphs(blocks, measures) {
-	if (blocks.length !== measures.length) panic("layoutTextBoxParagraphs: block and measure counts must match");
+function layoutTextBoxContent(blocks, measures) {
+	if (blocks.length !== measures.length) panic("layoutTextBoxContent: block and measure counts must match");
 	const placements = [];
 	let totalHeight = 0;
 	let trailingSpacing = 0;
 	for (let index = 0; index < blocks.length; index += 1) {
 		const block = blocks[index];
 		const measure = measures[index];
-		const leadingSpacing = Math.max(getParagraphSpacingBefore(block), trailingSpacing);
+		if (block.kind === "table") {
+			if (measure.kind !== "table") panic("layoutTextBoxContent: block and measure kinds must match");
+			const leadingSpacing = trailingSpacing;
+			const contentHeight = measure.totalHeight;
+			placements.push({
+				leadingSpacing,
+				contentHeight
+			});
+			totalHeight += leadingSpacing + contentHeight;
+			trailingSpacing = 0;
+			continue;
+		}
+		if (measure.kind !== "paragraph") panic("layoutTextBoxContent: block and measure kinds must match");
+		const leadingSpacing = collapseParagraphSpacing({
+			before: getParagraphSpacingBefore(block),
+			after: trailingSpacing
+		});
 		const contentHeight = measuredLineRangeHeight(measure.lines, 0, measure.lines.length);
 		placements.push({
 			leadingSpacing,
@@ -29,4 +45,4 @@ function layoutTextBoxParagraphs(blocks, measures) {
 	};
 }
 //#endregion
-export { layoutTextBoxParagraphs };
+export { layoutTextBoxContent };

package/dist/layout-engine/measure/textMeasurementPolicy.d.ts

@@ -14,5 +14,7 @@ declare function getRunFontKerningMode(run: RunKerningInput, fallbackFontSize: n
 declare function getFontKerningMode(style: Pick<FontStyle, "kerning">): FontKerningMode;
 /** Count ordinary ASCII spaces that justification may compress. */
 declare function countCompressibleSpaces(text: string): number;
+/** Paint OOXML no-break hyphens with the ordinary hyphen glyph. */
+declare function toPaintedText(text: string): string;
 //#endregion
-export { FONT_KERNING_MODE, FontKerningMode, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode };
+export { FONT_KERNING_MODE, FontKerningMode, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode, toPaintedText };

package/dist/layout-engine/measure/textMeasurementPolicy.js

@@ -3,6 +3,8 @@ const FONT_KERNING_MODE = {
 	enabled: "normal",
 	disabled: "none"
 };
+const NO_BREAK_HYPHEN = "‑";
+const PAINTED_HYPHEN = "-";
 /** Resolve an authored kerning threshold against the effective run size. */
 function getRunFontKerningMode(run, fallbackFontSize) {
 	const threshold = run.kerningMinPt;
@@ -20,5 +22,9 @@ function countCompressibleSpaces(text) {
 	for (const char of text) if (char === " ") count += 1;
 	return count;
 }
+/** Paint OOXML no-break hyphens with the ordinary hyphen glyph. */
+function toPaintedText(text) {
+	return text.replaceAll(NO_BREAK_HYPHEN, PAINTED_HYPHEN);
+}
 //#endregion
-export { FONT_KERNING_MODE, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode };
+export { FONT_KERNING_MODE, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode, toPaintedText };

package/dist/layout-engine/paginator.js

@@ -1,4 +1,5 @@
 import { FOOTNOTE_SEPARATOR_HEIGHT } from "./types.js";
+import { collapseParagraphSpacing } from "./paragraphSpacing.js";
 import { panic } from "better-result";
 //#region src/layout-engine/paginator.ts
 /**
@@ -178,7 +179,10 @@ function createPaginator(options) {
 	function addFragment(fragment, height, spaceBefore = 0, spaceAfter = 0) {
 		const initialState = getCurrentState();
 		const initialColumnIndex = initialState.columnIndex;
-		const effectiveSpaceBefore = Math.max(spaceBefore, initialState.trailingSpacing);
+		const effectiveSpaceBefore = collapseParagraphSpacing({
+			before: spaceBefore,
+			after: initialState.trailingSpacing
+		});
 		const state = ensureFits(effectiveSpaceBefore + height);
 		const actualSpaceBefore = state === initialState && state.columnIndex === initialColumnIndex ? effectiveSpaceBefore : spaceBefore;
 		const x = getColumnX(state.columnIndex);

package/dist/layout-engine/paragraphSpacing.d.ts

@@ -1,17 +1,41 @@
-import { ParagraphBlock } from "./types.js";
+import { FlowBlock, ParagraphBlock } from "./types.js";
 
 //#region src/layout-engine/paragraphSpacing.d.ts
+type EffectiveParagraphSpacing = Readonly<{
+  before: number;
+  after: number;
+}>;
+type CollapseParagraphSpacingOptions = {
+  before: number;
+  after: number;
+};
+/** Collapse adjacent paragraph spacing to the larger authored side. */
+declare const collapseParagraphSpacing: ({
+  before,
+  after
+}: CollapseParagraphSpacingOptions) => number;
 /** Whether a paragraph has no visible run content. */
 declare function isEmptyParagraph(block: ParagraphBlock): boolean;
 /**
  * Resolve leading paragraph spacing after applying the empty-paragraph
  * inherited-spacing collapse rule.
  */
-declare function getParagraphSpacingBefore(block: ParagraphBlock): number;
+declare const getParagraphSpacingBefore: (block: ParagraphBlock) => number;
 /**
  * Resolve trailing paragraph spacing after applying the empty-paragraph
  * inherited-spacing collapse rule.
  */
-declare function getParagraphSpacingAfter(block: ParagraphBlock): number;
+declare const getParagraphSpacingAfter: (block: ParagraphBlock) => number;
+/** Resolve empty-paragraph spacing without modifying the authored block. */
+declare const resolveEffectiveParagraphSpacing: (block: ParagraphBlock) => EffectiveParagraphSpacing;
+/**
+ * Derive sequence-level spacing suppression with structural sharing.
+ *
+ * Contextual and automatic list spacing affect layout values, not authored
+ * OOXML formatting. Only changed branches are cloned; the input tree remains
+ * untouched and repeated resolution is idempotent.
+ */
+declare const resolveEffectiveParagraphSpacingTree: (blocks: FlowBlock[]) => FlowBlock[];
+declare const paragraphsShareStyle: (previous: ParagraphBlock, current: ParagraphBlock) => boolean;
 //#endregion
-export { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph };
+export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };

package/dist/layout-engine/paragraphSpacing.js

@@ -1,4 +1,7 @@
+import { continuesNumberedSequence } from "./paragraphSequence.js";
 //#region src/layout-engine/paragraphSpacing.ts
+/** Collapse adjacent paragraph spacing to the larger authored side. */
+const collapseParagraphSpacing = ({ before, after }) => Math.max(before, after);
 /** Whether a paragraph has no visible run content. */
 function isEmptyParagraph(block) {
 	if (block.runs.length === 0) return true;
@@ -10,21 +13,112 @@ function isEmptyParagraph(block) {
 * Resolve leading paragraph spacing after applying the empty-paragraph
 * inherited-spacing collapse rule.
 */
-function getParagraphSpacingBefore(block) {
-	const value = block.attrs?.spacing?.before ?? 0;
-	if (value === 0) return 0;
-	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.hasDirectParagraphFormatting && !block.attrs?.hasDirectParagraphMarkFormatting && !block.attrs?.spacingExplicit?.before) return 0;
-	return value;
-}
+const getParagraphSpacingBefore = (block) => resolveEffectiveParagraphSpacing(block).before;
 /**
 * Resolve trailing paragraph spacing after applying the empty-paragraph
 * inherited-spacing collapse rule.
 */
-function getParagraphSpacingAfter(block) {
-	const value = block.attrs?.spacing?.after ?? 0;
-	if (value === 0) return 0;
-	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.hasDirectParagraphFormatting && !block.attrs?.hasDirectParagraphMarkFormatting && !block.attrs?.spacingExplicit?.after) return 0;
-	return value;
-}
+const getParagraphSpacingAfter = (block) => resolveEffectiveParagraphSpacing(block).after;
+/** Resolve empty-paragraph spacing without modifying the authored block. */
+const resolveEffectiveParagraphSpacing = (block) => {
+	const before = block.attrs?.spacing?.before ?? 0;
+	const after = block.attrs?.spacing?.after ?? 0;
+	if (!isEmptyParagraph(block) || preservesInheritedEmptySpacing(block)) return {
+		before,
+		after
+	};
+	return {
+		before: block.attrs?.spacingExplicit?.before ? before : 0,
+		after: block.attrs?.spacingExplicit?.after ? after : 0
+	};
+};
+/**
+* Derive sequence-level spacing suppression with structural sharing.
+*
+* Contextual and automatic list spacing affect layout values, not authored
+* OOXML formatting. Only changed branches are cloned; the input tree remains
+* untouched and repeated resolution is idempotent.
+*/
+const resolveEffectiveParagraphSpacingTree = (blocks) => {
+	let changed = false;
+	const resolved = blocks.map((block, index) => {
+		const next = resolveBlockSpacing(blocks, index);
+		if (next !== block) changed = true;
+		return next;
+	});
+	return changed ? resolved : blocks;
+};
+const paragraphsShareStyle = (previous, current) => previous.attrs?.styleId === current.attrs?.styleId;
+const preservesInheritedEmptySpacing = (block) => Boolean(block.attrs?.styleId || block.attrs?.hasDirectParagraphFormatting || block.attrs?.hasDirectParagraphMarkFormatting);
+const resolveBlockSpacing = (blocks, index) => {
+	const block = blocks[index];
+	if (block.kind === "paragraph") return resolveParagraphSequenceSpacing(blocks, index, block);
+	if (block.kind === "table") return resolveTableSpacing(block);
+	if (block.kind === "textBox") return resolveTextBoxSpacing(block);
+	return block;
+};
+const resolveParagraphSequenceSpacing = (blocks, index, block) => {
+	const spacing = block.attrs?.spacing;
+	if (!spacing) return block;
+	const previous = blocks[index - 1];
+	const next = blocks[index + 1];
+	const suppressBefore = previous?.kind === "paragraph" && (block.attrs?.contextualSpacing === true && paragraphsShareStyle(previous, block) || block.attrs?.automaticSpacing?.before === true && continuesNumberedSequence(previous, block));
+	const suppressAfter = next?.kind === "paragraph" && (block.attrs?.contextualSpacing === true && paragraphsShareStyle(block, next) || block.attrs?.automaticSpacing?.after === true && continuesNumberedSequence(block, next));
+	const beforeChanged = suppressBefore && spacing.before !== 0;
+	const afterChanged = suppressAfter && spacing.after !== 0;
+	if (!beforeChanged && !afterChanged) return block;
+	const effectiveSpacing = { ...spacing };
+	if (beforeChanged) effectiveSpacing.before = 0;
+	if (afterChanged) effectiveSpacing.after = 0;
+	return {
+		...block,
+		attrs: {
+			...block.attrs,
+			spacing: effectiveSpacing
+		}
+	};
+};
+const resolveTextBoxContentSpacing = (blocks) => {
+	let changed = false;
+	const resolved = blocks.map((block, index) => {
+		const next = block.kind === "table" ? resolveTableSpacing(block) : resolveParagraphSequenceSpacing(blocks, index, block);
+		if (next !== block) changed = true;
+		return next;
+	});
+	return changed ? resolved : blocks;
+};
+const resolveTableSpacing = (block) => {
+	let changed = false;
+	const rows = block.rows.map((row) => {
+		let rowChanged = false;
+		const cells = row.cells.map((cell) => {
+			const blocks = resolveEffectiveParagraphSpacingTree(cell.blocks);
+			if (blocks === cell.blocks) return cell;
+			rowChanged = true;
+			return {
+				...cell,
+				blocks
+			};
+		});
+		if (!rowChanged) return row;
+		changed = true;
+		return {
+			...row,
+			cells
+		};
+	});
+	return changed ? {
+		...block,
+		rows
+	} : block;
+};
+const resolveTextBoxSpacing = (block) => {
+	const content = resolveTextBoxContentSpacing(block.content);
+	if (content === block.content) return block;
+	return {
+		...block,
+		content
+	};
+};
 //#endregion
-export { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph };
+export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };

package/dist/layout-engine/renderedBreakReconciliation.js

@@ -21,7 +21,7 @@ const reconcileBreakBeforeBlock = ({ state, block, previousBlock, page, blocksBy
 		state
 	};
 	const markerAlreadySatisfied = pageStartsWithPreviousParagraphContinuation(page, previousBlock) || state.type === "pageAdvance" && state.reason === "authoredBoundary" || state.type === "pageAdvance" && state.reason === "reflowBoundary" || state.type === "pageAdvance" && isPaginationEmptyParagraph(block) || state.type === "pageAdvance" && (continuesNumberedSequence(previousBlock, block) || continuesTabbedParagraphSequence(previousBlock, block));
-	const forcePageBreak = (renderedBreakNeedsSnap || block.attrs?.keepNext === true) && !markerAlreadySatisfied && pageHasVisibleBodyContent(page, blocksById);
+	const forcePageBreak = (renderedBreakNeedsSnap || block.attrs?.keepNext === true || (block.attrs?.spacing?.before ?? 0) > 0 && previousBlock?.kind !== "sectionBreak" || previousBlock?.kind === "table") && !markerAlreadySatisfied && pageHasVisibleBodyContent(page, blocksById);
 	const followsAuthoredPageBreak = previousBlock?.kind === "pageBreak";
 	const followsSectionBreak = previousBlock?.kind === "sectionBreak";
 	const followsPageBreakingSection = followsSectionBreak && previousBlock.type !== "continuous";

package/dist/layout-engine/types.d.ts

@@ -3,7 +3,7 @@ import { ImagePosition, ImageWrap, SdtProperties, SdtType, ShapeTextBody, TableC
 
 //#region src/layout-engine/types.d.ts
 declare namespace types_d_exports {
-  export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned };
+  export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, RenderedPageBreakRun, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned };
 }
 /**
  * Unique identifier for a block in the document.
@@ -87,6 +87,14 @@ type RunFormatting = {
   changeAuthor?: string; /** Date of the tracked change */
   changeDate?: string; /** Revision ID of the tracked change (for sidebar matching) */
   changeRevisionId?: number;
+  /**
+   * Whether this tracked insertion/deletion is an AI-proposed *suggestion*
+   * rather than a user change. Suggestions render with the same grammar but a
+   * dotted stroke and a dedicated hue; they are stripped from serialized DOCX
+   * until accepted.
+   */
+  isSuggestion?: boolean; /** Groups a suggestion's runs for accept/reject and scroll-to. */
+  suggestionId?: string;
 };
 /**
  * Hyperlink information for a run.
@@ -179,7 +187,10 @@ type ImageRun = {
   cropTop?: number;
   cropRight?: number;
   cropBottom?: number;
-  cropLeft?: number; /** Whether this picture is itself a tracked insertion (`<w:ins>`). eigenpal #641. */
+  cropLeft?: number; /** CSS border width in pixels. eigenpal #1096. */
+  borderWidth?: number; /** CSS border color. eigenpal #1096. */
+  borderColor?: string; /** CSS border style. eigenpal #1096. */
+  borderStyle?: string; /** Whether this picture is itself a tracked insertion (`<w:ins>`). eigenpal #641. */
   isInsertion?: boolean; /** Whether this picture is itself a tracked deletion (`<w:del>`). eigenpal #641. */
   isDeletion?: boolean; /** Author of the tracked change wrapping the picture. eigenpal #641. */
   changeAuthor?: string; /** Date of the tracked change wrapping the picture. eigenpal #641. */
@@ -196,6 +207,12 @@ type LineBreakRun = {
   pmStart?: number;
   pmEnd?: number;
 };
+/** Zero-width cached page boundary inside a paragraph. */
+type RenderedPageBreakRun = RunFormatting & {
+  kind: "renderedPageBreak";
+  pmStart?: number;
+  pmEnd?: number;
+};
 /**
  * A field run (PAGE, NUMPAGES, etc.) that gets substituted at render time.
  */
@@ -230,7 +247,7 @@ type MathRun = RunFormatting & {
 /**
  * Union of all run types.
  */
-type Run = TextRun | TabRun | ImageRun | LineBreakRun | FieldRun | MathRun;
+type Run = TextRun | TabRun | ImageRun | LineBreakRun | RenderedPageBreakRun | FieldRun | MathRun;
 /**
  * Paragraph spacing configuration.
  */
@@ -293,7 +310,10 @@ type ListNumPr = {
  * Paragraph block attributes.
  */
 type ParagraphAttrs = {
-  alignment?: "left" | "center" | "right" | "justify"; /** East Asian first/last-character restrictions (`w:kinsoku`). */
+  alignment?: "left" | "center" | "right" | "justify"; /** Document-generation policy for justified line fitting. */
+  justificationCompatibility?: {
+    type: "legacy";
+  }; /** East Asian first/last-character restrictions (`w:kinsoku`). */
   kinsoku?: boolean; /** Hanging punctuation (`w:overflowPunct`); defaults to enabled when omitted. */
   overflowPunctuation?: boolean; /** Exempt this paragraph from document automatic hyphenation. */
   suppressAutoHyphens?: boolean; /** Document-wide automatic hyphenation controls retained for line layout. */
@@ -315,7 +335,9 @@ type ParagraphAttrs = {
     useLegacyEthiopicAmharicRules?: boolean;
   }; /** OOXML outline level (`w:outlineLvl`), where zero is the top level. */
   outlineLevel?: number;
-  spacing?: ParagraphSpacing; /** Spacing sides resolved from OOXML automatic paragraph spacing. */
+  spacing?: ParagraphSpacing; /** Whether this paragraph participates in the active section line grid. */
+  snapToGrid?: boolean; /** Active section line pitch in pixels; present only on top-level body paragraphs. */
+  documentGridLinePitch?: number; /** Spacing sides resolved from OOXML automatic paragraph spacing. */
   automaticSpacing?: {
     before?: boolean;
     after?: boolean;
@@ -343,7 +365,7 @@ type ParagraphAttrs = {
   keepNext?: boolean;
   keepLines?: boolean;
   widowControl?: boolean;
-  pageBreakBefore?: boolean; /** Word's cached pagination hint (`w:lastRenderedPageBreak`). */
+  pageBreakBefore?: boolean; /** Cached OOXML pagination hint (`w:lastRenderedPageBreak`). */
   renderedPageBreakBefore?: boolean;
   styleId?: string;
   contextualSpacing?: boolean;
@@ -366,6 +388,12 @@ type ParagraphAttrs = {
   listMarkerHidden?: boolean;
   listMarkerFontFamily?: string;
   listMarkerFontSize?: number;
+  /**
+   * Effective paragraph-mark size used only to measure a visible list
+   * paragraph's final line. Word lets the inherited complex-script size raise
+   * that line box without enlarging the marker or Western text glyphs.
+   */
+  listParagraphMarkFontSize?: number;
   listMarkerBold?: boolean; /** Horizontal alignment of the marker around the paragraph's list anchor. */
   listMarkerAlignment?: "left" | "center" | "right";
   /**
@@ -555,7 +583,10 @@ type ImageBlock = {
   cropTop?: number;
   cropRight?: number;
   cropBottom?: number;
-  cropLeft?: number;
+  cropLeft?: number; /** CSS border width in pixels. eigenpal #1096. */
+  borderWidth?: number; /** CSS border color. eigenpal #1096. */
+  borderColor?: string; /** CSS border style. eigenpal #1096. */
+  borderStyle?: string;
   pmStart?: number;
   pmEnd?: number;
 };
@@ -572,7 +603,8 @@ type SectionBreakBlock = {
   };
   orientation?: "portrait" | "landscape";
   margins?: PageMargins;
-  columns?: ColumnLayout;
+  columns?: ColumnLayout; /** Line pitch authored by the section properties that end at this boundary, in twips. */
+  documentGridLinePitchTwips?: number;
 };
 type PageHeaderFooterRefs = {
   titlePg?: boolean;
@@ -612,7 +644,7 @@ declare const DEFAULT_TEXTBOX_MARGINS: {
 /** Default text box width in pixels when no width is specified */
 declare const DEFAULT_TEXTBOX_WIDTH = 200;
 /**
- * Text box block — positioned container with paragraph content.
+ * Text box block — positioned container with block content.
  */
 type TextBoxBlock = {
   kind: "textBox";
@@ -629,8 +661,8 @@ type TextBoxBlock = {
     bottom: number;
     left: number;
     right: number;
-  }; /** Paragraph blocks inside the text box */
-  content: ParagraphBlock[]; /** Display mode copied from the ProseMirror text box node. */
+  }; /** Flow blocks inside the text box */
+  content: (ParagraphBlock | TableBlock)[]; /** Display mode copied from the ProseMirror text box node. */
   displayMode?: "inline" | "float" | "block"; /** CSS float direction copied from the ProseMirror text box node. */
   cssFloat?: "left" | "right" | "none"; /** OOXML wrap type for anchored text boxes. */
   wrapType?: ImageWrap["type"]; /** OOXML wrapText direction for anchored text boxes. */
@@ -704,7 +736,8 @@ type MeasuredLine = {
   floatSkipBefore?: number; /** Decorative hyphen inserted at a dictionary break without changing source text. */
   discretionaryHyphen?: {
     runIndex: number;
-  };
+  }; /** A cached pagination boundary occurs immediately before this line. */
+  renderedPageBreakBefore?: boolean;
 };
 /**
  * Measurement result for a paragraph block.
@@ -782,8 +815,8 @@ type ColumnBreakMeasure = {
 type TextBoxMeasure = {
   kind: "textBox";
   width: number;
-  height: number; /** Pre-measured inner paragraph measures (avoids re-measuring during render) */
-  innerMeasures: ParagraphMeasure[];
+  height: number; /** Pre-measured inner content (avoids re-measuring during render) */
+  innerMeasures: (ParagraphMeasure | TableMeasure)[];
 };
 /**
  * Union of all measurement types.
@@ -1112,4 +1145,4 @@ declare function tableColumnsArePinned(table: TableBlock): boolean;
 /** Return the leading visual offset for a row with omitted grid columns. */
 declare const getTableRowLeadingWidth: (row: TableRow, columnWidths: readonly number[]) => number;
 //#endregion
-export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_d_exports };
+export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, RenderedPageBreakRun, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_d_exports };

package/dist/layout-painter/registry/modules/textBox.js

@@ -1,4 +1,5 @@
 import { renderTextBoxFragment } from "../../renderTextBox.js";
+import { renderNestedTable } from "../../renderTable.js";
 //#region src/layout-painter/registry/modules/textBox.ts
 /**
 * Text-box feature module — renders `TextBoxFragment`.
@@ -6,7 +7,10 @@ import { renderTextBoxFragment } from "../../renderTextBox.js";
 const textBoxModule = {
 	kind: "textBox",
 	render({ fragment, block, measure, context, doc }) {
-		return renderTextBoxFragment(fragment, block, measure, context, { document: doc });
+		return renderTextBoxFragment(fragment, block, measure, context, {
+			document: doc,
+			renderTable: renderNestedTable
+		});
 	}
 };
 //#endregion

package/dist/layout-painter/renderImage.d.ts

@@ -21,6 +21,17 @@ type ImageVisualAttrs = {
   cropBottom?: number;
   cropLeft?: number;
 };
+type ImageBorderAttrs = {
+  borderWidth?: number;
+  borderColor?: string;
+  borderStyle?: string;
+};
+/**
+ * Paint image borders carried through the layout model. Folio's PM schema
+ * uses `borderStyle` (not upstream's `borderKind`); the painter mirrors the
+ * editor DOM serialization while keeping the authored image box size stable.
+ */
+declare function applyImageBorder(element: HTMLElement, border: ImageBorderAttrs): void;
 /**
  * True when any visual attribute is set. Cheap call-site guard so the no-op
  * common case skips the helper call.
@@ -86,4 +97,4 @@ type RenderImageFragmentOptions = {
  */
 declare function renderImageFragment(fragment: ImageFragment, block: ImageBlock, _measure: ImageMeasure, _context: RenderContext, options?: RenderImageFragmentOptions): HTMLElement;
 //#endregion
-export { IMAGE_CLASS_NAMES, ImageVisualAttrs, RenderImageFragmentOptions, applyImageVisualAttrs, hasImageCrop, hasImageVisualAttrs, renderImageFragment, wrapImageWithCrop };
+export { IMAGE_CLASS_NAMES, ImageBorderAttrs, ImageVisualAttrs, RenderImageFragmentOptions, applyImageBorder, applyImageVisualAttrs, hasImageCrop, hasImageVisualAttrs, renderImageFragment, wrapImageWithCrop };

package/dist/layout-painter/renderImage.js

@@ -1,3 +1,5 @@
+import { sanitizeExternalUrl } from "../utils/urlSecurity.js";
+import { applySanitizedImageSrc } from "../utils/sanitizeImageSrc.js";
 //#region src/layout-painter/renderImage.ts
 /**
 * CSS class names for image elements
@@ -7,6 +9,18 @@ const IMAGE_CLASS_NAMES = {
 	imageAnchored: "layout-image-anchored"
 };
 /**
+* Paint image borders carried through the layout model. Folio's PM schema
+* uses `borderStyle` (not upstream's `borderKind`); the painter mirrors the
+* editor DOM serialization while keeping the authored image box size stable.
+*/
+function applyImageBorder(element, border) {
+	if (border.borderWidth == null || border.borderWidth <= 0) return;
+	const borderStyle = border.borderStyle || "solid";
+	const borderColor = border.borderColor || "#000000";
+	element.style.border = `${border.borderWidth}px ${borderStyle} ${borderColor}`;
+	element.style.boxSizing = "border-box";
+}
+/**
 * True when any visual attribute is set. Cheap call-site guard so the no-op
 * common case skips the helper call.
 *
@@ -118,7 +132,7 @@ function renderImageFragment(fragment, block, _measure, _context, options = {})
 	if (fragment.pmStart !== void 0) containerEl.dataset["pmStart"] = String(fragment.pmStart);
 	if (fragment.pmEnd !== void 0) containerEl.dataset["pmEnd"] = String(fragment.pmEnd);
 	const imgEl = doc.createElement("img");
-	imgEl.src = block.src;
+	applySanitizedImageSrc(imgEl, block.src);
 	imgEl.alt = block.alt ?? "";
 	imgEl.style.width = "100%";
 	imgEl.style.height = "100%";
@@ -127,9 +141,10 @@ function renderImageFragment(fragment, block, _measure, _context, options = {})
 	if (block.transform) imgEl.style.transform = block.transform;
 	if (hasImageVisualAttrs(block)) applyImageVisualAttrs(imgEl, block);
 	imgEl.draggable = false;
-	if (block.hlinkHref) {
+	const hlinkHref = sanitizeExternalUrl(block.hlinkHref);
+	if (hlinkHref) {
 		const linkEl = doc.createElement("a");
-		linkEl.href = block.hlinkHref;
+		linkEl.href = hlinkHref;
 		linkEl.target = "_blank";
 		linkEl.rel = "noopener noreferrer";
 		linkEl.style.display = "block";
@@ -138,7 +153,9 @@ function renderImageFragment(fragment, block, _measure, _context, options = {})
 		linkEl.append(imgEl);
 		containerEl.append(linkEl);
 	} else containerEl.append(imgEl);
+	if (hasImageCrop(block)) applyImageBorder(containerEl, block);
+	else applyImageBorder(imgEl, block);
 	return containerEl;
 }
 //#endregion
-export { IMAGE_CLASS_NAMES, applyImageVisualAttrs, hasImageCrop, hasImageVisualAttrs, renderImageFragment, wrapImageWithCrop };
+export { IMAGE_CLASS_NAMES, applyImageBorder, applyImageVisualAttrs, hasImageCrop, hasImageVisualAttrs, renderImageFragment, wrapImageWithCrop };