@betteroffice/docx 0.0.1 → 0.0.3

package/dist/measureBlocksPipeline-Df0Bbrwy.d.mts

@@ -1,109 +0,0 @@
-import { W as WrapTextDirection, i as PageGeometry, e as LayoutBlock, B as BlockExtent } from './types-DNrYr6yQ.mjs';
-
-/**
- * Clamp floating-wrap margins so at least a usable strip of the line
- * remains. Unchecked margins from near-full-width tables/images can exceed
- * contentWidth and collapse every line to ~1 glyph (the "single character
- * per line after a wide floating table" bug).
- *
- * Returned margins are zeroed when:
- * - either side alone is >= contentWidth (no strip on that side at all), or
- * - their sum is >= contentWidth (no strip exists between the two sides).
- */
-declare function clampFloatingWrapMargins(leftMargin: number, rightMargin: number, contentWidth: number): {
-    leftMargin: number;
-    rightMargin: number;
-};
-interface FloatingExclusionRect {
-    /** which margin absorbs the exclusion when wrapText alone doesn't pick a side. */
-    side: 'left' | 'right';
-    /** object's left edge in content-area px. */
-    x: number;
-    /** object's top edge in content-area px. */
-    y: number;
-    width: number;
-    height: number;
-    distTop: number;
-    distBottom: number;
-    distLeft: number;
-    distRight: number;
-    wrapText?: WrapTextDirection;
-    wrapType?: string;
-}
-interface FloatingImageZone {
-    leftMargin: number;
-    rightMargin: number;
-    topY: number;
-    bottomY: number;
-    segments?: FloatingLineSegmentZone[];
-    /**
-     * Full-width vertical band (OOXML `topAndBottom` wrap): no text fits beside
-     * it, so any line overlapping `[topY, bottomY]` is pushed below the band.
-     */
-    fullWidthBlock?: boolean;
-}
-interface FloatingLineSegmentZone {
-    leftOffset: number;
-    availableWidth: number;
-}
-interface FloatingLineMargins {
-    leftMargin: number;
-    rightMargin: number;
-    segments?: FloatingLineSegmentZone[];
-}
-declare function rectsToFloatingZones(rects: FloatingExclusionRect[], contentWidth: number): FloatingImageZone[];
-declare function getFloatingMargins(lineY: number, lineHeight: number, zones: FloatingImageZone[] | undefined, paragraphYOffset: number): FloatingLineMargins;
-
-/**
- * Floating-aware block measurement pipeline.
- *
- * Pre-scans a block list to extract exclusion zones from anchored images,
- * floating tables, and floating text boxes; groups co-located floats so
- * their combined exclusion applies starting from the earliest anchor; then
- * walks the blocks calling the caller-supplied `measureBlock` with the
- * active zones and cumulative Y at each step.
- *
- * Adapters (React, Vue) provide their own `measureBlock` so they can
- * decide e.g. whether to cache paragraph measures. The orchestration,
- * extraction, and grouping live here so both adapters stay in lockstep.
- *
- * @packageDocumentation
- * @public
- */
-
-/**
- * Block-measurement callback shape passed to {@link measureBlocksWithFloats}.
- * Adapters (React, Vue) supply this so they can decide platform-specific
- * concerns (e.g. paragraph-measure caching, per-section width) while
- * sharing the floating-zone orchestration. This is adapter-author API,
- * not end-consumer API.
- *
- * @public
- */
-type MeasureBlockFn = (block: LayoutBlock, contentWidth: number, floatingZones?: FloatingImageZone[], cumulativeY?: number) => BlockExtent;
-/**
- * Page geometry (CSS px) used to resolve page/margin-relative anchored objects
- * into content-area coordinates — currently the vertical anchor of a top-pinned
- * `topAndBottom` band. Same shape the painter uses (see `pageGeometryFromPage`),
- * so both paths resolve to identical positions.
- *
- * @public
- */
-type FloatPageGeometry = PageGeometry;
-/**
- * Walk `blocks` and produce one `BlockExtent` per block. Before measuring, this
- * extracts floating exclusion zones (images / floating tables / floating
- * textboxes), groups overlapping co-located floats, and threads the active
- * zones plus cumulative Y into each `measureBlock` call.
- *
- * Pass `pageGeometry` whenever the document may contain page/margin-anchored
- * `topAndBottom` text boxes (e.g. a title banner pinned to the page top):
- * without it their reserved band falls back to flow-relative Y and the band
- * won't line up with where the painter places the box. Build it with the
- * shared `pageGeometryFromPage` helper.
- *
- * @public
- */
-declare function measureBlocksWithFloats(blocks: LayoutBlock[], contentWidth: number | number[], measureBlock: MeasureBlockFn, pageGeometry?: FloatPageGeometry): BlockExtent[];
-
-export { type FloatPageGeometry as F, type MeasureBlockFn as M, type FloatingExclusionRect as a, type FloatingImageZone as b, type FloatingLineSegmentZone as c, clampFloatingWrapMargins as d, getFloatingMargins as g, measureBlocksWithFloats as m, rectsToFloatingZones as r };

