@graphrefly/graphrefly 0.43.0 → 0.45.0

package/dist/index-BdGtBX-X.d.cts

@@ -1,515 +0,0 @@
-import { M as MeasurementAdapter, P as PreparedSegment, L as LineBreaksResult, C as CharPosition, a as LayoutCursor, I as Interval, b as LayoutLine, c as LayoutNextLineContext, d as LayoutNextLineResult, R as ReactiveLayoutBundle, e as ReactiveLayoutOptions, S as SegmentBreakKind, f as SegmentMeasureStats, g as analyzeAndMeasure, h as carveTextLineSlots, i as computeCharPositions, j as computeLineBreaks, l as layoutNextLine, r as reactiveLayout } from './reactive-layout-Dsvob4zD.cjs';
-import { N as Node } from './node-ClS5yC-B.cjs';
-import { G as Graph } from './graph-C4SHb3Ly.cjs';
-
-/**
- * MeasurementAdapter implementations (roadmap §7.1 — pluggable backends).
- *
- * All adapters implement {@link MeasurementAdapter} from `reactive-layout.ts`.
- * Sync constructors, sync `measureSegment()` — no async, no polling.
- */
-
-type CliMeasureAdapterOptions = {
-    /** Pixel width per terminal cell (default: 8). */
-    cellPx?: number;
-};
-/**
- * Monospace terminal measurement adapter.
- *
- * Width = cell count × `cellPx`. CJK / fullwidth characters count as 2 cells.
- * No external dependencies. Works in any JS environment.
- */
-declare class CliMeasureAdapter implements MeasurementAdapter {
-    private readonly cellPx;
-    constructor(opts?: CliMeasureAdapterOptions);
-    measureSegment(text: string, _font: string): {
-        width: number;
-    };
-}
-type PrecomputedAdapterOptions = {
-    /**
-     * Pre-computed metrics: `{ font: { segment: widthPx } }`.
-     * Outer key is the CSS font string; inner key is the text segment.
-     */
-    metrics: Record<string, Record<string, number>>;
-    /**
-     * Fallback when a segment is not found in the metrics map.
-     * - `"per-char"`: sum individual character widths from the same font map (default)
-     * - `"error"`: throw an error for unknown segments
-     */
-    fallback?: "per-char" | "error";
-};
-/**
- * Pre-computed measurement adapter for SSR / snapshot replay.
- *
- * Reads from a static metrics object — zero measurement at runtime.
- * Ideal for server-side rendering or replaying snapshotted layouts.
- */
-declare class PrecomputedAdapter implements MeasurementAdapter {
-    private readonly metrics;
-    private readonly fallback;
-    constructor(opts: PrecomputedAdapterOptions);
-    measureSegment(text: string, font: string): {
-        width: number;
-    };
-}
-type CanvasMeasureAdapterOptions = {
-    /** Emoji width correction factor (default: 1, no correction). */
-    emojiCorrection?: number;
-};
-/**
- * Browser measurement adapter using `OffscreenCanvas.measureText()`.
- *
- * Lazily creates an OffscreenCanvas and 2D context on first call.
- * Requires a browser environment with OffscreenCanvas support.
- */
-declare class CanvasMeasureAdapter implements MeasurementAdapter {
-    private ctx;
-    private currentFont;
-    private readonly emojiCorrection;
-    constructor(opts?: CanvasMeasureAdapterOptions);
-    private getContext;
-    measureSegment(text: string, font: string): {
-        width: number;
-    };
-    clearCache(): void;
-}
-/**
- * Canvas API subset expected from `@napi-rs/canvas` or `skia-canvas`.
- * Passed via dependency injection — no dynamic import, no polling.
- */
-type CanvasModule = {
-    createCanvas(width: number, height: number): {
-        getContext(type: "2d"): {
-            font: string;
-            measureText(text: string): {
-                width: number;
-            };
-        };
-    };
-};
-/**
- * Node.js measurement adapter using an injected canvas module.
- *
- * ```ts
- * import * as canvas from "@napi-rs/canvas";
- * const adapter = new NodeCanvasMeasureAdapter(canvas);
- * ```
- *
- * Works with `@napi-rs/canvas`, `skia-canvas`, or any module exposing
- * `createCanvas(w, h).getContext("2d").measureText(text)`.
- */
-declare class NodeCanvasMeasureAdapter implements MeasurementAdapter {
-    private ctx;
-    private currentFont;
-    private readonly canvasModule;
-    constructor(canvasModule: CanvasModule);
-    private getContext;
-    measureSegment(text: string, font: string): {
-        width: number;
-    };
-    clearCache(): void;
-}
-/**
- * SVG measurement adapter — extracts dimensions from `viewBox` attribute
- * or explicit `width`/`height` attributes in the SVG string.
- *
- * Pure arithmetic: parses the SVG string for dimension attributes.
- * No DOM required. Works in any JS environment.
- *
- * Browser users who need `getBBox()` should pre-measure and pass explicit
- * `viewBox` on the content block instead.
- */
-declare class SvgBoundsAdapter {
-    measureSvg(content: string): {
-        width: number;
-        height: number;
-    };
-}
-/**
- * Image measurement adapter — returns pre-registered dimensions by src key.
- *
- * Sync-only: dimensions must be provided upfront via the `sizes` map.
- * No I/O, no polling, no async. For browser use, pre-measure via
- * `Image.onload` and pass natural dimensions on the content block directly,
- * or register them here.
- *
- * ```ts
- * const adapter = new ImageSizeAdapter({
- *   "hero.png": { width: 1200, height: 630 },
- *   "logo.svg": { width: 120, height: 40 },
- * });
- * ```
- */
-declare class ImageSizeAdapter {
-    private readonly sizes;
-    constructor(sizes: Record<string, {
-        width: number;
-        height: number;
-    }>);
-    measureImage(src: string): {
-        width: number;
-        height: number;
-    };
-}
-
-/** Pluggable measurement backend for SVG content. */
-interface SvgMeasurer {
-    measureSvg(content: string): {
-        width: number;
-        height: number;
-    };
-}
-/** Pluggable measurement backend for image content. */
-interface ImageMeasurer {
-    measureImage(src: string): {
-        width: number;
-        height: number;
-    };
-}
-/** Adapters map for `reactiveBlockLayout`. */
-type BlockAdapters = {
-    /** Text measurement adapter (required — delegates to `reactiveLayout` internals). */
-    text: MeasurementAdapter;
-    /** SVG measurement (optional — required only if SVG blocks are present). */
-    svg?: SvgMeasurer;
-    /** Image measurement (optional — required only if image blocks without explicit dimensions are present). */
-    image?: ImageMeasurer;
-};
-/** A content block — text, image, or SVG. */
-type ContentBlock = {
-    type: "text";
-    text: string;
-    font?: string;
-    lineHeight?: number;
-} | {
-    type: "image";
-    src: string;
-    /** Natural width in px. Required if no ImageMeasurer adapter is provided. */
-    naturalWidth?: number;
-    /** Natural height in px. Required if no ImageMeasurer adapter is provided. */
-    naturalHeight?: number;
-} | {
-    type: "svg";
-    content: string;
-    /** Explicit viewBox dimensions. Required if no SvgMeasurer adapter is provided. */
-    viewBox?: {
-        width: number;
-        height: number;
-    };
-};
-/**
- * A block after measurement — knows its natural dimensions.
- *
- * **Equality note:** The reactive `measured-blocks` node uses dimension-only equality
- * (`type`, `width`, `height`, `index`). Inner text layout data (`textSegments`,
- * `textLineBreaks`, `textCharPositions`) is NOT compared for change detection.
- * If you need text-level reactivity, use `reactiveLayout()` directly per text block.
- */
-type MeasuredBlock = {
-    index: number;
-    type: "text" | "image" | "svg";
-    width: number;
-    height: number;
-    /** For text blocks: the inner layout results. */
-    textSegments?: PreparedSegment[];
-    textLineBreaks?: LineBreaksResult;
-    textCharPositions?: CharPosition[];
-};
-/** A block after flow — positioned in the container. */
-type PositionedBlock = MeasuredBlock & {
-    x: number;
-    y: number;
-};
-/** Options for `reactiveBlockLayout`. */
-type ReactiveBlockLayoutOptions = {
-    adapters: BlockAdapters;
-    name?: string;
-    blocks?: ContentBlock[];
-    /** Container max width in px (clamped to ≥ 0 on init and `setMaxWidth`). */
-    maxWidth?: number;
-    /** Vertical gap between blocks in px (default 0). */
-    gap?: number;
-    /** Default font for text blocks that don't specify one. */
-    defaultFont?: string;
-    /** Default line height for text blocks that don't specify one. */
-    defaultLineHeight?: number;
-};
-/** Result bundle from `reactiveBlockLayout`. */
-type ReactiveBlockLayoutBundle = {
-    graph: Graph;
-    setBlocks: (blocks: ContentBlock[]) => void;
-    setMaxWidth: (maxWidth: number) => void;
-    setGap: (gap: number) => void;
-    measuredBlocks: Node<MeasuredBlock[]>;
-    blockFlow: Node<PositionedBlock[]>;
-    totalHeight: Node<number>;
-};
-/**
- * Measure a single content block, returning natural (unconstrained) dimensions.
- * Text blocks use the text layout pipeline; image/SVG use adapters or explicit dims.
- */
-declare function measureBlock(block: ContentBlock, maxWidth: number, adapters: BlockAdapters, measureCache: Map<string, Map<string, number>>, defaultFont: string, defaultLineHeight: number, index: number): MeasuredBlock;
-/**
- * Measure all blocks in a content array.
- */
-declare function measureBlocks(blocks: ContentBlock[], maxWidth: number, adapters: BlockAdapters, measureCache: Map<string, Map<string, number>>, defaultFont: string, defaultLineHeight: number): MeasuredBlock[];
-/**
- * Vertical stacking flow: blocks are placed top-to-bottom, left-aligned,
- * separated by `gap` pixels. Pure arithmetic over measured sizes.
- */
-declare function computeBlockFlow(measured: MeasuredBlock[], gap: number): PositionedBlock[];
-/**
- * Compute total height from positioned blocks.
- */
-declare function computeTotalHeight(flow: PositionedBlock[]): number;
-/**
- * Create a reactive block layout graph for mixed content (text + image + SVG).
- *
- * ```
- * Graph("reactive-block-layout")
- * ├── state("blocks")              — ContentBlock[] input
- * ├── state("max-width")           — container constraint
- * ├── state("gap")                 — vertical gap (px)
- * ├── derived("measured-blocks")   — blocks + max-width → MeasuredBlock[]
- * ├── derived("block-flow")        — measured-blocks + gap → PositionedBlock[]
- * ├── derived("total-height")      — block-flow → number
- * └── meta: { block-count, layout-time-ns }
- * ```
- */
-declare function reactiveBlockLayout(opts: ReactiveBlockLayoutOptions): ReactiveBlockLayoutBundle;
-
-/** A circle obstacle. Center `(cx, cy)`, radius `r`; text keeps `padding` distance. */
-type CircleObstacle = {
-    kind: "circle";
-    cx: number;
-    cy: number;
-    r: number;
-    /** Horizontal padding between obstacle and wrapped text (default 0). */
-    hPad?: number;
-    /** Vertical padding — band overlap tolerance (default 0). */
-    vPad?: number;
-};
-/** A rectangle obstacle. Top-left `(x, y)`, size `(w, h)`. */
-type RectObstacle = {
-    kind: "rect";
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-    hPad?: number;
-    vPad?: number;
-};
-/** Union of built-in obstacle shapes. */
-type Obstacle = CircleObstacle | RectObstacle;
-/**
- * Compute the horizontal interval occluded by a circle at vertical band
- * `[bandTop, bandBottom]`, or `null` if no occlusion.
- *
- * Exported so consumers that render obstacle outlines in sync with the flow
- * can reuse the same geometry the flow engine uses — no divergence.
- */
-declare function circleIntervalForBand(o: CircleObstacle, bandTop: number, bandBottom: number): Interval | null;
-/** Same as `circleIntervalForBand` for rectangles. */
-declare function rectIntervalForBand(o: RectObstacle, bandTop: number, bandBottom: number): Interval | null;
-type FlowContainer = {
-    width: number;
-    height: number;
-    paddingX?: number;
-    paddingY?: number;
-};
-type FlowColumns = {
-    count: number;
-    gap: number;
-};
-/** A single positioned line after flow layout. */
-type PositionedLine = {
-    x: number;
-    y: number;
-    /** Natural measured width of the text content. */
-    width: number;
-    /** Width of the slot this line was placed in — use this as the DOM element's
-     *  `width` when applying `text-align: justify` so the line stretches to the
-     *  obstacle edge on both sides. */
-    slotWidth: number;
-    text: string;
-    /** Which column index this line belongs to (0-based). */
-    columnIndex: number;
-    /** `true` iff the slot's right edge was carved short by an obstacle (the
-     *  slot sits to the LEFT of an obstacle). Renderers can right-align text
-     *  in these slots so single-word lines still hug the obstacle — CSS
-     *  `text-align: justify` can't stretch single-word lines, which otherwise
-     *  produces a visible asymmetry vs. the slot on the other side of the
-     *  obstacle (which is flush by default). */
-    flushToRight: boolean;
-};
-/** Options for `reactiveFlowLayout`. */
-type ReactiveFlowLayoutOptions = {
-    adapter: MeasurementAdapter;
-    name?: string;
-    text?: string;
-    font?: string;
-    lineHeight?: number;
-    container?: FlowContainer;
-    columns?: FlowColumns;
-    obstacles?: Obstacle[];
-    /** Minimum slot width (px) below which a slot is discarded rather than squeezed. Default `20`. */
-    minSlotWidth?: number;
-    /**
-     * Vertical gap (px) inserted after a hard-break segment (the spacing
-     * between paragraphs). When unset (or explicitly set to `null`), tracks
-     * the current `lineHeight` reactively — one line-height of visible
-     * paragraph gap, matching dense editorial layouts. Set to `0` for
-     * paragraph-preserving layout that reclaims the break line; set larger
-     * (e.g. `2 * lineHeight`) for looser manuscript settings. Reactive —
-     * update via `setParagraphSpacing(n)` or restore to track-lineHeight
-     * mode via `setParagraphSpacing(null)`.
-     */
-    paragraphSpacing?: number | null;
-};
-/** Result bundle from `reactiveFlowLayout`. */
-type ReactiveFlowLayoutBundle = {
-    graph: Graph;
-    setText: (text: string) => void;
-    setFont: (font: string) => void;
-    setLineHeight: (lh: number) => void;
-    setContainer: (c: FlowContainer) => void;
-    setColumns: (c: FlowColumns) => void;
-    setObstacles: (o: Obstacle[]) => void;
-    setParagraphSpacing: (ps: number | null) => void;
-    segments: Node<PreparedSegment[]>;
-    flowLines: Node<PositionedLine[]>;
-};
-/** Result of `computeFlowLines`. */
-type FlowLinesResult = {
-    /** Positioned lines in render order (columns inner-ordered top-to-bottom). */
-    lines: PositionedLine[];
-    /** Cursor position after the last line was placed. If
-     *  `cursor.segmentIndex < segments.length`, the layout **truncated** — the
-     *  container couldn't fit all text. */
-    cursor: LayoutCursor;
-};
-/** Optional tuning knobs for {@link computeFlowLines}. */
-type ComputeFlowLinesOptions = {
-    /**
-     * Vertical gap (px) inserted after a hard-break segment (the spacing
-     * between paragraphs). Defaults to `lineHeight` — one line-height of
-     * visible paragraph gap, which matches dense editorial layouts. Set to
-     * `0` for paragraph-preserving layout that reclaims the break line;
-     * set larger (e.g. `2 * lineHeight`) for looser manuscript settings.
-     */
-    paragraphSpacing?: number;
-};
-/**
- * Lay out `segments` across N columns, wrapping each line around `obstacles`.
- * Pure function — no reactive wiring. Exported for testing and for consumers
- * who want to run flow layout outside a Graph.
- *
- * `carveTextLineSlots` guarantees left-to-right-ordered, non-overlapping slots,
- * so this function does not sort them.
- */
-declare function computeFlowLines(segments: PreparedSegment[], container: FlowContainer, columns: FlowColumns, obstacles: Obstacle[], lineHeight: number, minSlotWidth: number, opts?: ComputeFlowLinesOptions): FlowLinesResult;
-/**
- * Create a reactive flow-layout graph: N columns of text wrapping around
- * shape obstacles. Re-runs only the dependent derived nodes on any input
- * change. Obstacle movement (e.g. rAF-driven) invalidates `flow-lines` only;
- * `segments` stays cached as long as `text`/`font` don't change.
- *
- * @example
- * ```ts
- * import { fromRaf, reactiveFlowLayout } from "@graphrefly/graphrefly-ts";
- *
- * const flow = reactiveFlowLayout({
- *   adapter: new CanvasMeasureAdapter(),
- *   text: longEssay,
- *   font: "18px serif",
- *   lineHeight: 26,
- *   container: { width: 900, height: 600, paddingX: 40, paddingY: 40 },
- *   columns: { count: 2, gap: 32 },
- *   obstacles: [{ kind: "circle", cx: 450, cy: 300, r: 80 }],
- * });
- *
- * // Animate the obstacle via rAF:
- * fromRaf().subscribe(([[, t]]) => {
- *   const x = 450 + 120 * Math.sin((t as number) * 0.001);
- *   flow.setObstacles([{ kind: "circle", cx: x, cy: 300, r: 80 }]);
- * });
- * ```
- */
-declare function reactiveFlowLayout(opts: ReactiveFlowLayoutOptions): ReactiveFlowLayoutBundle;
-
-/**
- * Reactive layout pattern — standalone subpath export.
- *
- * ```ts
- * import { reactiveLayout, CliMeasureAdapter } from "@graphrefly/graphrefly-ts/reactive-layout";
- * ```
- */
-
-type index_BlockAdapters = BlockAdapters;
-type index_CanvasMeasureAdapter = CanvasMeasureAdapter;
-declare const index_CanvasMeasureAdapter: typeof CanvasMeasureAdapter;
-type index_CanvasMeasureAdapterOptions = CanvasMeasureAdapterOptions;
-type index_CanvasModule = CanvasModule;
-declare const index_CharPosition: typeof CharPosition;
-type index_CircleObstacle = CircleObstacle;
-type index_CliMeasureAdapter = CliMeasureAdapter;
-declare const index_CliMeasureAdapter: typeof CliMeasureAdapter;
-type index_CliMeasureAdapterOptions = CliMeasureAdapterOptions;
-type index_ComputeFlowLinesOptions = ComputeFlowLinesOptions;
-type index_ContentBlock = ContentBlock;
-type index_FlowColumns = FlowColumns;
-type index_FlowContainer = FlowContainer;
-type index_FlowLinesResult = FlowLinesResult;
-type index_ImageMeasurer = ImageMeasurer;
-type index_ImageSizeAdapter = ImageSizeAdapter;
-declare const index_ImageSizeAdapter: typeof ImageSizeAdapter;
-declare const index_Interval: typeof Interval;
-declare const index_LayoutCursor: typeof LayoutCursor;
-declare const index_LayoutLine: typeof LayoutLine;
-declare const index_LayoutNextLineContext: typeof LayoutNextLineContext;
-declare const index_LayoutNextLineResult: typeof LayoutNextLineResult;
-declare const index_LineBreaksResult: typeof LineBreaksResult;
-type index_MeasuredBlock = MeasuredBlock;
-declare const index_MeasurementAdapter: typeof MeasurementAdapter;
-type index_NodeCanvasMeasureAdapter = NodeCanvasMeasureAdapter;
-declare const index_NodeCanvasMeasureAdapter: typeof NodeCanvasMeasureAdapter;
-type index_Obstacle = Obstacle;
-type index_PositionedBlock = PositionedBlock;
-type index_PositionedLine = PositionedLine;
-type index_PrecomputedAdapter = PrecomputedAdapter;
-declare const index_PrecomputedAdapter: typeof PrecomputedAdapter;
-type index_PrecomputedAdapterOptions = PrecomputedAdapterOptions;
-declare const index_PreparedSegment: typeof PreparedSegment;
-type index_ReactiveBlockLayoutBundle = ReactiveBlockLayoutBundle;
-type index_ReactiveBlockLayoutOptions = ReactiveBlockLayoutOptions;
-type index_ReactiveFlowLayoutBundle = ReactiveFlowLayoutBundle;
-type index_ReactiveFlowLayoutOptions = ReactiveFlowLayoutOptions;
-declare const index_ReactiveLayoutBundle: typeof ReactiveLayoutBundle;
-declare const index_ReactiveLayoutOptions: typeof ReactiveLayoutOptions;
-type index_RectObstacle = RectObstacle;
-declare const index_SegmentBreakKind: typeof SegmentBreakKind;
-declare const index_SegmentMeasureStats: typeof SegmentMeasureStats;
-type index_SvgBoundsAdapter = SvgBoundsAdapter;
-declare const index_SvgBoundsAdapter: typeof SvgBoundsAdapter;
-type index_SvgMeasurer = SvgMeasurer;
-declare const index_analyzeAndMeasure: typeof analyzeAndMeasure;
-declare const index_carveTextLineSlots: typeof carveTextLineSlots;
-declare const index_circleIntervalForBand: typeof circleIntervalForBand;
-declare const index_computeBlockFlow: typeof computeBlockFlow;
-declare const index_computeCharPositions: typeof computeCharPositions;
-declare const index_computeFlowLines: typeof computeFlowLines;
-declare const index_computeLineBreaks: typeof computeLineBreaks;
-declare const index_computeTotalHeight: typeof computeTotalHeight;
-declare const index_layoutNextLine: typeof layoutNextLine;
-declare const index_measureBlock: typeof measureBlock;
-declare const index_measureBlocks: typeof measureBlocks;
-declare const index_reactiveBlockLayout: typeof reactiveBlockLayout;
-declare const index_reactiveFlowLayout: typeof reactiveFlowLayout;
-declare const index_reactiveLayout: typeof reactiveLayout;
-declare const index_rectIntervalForBand: typeof rectIntervalForBand;
-declare namespace index {
-  export { type index_BlockAdapters as BlockAdapters, index_CanvasMeasureAdapter as CanvasMeasureAdapter, type index_CanvasMeasureAdapterOptions as CanvasMeasureAdapterOptions, type index_CanvasModule as CanvasModule, index_CharPosition as CharPosition, type index_CircleObstacle as CircleObstacle, index_CliMeasureAdapter as CliMeasureAdapter, type index_CliMeasureAdapterOptions as CliMeasureAdapterOptions, type index_ComputeFlowLinesOptions as ComputeFlowLinesOptions, type index_ContentBlock as ContentBlock, type index_FlowColumns as FlowColumns, type index_FlowContainer as FlowContainer, type index_FlowLinesResult as FlowLinesResult, type index_ImageMeasurer as ImageMeasurer, index_ImageSizeAdapter as ImageSizeAdapter, index_Interval as Interval, index_LayoutCursor as LayoutCursor, index_LayoutLine as LayoutLine, index_LayoutNextLineContext as LayoutNextLineContext, index_LayoutNextLineResult as LayoutNextLineResult, index_LineBreaksResult as LineBreaksResult, type index_MeasuredBlock as MeasuredBlock, index_MeasurementAdapter as MeasurementAdapter, index_NodeCanvasMeasureAdapter as NodeCanvasMeasureAdapter, type index_Obstacle as Obstacle, type index_PositionedBlock as PositionedBlock, type index_PositionedLine as PositionedLine, index_PrecomputedAdapter as PrecomputedAdapter, type index_PrecomputedAdapterOptions as PrecomputedAdapterOptions, index_PreparedSegment as PreparedSegment, type index_ReactiveBlockLayoutBundle as ReactiveBlockLayoutBundle, type index_ReactiveBlockLayoutOptions as ReactiveBlockLayoutOptions, type index_ReactiveFlowLayoutBundle as ReactiveFlowLayoutBundle, type index_ReactiveFlowLayoutOptions as ReactiveFlowLayoutOptions, index_ReactiveLayoutBundle as ReactiveLayoutBundle, index_ReactiveLayoutOptions as ReactiveLayoutOptions, type index_RectObstacle as RectObstacle, index_SegmentBreakKind as SegmentBreakKind, index_SegmentMeasureStats as SegmentMeasureStats, index_SvgBoundsAdapter as SvgBoundsAdapter, type index_SvgMeasurer as SvgMeasurer, index_analyzeAndMeasure as analyzeAndMeasure, index_carveTextLineSlots as carveTextLineSlots, index_circleIntervalForBand as circleIntervalForBand, index_computeBlockFlow as computeBlockFlow, index_computeCharPositions as computeCharPositions, index_computeFlowLines as computeFlowLines, index_computeLineBreaks as computeLineBreaks, index_computeTotalHeight as computeTotalHeight, index_layoutNextLine as layoutNextLine, index_measureBlock as measureBlock, index_measureBlocks as measureBlocks, index_reactiveBlockLayout as reactiveBlockLayout, index_reactiveFlowLayout as reactiveFlowLayout, index_reactiveLayout as reactiveLayout, index_rectIntervalForBand as rectIntervalForBand };
-}
-
-export { reactiveFlowLayout as A, type BlockAdapters as B, CanvasMeasureAdapter as C, rectIntervalForBand as D, type FlowColumns as F, type ImageMeasurer as I, type MeasuredBlock as M, NodeCanvasMeasureAdapter as N, type Obstacle as O, type PositionedBlock as P, type ReactiveBlockLayoutBundle as R, SvgBoundsAdapter as S, type CanvasMeasureAdapterOptions as a, type CanvasModule as b, type CircleObstacle as c, CliMeasureAdapter as d, type CliMeasureAdapterOptions as e, type ComputeFlowLinesOptions as f, type ContentBlock as g, type FlowContainer as h, index as i, type FlowLinesResult as j, ImageSizeAdapter as k, type PositionedLine as l, PrecomputedAdapter as m, type PrecomputedAdapterOptions as n, type ReactiveBlockLayoutOptions as o, type ReactiveFlowLayoutBundle as p, type ReactiveFlowLayoutOptions as q, type RectObstacle as r, type SvgMeasurer as s, circleIntervalForBand as t, computeBlockFlow as u, computeFlowLines as v, computeTotalHeight as w, measureBlock as x, measureBlocks as y, reactiveBlockLayout as z };

