@graphrefly/graphrefly 0.43.0 → 0.45.0

package/dist/reactive-layout-v7KPvxoc.d.ts

@@ -1,183 +0,0 @@
-import { N as Node } from './node-ClS5yC-B.js';
-import { G as Graph } from './graph-7VguS7a4.js';
-
-/** 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;
-};
-/**
- * A position within `PreparedSegment[]` — segment + grapheme offset.
- * `graphemeIndex: 0` at segment boundaries.
- *
- * Used by {@link layoutNextLine} for cursor-based line walking; needed when
- * lines have varying widths (multi-column flow, text wrapping around obstacles).
- */
-type LayoutCursor = {
-    segmentIndex: number;
-    graphemeIndex: number;
-};
-/** A horizontal span `[left, right]` in pixels — used by flow-layout slot carving. */
-type Interval = {
-    left: number;
-    right: number;
-};
-/** Result of a single `layoutNextLine` call. */
-type LayoutNextLineResult = {
-    text: string;
-    width: number;
-    start: LayoutCursor;
-    end: LayoutCursor;
-};
-/** Optional context for `layoutNextLine` — enables soft-hyphen visible-hyphen rendering. */
-type LayoutNextLineContext = {
-    adapter?: MeasurementAdapter;
-    font?: string;
-    cache?: Map<string, Map<string, 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;
-/**
- * Lay out the next single line starting from `cursor`, fitting into `slotWidth`.
- *
- * Unlike `computeLineBreaks`, which consumes whole text with one `maxWidth`,
- * this is the cursor-based primitive needed when successive lines have different
- * widths (multi-column flow, text wrapping around shape obstacles, mixed
- * column+pullquote layouts).
- *
- * Returns `null` when the cursor is past all segments (text exhausted).
- * At a hard-break with no preceding content, returns an empty line and advances
- * the cursor past the break so the caller can continue.
- *
- * ```ts
- * let cursor: LayoutCursor = { segmentIndex: 0, graphemeIndex: 0 };
- * while (true) {
- *   const line = layoutNextLine(segments, cursor, availableWidth);
- *   if (line === null) break;
- *   render(line);
- *   cursor = line.end;
- * }
- * ```
- */
-declare function layoutNextLine(segments: PreparedSegment[], cursor: LayoutCursor, slotWidth: number, ctx?: LayoutNextLineContext): LayoutNextLineResult | null;
-/**
- * Subtract blocked horizontal intervals from a base interval, producing
- * remaining ordered, non-overlapping slots wide enough to fit text.
- *
- * Pure geometry — no text dependency. Used by flow-layout to turn obstacle
- * intersections into per-line layout slots.
- *
- * ```ts
- * carveTextLineSlots({left: 0, right: 600}, [{left: 200, right: 280}])
- * // → [{left: 0, right: 200}, {left: 280, right: 600}]
- * ```
- */
-declare function carveTextLineSlots(base: Interval, blocked: Interval[], minSlotWidth?: number): Interval[];
-/** 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;
-
-export { type CharPosition as C, type Interval as I, type LineBreaksResult as L, type MeasurementAdapter as M, type PreparedSegment as P, type ReactiveLayoutBundle as R, type SegmentBreakKind as S, type LayoutCursor as a, type LayoutLine as b, type LayoutNextLineContext as c, type LayoutNextLineResult as d, type ReactiveLayoutOptions as e, type SegmentMeasureStats as f, analyzeAndMeasure as g, carveTextLineSlots as h, computeCharPositions as i, computeLineBreaks as j, layoutNextLine as l, reactiveLayout as r };

package/dist/reactive-log-B00laMSQ.d.cts

@@ -1,223 +0,0 @@
-import { V as VersioningLevel, b as NodeGuard, N as Node } from './node-ClS5yC-B.cjs';
-import { AppendLogStorageTier } from './extra/storage-tiers.cjs';
-
-type ReactiveLogOptions<T> = {
-    name?: string;
-    maxSize?: number;
-    /**
-     * Optional versioning level for the underlying `entries` state node. Set
-     * at construction time; cannot be changed later. Pass `0` for V0 identity
-     * + monotonic version counter, or `1` for V1 + content-addressed cid.
-     */
-    versioning?: VersioningLevel;
-    /**
-     * Optional guard policy applied to the `entries` node. Use to deny
-     * external `write` while permitting `observe` / `signal` — eliminates the
-     * passthrough-derived pattern in CQRS event streams (Audit 1 #7).
-     */
-    guard?: NodeGuard;
-    /**
-     * Storage backend. Defaults to `NativeLogBackend` (ring buffer if `maxSize` is set,
-     * flat array otherwise). Users can plug in persistent / RRB-tree backends via
-     * the {@link LogBackend} interface.
-     */
-    backend?: LogBackend<T>;
-};
-/**
- * Discriminated view spec for {@link ReactiveLogBundle.view}. New `kind`s
- * (e.g. `"filter"`, `"windowByTime"`) layer in without new methods.
- */
-type ViewSpec<_T = unknown> = {
-    kind: "tail";
-    n: number;
-} | {
-    kind: "slice";
-    start: number;
-    stop?: number;
-} | {
-    kind: "fromCursor";
-    cursor: Node<number>;
-};
-type ReactiveLogBundle<T> = {
-    /** Emits `readonly T[]` on each append/clear/trim (two-phase). */
-    readonly entries: Node<readonly T[]>;
-    /** Current entry count (O(1)). */
-    readonly size: number;
-    /** Positional access (O(1)); returns `undefined` on out-of-range. Supports negative indices. */
-    at: (index: number) => T | undefined;
-    append: (value: T) => void;
-    /** Push all values, emit one snapshot. No-op if `values` is empty. */
-    appendMany: (values: readonly T[]) => void;
-    clear: () => void;
-    /** Remove the first `n` entries (clamped to `size`). */
-    trimHead: (n: number) => void;
-    /**
-     * Activate the {@link ReactiveLogBundle.lastValue} / {@link ReactiveLogBundle.hasLatest}
-     * companion nodes (lazy — installed on first call, reused thereafter).
-     * Returns `entries` so chaining reads naturally.
-     *
-     * **Companion-node access is on the bundle** (not `entries.meta`) because
-     * `Node.meta` is frozen at construction; bundle-level lazy properties
-     * give the same semantics with simpler ergonomics.
-     */
-    withLatest: () => Node<readonly T[]>;
-    /**
-     * Most-recently-appended value, or `undefined` if no entries exist (spec
-     * §5.12 SENTINEL alignment). Accessing this property activates the
-     * companion lazily — same as calling {@link ReactiveLogBundle.withLatest}.
-     *
-     * **Empty-log path emits `RESOLVED`, not `DATA(undefined)`.** When the log
-     * holds no entries, `lastValue` settles via `[[RESOLVED]]` so the §1.2
-     * "DATA(undefined) is not a valid emission" invariant stands.
-     *
-     * **Caveat when `T` itself includes `undefined`:** if a literal `undefined`
-     * value is appended, `lastValue` emits `[[DATA, undefined]]` for that
-     * append wave — the per-value semantics are intentionally preserved so
-     * subscribers can observe the transition. Use
-     * {@link ReactiveLogBundle.hasLatest} to disambiguate "no entries yet"
-     * from "an undefined value was appended"; `lastValue.cache` alone cannot
-     * tell them apart.
-     */
-    readonly lastValue: Node<T | undefined>;
-    /** Reactive `true` once at least one entry has been appended. */
-    readonly hasLatest: Node<boolean>;
-    /**
-     * Reactive view per discriminated `ViewSpec`. Memoized per-spec — repeat
-     * calls with identical spec return the same node.
-     */
-    view: (spec: ViewSpec<T>) => Node<readonly T[]>;
-    /**
-     * Subscribe to `upstream` and append every DATA into this log. Returns a
-     * disposer. ERROR / COMPLETE on `upstream` propagate through the disposer
-     * (caller is responsible for terminal handling on the log).
-     */
-    attach: (upstream: Node<T>) => () => void;
-    /**
-     * Wire one or more append-log storage tiers. Each tier receives entries on
-     * every append wave; tier-internal flush/rollback honors the wave-as-
-     * transaction model (Audit 4). Returns a disposer.
-     */
-    attachStorage: (tiers: readonly AppendLogStorageTier<T>[]) => () => void;
-    /** Releases all cached views (tail + slice + fromCursor). */
-    disposeAllViews: () => void;
-    /** Releases all internal keepalives. Idempotent. */
-    dispose: () => void;
-};
-/**
- * Storage contract for {@link reactiveLog}. Implementations own the mutable state and
- * expose a monotonic `version` counter that increments on every structural change.
- *
- * **Audit 1:** `snapshot()` returns an immutable readonly view (codec encodes
- * at the storage tier boundary). `restore(values)` replaces backend state on
- * cold-tier startup load — fires one DATA emission for the restored shape.
- *
- * @category extra
- */
-interface LogBackend<T> {
-    readonly version: number;
-    readonly size: number;
-    at(index: number): T | undefined;
-    append(value: T): void;
-    appendMany(values: readonly T[]): void;
-    clear(): number;
-    trimHead(n: number): number;
-    slice(start: number, stop?: number): readonly T[];
-    tail(n: number): readonly T[];
-    toArray(): readonly T[];
-    /** Immutable snapshot for codec serialization. Equivalent to `toArray()`. */
-    snapshot(): readonly T[];
-    /** Replace backend state with `values` (used by cold-tier restore). */
-    restore(values: readonly T[]): void;
-}
-/**
- * Default append-only log backend.
- *
- * - When `maxSize` is set: uses a **ring buffer** with `_head` index and circular
- *   modular arithmetic. Append and trim become O(1); snapshot is O(size) unrolling.
- * - When `maxSize` is unset: uses a flat array with standard push/splice.
- *
- * @category extra
- */
-declare class NativeLogBackend<T> implements LogBackend<T> {
-    private _version;
-    private readonly _maxSize?;
-    private readonly _buf;
-    private _head;
-    private _size;
-    constructor(initial?: readonly T[], maxSize?: number);
-    get version(): number;
-    get size(): number;
-    at(index: number): T | undefined;
-    append(value: T): void;
-    appendMany(values: readonly T[]): void;
-    clear(): number;
-    trimHead(n: number): number;
-    slice(start: number, stop?: number): readonly T[];
-    tail(n: number): readonly T[];
-    toArray(): readonly T[];
-    snapshot(): readonly T[];
-    restore(values: readonly T[]): void;
-    private _rawAppend;
-}
-/**
- * Creates an append-only reactive log that emits immutable `readonly T[]` snapshots.
- *
- * Each structural mutation (`append`, `appendMany`, `clear`, `trimHead`) triggers
- * a two-phase `[DIRTY, DATA]` emission on the `entries` node so downstream
- * derived nodes update reactively. Views (`tail`, `slice`, `fromCursor`) are
- * memoized derived nodes — subscribe once and they stay live.
- *
- * @param initial - Optional initial entries loaded into the log at construction.
- * @param options - Optional name, max size (ring buffer), versioning level, guard policy, and custom backend.
- * @returns `ReactiveLogBundle<T>` with `entries`, `append`, `appendMany`, `clear`, `trimHead`, `view`, `attach`, `attachStorage`, and disposal methods.
- *
- * @example
- * ```ts
- * import { reactiveLog } from "@graphrefly/graphrefly/extra";
- *
- * const log = reactiveLog<string>([], { name: "messages" });
- * log.entries.subscribe((msgs) => {
- *   for (const m of msgs) {
- *     if (m[0] === 1) console.log("entries:", m[1]);
- *   }
- * });
- * log.append("hello");
- * log.append("world");
- * ```
- *
- * @remarks
- * **Ring buffer:** Pass `maxSize` to cap the log length; older entries are evicted on overflow.
- * **Storage:** Call `attachStorage(tiers)` to wire one or more `AppendLogStorageTier` instances for persistence.
- *
- * @category extra
- */
-declare function reactiveLog<T>(initial?: readonly T[], options?: ReactiveLogOptions<T>): ReactiveLogBundle<T>;
-/**
- * Bundle returned by {@link mergeReactiveLogs}. `node` is the merged output;
- * `dispose()` releases the internal subscriptions to all input logs and the
- * keepalive on `node`. After dispose the merge stops responding to inputs
- * but `node`'s last cached value remains queryable.
- *
- * @category extra
- */
-interface MergedReactiveLog<T> {
-    readonly node: Node<readonly T[]>;
-    dispose(): void;
-}
-/**
- * Fan-in helper that merges N reactive logs into a single time-ordered output
- * by concatenation. Returns `{ node, dispose }`. Producer-pattern: subscribes
- * to each input internally; COMPLETE on an input drops it from the active
- * set; ERROR propagates per spec §2.2. Memoized by reference identity on the
- * `logs` array — repeat calls with the same reference return the same bundle.
- *
- * Internal subscriptions are invisible in `describe()` (sanctioned per §24);
- * `explain()` across the merge surfaces only the merged stream. Caller must
- * `dispose()` when done to release subscriptions to input logs (no auto-GC
- * because of the memoization map).
- *
- * @category extra
- */
-declare function mergeReactiveLogs<T>(logs: readonly Node<readonly T[]>[]): MergedReactiveLog<T>;
-
-export { type LogBackend as L, type MergedReactiveLog as M, NativeLogBackend as N, type ReactiveLogOptions as R, type ViewSpec as V, type ReactiveLogBundle as a, mergeReactiveLogs as m, reactiveLog as r };

