superdoc 2.2.0 → 2.3.0

package/dist/layout-engine/layout-engine/src/index.d.ts

@@ -0,0 +1,349 @@
+import { ColumnLayout, FlowBlock, HeaderFooterLayout, Layout, Measure, Page, ParagraphBlock, ParagraphMeasure, SectionMetadata, FlowMode, DocumentBackground } from '../../contracts/src/index.js';
+import { PageState, ConstraintBoundary } from './paginator.js';
+type PageSize = {
+    w: number;
+    h: number;
+};
+type Margins = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    header?: number;
+    footer?: number;
+};
+/**
+ * Synthetic page height used in semantic flow mode to avoid pagination-driven clipping
+ * during measurement. A large finite value preserves stable measurement constraints.
+ */
+export declare const SEMANTIC_PAGE_HEIGHT_PX = 1000000;
+export type LayoutOptions = {
+    pageSize?: PageSize;
+    margins?: Margins;
+    documentBackground?: DocumentBackground;
+    columns?: ColumnLayout;
+    flowMode?: FlowMode;
+    semantic?: {
+        contentWidth?: number;
+        marginLeft?: number;
+        marginRight?: number;
+        marginTop?: number;
+        marginBottom?: number;
+    };
+    remeasureParagraph?: (block: ParagraphBlock, maxWidth: number, firstLineIndent?: number) => ParagraphMeasure;
+    /** @internal Positioned paragraph frames that render without advancing the story cursor. */
+    nonFlowPositionedParagraphFrameIds?: ReadonlySet<string>;
+    sectionMetadata?: SectionMetadata[];
+    /**
+     * Extra bottom margin per page index (0-based) reserved for non-body content
+     * rendered at the bottom of the page (e.g., footnotes).
+     *
+     * When provided, the paginator will shrink the body content area on that page by
+     * increasing the effective bottom margin for that page only.
+     */
+    footnoteReservedByPageIndex?: number[];
+    /**
+     * Footnote metadata. The core layout engine consumes only the fields below
+     * (SD-3049: ref positions + per-footnote body heights for block-aware breaks).
+     * Higher-level orchestration (layout-bridge) attaches additional fields
+     * (`blocksById`, separator dimensions, etc.) which the engine ignores.
+     */
+    footnotes?: {
+        refs?: Array<{
+            id: string;
+            pos: number;
+        }>;
+        /**
+         * SD-3049: total measured body height per footnote id (sum of measured
+         * paragraph heights + per-paragraph spacingAfter + inter-footnote gap +
+         * separator overhead). Used by the body paginator to consult footnote
+         * demand at fragment-commit time so body packs tight to the demand.
+         */
+        bodyHeightById?: Map<string, number>;
+        /**
+         * SD-2656: per-footnote first valid line/run height. The ordered-cluster
+         * rule (Word-style) requires only the LAST anchor on a page to fit its
+         * first line; all earlier anchors must fit fully (bodyHeightById). When
+         * present, the body slicer uses this value for the last anchor in the
+         * candidate cluster, otherwise falls back to bodyHeightById.
+         */
+        firstLineHeightById?: Map<string, number>;
+        [key: string]: unknown;
+    };
+    /**
+     * Actual measured header content heights per variant type.
+     * When provided, the layout engine will ensure body content starts below
+     * the header content, preventing overlap when headers exceed their allocated margin space.
+     *
+     * Keys correspond to header variant types: 'default', 'first', 'even', 'odd'
+     * Values are the actual content heights in pixels.
+     */
+    headerContentHeights?: Partial<Record<'default' | 'first' | 'even' | 'odd', number>>;
+    /**
+     * Actual measured footer content heights per variant type.
+     * When provided, the layout engine will ensure body content ends above
+     * the footer content, preventing overlap when footers exceed their allocated margin space.
+     *
+     * Keys correspond to footer variant types: 'default', 'first', 'even', 'odd'
+     * Values are the actual content heights in pixels.
+     */
+    footerContentHeights?: Partial<Record<'default' | 'first' | 'even' | 'odd', number>>;
+    /**
+     * Actual measured header content heights per relationship ID.
+     * Used for multi-section documents where each section may have unique
+     * headers/footers referenced by their relationship IDs.
+     *
+     * Keys are relationship IDs (e.g., 'rId6', 'rId7')
+     * Values are the actual content heights in pixels.
+     */
+    headerContentHeightsByRId?: Map<string, number>;
+    /**
+     * Actual measured header content heights per section-specific reference.
+     *
+     * Keys combine the relationship ID and section index using the form
+     * `${rId}::s${sectionIndex}` so the reserve path can distinguish documents
+     * that reuse the same header part across sections with different geometry.
+     */
+    headerContentHeightsBySectionRef?: Map<string, number>;
+    /**
+     * Actual measured footer content heights per relationship ID.
+     * Used for multi-section documents where each section may have unique
+     * footers referenced by their relationship IDs.
+     *
+     * Keys are relationship IDs (e.g., 'rId8', 'rId9')
+     * Values are the actual content heights in pixels.
+     */
+    footerContentHeightsByRId?: Map<string, number>;
+    /**
+     * Actual measured footer content heights per section-specific reference.
+     *
+     * Keys combine the relationship ID and section index using the form
+     * `${rId}::s${sectionIndex}` so the reserve path can distinguish documents
+     * that reuse the same footer part across sections with different geometry.
+     */
+    footerContentHeightsBySectionRef?: Map<string, number>;
+    /**
+     * Allow body layout to synthesize page 1 for anchored tables when a document has
+     * no anchor paragraphs and would otherwise render zero pages.
+     *
+     * Header/footer layout keeps this disabled to avoid changing long-standing
+     * overlay behavior in paragraph-free header/footer regions.
+     */
+    allowParagraphlessAnchoredTableFallback?: boolean;
+    allowParagraphlessAnchoredDrawingFallback?: boolean;
+    /**
+     * Allow body layout to synthesize page 1 when section metadata exists but no
+     * renderable body blocks survive conversion.
+     *
+     * Header/footer layout keeps this disabled to preserve existing empty-region
+     * behavior for paragraph-free overlays.
+     */
+    allowSectionBreakOnlyPageFallback?: boolean;
+    /**
+     * Whether the document has odd/even header/footer differentiation enabled.
+     * Corresponds to the w:evenAndOddHeaders element in OOXML settings.xml.
+     * When true, odd pages use the 'odd' variant and even pages use the 'even' variant.
+     * When false or omitted, all pages use the 'default' variant.
+     *
+     * Must stay in sync with `getHeaderFooterTypeForSection` in
+     * `layout-bridge/src/headerFooterUtils.ts` — both sides read this value
+     * and must agree on variant selection.
+     */
+    alternateHeaders?: boolean;
+    /**
+     * Additive start context for page-boundary resume callers. Omitted input
+     * preserves the historical page-1 start behavior.
+     */
+    startContext?: {
+        /** Physical page-number offset for emitted `Page.number` values. */
+        pageNumberOffset?: number;
+        /** Display/effective page counter to stamp on the first emitted page. */
+        activePageCounter?: number;
+        /** Active section index at the page boundary. */
+        activeSectionIndex?: number;
+        /** Physical page number on which the active section began. */
+        activeSectionFirstPageNumber?: number;
+        /** Effective inherited header/footer refs at the resumed page boundary. */
+        activeSectionRefs?: {
+            headerRefs?: Partial<Record<'default' | 'first' | 'even' | 'odd', string>>;
+            footerRefs?: Partial<Record<'default' | 'first' | 'even' | 'odd', string>>;
+        };
+        /** Effective page orientation at the resumed page boundary. */
+        activeOrientation?: 'portrait' | 'landscape' | null;
+        /**
+         * Base (uninflated) top/bottom margins of the active section at the
+         * resumed boundary (SD-3772 D2). These seed the section base state so a
+         * resumed run can never re-inflate an already header/footer-inflated
+         * effective margin; `options.margins` stays the document default so
+         * later section breaks with missing fields fall back exactly like cold.
+         */
+        activeSectionBaseMargins?: {
+            top: number;
+            bottom: number;
+        };
+        /** Active left/right margins of the resumed section. */
+        activeSectionSideMargins?: {
+            left: number;
+            right: number;
+        };
+        /** Active header/footer distances of the resumed section. */
+        activeHeaderFooterDistances?: {
+            header: number;
+            footer: number;
+        };
+        /** Active page size at the resumed boundary (document default when omitted). */
+        activePageSize?: {
+            w: number;
+            h: number;
+        };
+        /** Resolved active column layout at the resumed boundary. */
+        activeColumns?: ColumnLayout;
+        /** Engine-authored exact state for a paragraph boundary inside the first emitted page. */
+        initialPageState?: {
+            prefixFragments: readonly Page['fragments'][number][];
+            cursorY: number;
+            maxCursorY: number;
+            columnIndex: number;
+            trailingSpacing: number;
+            lastParagraphStyleId?: string;
+            lastParagraphContextualSpacing: boolean;
+            lastParagraphBorderHash?: string;
+            constraintBoundaries: readonly ConstraintBoundary[];
+            activeConstraintIndex: number;
+            footnoteDemandThisPage: number;
+            footnoteRefsThisPage: number;
+            footnoteAnchorsThisPage: readonly PageState['footnoteAnchorsThisPage'][number][];
+        };
+    };
+    /**
+     * Optional page-boundary stop callback. Called after a page has completed
+     * and before the next page is created; returning true makes layoutDocument
+     * return the completed prefix.
+     */
+    pageBoundary?: {
+        shouldStopBeforeNewPage?: (input: {
+            completedPageIndex: number;
+            pages: readonly Page[];
+        }) => boolean;
+    };
+};
+export type HeaderFooterConstraints = {
+    width: number;
+    /** Body content height used as the measurement canvas (pagination boundary). */
+    height: number;
+    /** Actual page width for page-relative anchor positioning. */
+    pageWidth?: number;
+    /** Physical page height for vertical page-relative anchor conversion. */
+    pageHeight?: number;
+    /**
+     * Page margins for anchor positioning.
+     * `left`/`right`: horizontal page-relative conversion.
+     * `top`/`bottom`: vertical margin-relative conversion and fallback footer band origin.
+     * `header`: header distance from page top edge (header band origin).
+     * `footer`: footer distance from page bottom edge (footer band origin).
+     */
+    margins?: {
+        left: number;
+        right: number;
+        top?: number;
+        bottom?: number;
+        header?: number;
+        footer?: number;
+    };
+    /**
+     * Optional base height used to bound behindDoc overflow handling.
+     * When provided, decorative assets far outside the header/footer band
+     * won't inflate layout height.
+     */
+    overflowBaseHeight?: number;
+};
+/**
+ * Layout FlowBlocks into paginated fragments using measured line data.
+ *
+ * The function is intentionally deterministic: it walks the provided
+ * FlowBlocks in order, consumes their Measure objects (same index),
+ * and greedily stacks fragments inside the content box of each page/column.
+ */
+export declare function layoutDocument(blocks: FlowBlock[], measures: Measure[], options?: LayoutOptions): Layout;
+export type LayoutRangeBoundaryPolicy = 'conservative-context' | 'overscan' | 'degraded-on-incomplete-state';
+export type LayoutRangeExactness = 'exact' | 'pending-layout' | 'degraded-unsupported' | 'stale';
+export type LayoutRangeSourceRange = {
+    startOrdinal: number;
+    endOrdinalExclusive: number;
+};
+export type LayoutRangePage = {
+    pageIndex: number;
+    page: Page;
+    sourceRange: LayoutRangeSourceRange | null;
+};
+export type LayoutRangeCheckpoint = {
+    pageIndex: number;
+    sourceOrdinal: number;
+    pageNumber?: number;
+    pageTopPx?: number;
+    pageSize?: PageSize;
+    margins?: Margins;
+    activeColumns?: ColumnLayout;
+};
+export type LayoutRangeInput = {
+    sourceSegment: {
+        blocks: readonly FlowBlock[];
+        measures: readonly Measure[];
+        sourceRange: LayoutRangeSourceRange;
+    };
+    startingCheckpoint: LayoutRangeCheckpoint | null;
+    pageRange: {
+        startPageIndex: number;
+        endPageIndexExclusive: number;
+    };
+    pageCountBudget?: number;
+    ordinalBudget?: number;
+    boundaryPolicy?: LayoutRangeBoundaryPolicy;
+    overscanBeforePages?: number;
+    overscanAfterPages?: number;
+    options?: LayoutOptions;
+};
+export type LayoutRangeResult = {
+    layout: Layout;
+    pages: readonly LayoutRangePage[];
+    endingCheckpoint: LayoutRangeCheckpoint | null;
+    exactness: LayoutRangeExactness;
+    diagnostics: readonly string[];
+};
+/**
+ * Legacy page-range exploration.
+ *
+ * This is not used by performance:pipeline or performance:pipeline:typing.
+ * The new mutation work starts with the dedicated snapshotComplete stage in
+ * the performance pipeline harness and should not be built on this API.
+ *
+ * Layout a page range from a validated page-boundary checkpoint without
+ * replaying the document prefix. This first production slice is deliberately
+ * conservative: simple self-contained ranges can be exact; unsupported shapes
+ * fail closed so callers can paint pending/degraded slots instead of compacting
+ * sparse content into fake page numbers.
+ */
+export declare function layoutDocumentRange(input: LayoutRangeInput): LayoutRangeResult;
+/**
+ * Lays out header or footer content within specified dimensional constraints.
+ *
+ * Positions blocks within a header/footer region, handling page-relative anchor
+ * transformations and computing the actual height required by visible content.
+ *
+ * When `kind` and `constraints.pageHeight` are provided, page-relative and
+ * margin-relative anchored drawings are post-normalized from the synthetic
+ * measurement canvas to header/footer-local coordinates.
+ *
+ * Returns separate measurement bounds (for pagination) and render bounds
+ * (for overlay shift). See the Coordinate Contract in the fix plan for details.
+ */
+export declare function layoutHeaderFooter(blocks: FlowBlock[], measures: Measure[], constraints: HeaderFooterConstraints, kind?: 'header' | 'footer', remeasureParagraph?: (block: ParagraphBlock, maxWidth: number, firstLineIndent?: number) => ParagraphMeasure): HeaderFooterLayout;
+export { buildAnchorMap, resolvePageRefTokens, getTocBlocksForRemeasurement } from './resolvePageRefs.js';
+export { buildChapterContextByPage, computeDisplayPageNumber, formatPageNumber, formatPageNumberFieldValue, formatSectionPageNumberText, normalizeChapterMarkerText, } from './pageNumbering.js';
+export type { ChapterPageInfo, DisplayPageInfo, PageNumberFormat } from './pageNumbering.js';
+export { resolvePageNumberTokens } from './resolvePageTokens.js';
+export type { NumberingContext, ResolvePageTokensResult, ResolvePageTokensOptions } from './resolvePageTokens.js';
+export { getCellLines, getEmbeddedRowLines, resolveTableFrame, resolveRenderedTableWidth } from './layout-table.js';
+export { describeCellRenderBlocks, computeCellSliceContentHeight } from './table-cell-slice.js';
+export { layoutTextboxContent, resolveTextboxContentMeasures } from './layout-textbox.js';
+export { SINGLE_COLUMN_DEFAULT } from './section-breaks.js';

