superdoc 2.2.0 → 2.3.0

package/dist/layout-engine/painters/dom/src/ruler/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Ruler Module - Per-page and interactive ruler rendering
+ *
+ * This module provides everything needed to render rulers in the document editor:
+ * - Core logic for generating ruler definitions (tick marks, margin positions)
+ * - DOM renderer for creating ruler elements
+ * - CSS styles for ruler appearance
+ *
+ * @module ruler
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   generateRulerDefinition,
+ *   createRulerElement,
+ *   ensureRulerStyles,
+ * } from './ruler/index.js';
+ *
+ * // Generate ruler data
+ * const definition = generateRulerDefinition({
+ *   pageSize: { width: 8.5, height: 11 },
+ *   pageMargins: { left: 1, right: 1, top: 1, bottom: 1 },
+ * });
+ *
+ * // Ensure styles are injected
+ * ensureRulerStyles(document);
+ *
+ * // Create display-only ruler for a page
+ * const ruler = createRulerElement({
+ *   definition,
+ *   doc: document,
+ *   interactive: false,
+ * });
+ *
+ * // Add to page
+ * pageElement.insertBefore(ruler, pageElement.firstChild);
+ * ```
+ */
+export { generateRulerDefinition, generateRulerDefinitionFromPx, pxToInches, inchesToPx, calculateMarginFromHandle, clampHandlePosition, createHandleStates, type PageSize, type PageMargins, type RulerTick, type RulerDefinition, type RulerConfig, type RulerConfigPx, type RulerHandleState, } from './ruler-core.js';
+export { createRulerElement, updateHandlePosition, createIndicatorElement, updateIndicator, RULER_CLASS_NAMES, type CreateRulerElementOptions, } from './ruler-renderer.js';
+export { ensureRulerStyles, _resetRulerStylesInjection } from './ruler-styles.js';

package/dist/layout-engine/painters/dom/src/ruler/ruler-core.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Ruler Core - Framework-agnostic ruler logic
+ *
+ * This module provides the core functionality for rendering rulers in the document editor.
+ * It can be used by both the DOM painter (for per-page rulers) and Vue components
+ * (for interactive overlay rulers).
+ *
+ * @module ruler-core
+ */
+/**
+ * Page size in inches
+ */
+export type PageSize = {
+    width: number;
+    height: number;
+};
+/**
+ * Page margins in inches
+ */
+export type PageMargins = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+/**
+ * A single tick mark on the ruler
+ */
+export type RulerTick = {
+    /** CSS class name suffix (e.g., 'main', 'half', 'eighth') */
+    size: 'main' | 'half' | 'eighth';
+    /** Height as CSS percentage string (e.g., '40%') */
+    height: string;
+    /** Optional whole-unit number label (inch or cm, per `unit`; only on main ticks) */
+    label?: number;
+    /** X position in pixels from left edge */
+    x: number;
+};
+/**
+ * Measurement unit the ruler numbers/ticks reflect. `in` = inches (the default,
+ * unchanged behaviour), `cm` = centimetres (Word's alternate measurement unit).
+ */
+export type RulerUnit = 'in' | 'cm';
+/**
+ * Complete ruler definition with ticks and margin positions
+ */
+export type RulerDefinition = {
+    /** Width of the ruler in pixels */
+    widthPx: number;
+    /** Height of the ruler in pixels */
+    heightPx: number;
+    /** Array of tick marks */
+    ticks: RulerTick[];
+    /** Left margin handle position in pixels */
+    leftMarginPx: number;
+    /** Right margin handle position in pixels */
+    rightMarginPx: number;
+    /** Page width in inches (for calculations) */
+    pageWidthInches: number;
+};
+/**
+ * Configuration for ruler generation
+ */
+export type RulerConfig = {
+    /** Page size in inches */
+    pageSize: PageSize;
+    /** Page margins in inches */
+    pageMargins: PageMargins;
+    /** Pixels per inch (default: 96) */
+    ppi?: number;
+    /** Ruler height in pixels (default: 25) */
+    heightPx?: number;
+    /** Measurement unit for tick numbering/spacing (default: 'in'). */
+    unit?: RulerUnit;
+};
+/**
+ * Generate a complete ruler definition based on page configuration.
+ *
+ * This function creates an array of tick marks representing inch markers,
+ * half-inch markers, and eighth-inch markers, along with margin handle positions.
+ *
+ * @param config - Ruler configuration including page size and margins
+ * @returns Complete ruler definition with ticks and margin positions
+ * @throws {Error} If PPI is not positive, page dimensions are not positive, or margins exceed page dimensions
+ *
+ * @example
+ * ```typescript
+ * const ruler = generateRulerDefinition({
+ *   pageSize: { width: 8.5, height: 11 },
+ *   pageMargins: { left: 1, right: 1, top: 1, bottom: 1 }
+ * });
+ * console.log(ruler.ticks.length); // Number of tick marks
+ * console.log(ruler.leftMarginPx); // 96 (1 inch * 96 PPI)
+ * ```
+ */
+export declare function generateRulerDefinition(config: RulerConfig): RulerDefinition;
+/**
+ * Convert a pixel position to inches.
+ *
+ * @param px - Position in pixels
+ * @param ppi - Pixels per inch (default: 96)
+ * @returns Position in inches
+ */
+export declare function pxToInches(px: number, ppi?: number): number;
+/**
+ * Convert inches to pixels.
+ *
+ * @param inches - Position in inches
+ * @param ppi - Pixels per inch (default: 96)
+ * @returns Position in pixels
+ */
+export declare function inchesToPx(inches: number, ppi?: number): number;
+/**
+ * Calculate new margin value from handle position.
+ *
+ * @param handleX - Handle X position in pixels
+ * @param side - Which margin side ('left' or 'right')
+ * @param pageWidthPx - Total page width in pixels
+ * @param ppi - Pixels per inch (default: 96)
+ * @returns New margin value in inches
+ */
+export declare function calculateMarginFromHandle(handleX: number, side: 'left' | 'right', pageWidthPx: number, ppi?: number): number;
+/**
+ * Clamp a handle position within valid bounds.
+ *
+ * @param handleX - Proposed handle X position in pixels
+ * @param side - Which margin side ('left' or 'right')
+ * @param otherHandleX - Position of the other handle in pixels
+ * @param pageWidthPx - Total page width in pixels
+ * @param minContentWidthPx - Minimum content width in pixels (default: 200)
+ * @returns Clamped handle position in pixels
+ * @throws {Error} If any input is not a finite number
+ */
+export declare function clampHandlePosition(handleX: number, side: 'left' | 'right', otherHandleX: number, pageWidthPx: number, minContentWidthPx?: number): number;
+/**
+ * Ruler handle state for drag interactions
+ */
+export type RulerHandleState = {
+    side: 'left' | 'right';
+    x: number;
+    isDragging: boolean;
+    initialX: number;
+};
+/**
+ * Create initial handle states from a ruler definition.
+ *
+ * @param definition - Ruler definition with margin positions
+ * @returns Object with left and right handle states
+ */
+export declare function createHandleStates(definition: RulerDefinition): {
+    left: RulerHandleState;
+    right: RulerHandleState;
+};
+/**
+ * Configuration for ruler generation using pixel values directly.
+ * Useful when working with the layout engine which uses pixels internally.
+ */
+export type RulerConfigPx = {
+    /** Page width in pixels */
+    pageWidthPx: number;
+    /** Page height in pixels */
+    pageHeightPx: number;
+    /** Left margin in pixels */
+    leftMarginPx: number;
+    /** Right margin in pixels */
+    rightMarginPx: number;
+    /** Pixels per inch (default: 96) - used for tick spacing */
+    ppi?: number;
+    /** Ruler height in pixels (default: 25) */
+    heightPx?: number;
+    /** Measurement unit for tick numbering/spacing (default: 'in'). */
+    unit?: RulerUnit;
+};
+/**
+ * Generate a ruler definition from pixel values.
+ *
+ * This is useful when integrating with the layout engine, which works in pixels.
+ * The tick marks are still generated based on inch divisions for visual consistency.
+ *
+ * @param config - Ruler configuration with pixel values
+ * @returns Complete ruler definition
+ * @throws {Error} If PPI is not positive, page dimensions are not positive, or margins exceed page dimensions
+ *
+ * @example
+ * ```typescript
+ * // In DOM painter with pixel values from layout
+ * const ruler = generateRulerDefinitionFromPx({
+ *   pageWidthPx: 816,   // 8.5 inches * 96
+ *   pageHeightPx: 1056, // 11 inches * 96
+ *   leftMarginPx: 96,   // 1 inch
+ *   rightMarginPx: 96,  // 1 inch
+ * });
+ * ```
+ */
+export declare function generateRulerDefinitionFromPx(config: RulerConfigPx): RulerDefinition;

package/dist/layout-engine/painters/dom/src/ruler/ruler-renderer.d.ts

@@ -0,0 +1,97 @@
+import { RulerDefinition } from './ruler-core.js';
+/**
+ * CSS class names for ruler elements
+ */
+export declare const RULER_CLASS_NAMES: {
+    /** Main ruler container */
+    readonly ruler: "superdoc-ruler";
+    /** Tick mark element */
+    readonly tick: "superdoc-ruler-tick";
+    /** Main (inch) tick */
+    readonly tickMain: "superdoc-ruler-tick--main";
+    /** Half-inch tick */
+    readonly tickHalf: "superdoc-ruler-tick--half";
+    /** Eighth-inch tick */
+    readonly tickEighth: "superdoc-ruler-tick--eighth";
+    /** Inch label number */
+    readonly label: "superdoc-ruler-label";
+    /** Margin handle */
+    readonly handle: "superdoc-ruler-handle";
+    /** Left margin handle */
+    readonly handleLeft: "superdoc-ruler-handle--left";
+    /** Right margin handle */
+    readonly handleRight: "superdoc-ruler-handle--right";
+    /** Vertical indicator line during drag */
+    readonly indicator: "superdoc-ruler-indicator";
+};
+/**
+ * Options for creating a ruler element
+ */
+export type CreateRulerElementOptions = {
+    /** The ruler definition from generateRulerDefinition() */
+    definition: RulerDefinition;
+    /** Document to create elements in */
+    doc: Document;
+    /** Whether to include interactive margin handles (default: false for per-page rulers) */
+    interactive?: boolean;
+    /** Callback when margin handle drag starts */
+    onDragStart?: (side: 'left' | 'right', event: PointerEvent) => void;
+    /** Callback when margin handle is dragged */
+    onDrag?: (side: 'left' | 'right', x: number, event: PointerEvent) => void;
+    /** Callback when margin handle drag ends */
+    onDragEnd?: (side: 'left' | 'right', x: number, event: PointerEvent) => void;
+};
+/**
+ * Create a ruler DOM element.
+ *
+ * Creates a complete ruler with tick marks and optionally interactive margin handles.
+ * For per-page rulers in the painter, set `interactive: false` to render display-only rulers.
+ * For the main interactive ruler overlay, set `interactive: true` and provide callbacks.
+ *
+ * @param options - Options for creating the ruler
+ * @returns The ruler container element
+ *
+ * @example
+ * ```typescript
+ * // Display-only ruler for per-page rendering
+ * const ruler = createRulerElement({
+ *   definition: generateRulerDefinition({ pageSize, pageMargins }),
+ *   doc: document,
+ *   interactive: false,
+ * });
+ * pageElement.insertBefore(ruler, pageElement.firstChild);
+ *
+ * // Interactive ruler with margin handles
+ * const interactiveRuler = createRulerElement({
+ *   definition,
+ *   doc: document,
+ *   interactive: true,
+ *   onDragEnd: (side, x) => editor.updatePageStyle({ pageMargins: { [side]: x / 96 } }),
+ * });
+ * ```
+ */
+export declare function createRulerElement(options: CreateRulerElementOptions): HTMLElement;
+/**
+ * Update a handle's position.
+ *
+ * @param ruler - Ruler container element
+ * @param side - Which handle to update
+ * @param x - New X position in pixels
+ */
+export declare function updateHandlePosition(ruler: HTMLElement, side: 'left' | 'right', x: number): void;
+/**
+ * Create a vertical indicator line element for drag feedback.
+ *
+ * @param doc - Document to create element in
+ * @param height - Height of the indicator in pixels
+ * @returns Indicator element
+ */
+export declare function createIndicatorElement(doc: Document, height: number): HTMLElement;
+/**
+ * Show/hide and position the vertical indicator.
+ *
+ * @param indicator - Indicator element
+ * @param visible - Whether to show the indicator
+ * @param x - X position in pixels (only used when visible)
+ */
+export declare function updateIndicator(indicator: HTMLElement, visible: boolean, x?: number): void;

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

@@ -0,0 +1,31 @@
+/**
+ * Ruler Styles - CSS injection for ruler elements
+ *
+ * This module provides CSS styles for ruler elements that are injected once
+ * into the document head, similar to other painter styles.
+ *
+ * @module ruler-styles
+ */
+/**
+ * Inject ruler styles into the document head.
+ *
+ * Styles are only injected once per document lifecycle.
+ * Call this when initializing the painter or rendering the first ruler.
+ *
+ * @param doc - The document to inject styles into
+ *
+ * @example
+ * ```typescript
+ * // In DomPainter initialization
+ * ensureRulerStyles(document);
+ *
+ * // Styles are now available for all ruler elements
+ * const ruler = createRulerElement({ definition, doc: document });
+ * ```
+ */
+export declare function ensureRulerStyles(doc: Document | null | undefined): void;
+/**
+ * Reset the injection state (useful for testing).
+ * @internal
+ */
+export declare function _resetRulerStylesInjection(): void;

package/dist/layout-engine/painters/dom/src/runs/field-annotation-run.d.ts

@@ -0,0 +1,14 @@
+import { FieldAnnotationRun } from '../../../../contracts/src/index.js';
+import { RunRenderContext } from './types.js';
+/**
+ * Renders a FieldAnnotationRun as an inline "pill" element matching SuperDoc's
+ * visual appearance.
+ *
+ * Field annotations are styled inline elements that display form fields with:
+ * - Outer span with border, border-radius, padding, and background color
+ * - Inner span containing the displayLabel or type-specific content (image, link, etc.)
+ *
+ * @param run - The FieldAnnotationRun to render containing field configuration and styling
+ * @returns HTMLElement (span) or null if document is not available
+ */
+export declare const renderFieldAnnotationRun: (run: FieldAnnotationRun, context: RunRenderContext) => HTMLElement | null;

package/dist/layout-engine/painters/dom/src/runs/font-synthesis.d.ts

@@ -0,0 +1 @@
+export declare function allowFontSynthesis(element: HTMLElement): void;

package/dist/layout-engine/painters/dom/src/runs/formatting-marks.d.ts

@@ -0,0 +1,3 @@
+import { Line, Run } from '../../../../contracts/src/index.js';
+export declare const setTextContentWithFormattingSpaceMarks: (element: HTMLElement, text: string, doc: Document, showFormattingMarks: boolean) => void;
+export declare const appendFormattingParagraphMark: (lineEl: HTMLElement, line: Line, runs: Run[], leftOffsetPx: number, availableWidth: number, hasExplicitPositioning: boolean, doc: Document, showFormattingMarks: boolean) => void;

package/dist/layout-engine/painters/dom/src/runs/hash.d.ts

@@ -0,0 +1,82 @@
+import { Run, TextRun } from '../../../../contracts/src/index.js';
+/**
+ * Type guard to check if a run has a string property.
+ *
+ * @param run - The run to check
+ * @param prop - The property name to check
+ * @returns True if the run has the property and it's a string
+ */
+export declare const hasStringProp: (run: Run, prop: string) => run is Run & Record<string, string>;
+/**
+ * Type guard to check if a run has a number property.
+ *
+ * @param run - The run to check
+ * @param prop - The property name to check
+ * @returns True if the run has the property and it's a number
+ */
+export declare const hasNumberProp: (run: Run, prop: string) => run is Run & Record<string, number>;
+/**
+ * Type guard to check if a run has a boolean property.
+ *
+ * @param run - The run to check
+ * @param prop - The property name to check
+ * @returns True if the run has the property and it's a boolean
+ */
+export declare const hasBooleanProp: (run: Run, prop: string) => run is Run & Record<string, boolean>;
+/**
+ * Safely gets a string property from a run, with type narrowing.
+ *
+ * @param run - The run to get the property from
+ * @param prop - The property name
+ * @returns The string value or empty string if not present
+ */
+export declare const getRunStringProp: (run: Run, prop: string) => string;
+/**
+ * Safely gets a number property from a run, with type narrowing.
+ *
+ * @param run - The run to get the property from
+ * @param prop - The property name
+ * @returns The number value or 0 if not present
+ */
+export declare const getRunNumberProp: (run: Run, prop: string) => number;
+/**
+ * Safely gets a boolean property from a run, with type narrowing.
+ *
+ * @param run - The run to get the property from
+ * @param prop - The property name
+ * @returns The boolean value or false if not present
+ */
+export declare const getRunBooleanProp: (run: Run, prop: string) => boolean;
+/**
+ * Safely gets the underline style from a run.
+ * Handles the object-shaped underline property { style?, color? }.
+ *
+ * @param run - The run to get the underline style from
+ * @returns The underline style or empty string if not present
+ */
+export declare const getRunUnderlineStyle: (run: Run) => string;
+/**
+ * Safely gets the underline color from a run.
+ * Handles the object-shaped underline property { style?, color? }.
+ *
+ * @param run - The run to get the underline color from
+ * @returns The underline color or empty string if not present
+ */
+export declare const getRunUnderlineColor: (run: Run) => string;
+/**
+ * Applies data-* attributes from a text run to a DOM element.
+ * Validates attribute names and safely sets them on the element.
+ * Invalid or unsafe attributes are skipped with development-mode logging.
+ *
+ * @param element - The HTML element to apply attributes to
+ * @param dataAttrs - Record of data-* attribute key-value pairs from the text run
+ *
+ * @example
+ * ```typescript
+ * const span = document.createElement('span');
+ * applyRunDataAttributes(span, { 'data-id': '123', 'data-name': 'test' });
+ * // span now has: <span data-id="123" data-name="test"></span>
+ * ```
+ */
+export declare const applyRunDataAttributes: (element: HTMLElement, dataAttrs?: Record<string, string>) => void;
+export declare const textRunMergeSignature: (run: TextRun) => string;

package/dist/layout-engine/painters/dom/src/runs/image-run.d.ts

@@ -0,0 +1,37 @@
+import { ImageBlock, ImageRun, ImageRunVerticalAlign } from '../../../../contracts/src/index.js';
+import { RunRenderContext, TrackedChangesRenderConfig } from './types.js';
+type ImageFilterSource = Pick<ImageBlock, 'grayscale' | 'gain' | 'blacklevel' | 'lum'>;
+type ImageOpacitySource = Pick<ImageBlock, 'alphaModFix'>;
+/**
+ * Resolve the effective CSS `vertical-align` for an inline image run.
+ *
+ * Single source of truth for every vertical-align write site in this module
+ * (raw image, clip wrapper, and legacy clip fallback) so they never drift. The
+ * effective alignment is resolved upstream: render-line.ts copies the measured
+ * per-line alignment onto the run before this module runs, and an authored
+ * `run.verticalAlign` always wins. Absent any value, legacy `'top'` applies.
+ */
+export declare const resolveImageVerticalAlign: (run: Pick<ImageRun, "verticalAlign">) => ImageRunVerticalAlign;
+export declare const buildImageFilters: (source: ImageFilterSource) => string[];
+export declare const resolveImageOpacity: (source: ImageOpacitySource) => string | null;
+/**
+ * Renders an ImageRun as an inline <img> element.
+ *
+ * SECURITY NOTES:
+ * - Data URLs are validated against an allowlist of image MIME types
+ * - Size limit prevents DoS attacks from extremely large images
+ * - Only allows safe image MIME types; non-base64 data URLs are limited to SVG
+ * - Non-data URLs are sanitized through sanitizeUrl to prevent XSS
+ *
+ * METADATA ATTRIBUTE:
+ * - Adds `data-image-metadata` attribute to enable interactive resizing via ImageResizeOverlay
+ * - Metadata includes: originalWidth, originalHeight, aspectRatio, min/max dimensions
+ * - Only added when run.width > 0 && run.height > 0 to prevent invalid metadata
+ * - Max dimensions: 3x original size or 1000px (whichever is larger)
+ * - Min dimensions: 20px to ensure visibility and interactivity
+ *
+ * @param run - The ImageRun to render containing image source, dimensions, and spacing
+ * @returns HTMLElement (img) or null if src is missing or invalid
+ */
+export declare const renderImageRun: (run: ImageRun, context: RunRenderContext, trackedConfig?: TrackedChangesRenderConfig) => HTMLElement | null;
+export {};

package/dist/layout-engine/painters/dom/src/runs/index.d.ts

@@ -0,0 +1,13 @@
+export { renderLine } from './render-line.js';
+export { renderRun } from './render-run.js';
+export { renderTextRun } from './text-run.js';
+export { renderImageRun } from './image-run.js';
+export { renderFieldAnnotationRun } from './field-annotation-run.js';
+export { renderMathRun } from './math-run.js';
+export { renderInlineTabRun, renderPositionedTabRun } from './tab-run.js';
+export { appendFormattingParagraphMark, setTextContentWithFormattingSpaceMarks } from './formatting-marks.js';
+export { sanitizeUrl, linkMetrics } from './links.js';
+export { applyRunDataAttributes } from './hash.js';
+export { resolveTrackedChangesConfig, applyTrackedChangeDecorations, applyRowTrackedChangeToCell, } from './tracked-changes.js';
+export { resolveRunSdtId, createInlineSdtWrapper, syncInlineSdtWrapperTypography, expandSdtWrapperPmRange, } from '../sdt/inline.js';
+export type { RenderedLineInfo, RenderLineParams, RunRenderContext, TrackedChangesRenderConfig } from './types.js';

package/dist/layout-engine/painters/dom/src/runs/links.d.ts

@@ -0,0 +1,58 @@
+import { FlowRunLink } from '../../../../contracts/src/index.js';
+import { LinkRenderData, RunRenderContext } from './types.js';
+/**
+ * Hyperlink rendering metrics for observability.
+ * Tracks sanitization, blocking, and security-related events.
+ */
+export declare const linkMetrics: {
+    sanitized: number;
+    blocked: number;
+    invalidProtocol: number;
+    homographWarnings: number;
+    reset(): void;
+    getMetrics(): {
+        'hyperlink.sanitized.count': number;
+        'hyperlink.blocked.count': number;
+        'hyperlink.invalid_protocol.count': number;
+        'hyperlink.homograph_warnings.count': number;
+    };
+};
+/**
+ * Sanitize a URL to prevent XSS attacks.
+ * Only allows http, https, mailto, tel, and internal anchors.
+ *
+ * @param href - The URL to sanitize
+ * @returns Sanitized URL or null if blocked
+ */
+export declare function sanitizeUrl(href: string): string | null;
+/**
+ * Apply data-* attributes to an HTML element from a dataset object.
+ * Safely assigns dataset properties while filtering out null/undefined values.
+ *
+ * @param element - Target HTML element to receive data attributes
+ * @param dataset - Object mapping data attribute keys to string values
+ */
+export declare const applyLinkDataset: (element: HTMLElement, dataset?: Record<string, string>) => void;
+export declare const buildLinkRenderData: (link: FlowRunLink) => LinkRenderData | null;
+/**
+ * Apply tooltip accessibility using aria-describedby for better screen reader support.
+ * Creates a visually-hidden element containing the tooltip text and links it to the anchor.
+ *
+ * @param elem - The anchor element to enhance
+ * @param tooltip - The tooltip text to make accessible
+ * @returns The unique ID generated for this link
+ */
+export declare const applyTooltipAccessibility: (elem: HTMLAnchorElement, tooltip: string | null, context: RunRenderContext) => string;
+/**
+ * Enhance accessibility of a link element with ARIA labels and attributes.
+ * Adds descriptive ARIA labels for ambiguous text and target=_blank links (WCAG 2.4.4).
+ *
+ * @param elem - The anchor element to enhance
+ * @param linkData - Link metadata including href and target
+ * @param textContent - The visible link text to analyze for ambiguity
+ */
+export declare const enhanceAccessibility: (elem: HTMLAnchorElement, linkData: LinkRenderData, textContent: string) => void;
+/**
+ * Apply link attributes to an anchor element.
+ */
+export declare const applyLinkAttributes: (elem: HTMLAnchorElement, linkData: LinkRenderData) => void;

package/dist/layout-engine/painters/dom/src/runs/math-run.d.ts

@@ -0,0 +1,7 @@
+import { MathRun } from '../../../../contracts/src/index.js';
+import { RunRenderContext } from './types.js';
+/**
+ * Render a math run as a MathML element wrapped in a span.
+ * Follows the same pattern as renderImageRun — sets explicit dimensions.
+ */
+export declare const renderMathRun: (run: MathRun, context: RunRenderContext) => HTMLElement | null;

package/dist/layout-engine/painters/dom/src/runs/render-line.d.ts

@@ -0,0 +1,2 @@
+import { RenderLineParams } from './types.js';
+export declare const renderLine: ({ block, line, context, availableWidthOverride, lineIndex, skipJustify, preExpandedRuns, resolvedListTextStartPx, indentOffsetOverride, paragraphMarkLeftOffsetOverride, runContext, }: RenderLineParams) => HTMLElement;

package/dist/layout-engine/painters/dom/src/runs/render-run.d.ts

@@ -0,0 +1,12 @@
+import { FieldAnnotationRun, ImageRun, MathRun, Run } from '../../../../contracts/src/index.js';
+import { FragmentRenderContext } from '../renderer.js';
+import { RunRenderContext, TrackedChangesRenderConfig } from './types.js';
+export declare const isImageRun: (run: Run) => run is ImageRun;
+export declare const isLineBreakRun: (run: Run) => run is import('../../../../contracts/src/index.js').LineBreakRun;
+export declare const isBreakRun: (run: Run) => run is import('../../../../contracts/src/index.js').BreakRun;
+export declare const isFieldAnnotationRun: (run: Run) => run is FieldAnnotationRun;
+export declare const isMathRun: (run: Run) => run is MathRun;
+/**
+ * Render a single run as an HTML element (span or anchor).
+ */
+export declare const renderRun: (run: Run, context: FragmentRenderContext, renderContext: RunRenderContext, trackedConfig?: TrackedChangesRenderConfig) => HTMLElement | null;