package/dist/reactive-log-BezYsbA_.d.ts

@@ -1,223 +0,0 @@
-import { V as VersioningLevel, b as NodeGuard, N as Node } from './node-ClS5yC-B.js';
-import { AppendLogStorageTier } from './extra/storage-tiers.js';
-
-type ReactiveLogOptions<T> = {
-    name?: string;
-    maxSize?: number;
-    /**
-     * Optional versioning level for the underlying `entries` state node. Set
-     * at construction time; cannot be changed later. Pass `0` for V0 identity
-     * + monotonic version counter, or `1` for V1 + content-addressed cid.
-     */
-    versioning?: VersioningLevel;
-    /**
-     * Optional guard policy applied to the `entries` node. Use to deny
-     * external `write` while permitting `observe` / `signal` — eliminates the
-     * passthrough-derived pattern in CQRS event streams (Audit 1 #7).
-     */
-    guard?: NodeGuard;
-    /**
-     * Storage backend. Defaults to `NativeLogBackend` (ring buffer if `maxSize` is set,
-     * flat array otherwise). Users can plug in persistent / RRB-tree backends via
-     * the {@link LogBackend} interface.
-     */
-    backend?: LogBackend<T>;
-};
-/**
- * Discriminated view spec for {@link ReactiveLogBundle.view}. New `kind`s
- * (e.g. `"filter"`, `"windowByTime"`) layer in without new methods.
- */
-type ViewSpec<_T = unknown> = {
-    kind: "tail";
-    n: number;
-} | {
-    kind: "slice";
-    start: number;
-    stop?: number;
-} | {
-    kind: "fromCursor";
-    cursor: Node<number>;
-};
-type ReactiveLogBundle<T> = {
-    /** Emits `readonly T[]` on each append/clear/trim (two-phase). */
-    readonly entries: Node<readonly T[]>;
-    /** Current entry count (O(1)). */
-    readonly size: number;
-    /** Positional access (O(1)); returns `undefined` on out-of-range. Supports negative indices. */
-    at: (index: number) => T | undefined;
-    append: (value: T) => void;
-    /** Push all values, emit one snapshot. No-op if `values` is empty. */
-    appendMany: (values: readonly T[]) => void;
-    clear: () => void;
-    /** Remove the first `n` entries (clamped to `size`). */
-    trimHead: (n: number) => void;
-    /**
-     * Activate the {@link ReactiveLogBundle.lastValue} / {@link ReactiveLogBundle.hasLatest}
-     * companion nodes (lazy — installed on first call, reused thereafter).
-     * Returns `entries` so chaining reads naturally.
-     *
-     * **Companion-node access is on the bundle** (not `entries.meta`) because
-     * `Node.meta` is frozen at construction; bundle-level lazy properties
-     * give the same semantics with simpler ergonomics.
-     */
-    withLatest: () => Node<readonly T[]>;
-    /**
-     * Most-recently-appended value, or `undefined` if no entries exist (spec
-     * §5.12 SENTINEL alignment). Accessing this property activates the
-     * companion lazily — same as calling {@link ReactiveLogBundle.withLatest}.
-     *
-     * **Empty-log path emits `RESOLVED`, not `DATA(undefined)`.** When the log
-     * holds no entries, `lastValue` settles via `[[RESOLVED]]` so the §1.2
-     * "DATA(undefined) is not a valid emission" invariant stands.
-     *
-     * **Caveat when `T` itself includes `undefined`:** if a literal `undefined`
-     * value is appended, `lastValue` emits `[[DATA, undefined]]` for that
-     * append wave — the per-value semantics are intentionally preserved so
-     * subscribers can observe the transition. Use
-     * {@link ReactiveLogBundle.hasLatest} to disambiguate "no entries yet"
-     * from "an undefined value was appended"; `lastValue.cache` alone cannot
-     * tell them apart.
-     */
-    readonly lastValue: Node<T | undefined>;
-    /** Reactive `true` once at least one entry has been appended. */
-    readonly hasLatest: Node<boolean>;
-    /**
-     * Reactive view per discriminated `ViewSpec`. Memoized per-spec — repeat
-     * calls with identical spec return the same node.
-     */
-    view: (spec: ViewSpec<T>) => Node<readonly T[]>;
-    /**
-     * Subscribe to `upstream` and append every DATA into this log. Returns a
-     * disposer. ERROR / COMPLETE on `upstream` propagate through the disposer
-     * (caller is responsible for terminal handling on the log).
-     */
-    attach: (upstream: Node<T>) => () => void;
-    /**
-     * Wire one or more append-log storage tiers. Each tier receives entries on
-     * every append wave; tier-internal flush/rollback honors the wave-as-
-     * transaction model (Audit 4). Returns a disposer.
-     */
-    attachStorage: (tiers: readonly AppendLogStorageTier<T>[]) => () => void;
-    /** Releases all cached views (tail + slice + fromCursor). */
-    disposeAllViews: () => void;
-    /** Releases all internal keepalives. Idempotent. */
-    dispose: () => void;
-};
-/**
- * Storage contract for {@link reactiveLog}. Implementations own the mutable state and
- * expose a monotonic `version` counter that increments on every structural change.
- *
- * **Audit 1:** `snapshot()` returns an immutable readonly view (codec encodes
- * at the storage tier boundary). `restore(values)` replaces backend state on
- * cold-tier startup load — fires one DATA emission for the restored shape.
- *
- * @category extra
- */
-interface LogBackend<T> {
-    readonly version: number;
-    readonly size: number;
-    at(index: number): T | undefined;
-    append(value: T): void;
-    appendMany(values: readonly T[]): void;
-    clear(): number;
-    trimHead(n: number): number;
-    slice(start: number, stop?: number): readonly T[];
-    tail(n: number): readonly T[];
-    toArray(): readonly T[];
-    /** Immutable snapshot for codec serialization. Equivalent to `toArray()`. */
-    snapshot(): readonly T[];
-    /** Replace backend state with `values` (used by cold-tier restore). */
-    restore(values: readonly T[]): void;
-}
-/**
- * Default append-only log backend.
- *
- * - When `maxSize` is set: uses a **ring buffer** with `_head` index and circular
- *   modular arithmetic. Append and trim become O(1); snapshot is O(size) unrolling.
- * - When `maxSize` is unset: uses a flat array with standard push/splice.
- *
- * @category extra
- */
-declare class NativeLogBackend<T> implements LogBackend<T> {
-    private _version;
-    private readonly _maxSize?;
-    private readonly _buf;
-    private _head;
-    private _size;
-    constructor(initial?: readonly T[], maxSize?: number);
-    get version(): number;
-    get size(): number;
-    at(index: number): T | undefined;
-    append(value: T): void;
-    appendMany(values: readonly T[]): void;
-    clear(): number;
-    trimHead(n: number): number;
-    slice(start: number, stop?: number): readonly T[];
-    tail(n: number): readonly T[];
-    toArray(): readonly T[];
-    snapshot(): readonly T[];
-    restore(values: readonly T[]): void;
-    private _rawAppend;
-}
-/**
- * Creates an append-only reactive log that emits immutable `readonly T[]` snapshots.
- *
- * Each structural mutation (`append`, `appendMany`, `clear`, `trimHead`) triggers
- * a two-phase `[DIRTY, DATA]` emission on the `entries` node so downstream
- * derived nodes update reactively. Views (`tail`, `slice`, `fromCursor`) are
- * memoized derived nodes — subscribe once and they stay live.
- *
- * @param initial - Optional initial entries loaded into the log at construction.
- * @param options - Optional name, max size (ring buffer), versioning level, guard policy, and custom backend.
- * @returns `ReactiveLogBundle<T>` with `entries`, `append`, `appendMany`, `clear`, `trimHead`, `view`, `attach`, `attachStorage`, and disposal methods.
- *
- * @example
- * ```ts
- * import { reactiveLog } from "@graphrefly/graphrefly/extra";
- *
- * const log = reactiveLog<string>([], { name: "messages" });
- * log.entries.subscribe((msgs) => {
- *   for (const m of msgs) {
- *     if (m[0] === 1) console.log("entries:", m[1]);
- *   }
- * });
- * log.append("hello");
- * log.append("world");
- * ```
- *
- * @remarks
- * **Ring buffer:** Pass `maxSize` to cap the log length; older entries are evicted on overflow.
- * **Storage:** Call `attachStorage(tiers)` to wire one or more `AppendLogStorageTier` instances for persistence.
- *
- * @category extra
- */
-declare function reactiveLog<T>(initial?: readonly T[], options?: ReactiveLogOptions<T>): ReactiveLogBundle<T>;
-/**
- * Bundle returned by {@link mergeReactiveLogs}. `node` is the merged output;
- * `dispose()` releases the internal subscriptions to all input logs and the
- * keepalive on `node`. After dispose the merge stops responding to inputs
- * but `node`'s last cached value remains queryable.
- *
- * @category extra
- */
-interface MergedReactiveLog<T> {
-    readonly node: Node<readonly T[]>;
-    dispose(): void;
-}
-/**
- * Fan-in helper that merges N reactive logs into a single time-ordered output
- * by concatenation. Returns `{ node, dispose }`. Producer-pattern: subscribes
- * to each input internally; COMPLETE on an input drops it from the active
- * set; ERROR propagates per spec §2.2. Memoized by reference identity on the
- * `logs` array — repeat calls with the same reference return the same bundle.
- *
- * Internal subscriptions are invisible in `describe()` (sanctioned per §24);
- * `explain()` across the merge surfaces only the merged stream. Caller must
- * `dispose()` when done to release subscriptions to input logs (no auto-GC
- * because of the memoization map).
- *
- * @category extra
- */
-declare function mergeReactiveLogs<T>(logs: readonly Node<readonly T[]>[]): MergedReactiveLog<T>;
-
-export { type LogBackend as L, type MergedReactiveLog as M, NativeLogBackend as N, type ReactiveLogOptions as R, type ViewSpec as V, type ReactiveLogBundle as a, mergeReactiveLogs as m, reactiveLog as r };