package/dist/index-Bf7eqeSF.d.ts

@@ -1,113 +0,0 @@
-import { N as Node, a as NodeOptions } from './node-ClS5yC-B.js';
-import { a as GraphOptions, G as Graph } from './graph-7VguS7a4.js';
-
-/**
- * Reduction primitives (roadmap §8.1).
- *
- * Composable building blocks for taking heterogeneous massive inputs and producing
- * prioritized, auditable, human-actionable output. Each primitive is either a Graph
- * factory or a Node factory, built on top of core + extra primitives.
- *
- * @module
- */
-
-type StepRef = string | Node<unknown>;
-/** A named stage for {@link funnel}. */
-type FunnelStage = {
-    /** Stage name (mounted as subgraph). */
-    name: string;
-    /** Builder: receives a sub-graph, should add an `"input"` and `"output"` node. */
-    build: (sub: Graph) => void;
-};
-/** Options for {@link funnel}. */
-type FunnelOptions = GraphOptions & {
-    meta?: Record<string, unknown>;
-};
-/**
- * Multi-source merge with sequential reduction stages.
- *
- * Sources are merged into a single stream. Each stage is a named subgraph
- * (mounted via `graph.mount()`). Stages connect linearly:
- * `merged → stage[0].input → stage[0].output → stage[1].input → ...`
- *
- * @param name - Graph name.
- * @param sources - Input nodes to merge.
- * @param stages - Sequential reduction stages.
- * @param opts - Optional graph/meta options.
- * @returns Graph with `"merged"` and mounted stage subgraphs.
- *
- * @category patterns
- */
-declare function funnel<T>(name: string, sources: ReadonlyArray<Node<T>>, stages: ReadonlyArray<FunnelStage>, opts?: FunnelOptions): Graph;
-/** Options for {@link feedback}. */
-type FeedbackOptions = {
-    /** Maximum feedback iterations before stopping (default: 10). */
-    maxIterations?: number;
-    /** Optional budget gate node path for cost-bounded iteration. */
-    budgetNode?: StepRef;
-    meta?: Record<string, unknown>;
-};
-/**
- * Introduce a bounded reactive cycle into an existing graph.
- *
- * When `condition` emits a non-null DATA value, the feedback effect routes it
- * back to the `reentry` state node — creating a cycle. Bounded by
- * `maxIterations` (default 10). The counter node (`__feedback_<condition>`)
- * is the source of truth — reset it to 0 to allow more iterations.
- *
- * To remove the feedback cycle, call `graph.remove("__feedback_<condition>")`.
- *
- * @param graph - Existing graph to augment with a feedback cycle.
- * @param condition - Path to a node whose DATA triggers feedback.
- * @param reentry - Path to a state node that receives the feedback value.
- * @param opts - Iteration bounds and metadata.
- * @returns The same graph (mutated with feedback nodes added).
- *
- * @category patterns
- */
-declare function feedback(graph: Graph, condition: string, reentry: string, opts?: FeedbackOptions): Graph;
-/** A scored item with full breakdown. */
-type ScoredItem<T = unknown> = {
-    /** Original value. */
-    value: T;
-    /** Final weighted score. */
-    score: number;
-    /** Per-signal breakdown: signal index → weighted contribution. */
-    breakdown: number[];
-};
-/** Options for {@link scorer}. */
-type ScorerOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
-    meta?: Record<string, unknown>;
-    /** Custom scoring function per signal. Default: identity (signal value IS the score). */
-    scoreFns?: ReadonlyArray<(value: unknown) => number>;
-};
-/**
- * Reactive multi-signal scoring with live weights.
- *
- * Each source emits items to score. Weights are reactive state nodes that
- * LLM or human can adjust live. Output is sorted scored items with full
- * breakdown.
- *
- * @param sources - Signal nodes (each emits a numeric score dimension).
- * @param weights - Reactive weight nodes (one per source).
- * @param opts - Optional node/meta options.
- * @returns Node emitting scored output.
- *
- * @category patterns
- */
-declare function scorer(sources: ReadonlyArray<Node<number>>, weights: ReadonlyArray<Node<number>>, opts?: ScorerOptions): Node<ScoredItem<number[]>>;
-
-type index_FeedbackOptions = FeedbackOptions;
-type index_FunnelOptions = FunnelOptions;
-type index_FunnelStage = FunnelStage;
-type index_ScoredItem<T = unknown> = ScoredItem<T>;
-type index_ScorerOptions = ScorerOptions;
-type index_StepRef = StepRef;
-declare const index_feedback: typeof feedback;
-declare const index_funnel: typeof funnel;
-declare const index_scorer: typeof scorer;
-declare namespace index {
-  export { type index_FeedbackOptions as FeedbackOptions, type index_FunnelOptions as FunnelOptions, type index_FunnelStage as FunnelStage, type index_ScoredItem as ScoredItem, type index_ScorerOptions as ScorerOptions, type index_StepRef as StepRef, index_feedback as feedback, index_funnel as funnel, index_scorer as scorer };
-}
-
-export { type FeedbackOptions as F, type ScoredItem as S, type FunnelOptions as a, type FunnelStage as b, type ScorerOptions as c, type StepRef as d, funnel as e, feedback as f, index as i, scorer as s };