@graphrefly/graphrefly 0.24.0 → 0.26.0

package/dist/index-BjI6ty9z.d.ts

@@ -0,0 +1,121 @@
+import { i as index$2 } from './index-qldRdbQw.js';
+import { i as index$3 } from './index-xdGjv0nO.js';
+import { i as index$4 } from './index-CuYwdKO-.js';
+import { i as index$5 } from './index-CPgZ5wRl.js';
+import { N as Node } from './node-C_IBuvX2.js';
+import { i as index$6 } from './index-CDAjUFIv.js';
+import { i as index$7 } from './index-DrISNAOm.js';
+import { i as index$8 } from './index-BYOHF0zP.js';
+import { i as index$9 } from './index-CmnuOibw.js';
+
+/**
+ * Options for creating signals.
+ *
+ * @category compat
+ */
+interface SignalOptions {
+    /** Optional identifier for the underlying node. */
+    name?: string;
+    /** Custom equality function for change detection. */
+    equals?: (a: any, b: any) => boolean;
+}
+/**
+ * Common interface for all reactive signals.
+ *
+ * @category compat
+ */
+interface AnySignal<T> {
+    /** Returns the current value of the signal. */
+    get(): T;
+    /** @internal The underlying GraphReFly node. */
+    _node: Node<T>;
+}
+/**
+ * TC39 `Signal.State` — a writable signal backed by a GraphReFly `state` node.
+ * Automatically registers itself as a dependency if read inside a `Computed`.
+ *
+ * @example
+ * ```ts
+ * const count = new Signal.State(0);
+ * count.get(); // 0
+ * count.set(1);
+ * count.get(); // 1
+ * ```
+ */
+declare class SignalState<T> implements AnySignal<T> {
+    /** @internal */
+    _node: Node<T>;
+    private readonly _equals;
+    constructor(initial: T, opts?: SignalOptions);
+    get(): T;
+    set(value: T): void;
+}
+/**
+ * TC39 `Signal.Computed` — a read-only signal backed by `dynamicNode`.
+ * Automatically tracks dependencies when `get()` is called on other signals
+ * during its computation.
+ *
+ * @example
+ * ```ts
+ * const count = new Signal.State(0);
+ * const doubled = new Signal.Computed(() => count.get() * 2);
+ * ```
+ */
+declare class SignalComputed<T> implements AnySignal<T> {
+    /** @internal */
+    _node: Node<T>;
+    constructor(computation: () => T, opts?: SignalOptions);
+    get(): T;
+}
+/**
+ * TC39 Signals-compatible namespace. Wraps GraphReFly primitives.
+ * Provides auto-tracking conforming to the TS39 signals proposal.
+ *
+ * @category compat
+ */
+declare const Signal: {
+    readonly State: typeof SignalState;
+    readonly Computed: typeof SignalComputed;
+    /**
+     * Subscribes to changes on a signal.
+     * Returns an unsubscribe callback.
+     *
+     * @example
+     * ```ts
+     * const count = new Signal.State(0);
+     * const unsub = Signal.sub(count, v => console.log(v));
+     * ```
+     */
+    readonly sub: <T>(signal: AnySignal<T>, callback: ((value: T) => void) | {
+        data?: (value: T) => void;
+        error?: (err: unknown) => void;
+        complete?: () => void;
+    }) => (() => void);
+};
+
+type index$1_AnySignal<T> = AnySignal<T>;
+declare const index$1_Signal: typeof Signal;
+type index$1_SignalComputed<T> = SignalComputed<T>;
+declare const index$1_SignalComputed: typeof SignalComputed;
+type index$1_SignalOptions = SignalOptions;
+type index$1_SignalState<T> = SignalState<T>;
+declare const index$1_SignalState: typeof SignalState;
+declare namespace index$1 {
+  export { type index$1_AnySignal as AnySignal, index$1_Signal as Signal, index$1_SignalComputed as SignalComputed, type index$1_SignalOptions as SignalOptions, index$1_SignalState as SignalState };
+}
+
+/**
+ * Compat layer: compatibility wrappers for other state management libraries (Phase 5.1b).
+ *
+ * Framework adapters are optional peers. Install only what you use:
+ * - `@graphrefly/graphrefly-ts/compat/react` -> `react`, `react-dom`
+ * - `@graphrefly/graphrefly-ts/compat/vue` -> `vue`
+ * - `@graphrefly/graphrefly-ts/compat/svelte` -> `svelte`
+ * - `@graphrefly/graphrefly-ts/compat/solid` -> `solid-js`
+ */
+
+declare namespace index {
+  export { index$2 as jotai, index$3 as nanostores, index$4 as nestjs, index$5 as react, index$1 as signals, index$6 as solid, index$7 as svelte, index$8 as vue, index$9 as zustand };
+}
+
+export { index$1 as a, index as i };