package/dist/layout-engine/layout-engine/src/layout-drawing.d.ts

@@ -0,0 +1,60 @@
+import { DrawingBlock, DrawingMeasure, ParagraphMeasure } from '../../contracts/src/index.js';
+import { NormalizedColumns } from './layout-image.js';
+import { PageState } from './paginator.js';
+/**
+ * Context for laying out a drawing block (vector shape) within the page layout.
+ *
+ * Drawings are vector-based graphical objects (shapes, diagrams, etc.) that can be
+ * positioned inline or anchored. This context provides all necessary information and
+ * callbacks for positioning the drawing fragment on the current page/column.
+ */
+export type DrawingLayoutContext = {
+    /** The drawing block to layout */
+    block: DrawingBlock;
+    /** Measured dimensions and geometry data for the drawing */
+    measure: DrawingMeasure;
+    /** Normalized column configuration (width, gap, count) for the current layout */
+    columns: NormalizedColumns;
+    /** Ensures a page exists and returns the current page state */
+    ensurePage: () => PageState;
+    /** Advances to the next column or page, returning the new page state */
+    advanceColumn: (state: PageState) => PageState;
+    /** Computes the X coordinate for a column in the given page state (SD-2629). */
+    columnX: (state: PageState, columnIndex?: number) => number;
+    /** Optional textbox paragraph measurements carried alongside textbox drawings. */
+    textboxContentMeasures?: ParagraphMeasure[];
+};
+/**
+ * Layout a drawing block (vector shape) within the document flow.
+ *
+ * This function handles inline/block-level vector shapes (rectangles, circles, etc.),
+ * positioning them on the page with proper scaling and margin handling. Anchored
+ * drawings (positioned objects) are skipped and handled separately via the anchoring
+ * system.
+ *
+ * Algorithm:
+ * 1. Skip anchored drawings (handled by anchor system)
+ * 2. Apply margins and scale drawing to fit within column width
+ * 3. Scale down if drawing exceeds page content height
+ * 4. Advance column/page if drawing doesn't fit at current cursor position
+ * 5. Create DrawingFragment with final position and dimensions
+ * 6. Push fragment to page and advance cursor
+ *
+ * @param context - Layout context containing block, measure, and layout callbacks
+ *
+ * @remarks
+ * **Side Effects:**
+ * - Mutates page state via `ensurePage()` and `advanceColumn()`
+ * - Pushes DrawingFragment to `state.page.fragments`
+ * - Advances `state.cursorY` by the drawing's total height (including margins)
+ *
+ * **Scaling Behavior:**
+ * - Width is constrained to fit within column width (minus margins)
+ * - Height is constrained to fit within page content height
+ * - Aspect ratio is preserved during scaling
+ *
+ * **Anchored Drawings:**
+ * - Anchored drawings (`block.anchor?.isAnchored === true`) are skipped
+ * - They are positioned via the paragraph anchoring pre-pass
+ */
+export declare function layoutDrawingBlock({ block, measure, columns, ensurePage, advanceColumn, columnX, textboxContentMeasures, }: DrawingLayoutContext): void;