package/dist/measuredBlock-DZwz8zhD.d.mts

@@ -1,26 +0,0 @@
-import { e as LayoutBlock, B as BlockExtent } from './types-DNrYr6yQ.mjs';
-
-/**
- * The colocated block+measure unit consumed by the paginator.
- */
-
-/**
- * A flow block paired with its measurement. The paginator consumes
- * `MeasuredBlock[]` instead of two parallel `LayoutBlock[]` + `BlockExtent[]`
- * arrays kept in lockstep by index — colocating the pair makes a misaligned
- * block/measure unrepresentable.
- * @public
- */
-type MeasuredBlock = {
-    block: LayoutBlock;
-    measure: BlockExtent;
-};
-/**
- * Zip aligned `blocks` and `measures` into `MeasuredBlock[]`. This is the one
- * place a length assumption is localized — the pervasive per-index coupling it
- * replaces is what the measured-block model removes.
- * @public
- */
-declare function toMeasuredBlocks(blocks: LayoutBlock[], measures: BlockExtent[]): MeasuredBlock[];
-
-export { type MeasuredBlock as M, toMeasuredBlocks as t };

package/dist/plugin-api/types.d.mts

@@ -1,193 +0,0 @@
-import { Document } from '../types/document.mjs';
-import '../content-sSHuWw49.mjs';
-import '../formatting-DoL7KBSL.mjs';
-import '../docx/wrapTypes.mjs';
-import '../styles-VxNcXLdi.mjs';
-import '../settingsParser-CcGvtmCK.mjs';
-
-/**
- * Framework-Agnostic Plugin Interface for the DOCX Editor
- *
- * Core plugin types that can be used by any framework (React, Vue, etc.).
- * Framework-specific adapters extend EditorPluginCore with their own
- * UI rendering capabilities (e.g., ReactEditorPlugin, VueEditorPlugin).
- * @packageDocumentation
- * @public
- */
-
-/**
- * Coordinates returned by position lookup in the rendered DOM.
- */
-interface PositionCoordinates {
-    x: number;
-    y: number;
-    height: number;
-}
-/**
- * Context for accessing rendered-page geometry in the paged editor.
- *
- * Provides position mapping over the canvas renderer's output (Rust
- * display-list queries, with the accessibility mirror's DOM as fallback).
- * Use this for rendering overlays, annotations, and other visual elements
- * positioned relative to rendered content.
- *
- * The mirror DOM uses data-doc-start/data-doc-end attributes on spans
- * to map between display positions and DOM elements.
- */
-interface RenderedDomContext {
-    /** The container element holding all rendered pages. */
-    pagesContainer: HTMLElement;
-    /**
-     * Get pixel coordinates for a display position in the rendered DOM.
-     * Returns null if the position cannot be found.
-     */
-    getCoordinatesForPosition(position: number): PositionCoordinates | null;
-    /**
-     * Find DOM elements that overlap with a display-position range.
-     */
-    findElementsForRange(from: number, to: number): Element[];
-    /**
-     * Get bounding rectangles for a range of text, accounting for line wraps.
-     * Returns rects relative to the pages container.
-     */
-    getRectsForRange(from: number, to: number): Array<{
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }>;
-    /** Query-backed caret coordinates for one explicit header/footer page. */
-    getCoordinatesForHfPosition(region: 'header' | 'footer', rId: string, position: number, pageIndex: number): PositionCoordinates | null;
-    /** Query-backed range rectangles for one explicit header/footer page. */
-    getRectsForHfRange(region: 'header' | 'footer', rId: string, from: number, to: number, pageIndex: number): Array<{
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }>;
-    /** Bounds of one rendered page relative to the pages container. */
-    getPageBounds(pageIndex: number): {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    } | null;
-    /** Current zoom level (1 = 100%). */
-    zoom: number;
-    /**
-     * Offset of the pages container from its parent viewport.
-     */
-    getContainerOffset(): {
-        x: number;
-        y: number;
-    };
-}
-/**
- * Props passed to plugin panel components (framework-agnostic base).
- */
-interface PluginPanelProps<TState = unknown> {
-    /** Current serializer-facing document snapshot. */
-    document: Document | null;
-    /** Scroll editor to a specific position */
-    scrollToPosition: (pos: number) => void;
-    /** Select a range in the editor */
-    selectRange: (from: number, to: number) => void;
-    /** Plugin-specific state (managed by the plugin) */
-    pluginState: TState;
-    /** Width of the panel in pixels */
-    panelWidth: number;
-    /**
-     * Context for the rendered pages (canvas renderer output).
-     * May be null if layout hasn't completed yet.
-     */
-    renderedDomContext: RenderedDomContext | null;
-}
-/**
- * Configuration for plugin panel rendering.
- */
-interface PanelConfig {
-    /** Where to render the panel */
-    position: 'left' | 'right' | 'bottom';
-    /** Default width/height of the panel */
-    defaultSize: number;
-    /** Minimum size */
-    minSize?: number;
-    /** Maximum size */
-    maxSize?: number;
-    /** Whether the panel is resizable */
-    resizable?: boolean;
-    /** Whether the panel can be collapsed */
-    collapsible?: boolean;
-    /** Initial collapsed state */
-    defaultCollapsed?: boolean;
-}
-/**
- * Framework-agnostic core plugin interface.
- *
- * Contains all non-UI plugin capabilities:
- * - State management (initialize, onStateChange, destroy)
- * - CSS injection
- * - Panel configuration
- *
- * Framework adapters (ReactEditorPlugin, VueEditorPlugin) extend this
- * with their own Panel component type and renderOverlay function.
- */
-interface EditorPluginCore<TState = any> {
-    /** Unique plugin identifier */
-    id: string;
-    /** Display name for the plugin */
-    name: string;
-    /**
-     * Configuration for the panel (position, size, etc.)
-     */
-    panelConfig?: PanelConfig;
-    /**
-     * Called when the projected document changes.
-     * Use this to update plugin-specific state based on document changes.
-     */
-    onStateChange?: (document: Document) => TState | undefined;
-    /**
-     * Initialize plugin state when the plugin is first loaded.
-     */
-    initialize?: (document: Document | null) => TState;
-    /**
-     * Called when the plugin is being destroyed.
-     * Use this for cleanup (subscriptions, timers, etc.)
-     */
-    destroy?: () => void;
-    /**
-     * CSS styles to inject for this plugin.
-     * Can be a string of CSS or a URL to a stylesheet.
-     */
-    styles?: string;
-}
-/**
- * A sidebar item anchored to a document position.
- * Framework adapters extend this with rendering capabilities.
- */
-interface SidebarItem {
-    /** Unique ID for this item (used as React key and for overlap resolution). */
-    id: string;
-    /** Display position this item anchors to. */
-    anchorPos: number;
-    /** Optional key into the anchorPositions Map (e.g. "comment-42", "revision-7"). */
-    anchorKey?: string;
-    /** Sort priority within items at the same anchor Y. Lower = first. Default: 0. */
-    priority?: number;
-    /** Temporary items (e.g. "add comment" input) skip entrance animation. */
-    isTemporary?: boolean;
-    /** Pre-computed Y position (scroll-container coords, pre-zoom). Overrides anchor resolution. */
-    fixedY?: number;
-}
-/**
- * Context provided to plugins when computing sidebar items.
- */
-interface SidebarItemContext {
-    document: Document | null;
-    renderedDomContext: RenderedDomContext | null;
-    /** Pre-computed Y positions from layout engine (keys like "comment-{id}"). */
-    anchorPositions: Map<string, number>;
-    zoom: number;
-}
-
-export type { EditorPluginCore, PanelConfig, PluginPanelProps, PositionCoordinates, RenderedDomContext, SidebarItem, SidebarItemContext };

package/dist/processTemplate-HDUIZFJ5.mjs

@@ -1 +0,0 @@
-export{j as createTemplateProcessor,k as default,g as getMissingVariables,e as getTemplateTags,h as previewTemplate,a as processTemplate,i as processTemplateAdvanced,d as processTemplateAndDownload,c as processTemplateAsBlob,b as processTemplateDetailed,f as validateTemplate}from'./chunk-O2QSE2I7.mjs';import'./chunk-TTRUPDAB.mjs';

package/dist/registry-DMM5VTdT.d.mts

@@ -1,165 +0,0 @@
-import { b as CorePlugin, k as PluginOptions, l as PluginRegistrationResult, C as CommandHandler, f as McpToolDefinition, j as PluginEventListener } from './types-dYdjUZMo.mjs';
-
-/**
- * Plugin Registry
- *
- * Central registry for core plugins. Manages plugin lifecycle,
- * collects command handlers from all plugins, and aggregates
- * MCP tool definitions for the MCP server.
- */
-
-/**
- * Plugin Registry - manages core plugins
- *
- * @example
- * ```ts
- * import { pluginRegistry, docxtemplaterPlugin } from '@betteroffice/docx/core-plugins';
- *
- * // Register plugins
- * pluginRegistry.register(docxtemplaterPlugin);
- *
- * // Get all MCP tools for MCP server
- * const tools = pluginRegistry.getMcpTools();
- *
- * // Get command handler for executor
- * const handler = pluginRegistry.getCommandHandler('insertTemplateVariable');
- * ```
- */
-declare class PluginRegistry {
-    private plugins;
-    private commandHandlers;
-    private eventListeners;
-    private initialized;
-    /**
-     * Register a plugin
-     *
-     * @param plugin - The plugin to register
-     * @param options - Optional configuration
-     * @returns Registration result
-     */
-    register(plugin: CorePlugin, options?: PluginOptions): PluginRegistrationResult;
-    /**
-     * Unregister a plugin
-     *
-     * @param pluginId - ID of the plugin to unregister
-     * @returns Whether unregistration succeeded
-     */
-    unregister(pluginId: string): boolean;
-    /**
-     * Get a registered plugin by ID
-     *
-     * @param id - Plugin ID
-     * @returns The plugin or undefined
-     */
-    get(id: string): CorePlugin | undefined;
-    /**
-     * Get all registered plugins
-     *
-     * @returns Array of all plugins
-     */
-    getAll(): CorePlugin[];
-    /**
-     * Check if a plugin is registered
-     *
-     * @param id - Plugin ID
-     * @returns Whether the plugin is registered
-     */
-    has(id: string): boolean;
-    /**
-     * Get number of registered plugins
-     */
-    get size(): number;
-    /**
-     * Get a command handler for a command type
-     *
-     * @param commandType - The command type
-     * @returns The handler or undefined
-     */
-    getCommandHandler(commandType: string): CommandHandler | undefined;
-    /**
-     * Get all registered command types
-     *
-     * @returns Array of command type strings
-     */
-    getCommandTypes(): string[];
-    /**
-     * Check if a command type has a handler
-     *
-     * @param commandType - The command type
-     * @returns Whether a handler exists
-     */
-    hasCommandHandler(commandType: string): boolean;
-    /**
-     * Get all MCP tools from all registered plugins
-     *
-     * @returns Array of MCP tool definitions
-     */
-    getMcpTools(): McpToolDefinition[];
-    /**
-     * Get MCP tools from a specific plugin
-     *
-     * @param pluginId - Plugin ID
-     * @returns Array of MCP tool definitions
-     */
-    getMcpToolsForPlugin(pluginId: string): McpToolDefinition[];
-    /**
-     * Get an MCP tool by name
-     *
-     * @param toolName - Tool name
-     * @returns The tool definition or undefined
-     */
-    getMcpTool(toolName: string): McpToolDefinition | undefined;
-    /**
-     * Add an event listener
-     *
-     * @param listener - Event listener function
-     */
-    addEventListener(listener: PluginEventListener): void;
-    /**
-     * Remove an event listener
-     *
-     * @param listener - Event listener function
-     */
-    removeEventListener(listener: PluginEventListener): void;
-    /**
-     * Emit an event to all listeners
-     */
-    private emit;
-    /**
-     * Clear all registered plugins
-     *
-     * Useful for testing or resetting state.
-     */
-    clear(): void;
-    /**
-     * Get registry state for debugging
-     */
-    getDebugInfo(): {
-        plugins: string[];
-        commandTypes: string[];
-        mcpTools: string[];
-        initialized: string[];
-    };
-}
-/**
- * Global plugin registry instance
- *
- * Use this for registering plugins and accessing their capabilities.
- */
-declare const pluginRegistry: PluginRegistry;
-/**
- * Register multiple plugins at once
- *
- * @param plugins - Array of plugins to register
- * @returns Array of registration results
- */
-declare function registerPlugins(plugins: CorePlugin[], options?: PluginOptions): PluginRegistrationResult[];
-/**
- * Create a plugin registration helper with options pre-configured
- *
- * @param options - Default options for plugin registration
- * @returns Registration function
- */
-declare function createPluginRegistrar(options: PluginOptions): (plugin: CorePlugin) => PluginRegistrationResult;
-
-export { PluginRegistry as P, createPluginRegistrar as c, pluginRegistry as p, registerPlugins as r };