package/dist/index-Bxb5ZYc9.d.cts

@@ -0,0 +1,34 @@
+import { Ref, WatchSource } from 'vue';
+import { N as Node } from './node-C_IBuvX2.cjs';
+
+/**
+ * Subscribe to a read-only `Node<T>` as a Vue `Ref<T>`. Auto-unsubscribes on scope disposal.
+ * Subscription lifecycle is tied to Vue scope disposal (not node terminal messages).
+ */
+declare function useSubscribe<T>(node: Node<T>): Readonly<Ref<T | undefined | null>>;
+/**
+ * Bind a writable `Node<T>` as a Vue `Ref<T>`. Reads and writes are bidirectional.
+ * Value sets always dispatch `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Vue scope disposal (not node terminal messages).
+ */
+declare function useStore<T>(node: Node<T>): Ref<T | undefined | null>;
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord` factory. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records. When keys change,
+ * old subscriptions are torn down and new ones created automatically.
+ * Must be called during Vue `setup()`.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keys: WatchSource<K[] | undefined>, factory: NodeFactory<K, R>): Readonly<Ref<Record<K, R>>>;
+
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/{index-BJB7t9gg.d.cts → index-C0ZXMaXO.d.cts}

@@ -1,5 +1,5 @@
-import { t as Messages, a as NodeOptions, F as FnCtx, N as Node, b as NodeActions, x as NodeFnCleanup, A as Actor, C as COMPLETE, c as COMPLETE_MSG, d as COMPLETE_ONLY_BATCH, D as DATA, e as DEFAULT_ACTOR, f as DIRTY, g as DIRTY_MSG, h as DIRTY_ONLY_BATCH, i as DepRecord, E as ERROR, G as GlobalInspectorEvent, j as GlobalInspectorHook, k as GraphReFlyConfig, l as GuardAction, m as GuardDenied, n as GuardDeniedDetails, H as HashFn, I as INVALIDATE, o as INVALIDATE_MSG, p as INVALIDATE_ONLY_BATCH, M as Message, q as MessageContext, r as MessageTypeRegistration, s as MessageTypeRegistrationInput, u as NodeCtx, v as NodeDescribeKind, w as NodeFn, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, P as NodeVersionInfo, Q as OnMessageHandler, R as OnSubscribeHandler, S as PAUSE, T as PolicyAllow, U as PolicyDeny, V as PolicyRuleData, W as RESOLVED, X as RESOLVED_MSG, Y as RESOLVED_ONLY_BATCH, Z as RESUME, _ as START, $ as START_MSG, a0 as SubscribeContext, a1 as TEARDOWN, a2 as TEARDOWN_MSG, a3 as TEARDOWN_ONLY_BATCH, a4 as V0, a5 as V1, a6 as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-B-f-Lu-k.cjs';
-import { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-DWbkoq1s.cjs';
+import { t as Messages, a as NodeOptions, F as FnCtx, N as Node, b as NodeActions, x as NodeFnCleanup, A as Actor, C as COMPLETE, c as COMPLETE_MSG, d as COMPLETE_ONLY_BATCH, D as DATA, e as DEFAULT_ACTOR, f as DIRTY, g as DIRTY_MSG, h as DIRTY_ONLY_BATCH, i as DepRecord, E as ERROR, j as GlobalInspectorEvent, k as GlobalInspectorHook, l as GraphReFlyConfig, G as GuardAction, m as GuardDenied, n as GuardDeniedDetails, H as HashFn, I as INVALIDATE, o as INVALIDATE_MSG, p as INVALIDATE_ONLY_BATCH, M as Message, q as MessageContext, r as MessageTypeRegistration, s as MessageTypeRegistrationInput, u as NodeCtx, v as NodeDescribeKind, w as NodeFn, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, V as PolicyDeny, P as PolicyRuleData, W as RESOLVED, X as RESOLVED_MSG, Y as RESOLVED_ONLY_BATCH, Z as RESUME, _ as START, $ as START_MSG, a0 as SubscribeContext, a1 as TEARDOWN, a2 as TEARDOWN_MSG, a3 as TEARDOWN_ONLY_BATCH, a4 as V0, a5 as V1, a6 as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-C_IBuvX2.cjs';
+import { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-C0-8XW6Q.cjs';
 
 /**
  * Batch deferral for tier-3+ messages, plus per-node emit coalescing inside

package/dist/{index-b5BYtczN.d.cts → index-C8mdwMXc.d.cts}

@@ -1,119 +1,6 @@
-import { N as Node } from './node-B-f-Lu-k.cjs';
-import { G as Graph } from './graph-D-3JIQme.cjs';
-
-/** Pluggable measurement backend. */
-interface MeasurementAdapter {
-    measureSegment(text: string, font: string): {
-        width: number;
-    };
-    /** Optional; adapters may omit for read-only / stateless measurement. */
-    clearCache?(): void;
-}
-/** Mutable counters for `analyzeAndMeasure` cache hit ratio (hits / (hits + misses)). */
-type SegmentMeasureStats = {
-    hits: number;
-    misses: number;
-};
-/** Break kind for each segment (ported from Pretext analysis.ts). */
-type SegmentBreakKind = "text" | "space" | "zero-width-break" | "soft-hyphen" | "hard-break";
-/** A measured text segment ready for line breaking. */
-type PreparedSegment = {
-    text: string;
-    width: number;
-    kind: SegmentBreakKind;
-    /** Grapheme widths for overflow-wrap: break-word (null if single grapheme). */
-    graphemeWidths: number[] | null;
-};
-/** A laid-out line with start/end cursors. */
-type LayoutLine = {
-    text: string;
-    width: number;
-    startSegment: number;
-    startGrapheme: number;
-    endSegment: number;
-    endGrapheme: number;
-};
-/** Per-character position for hit testing. */
-type CharPosition = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    line: number;
-};
-/** Full layout result from the line-breaks derived node. */
-type LineBreaksResult = {
-    lines: LayoutLine[];
-    lineCount: number;
-};
-/** Result of the reactive layout graph's describe-accessible state. */
-type ReactiveLayoutBundle = {
-    graph: Graph;
-    /** Set input text. */
-    setText: (text: string) => void;
-    /** Set CSS font string. */
-    setFont: (font: string) => void;
-    /** Set line height (px). */
-    setLineHeight: (lineHeight: number) => void;
-    /** Set max width constraint (px). */
-    setMaxWidth: (maxWidth: number) => void;
-    /** Segments node. */
-    segments: Node<PreparedSegment[]>;
-    /** Line breaks node. */
-    lineBreaks: Node<LineBreaksResult>;
-    /** Total height node. */
-    height: Node<number>;
-    /** Per-character positions node. */
-    charPositions: Node<CharPosition[]>;
-};
-/**
- * Merge segmentation pieces: sticky punctuation, CJK per-grapheme splitting,
- * and produce the final measured segment list.
- */
-declare function analyzeAndMeasure(text: string, font: string, adapter: MeasurementAdapter, cache: Map<string, Map<string, number>>, stats?: SegmentMeasureStats): PreparedSegment[];
-/**
- * Greedy line-breaking algorithm.
- *
- * Walks segments left to right, accumulating width. Breaks when a segment would
- * overflow maxWidth. Supports:
- * - Trailing space hang (spaces don't trigger breaks)
- * - overflow-wrap: break-word via grapheme widths
- * - Soft hyphens (break opportunity, adds visible hyphen width)
- * - Hard breaks (forced newline)
- */
-declare function computeLineBreaks(segments: PreparedSegment[], maxWidth: number, adapter: MeasurementAdapter, font: string, cache: Map<string, Map<string, number>>): LineBreaksResult;
-/** Compute per-character x,y positions from line breaks and segments. */
-declare function computeCharPositions(lineBreaks: LineBreaksResult, segments: PreparedSegment[], lineHeight: number): CharPosition[];
-type ReactiveLayoutOptions = {
-    /** Measurement backend (required). */
-    adapter: MeasurementAdapter;
-    /** Graph name (default: "reactive-layout"). */
-    name?: string;
-    /** Initial text. */
-    text?: string;
-    /** Initial CSS font string. */
-    font?: string;
-    /** Initial line height in px. */
-    lineHeight?: number;
-    /** Initial max width in px (clamped to ≥ 0). */
-    maxWidth?: number;
-};
-/**
- * Create a reactive text layout graph.
- *
- * ```
- * Graph("reactive-layout")
- * ├── state("text")
- * ├── state("font")
- * ├── state("line-height")
- * ├── state("max-width")
- * ├── derived("segments")      — text + font → PreparedSegment[]
- * ├── derived("line-breaks")   — segments + max-width → LineBreaksResult
- * ├── derived("height")        — line-breaks → number
- * └── derived("char-positions") — line-breaks + segments → CharPosition[]
- * ```
- */
-declare function reactiveLayout(opts: ReactiveLayoutOptions): ReactiveLayoutBundle;
+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-BaOQefHu.cjs';
+import { N as Node } from './node-C_IBuvX2.cjs';
+import { G as Graph } from './graph-6tZ5jEzr.cjs';
 
 /**
  * MeasurementAdapter implementations (roadmap §7.1 — pluggable backends).
@@ -392,6 +279,142 @@ declare function computeTotalHeight(flow: PositionedBlock[]): number;
  */
 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;
+};
+/** 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;
+    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;
+};
+/**
+ * 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): 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.
  *
@@ -405,45 +428,64 @@ type index_CanvasMeasureAdapter = CanvasMeasureAdapter;
 declare const index_CanvasMeasureAdapter: typeof CanvasMeasureAdapter;
 type index_CanvasMeasureAdapterOptions = CanvasMeasureAdapterOptions;
 type index_CanvasModule = CanvasModule;
-type index_CharPosition = CharPosition;
+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_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;
-type index_LayoutLine = LayoutLine;
-type index_LineBreaksResult = LineBreaksResult;
+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;
-type index_MeasurementAdapter = MeasurementAdapter;
+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;
-type index_PreparedSegment = PreparedSegment;
+declare const index_PreparedSegment: typeof PreparedSegment;
 type index_ReactiveBlockLayoutBundle = ReactiveBlockLayoutBundle;
 type index_ReactiveBlockLayoutOptions = ReactiveBlockLayoutOptions;
-type index_ReactiveLayoutBundle = ReactiveLayoutBundle;
-type index_ReactiveLayoutOptions = ReactiveLayoutOptions;
-type index_SegmentBreakKind = SegmentBreakKind;
-type index_SegmentMeasureStats = SegmentMeasureStats;
+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, type index_CharPosition as CharPosition, index_CliMeasureAdapter as CliMeasureAdapter, type index_CliMeasureAdapterOptions as CliMeasureAdapterOptions, type index_ContentBlock as ContentBlock, type index_ImageMeasurer as ImageMeasurer, index_ImageSizeAdapter as ImageSizeAdapter, type index_LayoutLine as LayoutLine, type index_LineBreaksResult as LineBreaksResult, type index_MeasuredBlock as MeasuredBlock, type index_MeasurementAdapter as MeasurementAdapter, index_NodeCanvasMeasureAdapter as NodeCanvasMeasureAdapter, type index_PositionedBlock as PositionedBlock, index_PrecomputedAdapter as PrecomputedAdapter, type index_PrecomputedAdapterOptions as PrecomputedAdapterOptions, type index_PreparedSegment as PreparedSegment, type index_ReactiveBlockLayoutBundle as ReactiveBlockLayoutBundle, type index_ReactiveBlockLayoutOptions as ReactiveBlockLayoutOptions, type index_ReactiveLayoutBundle as ReactiveLayoutBundle, type index_ReactiveLayoutOptions as ReactiveLayoutOptions, type index_SegmentBreakKind as SegmentBreakKind, type index_SegmentMeasureStats as SegmentMeasureStats, index_SvgBoundsAdapter as SvgBoundsAdapter, type index_SvgMeasurer as SvgMeasurer, index_analyzeAndMeasure as analyzeAndMeasure, index_computeBlockFlow as computeBlockFlow, index_computeCharPositions as computeCharPositions, index_computeLineBreaks as computeLineBreaks, index_computeTotalHeight as computeTotalHeight, index_measureBlock as measureBlock, index_measureBlocks as measureBlocks, index_reactiveBlockLayout as reactiveBlockLayout, index_reactiveLayout as reactiveLayout };
+  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_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 { reactiveBlockLayout as A, type BlockAdapters as B, CanvasMeasureAdapter as C, reactiveLayout as D, type ImageMeasurer as I, type LayoutLine as L, type MeasurementAdapter as M, NodeCanvasMeasureAdapter as N, type PositionedBlock as P, type ReactiveBlockLayoutBundle as R, type SegmentBreakKind as S, type CanvasMeasureAdapterOptions as a, type CanvasModule as b, type CharPosition as c, CliMeasureAdapter as d, type CliMeasureAdapterOptions as e, type ContentBlock as f, ImageSizeAdapter as g, type LineBreaksResult as h, index as i, type MeasuredBlock as j, PrecomputedAdapter as k, type PrecomputedAdapterOptions as l, type PreparedSegment as m, type ReactiveBlockLayoutOptions as n, type ReactiveLayoutBundle as o, type ReactiveLayoutOptions as p, type SegmentMeasureStats as q, SvgBoundsAdapter as r, type SvgMeasurer as s, analyzeAndMeasure as t, computeBlockFlow as u, computeCharPositions as v, computeLineBreaks as w, computeTotalHeight as x, measureBlock as y, measureBlocks as z };
+export { rectIntervalForBand as A, type BlockAdapters as B, CanvasMeasureAdapter as C, 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 ContentBlock as f, type FlowContainer as g, type FlowLinesResult as h, index as i, ImageSizeAdapter as j, type PositionedLine as k, PrecomputedAdapter as l, type PrecomputedAdapterOptions as m, type ReactiveBlockLayoutOptions as n, type ReactiveFlowLayoutBundle as o, type ReactiveFlowLayoutOptions as p, type RectObstacle as q, type SvgMeasurer as r, circleIntervalForBand as s, computeBlockFlow as t, computeFlowLines as u, computeTotalHeight as v, measureBlock as w, measureBlocks as x, reactiveBlockLayout as y, reactiveFlowLayout as z };

package/dist/index-CDAjUFIv.d.ts

@@ -0,0 +1,36 @@
+import { N as Node } from './node-C_IBuvX2.js';
+
+/** Solid accessor function — returns current value when called. */
+type Accessor<T> = () => T;
+/**
+ * Subscribe to a `Node<T>` as a Solid signal. Auto-cleans up with the owning scope.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useSubscribe<T>(node: Node<T>): Accessor<T | undefined | null>;
+/**
+ * Bind a writable `Node<T>` as a Solid resource tuple `[accessor, setter]`.
+ * Setter always forwards `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useStore<T>(node: Node<T>): [Accessor<T | undefined | null>, (v: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records as a Solid accessor.
+ * Re-subscribes all per-key fields whenever `keys` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Accessor<Record<K, R>>;
+
+type index_Accessor<T> = Accessor<T>;
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_Accessor as Accessor, type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type Accessor as A, type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/index-CPgZ5wRl.d.ts

@@ -0,0 +1,44 @@
+import { N as Node } from './node-C_IBuvX2.js';
+
+/**
+ * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - Any `Node<T>`.
+ * @returns `T | undefined` — the current node value, kept in sync via `useSyncExternalStore`.
+ */
+declare function useSubscribe<T>(node: Node<T>): T | undefined | null;
+/**
+ * Bind a writable `Node<T>` as a React `[value, setter]` tuple.
+ * Setting the value always pushes `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - A `Node<T>` (e.g. state node).
+ * @returns `[T | undefined, (value: T) => void]` — current value and setter function.
+ */
+declare function useStore<T>(node: Node<T>): [T | undefined | null, (value: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records.
+ * Re-subscribes all per-key fields whenever `keysNode` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ * Guaranteed to clean up strictly with React hook lifecycle, utilizing no global mappings.
+ *
+ * @param keysNode - Node of current keys (e.g. node IDs)
+ * @param factory - Function returning `{ [field]: Node<V> }` for each key.
+ * @returns `Record<K, R>` — snapshot of resolved values for all keys.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Record<K, R>;
+
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };