superdoc 2.2.1 → 2.4.0-next.1

package/dist/layout-engine/painters/dom/src/table/grid-geometry.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Grid position for a rendered table cell.
+ *
+ * The position describes the cell's occupied rectangle in table grid coordinates,
+ * not just the anchor column where the physical cell starts.
+ */
+export type TableCellGridPosition = {
+    /** Zero-based absolute row index where the cell starts. */
+    rowIndex: number;
+    /** Number of rows occupied by the cell. Defaults to 1 when omitted or invalid. */
+    rowSpan?: number;
+    /** Zero-based absolute grid column where the cell starts. */
+    gridColumnStart: number;
+    /** Number of columns occupied by the cell. Defaults to 1 when omitted or invalid. */
+    colSpan?: number;
+    /** Total row count in the table. */
+    totalRows: number;
+    /** Total column count in the table grid. */
+    totalCols: number;
+};
+/**
+ * Normalized grid bounds for a rendered table cell.
+ *
+ * The exclusive end indexes make edge checks straightforward:
+ * - `endColExclusive === totalCols` means the cell touches the right table edge
+ * - `endRowExclusive === totalRows` means the cell touches the bottom table edge
+ */
+export type TableCellGridBounds = {
+    /** Inclusive starting row index. */
+    startRow: number;
+    /** Exclusive ending row index. */
+    endRowExclusive: number;
+    /** Inclusive starting column index. */
+    startCol: number;
+    /** Exclusive ending column index. */
+    endColExclusive: number;
+    /** Whether the cell touches the table's top outer edge. */
+    touchesTopEdge: boolean;
+    /** Whether the cell touches the table's bottom outer edge. */
+    touchesBottomEdge: boolean;
+    /** Whether the cell touches the table's left outer edge. */
+    touchesLeftEdge: boolean;
+    /** Whether the cell touches the table's right outer edge. */
+    touchesRightEdge: boolean;
+};
+/**
+ * Computes the normalized grid bounds for a table cell.
+ *
+ * The DOM table painter uses these bounds to decide whether a cell owns
+ * the table's outer borders under the single-owner collapsed-border model.
+ *
+ * @param position - Cell position and span within the table grid
+ * @returns Normalized bounds plus edge-contact flags
+ *
+ * @example
+ * ```typescript
+ * const bounds = getTableCellGridBounds({
+ *   rowIndex: 0,
+ *   rowSpan: 1,
+ *   gridColumnStart: 0,
+ *   colSpan: 2,
+ *   totalRows: 5,
+ *   totalCols: 2,
+ * });
+ *
+ * bounds.touchesRightEdge; // true
+ * ```
+ */
+export declare const getTableCellGridBounds: (position: TableCellGridPosition) => TableCellGridBounds;

package/dist/layout-engine/painters/dom/src/table/renderTableCell.d.ts

@@ -0,0 +1,170 @@
+import { CellBorders, DrawingBlock, DrawingMeasure, ImageBlock, Line, ParagraphBlock, SdtMetadata, TableBlock, TableCell, TableMeasure } from '../../../../contracts/src/index.js';
+import { ResolvePhysicalFamily } from '../../../../../shared/font-system/src/index.js';
+import { FragmentRenderContext } from '../renderer.js';
+import { SdtAncestorOptions } from '../sdt/container.js';
+type TableRowMeasure = TableMeasure['rows'][number];
+type TableCellMeasure = TableRowMeasure['cells'][number];
+type TableCellBlock = NonNullable<TableCell['blocks']>[number];
+type TableCellBlockMeasure = NonNullable<TableCellMeasure['blocks']>[number];
+type ResolveCellAnchoredTopParams = {
+    anchor: ImageBlock['anchor'] | DrawingBlock['anchor'];
+    anchorParagraphId?: string;
+    cellBlocks: TableCellBlock[];
+    blockMeasures: TableCellBlockMeasure[];
+    globalFromLine: number;
+    globalToLine: number;
+    paddingTop: number;
+    objectHeight: number;
+};
+/**
+ * Compute the total segment count for a cell's blocks, matching the layout engine's
+ * recursive getCellLines() expansion. Paragraph blocks contribute their line count,
+ * embedded tables contribute the sum of their rows' recursive segment counts,
+ * and other blocks (images, drawings) contribute 1 segment.
+ */
+export declare function getCellSegmentCount(cell: TableCellMeasure): number;
+type CellAnchoredTop = {
+    top: number;
+    /**
+     * True only when the anchor paragraph was found and used as the base. Fallback results
+     * (page/margin bases, missing/unresolvable anchorParagraphId) keep the legacy
+     * top-of-cell invariant and must NOT be shifted by the vertical-alignment offset.
+     */
+    paragraphResolved: boolean;
+};
+export declare const resolveCellAnchoredTop: (params: ResolveCellAnchoredTopParams) => CellAnchoredTop | null;
+/**
+ * Dependencies required for rendering a table cell.
+ *
+ * Contains positioning, sizing, content, and rendering functions needed to
+ * create a table cell DOM element with its content.
+ */
+type TableCellRenderDependencies = {
+    /** Document object for creating DOM elements */
+    doc: Document;
+    /** Horizontal position (left edge) in pixels */
+    x: number;
+    /** Vertical position (top edge) in pixels */
+    y: number;
+    /** Height of the row containing this cell */
+    rowHeight: number;
+    /** Measurement data for this cell (width, paragraph layout) */
+    cellMeasure: TableRowMeasure['cells'][number];
+    /** Cell data (content, attributes), or undefined for empty cells */
+    cell?: TableBlock['rows'][number]['cells'][number];
+    /** Resolved borders for this cell */
+    borders?: CellBorders;
+    /** Whether to apply default border if no borders specified */
+    useDefaultBorder?: boolean;
+    /** Function to render a line of paragraph content */
+    renderLine: (block: ParagraphBlock, line: Line, context: FragmentRenderContext, lineIndex: number, isLastLine: boolean, resolvedListTextStartPx?: number) => HTMLElement;
+    /** Optional callback invoked after a table line's final styles/markers are applied. */
+    captureLineSnapshot?: (lineEl: HTMLElement, context: FragmentRenderContext, options?: {
+        inTableParagraph?: boolean;
+        wrapperEl?: HTMLElement;
+    }) => void;
+    /**
+     * Optional callback function to render drawing content (vectorShapes, shapeGroups).
+     * If provided, this callback is used to render DrawingBlocks with drawingKind of 'vectorShape' or 'shapeGroup'.
+     * The callback receives a DrawingBlock and must return an HTMLElement.
+     * The returned element will have width: 100% and height: 100% styles applied automatically.
+     * If undefined, a placeholder element with diagonal stripes pattern is rendered instead.
+     */
+    renderDrawingContent?: (block: DrawingBlock, interactionHost: HTMLElement, measure: DrawingMeasure) => HTMLElement;
+    /** Rendering context */
+    context: FragmentRenderContext;
+    /** Function to apply SDT metadata as data attributes */
+    applySdtDataset: (el: HTMLElement | null, metadata?: SdtMetadata | null) => void;
+    /** Built-in SDT chrome rendering mode. */
+    chrome?: 'default' | 'none';
+    /** Ancestor SDT container key for suppressing duplicate container styling in cells */
+    ancestorContainerKey?: string | null;
+    /** Ancestor SDT metadata for suppressing duplicate id-less container styling in cells */
+    ancestorContainerSdt?: SdtMetadata | null;
+    /** Ancestor SDT keys for suppressing duplicate container styling in cells */
+    ancestorContainerKeys?: SdtAncestorOptions['ancestorContainerKeys'];
+    /** Ancestor SDT metadata chain for suppressing duplicate id-less container styling in cells */
+    ancestorContainerSdts?: SdtAncestorOptions['ancestorContainerSdts'];
+    /** Receives notification when this cell or descendants render SDT container chrome */
+    onSdtContainerChrome?: () => void;
+    /** Table indent in pixels (applied to table fragment positioning) */
+    tableIndent?: number;
+    /** Whether the table is visually right-to-left (w:bidiVisual, ECMA-376 §17.4.1) */
+    isRtl?: boolean;
+    /** Computed cell width from rescaled columnWidths (overrides cellMeasure.width when present) */
+    cellWidth?: number;
+    /** Starting line index for partial row rendering (inclusive) */
+    fromLine?: number;
+    /** Ending line index for partial row rendering (exclusive), -1 means render to end */
+    toLine?: number;
+    /**
+     * Per-document logical->physical font resolver for in-cell list markers and drop caps. Threaded
+     * from the renderer's per-document resolver so they paint the same physical family they were
+     * measured in. Undefined falls back to the global resolver.
+     */
+    resolvePhysical?: ResolvePhysicalFamily;
+};
+/**
+ * Result of rendering a table cell.
+ */
+export type TableCellRenderResult = {
+    /** The cell container element (with borders, background, sizing, and content as child) */
+    cellElement: HTMLElement;
+};
+/**
+ * Renders a table cell as a DOM element.
+ *
+ * Creates a single cell element with content as a child:
+ * - cellElement: Absolutely-positioned container with borders, background, sizing, padding,
+ *   and content rendered inside. Cell uses overflow:hidden to clip any overflow.
+ *
+ * Handles:
+ * - Cell borders (explicit or default)
+ * - Background colors
+ * - Vertical alignment (top, center, bottom)
+ * - Cell padding (applied directly to cell element)
+ * - Empty cells
+ *
+ * **Multi-Block Cell Rendering:**
+ * - Iterates through all blocks in the cell (cell.blocks or cell.paragraph)
+ * - Each block is rendered sequentially and stacked vertically
+ * - Only paragraph blocks are currently rendered (other block types are ignored)
+ *
+ * **Backward Compatibility:**
+ * - Supports legacy cell.paragraph field (single paragraph)
+ * - Falls back to empty array if neither cell.blocks nor cell.paragraph is present
+ * - Handles mismatches between blockMeasures and cellBlocks arrays using bounds checking
+ *
+ * **Empty Cell Handling:**
+ * - Cells with no blocks render only the cell container (no content inside)
+ * - Empty blocks arrays are safe (no content rendered)
+ *
+ * @param deps - All dependencies required for rendering
+ * @returns Object containing cellElement (content is rendered inside as child)
+ *
+ * @example
+ * ```typescript
+ * const { cellElement } = renderTableCell({
+ *   doc: document,
+ *   x: 100,
+ *   y: 50,
+ *   rowHeight: 30,
+ *   cellMeasure,
+ *   cell,
+ *   borders,
+ *   useDefaultBorder: false,
+ *   renderLine,
+ *   renderDrawingContent: (block) => {
+ *     // Custom drawing renderer for vectorShapes and shapeGroups
+ *     const el = document.createElement('div');
+ *     // Render drawing content...
+ *     return el;
+ *   },
+ *   context,
+ *   applySdtDataset
+ * });
+ * container.appendChild(cellElement);
+ * ```
+ */
+export declare const renderTableCell: (deps: TableCellRenderDependencies) => TableCellRenderResult;
+export {};

package/dist/layout-engine/painters/dom/src/table/renderTableFragment.d.ts

@@ -0,0 +1,132 @@
+import { DrawingBlock, DrawingMeasure, Fragment, Line, ParagraphBlock, SdtMetadata, TableBlock, TableFragment, TableMeasure } from '../../../../contracts/src/index.js';
+import { ResolvePhysicalFamily } from '../../../../../shared/font-system/src/index.js';
+import { FragmentRenderContext } from '../renderer.js';
+import { SdtAncestorOptions, SdtBoundaryOptions } from '../sdt/container.js';
+type ApplyStylesFn = (el: HTMLElement, styles: Partial<CSSStyleDeclaration>) => void;
+/**
+ * Dependencies required for rendering a table fragment.
+ *
+ * Encapsulates all external dependencies needed to render a table, including
+ * document access, rendering context, pre-resolved table data, and helper functions.
+ */
+export type TableRenderDependencies = {
+    /** Document object for creating DOM elements */
+    doc: Document;
+    /** Table fragment to render (contains dimensions and row range) */
+    fragment: TableFragment;
+    /** Rendering context (section info, etc.) */
+    context: FragmentRenderContext;
+    /** Pre-extracted TableBlock (replaces blockLookup.get()) */
+    block: TableBlock;
+    /** Pre-extracted TableMeasure (replaces blockLookup.get()) */
+    measure: TableMeasure;
+    /** Pre-computed cell spacing in pixels */
+    cellSpacingPx: number;
+    /** Pre-computed effective column widths (fragment.columnWidths ?? measure.columnWidths) */
+    effectiveColumnWidths: number[];
+    /** Optional SDT boundary overrides for container styling */
+    sdtBoundary?: SdtBoundaryOptions;
+    /** Ancestor SDT key used to suppress duplicate container chrome in nested tables */
+    ancestorContainerKey?: string | null;
+    /** Ancestor SDT metadata used to suppress duplicate id-less container chrome in nested tables */
+    ancestorContainerSdt?: SdtMetadata | null;
+    /** Ancestor SDT keys used to suppress duplicate container chrome in nested tables */
+    ancestorContainerKeys?: SdtAncestorOptions['ancestorContainerKeys'];
+    /** Ancestor SDT metadata chain used to suppress duplicate id-less container chrome in nested tables */
+    ancestorContainerSdts?: SdtAncestorOptions['ancestorContainerSdts'];
+    /** Receives notification when this table fragment or descendants render SDT container chrome */
+    onSdtContainerChrome?: () => void;
+    /** Built-in SDT chrome rendering mode. */
+    chrome?: 'default' | 'none';
+    /** Function to render a line of paragraph content */
+    renderLine: (block: ParagraphBlock, line: Line, context: FragmentRenderContext, lineIndex: number, isLastLine: boolean) => HTMLElement;
+    /** Optional callback invoked after a table line's final styles/markers are applied. */
+    captureLineSnapshot?: (lineEl: HTMLElement, context: FragmentRenderContext, options?: {
+        inTableParagraph?: boolean;
+        wrapperEl?: HTMLElement;
+    }) => void;
+    /** Function to render drawing content (images, shapes, shape groups) */
+    renderDrawingContent?: (block: DrawingBlock, interactionHost: HTMLElement, measure: DrawingMeasure) => HTMLElement;
+    /** Function to apply fragment positioning and dimensions */
+    applyFragmentFrame: (el: HTMLElement, fragment: Fragment) => void;
+    /** Function to apply SDT metadata as data attributes */
+    applySdtDataset: (el: HTMLElement | null, metadata?: SdtMetadata | null) => void;
+    /** Function to apply container SDT metadata as data attributes */
+    applyContainerSdtDataset?: (el: HTMLElement | null, metadata?: SdtMetadata | null) => void;
+    /** Function to apply CSS styles to an element */
+    applyStyles: ApplyStylesFn;
+    /**
+     * Per-document logical->physical font resolver for in-cell list markers and drop caps. Threaded
+     * from the renderer's per-document resolver so they paint the same physical family they were
+     * measured in. Undefined falls back to the global resolver.
+     */
+    resolvePhysical?: ResolvePhysicalFamily;
+};
+/**
+ * Renders a table fragment as a DOM element.
+ *
+ * Creates a container div with absolutely-positioned rows and cells. Handles:
+ * - Table border overlays for outer borders
+ * - Border collapse settings
+ * - Cell spacing
+ * - Row-by-row rendering with proper positioning
+ * - Metadata embedding for interactive table resizing
+ *
+ * **Error Handling:**
+ * If the document is unavailable, returns an error placeholder instead of
+ * throwing. Table block/measure validation is performed by the caller before
+ * invoking this helper.
+ *
+ * **SDT Container Styling:**
+ * If the table block has SDT metadata (`block.attrs?.sdt`), applies appropriate
+ * container styling via `applySdtContainerChrome()`:
+ * - Document sections: Gray border with hover tooltip
+ * - Structured content blocks: Blue border with label
+ * Uses type-safe helper functions to avoid unsafe type assertions.
+ *
+ * **Metadata Embedding:**
+ * Embeds column boundary metadata in the `data-table-boundaries` attribute
+ * using a compact JSON format:
+ * ```json
+ * {
+ *   "columns": [
+ *     {"i": 0, "x": 0, "w": 100, "min": 25, "r": 1},
+ *     {"i": 1, "x": 100, "w": 150, "min": 30, "r": 1}
+ *   ],
+ *   "rows": [
+ *     {"i": 0, "y": 0, "h": 30, "min": 10, "r": 1},
+ *     {"i": 1, "y": 34, "h": 25, "min": 10, "r": 1}
+ *   ]
+ * }
+ * ```
+ * Where for columns: i=index, x=position, w=width, min=minWidth, r=resizable(0/1)
+ * Where for rows: i=index, y=position, h=height, min=minHeight, r=resizable(0/1)
+ *
+ * **Edge Cases:**
+ * - Missing metadata: Element created without data-table-boundaries attribute
+ * - Empty columnBoundaries: Creates empty columns array in JSON
+ * - Missing block ID: Element created without data-sd-block-id attribute
+ *
+ * @param deps - All dependencies required for rendering
+ * @returns HTMLElement containing the rendered table fragment, or error placeholder
+ *
+ * @example
+ * ```typescript
+ * const tableElement = renderTableFragment({
+ *   doc: document,
+ *   fragment: tableFragment,
+ *   context: renderContext,
+ *   block: tableBlock,
+ *   measure: tableMeasure,
+ *   cellSpacingPx: 0,
+ *   effectiveColumnWidths: tableMeasure.columnWidths,
+ *   renderLine,
+ *   applyFragmentFrame,
+ *   applySdtDataset,
+ *   applyStyles
+ * });
+ * container.appendChild(tableElement);
+ * ```
+ */
+export declare const renderTableFragment: (deps: TableRenderDependencies) => HTMLElement;
+export {};

package/dist/layout-engine/painters/dom/src/table/renderTableRow.d.ts

@@ -0,0 +1,146 @@
+import { DrawingBlock, DrawingMeasure, Line, ParagraphBlock, PartialRowInfo, SdtMetadata, TableBlock, TableBorders, TableMeasure } from '../../../../contracts/src/index.js';
+import { ResolvePhysicalFamily } from '../../../../../shared/font-system/src/index.js';
+import { FragmentRenderContext } from '../renderer.js';
+import { SdtAncestorOptions } from '../sdt/container.js';
+type TableRowMeasure = TableMeasure['rows'][number];
+type TableRow = TableBlock['rows'][number];
+/**
+ * Dependencies required for rendering a table row.
+ *
+ * Contains all information needed to render cells in a table row, including
+ * positioning, measurements, border resolution, and rendering functions.
+ */
+type TableRowRenderDependencies = {
+    /** Document object for creating DOM elements */
+    doc: Document;
+    /** Container element to append cell elements to */
+    container: HTMLElement;
+    /** Zero-based index of this row */
+    rowIndex: number;
+    /** Vertical position (top edge) in pixels */
+    y: number;
+    /** Measurement data for this row (height, cell measurements) */
+    rowMeasure: TableRowMeasure;
+    /** Row data (cells, attributes), or undefined for empty rows */
+    row?: TableRow;
+    /** Previous (above) row data + measure, for collapsed-border conflict resolution (§17.4.66). */
+    prevRow?: TableRow;
+    prevRowMeasure?: TableRowMeasure;
+    /** Next (below) row data, to detect a row-level border override that suppresses the shared
+     * horizontal edge so the current row closes the grid itself (§17.4.61/§17.4.66). */
+    nextRow?: TableRow;
+    /** Next (below) row measure, to detect a gridAfter gap under a spanning cell (SD-3345). */
+    nextRowMeasure?: TableRowMeasure;
+    /**
+     * Rightmost occupied grid column (exclusive) for THIS row, counting cells that span into it
+     * via w:vMerge (rowspan) from an earlier row. Falls back to this row's own cells when absent.
+     * Prevents a leftmost cell on a rowspan-continuation row from being treated as the rightmost
+     * column. (SD-1797)
+     */
+    rowOccupiedRightCol?: number;
+    /** Same as {@link rowOccupiedRightCol} for the NEXT row, so a rowspan continuation below is
+     * not mistaken for a gridAfter gap (which would double the shared bottom edge). (SD-1797) */
+    nextRowOccupiedRightCol?: number;
+    /** Total number of rows in the table (for border resolution) */
+    totalRows: number;
+    /** Table-level borders (for resolving cell borders) */
+    tableBorders?: TableBorders;
+    /** Column widths array for calculating x positions from gridColumnStart */
+    columnWidths: number[];
+    /** All row heights for calculating rowspan cell heights */
+    allRowHeights: number[];
+    /** Table indent in pixels (applied to table fragment positioning) */
+    tableIndent?: number;
+    /** Whether the table is visually right-to-left (w:bidiVisual, ECMA-376 §17.4.1) */
+    isRtl?: boolean;
+    /** Rendering context */
+    context: FragmentRenderContext;
+    /** Function to render a line of paragraph content */
+    renderLine: (block: ParagraphBlock, line: Line, context: FragmentRenderContext, lineIndex: number, isLastLine: boolean) => HTMLElement;
+    /** Optional callback invoked after a table line's final styles/markers are applied. */
+    captureLineSnapshot?: (lineEl: HTMLElement, context: FragmentRenderContext, options?: {
+        inTableParagraph?: boolean;
+        wrapperEl?: HTMLElement;
+    }) => void;
+    /** Function to render drawing content (images, shapes, shape groups) */
+    renderDrawingContent?: (block: DrawingBlock, interactionHost: HTMLElement, measure: DrawingMeasure) => HTMLElement;
+    /** Function to apply SDT metadata as data attributes */
+    applySdtDataset: (el: HTMLElement | null, metadata?: SdtMetadata | null) => void;
+    /** Ancestor SDT container key for suppressing duplicate container styling in cells */
+    ancestorContainerKey?: string | null;
+    /** Ancestor SDT metadata for suppressing duplicate id-less container styling in cells */
+    ancestorContainerSdt?: SdtMetadata | null;
+    /** Ancestor SDT keys for suppressing duplicate container styling in cells */
+    ancestorContainerKeys?: SdtAncestorOptions['ancestorContainerKeys'];
+    /** Ancestor SDT metadata chain for suppressing duplicate id-less container styling in cells */
+    ancestorContainerSdts?: SdtAncestorOptions['ancestorContainerSdts'];
+    /** Receives notification when cells render SDT container chrome */
+    onSdtContainerChrome?: () => void;
+    /**
+     * If true, this row is the first body row of a continuation fragment.
+     * MS Word draws borders at split points to visually close the table on each page,
+     * so we do NOT suppress borders - both fragments draw their edge borders.
+     */
+    continuesFromPrev?: boolean;
+    /**
+     * If true, this row is the last body row before a page break continuation.
+     * MS Word draws borders at split points to visually close the table on each page,
+     * so we do NOT suppress borders - both fragments draw their edge borders.
+     */
+    continuesOnNext?: boolean;
+    /**
+     * Partial row information for mid-row splits.
+     * Contains per-cell line ranges (fromLineByCell, toLineByCell) for rendering
+     * only a portion of the row's content.
+     */
+    partialRow?: PartialRowInfo;
+    /**
+     * Cell spacing in pixels (border-spacing between cells).
+     * Applied to cell x positions and row y advancement.
+     */
+    cellSpacingPx?: number;
+    /** Built-in SDT chrome rendering mode. */
+    chrome?: 'default' | 'none';
+    /**
+     * Per-document logical->physical font resolver for in-cell list markers and drop caps. Threaded
+     * from the renderer's per-document resolver so they paint the same physical family they were
+     * measured in. Undefined falls back to the global resolver.
+     */
+    resolvePhysical?: ResolvePhysicalFamily;
+};
+/**
+ * Renders all cells in a table row.
+ *
+ * Iterates through cells in the row, resolving borders based on cell position,
+ * and rendering each cell with its content. Cells are positioned horizontally
+ * by accumulating their widths.
+ *
+ * Border resolution logic:
+ * - Cells with explicit borders use those borders
+ * - Otherwise, cells use position-based borders from table borders:
+ *   - Edge cells use outer table borders
+ *   - Interior cells use inside borders (insideH, insideV)
+ * - If no table borders exist, default borders are applied
+ *
+ * @param deps - All dependencies required for rendering
+ *
+ * @example
+ * ```typescript
+ * renderTableRow({
+ *   doc: document,
+ *   container: tableContainer,
+ *   rowIndex: 0,
+ *   y: 0,
+ *   rowMeasure,
+ *   row,
+ *   totalRows: 3,
+ *   tableBorders,
+ *   context,
+ *   renderLine,
+ *   applySdtDataset
+ * });
+ * // Appends all cell elements to container
+ * ```
+ */
+export declare const renderTableRow: (deps: TableRowRenderDependencies) => void;
+export {};

package/dist/layout-engine/painters/dom/src/test-utils/normalize-line.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Test-only normalization helpers for comparing rendered line output
+ * across different rendering contexts (body, table-cell).
+ *
+ * DO NOT import this file from production code. Only *.test.ts and
+ * other test-utils/ files may import from here.
+ */
+export interface NormalizedRun {
+    text: string;
+    fontFamily: string | undefined;
+    fontSize: string | undefined;
+    fontWeight: string | undefined;
+    fontStyle: string | undefined;
+    color: string | undefined;
+    textDecoration: string | undefined;
+    backgroundColor: string | undefined;
+    href: string | undefined;
+    target: string | undefined;
+    rel: string | undefined;
+}
+export interface NormalizedLine {
+    textAlign: string;
+    wordSpacing: string;
+    runs: NormalizedRun[];
+    marker?: {
+        text: string;
+        justification: string | undefined;
+    };
+}
+/**
+ * Normalize a single .superdoc-line element into a semantic representation.
+ * Extracts line-level styles (textAlign, wordSpacing) and per-run styles
+ * from child span elements.
+ */
+export declare function normalizeLine(lineEl: HTMLElement): NormalizedLine;
+/**
+ * Find all .superdoc-line elements within a container and normalize them.
+ */
+export declare function normalizeLines(container: HTMLElement): NormalizedLine[];

package/dist/layout-engine/painters/dom/src/utils/anchor-helpers.d.ts

@@ -0,0 +1,3 @@
+import { WrapExclusion } from '../../../../contracts/src/index.js';
+import { RenderedLineInfo } from '../renderer.js';
+export declare const applySquareWrapExclusionsToLines: (renderedLines: RenderedLineInfo[], exclusions: WrapExclusion[], contentWidthPx: number, alignmentOffsetY: number) => void;

package/dist/layout-engine/painters/dom/src/utils/apply-styles.d.ts

@@ -0,0 +1 @@
+export declare const applyStyles: (el: HTMLElement, styles: Partial<CSSStyleDeclaration>) => void;

package/dist/layout-engine/painters/dom/src/utils/layout-identity.d.ts

@@ -0,0 +1,9 @@
+import { LayoutSourceIdentity } from '../../../../contracts/src/index.js';
+/**
+ * Stamp the editor-neutral layout-identity dataset (prep-001).
+ *
+ * Additive only — runs alongside legacy `data-pm-*` / `data-block-id` writes.
+ * v1 consumers still read PM-shaped datasets; future editor-neutral consumers
+ * read `data-layout-fragment-id` / `data-layout-story` / `data-layout-block-ref`.
+ */
+export declare function applyLayoutIdentityDataset(element: HTMLElement, identity: LayoutSourceIdentity | undefined): void;

package/dist/layout-engine/painters/dom/src/utils/source-anchor.d.ts

@@ -0,0 +1,2 @@
+import { SourceAnchor } from '../../../../contracts/src/index.js';
+export declare function applySourceAnchorDataset(element: HTMLElement, sourceAnchor?: SourceAnchor): void;

package/dist/layout-engine/style-engine/src/bench/resolveSdtMetadata.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/layout-engine/style-engine/src/cascade.d.ts

@@ -0,0 +1,43 @@
+import { ParagraphProperties, RunFontFamilyProperties, RunProperties } from './ooxml/types.js';
+import { TableCellProperties, TableProperties } from './ooxml/styles-types.js';
+export type PropertyObject = ParagraphProperties | RunProperties | TableCellProperties | TableProperties;
+/**
+ * Performs a deep merge on an ordered list of property objects.
+ *
+ * This is the core cascade function used throughout style resolution.
+ * Properties from later objects in the array override earlier ones.
+ *
+ * @param propertiesArray - Ordered list of property objects to combine (low -> high priority).
+ * @param options - Configuration for full overrides and special handling.
+ * @returns Combined property object.
+ */
+export declare function combineProperties<T extends PropertyObject>(propertiesArray: T[], options?: {
+    /**
+     * Keys that should completely overwrite instead of deep merge.
+     * Use this for complex objects like fontFamily or color that should
+     * be replaced entirely rather than merged property-by-property.
+     */
+    fullOverrideProps?: string[];
+    /**
+     * Custom merge handlers for specific keys.
+     * The handler receives the accumulated target and current source,
+     * and returns the new value for that key.
+     */
+    specialHandling?: Record<string, (target: Record<string, unknown>, source: Record<string, unknown>) => unknown>;
+}): T;
+/**
+ * Combines run property objects while fully overriding certain keys.
+ * This is a convenience wrapper for run properties (w:rPr).
+ *
+ * @param propertiesArray - Ordered list of run property objects.
+ * @returns Combined run property object.
+ */
+export declare const FONT_SLOT_THEME_PAIRS: Array<[keyof RunFontFamilyProperties, keyof RunFontFamilyProperties]>;
+export declare function combineRunProperties(propertiesArray: RunProperties[]): RunProperties;
+/**
+ * Combines indent properties with special handling for firstLine/hanging mutual exclusivity.
+ *
+ * @param indentChain - Ordered list of indent property objects (or objects with indent property).
+ * @returns Combined indent object.
+ */
+export declare function combineIndentProperties(indentChain: ParagraphProperties[]): ParagraphProperties;