package/dist/rustPagination-Bj2hq013.d.mts

@@ -1,106 +0,0 @@
-import { L as LayoutOptions, a as Layout } from './types-DNrYr6yQ.mjs';
-import { M as MeasuredBlock } from './measuredBlock-DZwz8zhD.mjs';
-
-/**
- * The mandatory Rust pagination source — the seam through which EVERY
- * pagination pass (full, incremental-trigger, footnote pass 1, and each
- * footnote-stabilization iteration in `layout/regions/footnoteLayout.ts`)
- * runs the wasm `docx-layout` engine. There is no TypeScript pagination
- * kernel anymore; this seam is the only way a `Layout` is produced.
- *
- * Contract (pinned by the golden corpus — `__golden__/rustParity.test.ts`
- * proves the engine reproduces every golden byte-for-byte, and
- * `__golden__/rustPaginationSeam.test.ts` proves this seam adds zero drift
- * on top):
- *  - Input marshaling is exactly the golden convention:
- *    `JSON.stringify({ measured, options }, mapReplacer)` where the replacer
- *    turns `Map`s (`options.footnoteReservedHeights`) into plain objects
- *    keyed by decimal page number — the shape the Rust `LayoutOptions`
- *    deserializer expects.
- *  - `layout_document_json` in, `Layout` JSON out. Engine failures THROW —
- *    the layout pipeline surfaces the error (`onError` / console) and keeps
- *    the previous committed layout; nothing falls back to a hidden kernel.
- *  - The wasm engine is synchronous once loaded. Adapters gate layout passes
- *    on {@link RustPaginationSource.isReady} / `whenReady()` (the same
- *    defer-and-rerun pattern as the Rust measurement readiness gate), so
- *    `paginate` never runs against an unloaded engine. The wasm module is
- *    shared with the measurement engine, so in practice it is already
- *    resolved by the time the first measured pass reaches pagination.
- *
- * @packageDocumentation
- * @public
- */
-
-/**
- * The narrow seam `editor/computeLayout.ts` consumes: a synchronous
- * pagination call over the measured blocks + options, plus the readiness
- * surface adapters use to defer layout passes until the wasm engine has
- * loaded. `paginate` throws if called before readiness or when the engine
- * rejects the input — there is no fallback engine.
- *
- * @public
- */
-interface LayoutPaginationSource {
-    /** Paginate through the loaded Rust engine. Throws when not ready or on engine failure. */
-    paginate(measured: MeasuredBlock[], options: LayoutOptions): Layout;
-    /** Whether the wasm engine has finished its lazy load. */
-    isReady(): boolean;
-    /** Resolves when the engine is loaded; rejects if the load failed. */
-    whenReady(): Promise<void>;
-}
-/**
- * Thin sync facade over the wasm pagination export (`layout_document_json`).
- * Injectable so unit tests can script responses without loading wasm — the
- * same pattern as the measurement seam's `RustTextEngine`.
- *
- * @public
- */
-interface RustLayoutEngine {
-    /** `{ measured, options }` JSON in, `Layout` JSON out. Throws on any input the engine rejects. */
-    layoutDocumentJson(input: string): string;
-}
-/**
- * Lazily load the embedded wasm module and expose its pagination surface as
- * a {@link RustLayoutEngine}. The dynamic `import()` keeps the ~800KB base64
- * module out of the synchronous require graph; the module — and therefore
- * the wasm instantiation — is shared with the measurement seam
- * (`getRustTextEngine`), so only one load happens per session.
- *
- * @public
- */
-declare function getRustLayoutEngine(): Promise<RustLayoutEngine>;
-/** Counters for observability (passes paginated / engine errors). @public */
-interface RustPaginationStats {
-    /** Layout passes paginated by the Rust engine. */
-    rustPaginated: number;
-    /** Passes where the engine threw (the pass produced no layout). */
-    engineErrors: number;
-}
-/** Options for {@link createRustPaginationSource}. @public */
-interface RustPaginationSourceOptions {
-    /** Pre-loaded engine (tests). When set, the source is ready immediately. */
-    engine?: RustLayoutEngine;
-    /** Engine loader override (tests). Defaults to {@link getRustLayoutEngine}. */
-    loadEngine?: () => Promise<RustLayoutEngine>;
-}
-/**
- * The mandatory pagination source. Create with
- * {@link createRustPaginationSource}; see the module doc for the contract.
- *
- * @public
- */
-interface RustPaginationSource extends LayoutPaginationSource {
-    /** Snapshot of the pagination counters (never reset implicitly). */
-    getStats(): RustPaginationStats;
-}
-/**
- * Build a {@link RustPaginationSource}. The wasm load starts immediately at
- * construction; adapters defer layout passes until `isReady()` and re-run
- * the pipeline off `whenReady()` — mirroring the Rust measurement readiness
- * gate, and sharing the same underlying wasm module load.
- *
- * @public
- */
-declare function createRustPaginationSource(opts?: RustPaginationSourceOptions): RustPaginationSource;
-
-export { type LayoutPaginationSource as L, type RustLayoutEngine as R, type RustPaginationSource as a, type RustPaginationSourceOptions as b, type RustPaginationStats as c, createRustPaginationSource as d, getRustLayoutEngine as g };

package/dist/sectionConfigs-DW3J8q0X.d.mts

@@ -1,55 +0,0 @@
-import { P as PageMargins, C as ColumnLayout, b as PageHeaderFooterRefs, c as PageNumberingContract, d as PageBorderContract, S as SectionBreakBlock, N as NoteSettingsContract, e as LayoutBlock, L as LayoutOptions } from './types-DNrYr6yQ.mjs';
-
-/**
- * Per-section geometry collection.
- *
- * Walks a block list once and resolves the effective page geometry of every
- * section (size, margins, columns, header/footer refs, numbering, borders,
- * …), inheriting from the previous section where a break leaves a property
- * unset and applying any upstream section contracts. The live consumer is
- * `layout/regions/sectionGeometry.ts` (per-section measurement widths); the
- * Rust engine mirrors the same resolution natively.
- */
-
-/**
- * Page-flow geometry resolved from a single section's properties.
- * Exported so the React paged editor can reuse the same shape when
- * measuring blocks per section width — keeping pagination and
- * measurement consistent.
- */
-type SectionLayoutConfig = {
-    pageSize: {
-        w: number;
-        h: number;
-    };
-    margins: PageMargins;
-    /** Optional. Sections without explicit columns inherit `{ count: 1 }`. */
-    columns?: ColumnLayout;
-    /** Stable section/page state copied onto every page created in this section. */
-    sectionIndex?: number;
-    sectionId?: string;
-    orientation?: 'portrait' | 'landscape';
-    headerFooterRefs?: PageHeaderFooterRefs;
-    pageNumbering?: PageNumberingContract;
-    pageBorders?: PageBorderContract;
-    watermark?: SectionBreakBlock['watermark'];
-    verticalAlign?: SectionBreakBlock['verticalAlign'];
-    noteSettings?: NoteSettingsContract;
-    /** Versioned page metadata is emitted only when an upstream contract opts in. */
-    emitPageMetadata?: boolean;
-};
-/**
- * Walk `blocks` once and collect per-section geometry. `configs` has one
- * entry per section break plus a trailing `finalConfig`. `breakIndices` is
- * 1-to-1 with the inner break entries (same length as `configs.length - 1`).
- * Callers that need the break `type` can read it from
- * `(blocks[breakIndices[i]] as SectionBreakBlock).type`.
- *
- * @internal
- */
-declare function collectSectionConfigs(blocks: LayoutBlock[], initialConfig: SectionLayoutConfig, finalConfig: SectionLayoutConfig, sectionContracts?: LayoutOptions['sections']): {
-    configs: SectionLayoutConfig[];
-    breakIndices: number[];
-};
-
-export { type SectionLayoutConfig as S, collectSectionConfigs as c };