package/dist/layout-engine/layout-engine/src/layout-image.d.ts

@@ -0,0 +1,16 @@
+import { ImageBlock, ImageMeasure } from '../../contracts/src/index.js';
+import { PageState } from './paginator.js';
+export type NormalizedColumns = {
+    width: number;
+    gap: number;
+    count: number;
+};
+export type ImageLayoutContext = {
+    block: ImageBlock;
+    measure: ImageMeasure;
+    columns: NormalizedColumns;
+    ensurePage: () => PageState;
+    advanceColumn: (state: PageState) => PageState;
+    columnX: (state: PageState, columnIndex?: number) => number;
+};
+export declare function layoutImageBlock({ block, measure, columns, ensurePage, advanceColumn, columnX, }: ImageLayoutContext): void;

package/dist/layout-engine/layout-engine/src/layout-paragraph.d.ts

@@ -0,0 +1,101 @@
+import { FloatingObjectManager } from './floating-objects.js';
+import { PageState } from './paginator.js';
+import { PageMargins, ParagraphBlock, ParagraphMeasure, ImageBlock, ImageMeasure, DrawingBlock, DrawingMeasure } from '../../contracts/src/index.js';
+import { AnchoredTable } from './anchors.js';
+/**
+ * SD-2656: ordered footnote anchor entry. The body slicer reads the candidate
+ * anchors for a given PM range and pushes them onto `PageState.footnoteAnchorsThisPage`
+ * after committing the slice; the demand formula consumes the resulting list.
+ */
+export type FootnoteAnchorRef = {
+    pmPos: number;
+    refId: string;
+    fullHeight: number;
+    firstLineHeight: number;
+};
+export type ParagraphLayoutContext = {
+    block: ParagraphBlock;
+    measure: ParagraphMeasure;
+    columnWidth: number;
+    ensurePage: () => PageState;
+    advanceColumn: (state: PageState) => PageState;
+    columnX: (state: PageState, columnIndex?: number) => number;
+    floatManager: FloatingObjectManager;
+    remeasureParagraph?: (block: ParagraphBlock, maxWidth: number, firstLineIndent?: number) => ParagraphMeasure;
+    /**
+     * Override the paragraph's spacing-after value. Used when contextual spacing
+     * should suppress spacing between this paragraph and the next (same-style) paragraph.
+     * When undefined, uses the value from block.attrs.spacing.after.
+     */
+    overrideSpacingAfter?: number;
+    /**
+     * SD-3049 / SD-2656: footnote demand under the ordered-cluster rule.
+     *
+     *   demand = sum(fullHeight of cluster[0..N-1]) + firstLineHeight(cluster[N-1])
+     *
+     * where `cluster` is the ordered list of footnote anchors on the page. The
+     * caller passes the already-committed anchors (from PageState) plus the
+     * candidate range; this returns the demand assuming the candidate range is
+     * appended to the page's cluster.
+     *
+     * With no committed list, the in-range anchors are treated as the full
+     * cluster. With no range, returns the whole-block demand.
+     */
+    getFootnoteDemandForBlockId?: (blockId: string, pmStart?: number, pmEnd?: number, committed?: ReadonlyArray<FootnoteAnchorRef>) => number;
+    /**
+     * SD-2656: returns the ordered anchor entries in `[pmStart, pmEnd]` so the
+     * slicer can push them onto PageState after accepting a candidate line.
+     */
+    getFootnoteAnchorsForBlockId?: (blockId: string, pmStart?: number, pmEnd?: number) => ReadonlyArray<FootnoteAnchorRef>;
+    /**
+     * SD-2656: companion to getFootnoteDemandForBlockId — returns the number
+     * of footnote refs anchored in a given PM range of this block. Used to
+     * compute band overhead (separator + per-extra-ref gap + safety margin)
+     * for the candidate slice.
+     */
+    getFootnoteRefCountForBlockId?: (blockId: string, pmStart?: number, pmEnd?: number) => number;
+    /**
+     * SD-2656: per-page footnote-band overhead in pixels for a given number of
+     * anchored refs. The slicer's `effectiveBottom` budget must match the
+     * planner's, otherwise body packs onto a page whose band cannot fit the
+     * refs. Source of truth lives in the planner (incrementalLayout.ts) and
+     * derives from `topPadding + dividerHeight + separatorSpacingBefore +
+     * (refs-1)*gap`. When not provided, the slicer falls back to a default
+     * formula that matches the planner's default values.
+     */
+    getFootnoteBandOverhead?: (refsTotal: number) => number;
+    /**
+     * True when this paragraph exists only as a split line-break carrier for an
+     * anchored sibling from the same source paragraph. The paragraph must remain
+     * anchorable, but it must not emit its own visible fragment or consume
+     * vertical layout height.
+     */
+    layoutOnlyAnchorCarrier?: boolean;
+    /**
+     * True when a split line-break carrier carries paragraph spacing that should
+     * remain in the flow. The carrier reserves one line plus spacing instead of
+     * using the standalone line-break measure, which would double-count the soft
+     * break after the paragraph was split around the anchored sibling.
+     */
+    collapseSplitLineBreakCarrier?: boolean;
+    /** Whether a wrap=around positioned frame advances the surrounding story flow. */
+    positionedFrameAffectsFlow?: boolean;
+};
+export type AnchoredDrawingEntry = {
+    block: ImageBlock | DrawingBlock;
+    measure: ImageMeasure | DrawingMeasure;
+};
+export type ParagraphAnchorsContext = {
+    anchoredDrawings?: AnchoredDrawingEntry[];
+    anchoredTables?: AnchoredTable[];
+    columnWidth: number;
+    pageWidth: number;
+    pageMargins: PageMargins;
+    columns: {
+        width: number;
+        gap: number;
+        count: number;
+    };
+    placedAnchoredIds: Set<string>;
+};
+export declare function layoutParagraphBlock(ctx: ParagraphLayoutContext, anchors?: ParagraphAnchorsContext): void;

package/dist/layout-engine/layout-engine/src/layout-table.d.ts

@@ -0,0 +1,71 @@
+import { TableBlock, TableMeasure, TableFragment, TableRowMeasure } from '../../contracts/src/index.js';
+import { PageState } from './paginator.js';
+export { ANCHORED_TABLE_FULL_WIDTH_RATIO, isAnchoredTableFullWidth } from './floating-table-anchor.js';
+export type TableLayoutContext = {
+    block: TableBlock;
+    measure: TableMeasure;
+    columnWidth: number;
+    ensurePage: () => PageState;
+    advanceColumn: (state: PageState) => PageState;
+    columnX: (state: PageState, columnIndex?: number) => number;
+};
+export declare function resolveRenderedTableWidth(columnWidth: number, measuredWidth: number, attrs: TableBlock['attrs']): number;
+/**
+ * Resolve the table fragment frame within a column based on justification.
+ *
+ * When justification is center or right/end, the table is aligned within the
+ * column width and tableIndent is ignored. Otherwise, tableIndent offsets the
+ * table from the left margin and clamps width only when needed to avoid overflow.
+ *
+ * @param baseX - Left edge of the column in pixels
+ * @param columnWidth - Available column width in pixels
+ * @param tableWidth - Measured table width in pixels
+ * @param attrs - Table attributes
+ * @returns Resolved x and width for the table fragment
+ */
+export declare function resolveTableFrame(baseX: number, columnWidth: number, tableWidth: number, attrs: TableBlock['attrs']): {
+    x: number;
+    width: number;
+};
+/**
+ * Get the line segments for a single embedded table row.
+ *
+ * If any cell in the row contains nested tables, recursively expand using
+ * the tallest cell's segments. This enables the layout engine to split at
+ * sub-row boundaries even for deeply nested tables (table-in-table-in-table).
+ * Otherwise, return the row as a single segment with its measured height.
+ */
+export declare function getEmbeddedRowLines(row: TableRowMeasure): Array<{
+    lineHeight: number;
+}>;
+export declare function getCellLines(cell: TableRowMeasure['cells'][number]): Array<{
+    lineHeight: number;
+}>;
+/**
+ * Layout a table block with row-boundary and mid-row splitting.
+ *
+ * Implements MS Word-compatible table splitting:
+ * - Breaks tables at row boundaries when exceeding page height
+ * - Splits rows mid-content when cantSplit is false (default)
+ * - Respects cantSplit attribute (prevents row from splitting)
+ * - Repeats header rows on continuation fragments
+ * - Handles floating tables (tblpPr) with monolithic layout
+ * - Tracks partial row continuations across pages
+ *
+ * Algorithm:
+ * 1. Detect floating tables → delegate to monolithic layout
+ * 2. Count header rows
+ * 3. Loop through rows, finding split points
+ * 4. When a partial row split occurs, track it for continuation
+ * 5. Create fragments with proper fromRow/toRow/repeatHeaderCount/partialRow
+ * 6. Advance cursor by actual fragment height (not total table height)
+ *
+ * @param context - Table layout context
+
+ */
+export declare function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColumn, columnX, }: TableLayoutContext): void;
+/**
+ * Create a table fragment for an anchored/floating table at its computed position.
+ * Called by the layout engine after the float manager computes the table's position.
+ */
+export declare function createAnchoredTableFragment(block: TableBlock, measure: TableMeasure, x: number, y: number): TableFragment;

package/dist/layout-engine/layout-engine/src/layout-textbox.d.ts

@@ -0,0 +1,4 @@
+import { DrawingMeasure, ParagraphMeasure, TextboxDrawing } from '../../contracts/src/index.js';
+export declare function layoutTextboxContent(block: TextboxDrawing, remeasureParagraph: (block: TextboxDrawing['contentBlocks'][number], maxWidth: number) => ParagraphMeasure): ParagraphMeasure[];
+/** Prefer canonical measurement output, retaining the synchronous bridge as a legacy fallback. */
+export declare function resolveTextboxContentMeasures(block: TextboxDrawing, measure: DrawingMeasure, remeasureParagraph?: (block: TextboxDrawing['contentBlocks'][number], maxWidth: number) => ParagraphMeasure): ParagraphMeasure[] | undefined;