superdoc 2.2.0 → 2.3.0

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

@@ -0,0 +1,185 @@
+import { BorderSpec, CellBorders, TableBorderValue, TableBorders, TableFragment } from '../../../../contracts/src/index.js';
+import { TableCellGridPosition } from './grid-geometry.js';
+/**
+ * Applies a border specification to one side of an HTML element.
+ *
+ * Converts BorderSpec format to CSS border properties and applies them to the specified
+ * side of the element. Handles style conversion (e.g., 'single' → 'solid'), color validation,
+ * and special cases like 'thick' borders which use doubled width.
+ *
+ * @param element - The HTML element to apply the border to
+ * @param side - Which side of the element to apply the border ('Top', 'Right', 'Bottom', or 'Left')
+ * @param border - The border specification to apply, or undefined to skip
+ *
+ * @example
+ * ```typescript
+ * const cell = document.createElement('td');
+ * applyBorder(cell, 'Top', { style: 'single', width: 2, color: '#FF0000' });
+ * // Sets cell.style.borderTop = '2px solid #FF0000'
+ * ```
+ */
+export declare const applyBorder: (element: HTMLElement, side: "Top" | "Right" | "Bottom" | "Left", border?: BorderSpec) => void;
+/**
+ * Applies border specifications to all four sides of a table cell element.
+ *
+ * Convenience function that applies borders to top, right, bottom, and left sides
+ * of an element using applyBorder(). Only applies borders for sides that are defined
+ * in the CellBorders object.
+ *
+ * @param element - The HTML element (typically a table cell) to apply borders to
+ * @param borders - Cell border specifications for each side, or undefined to skip
+ *
+ * @example
+ * ```typescript
+ * const cell = document.createElement('td');
+ * applyCellBorders(cell, {
+ *   top: { style: 'single', width: 1, color: '#000000' },
+ *   left: { style: 'double', width: 2, color: '#FF0000' }
+ * });
+ * ```
+ */
+export declare const applyCellBorders: (element: HTMLElement, borders?: CellBorders) => void;
+/**
+ * Converts a TableBorderValue to a BorderSpec for rendering.
+ *
+ * Handles conversion of table-level border values (which may include {none: true} markers)
+ * to BorderSpec format used by the DOM renderer. Supports both 'width' and legacy 'size'
+ * properties.
+ *
+ * @param value - Table border value to convert, or null/undefined
+ * @returns BorderSpec for rendering, or undefined if value is null/undefined
+ *
+ * @example
+ * ```typescript
+ * const spec = borderValueToSpec({ style: 'single', width: 2, color: '#FF0000' });
+ * // Returns: { style: 'single', width: 2, color: '#FF0000' }
+ *
+ * const none = borderValueToSpec({ none: true });
+ * // Returns: { style: 'none', width: 0 }
+ * ```
+ */
+export declare const borderValueToSpec: (value?: TableBorderValue | null) => BorderSpec | undefined;
+/**
+ * Resolves a table border value with fallback support.
+ *
+ * Attempts to use the explicit border value first, falling back to the fallback value
+ * if the explicit value is undefined or null. This is used when cell borders can come
+ * from either cell-specific definitions or table-level definitions.
+ *
+ * @param explicit - Primary border value to use (e.g., from cell attributes)
+ * @param fallback - Fallback border value (e.g., from table borders)
+ * @returns Resolved BorderSpec, or undefined if both values are undefined/null
+ *
+ * @example
+ * ```typescript
+ * const cellBorder = { style: 'double', width: 3, color: '#FF0000' };
+ * const tableBorder = { style: 'single', width: 1, color: '#000000' };
+ * const result = resolveTableBorderValue(cellBorder, tableBorder);
+ * // Returns BorderSpec from cellBorder (explicit wins)
+ * ```
+ */
+export declare const resolveTableBorderValue: (explicit: TableBorderValue | undefined | null, fallback?: TableBorderValue | undefined | null) => BorderSpec | undefined;
+export declare const isPresentBorder: (b?: BorderSpec) => b is BorderSpec;
+/**
+ * True when a border is EXPLICITLY set to none/nil (`w:val="nil"`/`"none"`), as opposed to
+ * simply unset/absent. The distinction matters for shared interior edges (§17.4.66): an
+ * explicit none on BOTH adjacent cells suppresses the divider, while an unset side inherits
+ * the table's insideH/insideV. Accepts either a CellBorders BorderSpec (`{style:'none'}`) or
+ * a TableBorderValue (`{none:true}`).
+ */
+export declare const isExplicitNoneBorder: (b?: unknown) => boolean;
+/**
+ * OOXML cell-border conflict resolution (ECMA-376 §17.4.66).
+ *
+ * With zero cell spacing, two cells sharing an edge each specify a border; the spec
+ * collapses them to a SINGLE displayed border:
+ *  1. If either side is nil/none/absent, the opposing (present) border is displayed.
+ *  2. Otherwise the border with greater weight wins, where
+ *     weight = (#lines in the style) × (style number).
+ *  3. Equal weight → the style higher on the precedence list (single first) wins.
+ *  4. Identical style → the color with the smaller brightness (R+B+2G, then B+2G, then
+ *     G) wins; finally the first border (reading order) wins.
+ *
+ * @param a - One side's border (the owning cell's, e.g. the lower/right cell)
+ * @param b - The opposing side's border (e.g. the upper/left neighbor)
+ * @returns The single BorderSpec to display, or undefined if neither is present.
+ */
+export declare const resolveBorderConflict: (a?: BorderSpec, b?: BorderSpec) => BorderSpec | undefined;
+/**
+ * Creates a border overlay element for a table fragment.
+ *
+ * Generates an absolutely-positioned div that renders table-level borders (top, right,
+ * bottom, left) on top of the table content. This is used to apply outer table borders
+ * without affecting the table's internal layout.
+ *
+ * @param doc - Document object for creating the overlay element
+ * @param fragment - Table fragment containing dimensions for the overlay
+ * @param tableBorders - Table border specifications
+ * @returns HTMLElement overlay with borders applied, or null if no borders are defined
+ *
+ * @example
+ * ```typescript
+ * const overlay = createTableBorderOverlay(document, fragment, {
+ *   top: { style: 'single', width: 2, color: '#000000' },
+ *   bottom: { style: 'single', width: 2, color: '#000000' }
+ * });
+ * if (overlay) container.appendChild(overlay);
+ * ```
+ */
+export declare const createTableBorderOverlay: (doc: Document, fragment: TableFragment, tableBorders: TableBorders) => HTMLElement | null;
+/**
+ * Resolves cell-specific borders based on cell position within a table.
+ *
+ * Implements a **single-owner border model** to prevent double borders when
+ * rendering tables with absolutely-positioned divs (which don't support CSS
+ * border-collapse). Each shared border is owned by exactly one cell:
+ *
+ * - TOP border: Cell owns its own top (first row uses table.top, others use insideH)
+ * - LEFT border: Cell owns its own left (first col uses table.left, others use insideV)
+ * - BOTTOM border: Only last row renders it (using table.bottom)
+ * - RIGHT border: Only last column renders it (using table.right)
+ *
+ * This ensures each border line is rendered exactly once, eliminating the
+ * double-border issue that occurs when adjacent cells both render their
+ * shared edge.
+ *
+ * @param tableBorders - Table-level border definitions
+ * @param cellPosition - Cell position and span within the table grid
+ * @returns CellBorders object with resolved borders for all four sides
+ *
+ * @example
+ * ```typescript
+ * // For a 3x3 table:
+ * // Cell (0,0): top=table.top, left=table.left, bottom=undefined, right=undefined
+ * // Cell (1,1): top=insideH, left=insideV, bottom=undefined, right=undefined
+ * // Cell (2,2): top=insideH, left=insideV, bottom=table.bottom, right=table.right
+ * ```
+ */
+/**
+ * Checks whether a CellBorders object has at least one explicitly defined side.
+ *
+ * Returns false when borders is undefined/null or when all four sides are undefined.
+ * Used to distinguish "no borders attribute" from "borders attribute present but empty"
+ * (intentionally borderless).
+ *
+ * @param cellBorders - Cell border definitions to check
+ * @returns True if at least one side (top, right, bottom, left) is defined
+ */
+export declare const hasExplicitCellBorders: (cellBorders?: CellBorders) => cellBorders is CellBorders;
+export declare const resolveTableCellBorders: (tableBorders: {
+    top?: TableBorderValue;
+    bottom?: TableBorderValue;
+    left?: TableBorderValue;
+    right?: TableBorderValue;
+    insideH?: TableBorderValue;
+    insideV?: TableBorderValue;
+}, cellPosition: TableCellGridPosition) => CellBorders;
+/**
+ * Swap left↔right on table borders for RTL tables (ECMA-376 Part 4 §14.3.2, §14.3.6).
+ * insideH/insideV and top/bottom are not affected by direction.
+ */
+export declare const swapTableBordersLR: (borders: TableBorders | undefined) => TableBorders | undefined;
+/**
+ * Swap left↔right on cell borders for RTL tables (ECMA-376 Part 4 §14.3.1, §14.3.5).
+ */
+export declare const swapCellBordersLR: (borders: CellBorders | undefined) => CellBorders | undefined;

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