@graphrefly/graphrefly 0.1.0

package/dist/index-BHUvlQ3v.d.ts

@@ -0,0 +1,3463 @@
+import { N as Node, a as NodeOptions, M as Message, i as Messages } from './meta-BsF6Sag9.js';
+import { q as GraphPersistSnapshot, G as Graph } from './graph-D18qmsNm.js';
+import { V as Versioned, a as ReactiveLogBundle, b as ReactiveLogOptions, R as ReactiveLogSnapshot, l as logSlice, o as observeGraph$, c as observeNode$, r as reactiveLog, t as toMessages$, d as toObservable } from './reactive-log-ohLmTXoZ.js';
+
+/**
+ * Backoff strategies for {@link retry} (roadmap §3.1). Delays are in **nanoseconds**.
+ *
+ * Convention: all graphrefly-ts timestamps and durations use nanoseconds (`_ns` suffix).
+ * 1 second = 1_000_000_000 ns, 1 ms = 1_000_000 ns.
+ */
+declare const NS_PER_MS = 1000000;
+declare const NS_PER_SEC = 1000000000;
+type JitterMode = "none" | "full" | "equal";
+type BackoffPreset = "constant" | "linear" | "exponential" | "fibonacci" | "decorrelatedJitter";
+/** `(attempt, error?, previousDelayNs?) => delayNs | null` — `null` means zero delay. */
+type BackoffStrategy = (attempt: number, error?: unknown, prevDelayNs?: number | null) => number | null;
+/**
+ * Builds a strategy that always returns the same delay in nanoseconds.
+ *
+ * @param delayNs - Non-negative delay in nanoseconds; values below zero are clamped to zero.
+ * @returns `BackoffStrategy` for use with {@link retry} or custom timers.
+ *
+ * @example
+ * ```ts
+ * import { constant, retry, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
+ *
+ * const out = retry(source, { count: 3, backoff: constant(0.25 * NS_PER_SEC) });
+ * ```
+ *
+ * @category extra
+ */
+declare function constant(delayNs: number): BackoffStrategy;
+/**
+ * Builds linear backoff: `baseNs + stepNs * attempt` (`stepNs` defaults to `baseNs`).
+ *
+ * @param baseNs - Base delay in nanoseconds (clamped non-negative).
+ * @param stepNs - Added per retry attempt in nanoseconds (clamped non-negative).
+ * @returns `BackoffStrategy` for {@link retry}.
+ *
+ * @example
+ * ```ts
+ * import { linear, retry, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
+ *
+ * // Attempt 0 → 1 s, attempt 1 → 2 s, attempt 2 → 3 s …
+ * const out = retry(source, { count: 4, backoff: linear(NS_PER_SEC) });
+ * ```
+ *
+ * @category extra
+ */
+declare function linear(baseNs: number, stepNs?: number): BackoffStrategy;
+type ExponentialBackoffOptions = {
+    baseNs?: number;
+    factor?: number;
+    maxDelayNs?: number;
+    jitter?: JitterMode;
+};
+/**
+ * Builds exponential backoff in nanoseconds, capped by `maxDelayNs`, with optional jitter.
+ *
+ * @param options - Base, factor, cap, and jitter mode.
+ * @returns `BackoffStrategy` for {@link retry}.
+ *
+ * @remarks
+ * **Jitter:** `"full"` spreads delay across `[0, delay]`; `"equal"` uses `[delay/2, delay]`.
+ *
+ * @example
+ * ```ts
+ * import { exponential, retry, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
+ *
+ * // 100 ms → 200 ms → 400 ms … capped at 30 s, with full jitter
+ * const out = retry(source, {
+ *   count: 5,
+ *   backoff: exponential({ baseNs: 100 * NS_PER_SEC / 1000, jitter: "full" }),
+ * });
+ * ```
+ *
+ * @category extra
+ */
+declare function exponential(options?: ExponentialBackoffOptions): BackoffStrategy;
+/**
+ * Builds Fibonacci-scaled delays: `1, 2, 3, 5, … × baseNs`, capped at `maxDelayNs`.
+ *
+ * @param baseNs - Multiplier applied to the Fibonacci unit (default `100ms` in nanoseconds).
+ * @param maxDelayNs - Upper bound in nanoseconds (default `30s`).
+ * @returns `BackoffStrategy` for {@link retry}.
+ *
+ * @example
+ * ```ts
+ * import { fibonacci, retry, NS_PER_MS } from "@graphrefly/graphrefly-ts";
+ *
+ * // Delays: 100 ms, 200 ms, 300 ms, 500 ms, 800 ms … (× 100 ms base)
+ * const out = retry(source, { count: 5, backoff: fibonacci(100 * NS_PER_MS) });
+ * ```
+ *
+ * @category extra
+ */
+declare function fibonacci(baseNs?: number, maxDelayNs?: number): BackoffStrategy;
+/**
+ * Decorrelated jitter (AWS-recommended): `random(baseNs, min(maxNs, lastDelay * 3))`.
+ *
+ * Stateless — uses `prevDelayNs` (passed by the consumer) instead of closure state.
+ * Safe to share across concurrent retry sequences.
+ *
+ * @param baseNs - Floor of the random range (default `100ms` in nanoseconds).
+ * @param maxNs - Ceiling cap (default `30s` in nanoseconds).
+ * @returns `BackoffStrategy` for {@link retry}.
+ *
+ * @example
+ * ```ts
+ * import { decorrelatedJitter, retry, NS_PER_MS, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
+ *
+ * const out = retry(source, {
+ *   count: 6,
+ *   backoff: decorrelatedJitter(100 * NS_PER_MS, 10 * NS_PER_SEC),
+ * });
+ * ```
+ *
+ * @category extra
+ */
+declare function decorrelatedJitter(baseNs?: number, maxNs?: number): BackoffStrategy;
+/**
+ * Decorator that caps any strategy at `maxAttempts`. Returns `null` (stop retrying) after the cap.
+ *
+ * @param strategy - Inner strategy to wrap.
+ * @param maxAttempts - Maximum number of attempts (inclusive).
+ * @returns Wrapped `BackoffStrategy`.
+ *
+ * @example
+ * ```ts
+ * import { withMaxAttempts, exponential } from "@graphrefly/graphrefly-ts";
+ *
+ * const capped = withMaxAttempts(exponential(), 3);
+ * capped(3); // null — no more retries beyond attempt 3
+ * ```
+ *
+ * @category extra
+ */
+declare function withMaxAttempts(strategy: BackoffStrategy, maxAttempts: number): BackoffStrategy;
+/**
+ * Maps a preset name to a concrete {@link BackoffStrategy} with library-default parameters.
+ *
+ * @param name - One of `constant`, `linear`, `exponential`, `fibonacci`, or `decorrelatedJitter`.
+ * @returns Configured strategy with default parameters.
+ * @throws Error when `name` is not a known preset.
+ *
+ * @example
+ * ```ts
+ * import { resolveBackoffPreset, retry } from "@graphrefly/graphrefly-ts";
+ *
+ * const out = retry(source, { count: 3, backoff: resolveBackoffPreset("exponential") });
+ * // Equivalent to retry(source, { count: 3, backoff: exponential() })
+ * ```
+ *
+ * @category extra
+ */
+declare function resolveBackoffPreset(name: BackoffPreset): BackoffStrategy;
+
+type RetryOptions = {
+    /** Max retry attempts after each terminal `ERROR` (not counting the first failure). */
+    count?: number;
+    /** Delay between attempts; strategies use **nanoseconds**. */
+    backoff?: BackoffStrategy | BackoffPreset;
+};
+/**
+ * Resubscribes to the upstream node after each terminal `ERROR`, after an optional delay.
+ *
+ * @param source - Upstream node (should use `resubscribable: true`).
+ * @param opts - `count` caps attempts; `backoff` supplies delay in **nanoseconds** (or a preset name).
+ * @returns Node that retries on error.
+ *
+ * @remarks
+ * **Resubscribable sources:** The upstream should use `resubscribable: true` if it must emit again after `ERROR`.
+ * **Protocol:** Forwards unknown message tuples unchanged; handles `DIRTY`, `DATA`, `RESOLVED`, `COMPLETE`, `ERROR`.
+ *
+ * @example
+ * ```ts
+ * import { ERROR, NS_PER_SEC, pipe, producer, retry, constant } from "@graphrefly/graphrefly-ts";
+ *
+ * const src = producer(
+ *   (_d, a) => {
+ *     a.down([[ERROR, new Error("x")]]);
+ *   },
+ *   { resubscribable: true },
+ * );
+ * const out = retry(src, { count: 2, backoff: constant(0.25 * NS_PER_SEC) });
+ * ```
+ *
+ * @category extra
+ */
+declare function retry<T>(source: Node<T>, opts?: RetryOptions): Node<T>;
+type CircuitState = "closed" | "open" | "half-open";
+/**
+ * Thrown when {@link withBreaker} is configured with `onOpen: "error"` and the breaker rejects work.
+ *
+ * @category extra
+ */
+declare class CircuitOpenError extends Error {
+    name: string;
+    constructor();
+}
+interface CircuitBreakerOptions {
+    /** Number of consecutive failures before opening. Default: 5. */
+    failureThreshold?: number;
+    /** Base cooldown in nanoseconds before transitioning to half-open. Default: 30s. */
+    cooldownNs?: number;
+    /** Backoff strategy for cooldown escalation across consecutive open cycles. Overrides `cooldownNs` when provided. */
+    cooldown?: BackoffStrategy;
+    /** Max trial requests allowed in half-open state. Default: 1. */
+    halfOpenMax?: number;
+    /** Clock function returning nanoseconds (for testability). Default: `monotonicNs`. */
+    now?: () => number;
+}
+interface CircuitBreaker {
+    /** Whether a request should be allowed through. Triggers open→half-open transition when cooldown expires. */
+    canExecute(): boolean;
+    /** Record a successful execution. Resets to closed. */
+    recordSuccess(): void;
+    /** Record a failed execution. May transition to open. */
+    recordFailure(error?: unknown): void;
+    /** Current circuit state (read-only, does not trigger transitions). */
+    readonly state: CircuitState;
+    /** Number of consecutive failures in the current closed period. */
+    readonly failureCount: number;
+    /** Manually reset to closed state, clearing all counters. */
+    reset(): void;
+}
+/**
+ * Factory for a synchronous circuit breaker with `closed`, `open`, and `half-open` states.
+ *
+ * Supports escalating cooldown via an optional {@link BackoffStrategy} — each consecutive
+ * open→half-open→open cycle increments the backoff attempt.
+ *
+ * @param options - Threshold, cooldown, half-open limit, and optional clock override.
+ * @returns {@link CircuitBreaker} instance.
+ *
+ * @remarks
+ * **Timing:** Uses `monotonicNs()` by default (nanoseconds). Override `now` for tests.
+ *
+ * @example
+ * ```ts
+ * import { circuitBreaker, exponential, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
+ *
+ * const b = circuitBreaker({
+ *   failureThreshold: 3,
+ *   cooldown: exponential({ baseNs: 1 * NS_PER_SEC }),
+ * });
+ * ```
+ *
+ * @category extra
+ */
+declare function circuitBreaker(options?: CircuitBreakerOptions): CircuitBreaker;
+type WithBreakerBundle<T> = {
+    node: Node<T>;
+    breakerState: Node<CircuitState>;
+};
+/**
+ * Returns a unary wrapper that gates upstream `DATA` through a {@link CircuitBreaker}.
+ *
+ * @param breaker - Shared breaker instance (typically one per resource).
+ * @param options - `onOpen: "skip"` emits `RESOLVED` when open; `"error"` emits {@link CircuitOpenError}.
+ * @returns Function mapping `Node<T>` to `{ node, breakerState }` companion nodes.
+ *
+ * @remarks
+ * **Success path:** `COMPLETE` calls {@link CircuitBreaker.recordSuccess}. **Failure path:** upstream `ERROR` calls {@link CircuitBreaker.recordFailure} and is forwarded.
+ *
+ * @example
+ * ```ts
+ * import { state, withBreaker, circuitBreaker } from "@graphrefly/graphrefly-ts";
+ *
+ * const b = circuitBreaker({ failureThreshold: 2 });
+ * const s = state(1);
+ * const { node, breakerState } = withBreaker(b)(s);
+ * ```
+ *
+ * @category extra
+ */
+declare function withBreaker<T>(breaker: CircuitBreaker, options?: {
+    onOpen?: "skip" | "error";
+}): (source: Node<T>) => WithBreakerBundle<T>;
+interface TokenBucket {
+    /** Number of tokens currently available (after refill). */
+    available(): number;
+    /** Try to consume `cost` tokens. Returns `true` if successful. */
+    tryConsume(cost?: number): boolean;
+}
+/**
+ * Token-bucket meter (capacity + refill rate per second). Use with {@link rateLimiter} or custom gates.
+ *
+ * @param capacity - Maximum tokens (must be positive).
+ * @param refillPerSecond - Tokens added per elapsed second (non-negative).
+ * @returns {@link TokenBucket} instance.
+ *
+ * @example
+ * ```ts
+ * import { tokenBucket } from "@graphrefly/graphrefly-ts";
+ *
+ * const bucket = tokenBucket(10, 2); // capacity 10, refill 2 tokens/sec
+ * bucket.tryConsume(3); // true — 7 tokens remaining
+ * bucket.available();   // ~7 (plus any elapsed refill)
+ * ```
+ *
+ * @category extra
+ */
+declare function tokenBucket(capacity: number, refillPerSecond: number): TokenBucket;
+/**
+ * Same behavior as {@link tokenBucket}. Exposed for naming parity with graphrefly-py (`token_tracker`).
+ *
+ * @param capacity - Maximum tokens (must be positive).
+ * @param refillPerSecond - Tokens added per elapsed second (non-negative).
+ * @returns A {@link TokenBucket} instance.
+ *
+ * @example
+ * ```ts
+ * import { tokenTracker } from "@graphrefly/graphrefly-ts";
+ *
+ * const tracker = tokenTracker(100, 10); // 100-token capacity, 10/sec refill
+ * tracker.tryConsume(5); // true
+ * ```
+ *
+ * @category extra
+ */
+declare function tokenTracker(capacity: number, refillPerSecond: number): TokenBucket;
+/**
+ * Enforces a sliding window: at most `maxEvents` `DATA` values per `windowNs`.
+ *
+ * @param source - Upstream node.
+ * @param maxEvents - Maximum `DATA` emissions per window (must be positive).
+ * @param windowNs - Window length in nanoseconds (must be positive).
+ * @returns Node that queues excess values FIFO until a slot frees.
+ *
+ * @remarks
+ * **Terminal:** `COMPLETE` / `ERROR` cancel timers, drop pending queue, and clear window state.
+ *
+ * @example
+ * ```ts
+ * import { rateLimiter, state, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
+ *
+ * const src = state(0);
+ * // Allow at most 5 DATA values per second
+ * const limited = rateLimiter(src, 5, NS_PER_SEC);
+ * limited.subscribe((msgs) => console.log(msgs));
+ * ```
+ *
+ * @category extra
+ */
+declare function rateLimiter<T>(source: Node<T>, maxEvents: number, windowNs: number): Node<T>;
+type StatusValue = "pending" | "active" | "completed" | "errored";
+type WithStatusBundle<T> = {
+    node: Node<T>;
+    status: Node<StatusValue>;
+    error: Node<unknown | null>;
+};
+/**
+ * Wraps `src` with `status` and `error` {@link state} companions for UI or meta snapshots.
+ *
+ * @param src - Upstream node to mirror.
+ * @param options - `initialStatus` defaults to `"pending"`.
+ * @returns `{ node, status, error }` where `error` holds the last `ERROR` payload.
+ *
+ * @remarks
+ * **Recovery:** After `errored`, the next `DATA` clears `error` and sets `active` inside {@link batch} (matches graphrefly-py).
+ *
+ * @example
+ * ```ts
+ * import { withStatus, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const src = state<number>(0);
+ * const { node, status, error } = withStatus(src);
+ *
+ * status.subscribe((msgs) => console.log("status:", msgs));
+ * src.down([[DATA, 42]]); // status → "active"
+ * ```
+ *
+ * @category extra
+ */
+declare function withStatus<T>(src: Node<T>, options?: {
+    initialStatus?: StatusValue;
+}): WithStatusBundle<T>;
+
+/**
+ * Core reactive sources, sinks, and utilities (roadmap §2.3).
+ *
+ * Each API returns a {@link Node} built with {@link node}, {@link producer},
+ * {@link derived}, or {@link effect} — no second protocol.
+ *
+ * Protocol/system/ingest adapters (fromHTTP, fromWebSocket, fromKafka, etc.)
+ * live in {@link ./adapters.ts}.
+ */
+
+type ExtraOpts$2 = Omit<NodeOptions, "describeKind">;
+/** Options for {@link fromTimer} / {@link fromPromise} / {@link fromAsyncIter}. */
+type AsyncSourceOpts = ExtraOpts$2 & {
+    signal?: AbortSignal;
+};
+/**
+ * Values accepted by {@link fromAny}.
+ *
+ * @category extra
+ */
+type NodeInput<T> = Node<T> | PromiseLike<T> | AsyncIterable<T> | Iterable<T> | T;
+/** Options for {@link fromCron}. */
+type FromCronOptions = ExtraOpts$2 & {
+    /** Polling interval in ms. Default `60_000`. */
+    tickMs?: number;
+    /** Output format: `"timestamp_ns"` (default) emits wall-clock nanoseconds; `"date"` emits a `Date` object. */
+    output?: "timestamp_ns" | "date";
+};
+/** DOM-style event target (browser or `node:events`). */
+type EventTargetLike = {
+    addEventListener(type: string, listener: (ev: unknown) => void, options?: boolean | {
+        capture?: boolean;
+        passive?: boolean;
+        once?: boolean;
+    }): void;
+    removeEventListener(type: string, listener: (ev: unknown) => void, options?: boolean | {
+        capture?: boolean;
+        passive?: boolean;
+        once?: boolean;
+    }): void;
+};
+type FSEventType = "change" | "rename" | "create" | "delete";
+type FSEvent = {
+    type: FSEventType;
+    path: string;
+    root: string;
+    relative_path: string;
+    src_path?: string;
+    dest_path?: string;
+    timestamp_ns: number;
+};
+type FromFSWatchOptions = ExtraOpts$2 & {
+    recursive?: boolean;
+    debounce?: number;
+    include?: string[];
+    exclude?: string[];
+};
+/** @internal Shared with adapters.ts for glob matching in fromFSWatch / fromGitHook. */
+declare function escapeRegexChar(ch: string): string;
+/** @internal */
+declare function globToRegExp(glob: string): RegExp;
+/** @internal */
+declare function matchesAnyPattern(path: string, patterns: RegExp[]): boolean;
+/**
+ * Builds a timer-driven source: one-shot (first tick then `COMPLETE`) or periodic (`0`, `1`, `2`, …).
+ *
+ * @param ms - Milliseconds before the first emission.
+ * @param opts - Producer options plus optional `period` for repeating ticks and optional `signal` (`AbortSignal`) to cancel with `ERROR`.
+ * @returns `Node<number>` — tick counter from `0`; teardown clears timers.
+ *
+ * @example
+ * ```ts
+ * import { fromTimer } from "@graphrefly/graphrefly-ts";
+ *
+ * fromTimer(250, { period: 1_000 });
+ * ```
+ *
+ * @category extra
+ */
+declare function fromTimer(ms: number, opts?: AsyncSourceOpts & {
+    period?: number;
+}): Node<number>;
+/**
+ * Polls on an interval; when the current minute matches a 5-field cron expression, emits once (see {@link parseCron}).
+ *
+ * @param expr - Cron string (`min hour dom month dow`).
+ * @param opts - Producer options plus `tickMs` (default `60_000`) and `output` (`timestamp_ns` default, or `date` for `Date` values).
+ * @returns `Node<number>` (nanosecond timestamp) or `Node<Date>` when `output: "date"`.
+ *
+ * @example
+ * ```ts
+ * import { fromCron } from "@graphrefly/graphrefly-ts";
+ *
+ * fromCron("0 9 * * 1");
+ * ```
+ *
+ * @category extra
+ */
+declare function fromCron(expr: string, opts?: FromCronOptions & {
+    output: "date";
+}): Node<Date>;
+declare function fromCron(expr: string, opts?: FromCronOptions): Node<number>;
+/**
+ * Wraps a DOM-style `addEventListener` target; each event becomes a `DATA` emission.
+ *
+ * @param target - Object with `addEventListener` / `removeEventListener`.
+ * @param type - Event name (e.g. `"click"`).
+ * @param opts - Producer options plus listener options (`capture`, `passive`, `once`).
+ * @returns `Node<T>` — event payloads; teardown removes the listener.
+ *
+ * @example
+ * ```ts
+ * import { fromEvent } from "@graphrefly/graphrefly-ts";
+ *
+ * fromEvent(document.body, "click");
+ * ```
+ *
+ * @category extra
+ */
+declare function fromEvent<T = unknown>(target: EventTargetLike, type: string, opts?: ExtraOpts$2 & {
+    capture?: boolean;
+    passive?: boolean;
+    once?: boolean;
+}): Node<T>;
+/**
+ * Watches filesystem paths and emits debounced change events.
+ *
+ * Uses `fs.watch` only (no polling fallback). Teardown closes all watchers.
+ *
+ * @category extra
+ */
+declare function fromFSWatch(paths: string | string[], opts?: FromFSWatchOptions): Node<FSEvent>;
+/**
+ * Drains a synchronous iterable; each item is `DATA`, then `COMPLETE`, or `ERROR` if iteration throws.
+ *
+ * @param iterable - Values to emit in order.
+ * @param opts - Optional producer options.
+ * @returns `Node<T>` — one emission per element.
+ *
+ * @example
+ * ```ts
+ * import { fromIter } from "@graphrefly/graphrefly-ts";
+ *
+ * fromIter([1, 2, 3]);
+ * ```
+ *
+ * @category extra
+ */
+declare function fromIter<T>(iterable: Iterable<T>, opts?: ExtraOpts$2): Node<T>;
+/**
+ * Lifts a Promise (or thenable) to a single-value stream: one `DATA` then `COMPLETE`, or `ERROR` on rejection.
+ *
+ * @param p - Promise to await.
+ * @param opts - Producer options plus optional `signal` for abort → `ERROR` with reason.
+ * @returns `Node<T>` — settles once.
+ *
+ * @example
+ * ```ts
+ * import { fromPromise } from "@graphrefly/graphrefly-ts";
+ *
+ * fromPromise(Promise.resolve(42));
+ * ```
+ *
+ * @category extra
+ */
+declare function fromPromise<T>(p: Promise<T> | PromiseLike<T>, opts?: AsyncSourceOpts): Node<T>;
+/**
+ * Reads an async iterable; each `next()` value becomes `DATA`; `COMPLETE` when done; `ERROR` on failure.
+ *
+ * @param iterable - Async source (`for await` shape).
+ * @param opts - Producer options plus optional `signal` to abort the pump.
+ * @returns `Node<T>` — async pull stream.
+ *
+ * @example
+ * ```ts
+ * import { fromAsyncIter } from "@graphrefly/graphrefly-ts";
+ *
+ * async function* gen() {
+ *   yield 1;
+ * }
+ * fromAsyncIter(gen());
+ * ```
+ *
+ * @category extra
+ */
+declare function fromAsyncIter<T>(iterable: AsyncIterable<T>, opts?: AsyncSourceOpts): Node<T>;
+/**
+ * Coerces a value to a `Node` by shape: existing `Node` passthrough, thenable → {@link fromPromise},
+ * async iterable → {@link fromAsyncIter}, sync iterable → {@link fromIter}, else scalar → {@link of}.
+ *
+ * @param input - Any value to wrap.
+ * @param opts - Passed through when a Promise/async path is chosen.
+ * @returns `Node` of the inferred element type.
+ *
+ * @example
+ * ```ts
+ * import { fromAny, state } from "@graphrefly/graphrefly-ts";
+ *
+ * fromAny(state(1));
+ * fromAny(Promise.resolve(2));
+ * ```
+ *
+ * @category extra
+ */
+declare function fromAny<T>(input: NodeInput<T>, opts?: AsyncSourceOpts): Node<T>;
+/**
+ * Emits each argument as `DATA` in order, then `COMPLETE` (implemented via {@link fromIter}).
+ *
+ * @param values - Values to emit.
+ * @returns `Node<T>` — finite sequence.
+ *
+ * @example
+ * ```ts
+ * import { of } from "@graphrefly/graphrefly-ts";
+ *
+ * of(1, 2, 3);
+ * ```
+ *
+ * @category extra
+ */
+declare function of<T>(...values: T[]): Node<T>;
+/**
+ * Completes immediately with no `DATA` (cold `EMPTY` analogue).
+ *
+ * @param opts - Optional producer options.
+ * @returns `Node<T>` — terminal `COMPLETE` only.
+ *
+ * @example
+ * ```ts
+ * import { empty } from "@graphrefly/graphrefly-ts";
+ *
+ * empty();
+ * ```
+ *
+ * @category extra
+ */
+declare function empty<T = never>(opts?: ExtraOpts$2): Node<T>;
+/**
+ * Never emits and never completes until teardown (cold `NEVER` analogue).
+ *
+ * @param opts - Optional producer options.
+ * @returns `Node<T>` — silent until unsubscribed.
+ *
+ * @example
+ * ```ts
+ * import { never } from "@graphrefly/graphrefly-ts";
+ *
+ * never();
+ * ```
+ *
+ * @category extra
+ */
+declare function never<T = never>(opts?: ExtraOpts$2): Node<T>;
+/**
+ * Emits `ERROR` as soon as the producer starts (cold error source).
+ *
+ * @param err - Error payload forwarded as `ERROR` data.
+ * @param opts - Optional producer options.
+ * @returns `Node<never>` — terminates with `ERROR`.
+ *
+ * @example
+ * ```ts
+ * import { throwError } from "@graphrefly/graphrefly-ts";
+ *
+ * throwError(new Error("fail"));
+ * ```
+ *
+ * @category extra
+ */
+declare function throwError(err: unknown, opts?: ExtraOpts$2): Node<never>;
+/**
+ * Subscribes immediately and runs `fn` for each upstream `DATA`; returns unsubscribe.
+ *
+ * @param source - Upstream node.
+ * @param fn - Side effect per value.
+ * @param opts - Effect node options.
+ * @returns Unsubscribe function (idempotent).
+ *
+ * @example
+ * ```ts
+ * import { forEach, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const u = forEach(state(1), (v) => console.log(v));
+ * u();
+ * ```
+ *
+ * @category extra
+ */
+declare function forEach<T>(source: Node<T>, fn: (value: T) => void, opts?: ExtraOpts$2): () => void;
+/**
+ * Buffers every `DATA`; on upstream `COMPLETE` emits one `DATA` with the full array then `COMPLETE`.
+ *
+ * @param source - Upstream node.
+ * @param opts - Optional node options (operator describe kind).
+ * @returns `Node<T[]>` — single array emission before completion.
+ *
+ * @example
+ * ```ts
+ * import { of, toArray } from "@graphrefly/graphrefly-ts";
+ *
+ * toArray(of(1, 2, 3));
+ * ```
+ *
+ * @category extra
+ */
+declare function toArray<T>(source: Node<T>, opts?: ExtraOpts$2): Node<T[]>;
+/**
+ * Multicasts upstream: one subscription to `source` while this wrapper has subscribers (via {@link producer}).
+ *
+ * @param source - Upstream node to share.
+ * @param opts - Producer options; `initial` seeds from `source.get()` when set by factory.
+ * @returns `Node<T>` — hot ref-counted bridge.
+ *
+ * @example
+ * ```ts
+ * import { share, state } from "@graphrefly/graphrefly-ts";
+ *
+ * share(state(0));
+ * ```
+ *
+ * @category extra
+ */
+declare function share<T>(source: Node<T>, opts?: ExtraOpts$2): Node<T>;
+/**
+ * Like {@link share} with a bounded replay buffer: new subscribers receive the last `bufferSize`
+ * `DATA` payloads (as separate batches) before live updates.
+ *
+ * @param source - Upstream node.
+ * @param bufferSize - Maximum past values to replay (≥ 1).
+ * @param opts - Producer options.
+ * @returns `Node<T>` — multicast with replay on subscribe.
+ *
+ * @example
+ * ```ts
+ * import { replay, state } from "@graphrefly/graphrefly-ts";
+ *
+ * replay(state(0), 3);
+ * ```
+ *
+ * @category extra
+ */
+declare function replay<T>(source: Node<T>, bufferSize: number, opts?: ExtraOpts$2): Node<T>;
+/**
+ * {@link replay} with `bufferSize === 1` — replays the latest `DATA` to new subscribers.
+ *
+ * @param source - Upstream node.
+ * @param opts - Producer options.
+ * @returns `Node<T>` — share + last-value replay.
+ *
+ * @example
+ * ```ts
+ * import { cached, state } from "@graphrefly/graphrefly-ts";
+ *
+ * cached(state(0));
+ * ```
+ *
+ * @category extra
+ */
+declare function cached<T>(source: Node<T>, opts?: ExtraOpts$2): Node<T>;
+/**
+ * Converts the first `DATA` on `source` into a Promise; rejects on `ERROR` or `COMPLETE` without data.
+ *
+ * @param source - Node to read once.
+ * @returns Promise of the first value.
+ *
+ * @example
+ * ```ts
+ * import { firstValueFrom, of } from "@graphrefly/graphrefly-ts";
+ *
+ * await firstValueFrom(of(42));
+ * ```
+ *
+ * @category extra
+ */
+declare function firstValueFrom<T>(source: Node<T>): Promise<T>;
+/**
+ * RxJS-named alias for {@link replay} — multicast with a replay buffer of size `bufferSize`.
+ *
+ * @param source - Upstream node.
+ * @param bufferSize - Replay depth (≥ 1).
+ * @param opts - Producer options.
+ * @returns Same behavior as `replay`.
+ *
+ * @example
+ * ```ts
+ * import { shareReplay, state } from "@graphrefly/graphrefly-ts";
+ *
+ * shareReplay(state(0), 5);
+ * ```
+ *
+ * @category extra
+ */
+declare const shareReplay: typeof replay;
+
+/**
+ * Protocol, system, and ingest adapters (roadmap §5.2, §5.2c).
+ *
+ * Each adapter wraps an external protocol or system as a reactive {@link Node}
+ * built on {@link producer} / {@link node} — no second protocol.
+ *
+ * **Moved from sources.ts:** fromHTTP, fromWebSocket/toWebSocket, fromWebhook,
+ * toSSE, fromMCP, fromGitHook.
+ *
+ * **New (5.2c):** fromOTel, fromSyslog, fromStatsD, fromPrometheus,
+ * fromKafka/toKafka, fromRedisStream/toRedisStream, fromCSV, fromNDJSON,
+ * fromClickHouseWatch.
+ */
+
+/** Structured callback for sink transport failures (Kafka, Redis, etc.). */
+type SinkTransportError = {
+    stage: "serialize" | "send";
+    error: Error;
+    value: unknown;
+};
+type ExtraOpts$1 = Omit<NodeOptions, "describeKind">;
+/** WebSocket-like transport accepted by {@link fromWebSocket} / {@link toWebSocket}. */
+type WebSocketLike = {
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: "message" | "error" | "close", listener: (ev: unknown) => void): void;
+    removeEventListener(type: "message" | "error" | "close", listener: (ev: unknown) => void): void;
+};
+type WebSocketMessageEventLike = {
+    data: unknown;
+};
+type WebSocketRegister<T> = (emit: (payload: T) => void, error: (err: unknown) => void, complete: () => void) => () => void;
+/**
+ * Wraps a WebSocket as a GraphReFly producer source.
+ *
+ * Incoming socket messages are emitted as `DATA`; socket `error` emits `ERROR`; socket `close`
+ * emits `COMPLETE`. Teardown detaches listeners and optionally closes the socket.
+ *
+ * @category extra
+ */
+declare function fromWebSocket<T = unknown>(socket: WebSocketLike, opts?: ExtraOpts$1 & {
+    parse?: (payload: unknown, event: unknown) => T;
+    closeOnTeardown?: boolean;
+}): Node<T>;
+declare function fromWebSocket<T = unknown>(register: WebSocketRegister<T>, opts?: ExtraOpts$1 & {
+    parse?: (payload: unknown, event: unknown) => T;
+    closeOnTeardown?: boolean;
+}): Node<T>;
+/** Registration callback for {@link fromWebhook}. */
+type WebhookRegister<T> = (handlers: {
+    /** Push one webhook payload downstream as `[[DATA, payload]]`. */
+    emit: (payload: T) => void;
+    /** Push terminal error as `[[ERROR, err]]`. */
+    error: (err: unknown) => void;
+    /** Push terminal completion as `[[COMPLETE]]`. */
+    complete: () => void;
+}) => (() => void) | undefined;
+/**
+ * Bridges HTTP webhook callbacks into a GraphReFly source.
+ *
+ * The `register` callback wires your runtime/framework callback to GraphReFly and may return a
+ * cleanup function. This keeps the adapter runtime-agnostic while following the same producer
+ * pattern as {@link fromEvent}.
+ *
+ * @param register - Registers webhook handlers (`emit`, `error`, `complete`) and optionally returns cleanup.
+ * @param opts - Optional producer options.
+ * @returns `Node<T>` — webhook payloads as `DATA`; teardown runs returned cleanup.
+ *
+ * @example
+ * ```ts
+ * import express from "express";
+ * import { fromWebhook } from "@graphrefly/graphrefly-ts";
+ *
+ * type HookPayload = { event: string; data: unknown };
+ * const app = express();
+ * app.use(express.json());
+ *
+ * const hook$ = fromWebhook<HookPayload>(({ emit, error }) => {
+ *   const handler = (req: express.Request, res: express.Response) => {
+ *     try {
+ *       emit(req.body as HookPayload);
+ *       res.status(200).send("ok");
+ *     } catch (e) {
+ *       error(e);
+ *       res.status(500).send("error");
+ *     }
+ *   };
+ *   app.post("/webhook", handler);
+ *   return () => {
+ *     // Express has no direct route-removal API in common use.
+ *   };
+ * });
+ * ```
+ *
+ * @example Fastify
+ * ```ts
+ * import Fastify from "fastify";
+ * import { fromWebhook } from "@graphrefly/graphrefly-ts";
+ *
+ * const fastify = Fastify();
+ * const hook$ = fromWebhook<any>(({ emit, error }) => {
+ *   const handler = async (req: any, reply: any) => {
+ *     try {
+ *       emit(req.body);
+ *       reply.code(200).send({ ok: true });
+ *     } catch (e) {
+ *       error(e);
+ *       reply.code(500).send({ ok: false });
+ *     }
+ *   };
+ *   fastify.post("/webhook", handler);
+ *   return () => {};
+ * });
+ * ```
+ *
+ * @category extra
+ */
+declare function fromWebhook<T = unknown>(register: WebhookRegister<T>, opts?: ExtraOpts$1): Node<T>;
+/**
+ * Options for {@link fromHTTP}.
+ *
+ * @category extra
+ */
+interface FromHTTPOptions extends AsyncSourceOpts {
+    /** HTTP method. Default: `"GET"`. */
+    method?: string;
+    /** Request headers. */
+    headers?: Record<string, string>;
+    /** Request body (for POST/PUT/PATCH). */
+    body?: any;
+    /** Transform the Response before emitting. Default: `response.json()`. */
+    transform?: (response: Response) => any | Promise<any>;
+    /** Request timeout in **nanoseconds**. Default: `30s` (30 * NS_PER_SEC). */
+    timeoutNs?: number;
+}
+/**
+ * Result of {@link fromHTTP}: main source plus status, error, and fetch count companions.
+ *
+ * @category extra
+ */
+type HTTPBundle<T> = WithStatusBundle<T> & {
+    /** Number of successful fetches. */
+    fetchCount: Node<number>;
+    /** Nanosecond wall-clock timestamp of the last successful fetch. */
+    lastUpdated: Node<number>;
+};
+/**
+ * Creates a one-shot fetch-based HTTP source with lifecycle tracking.
+ *
+ * @category extra
+ */
+declare function fromHTTP<T = any>(url: string, opts?: FromHTTPOptions): HTTPBundle<T>;
+/** Options for {@link toSSE}. */
+type ToSSEOptions = {
+    /** Custom payload serializer for non-string payloads. Default: `JSON.stringify` fallback to `String(value)`. */
+    serialize?: (value: unknown) => string;
+    /** Event name for DATA tuples. Default: `"data"`. */
+    dataEvent?: string;
+    /** Event name for ERROR tuples. Default: `"error"`. */
+    errorEvent?: string;
+    /** Event name for COMPLETE tuples. Default: `"complete"`. */
+    completeEvent?: string;
+    /** Emit `event: resolved` when RESOLVED arrives. Default: `false`. */
+    includeResolved?: boolean;
+    /** Emit `event: dirty` when DIRTY arrives. Default: `false`. */
+    includeDirty?: boolean;
+    /** Add SSE comment keepalive frames (`: keepalive`) on an interval. Disabled when unset. */
+    keepAliveMs?: number;
+    /** Optional abort signal to terminate the stream early. */
+    signal?: AbortSignal;
+    /** Maps custom message types to SSE event names. */
+    eventNameResolver?: (type: symbol) => string;
+};
+/**
+ * Creates a standard Server-Sent Events stream from node messages.
+ *
+ * @category extra
+ */
+declare function toSSE<T>(source: Node<T>, opts?: ToSSEOptions): ReadableStream<Uint8Array>;
+/** Options for {@link toWebSocket}. */
+type ToWebSocketOptions<T> = {
+    /** Serialize DATA payloads before `socket.send(...)`. */
+    serialize?: (value: T) => string | ArrayBufferLike | Blob | ArrayBufferView;
+    /** Close socket when upstream emits COMPLETE. Default: `true`. */
+    closeOnComplete?: boolean;
+    /** Close socket when upstream emits ERROR. Default: `true`. */
+    closeOnError?: boolean;
+    /** Optional close code used when close is triggered by terminal tuples. */
+    closeCode?: number;
+    /** Optional close reason used when close is triggered by terminal tuples. */
+    closeReason?: string;
+    /** Structured callback for serialize/send/close transport failures. */
+    onTransportError?: (event: ToWebSocketTransportError) => void;
+};
+type ToWebSocketTransportError = {
+    stage: "serialize" | "send" | "close";
+    error: Error;
+    message: Message | undefined;
+};
+/**
+ * Forwards upstream `DATA` payloads to a WebSocket via `send`.
+ *
+ * @category extra
+ */
+declare function toWebSocket<T>(source: Node<T>, socket: WebSocketLike, opts?: ToWebSocketOptions<T>): () => void;
+/**
+ * Duck-typed MCP (Model Context Protocol) client — only the notification
+ * registration surface is required so callers are not coupled to a specific SDK.
+ */
+type MCPClientLike = {
+    setNotificationHandler(method: string, handler: (notification: unknown) => void): void;
+};
+/** Options for {@link fromMCP}. */
+type FromMCPOptions = ExtraOpts$1 & {
+    /** MCP notification method to subscribe to. Default `"notifications/message"`. */
+    method?: string;
+    onDisconnect?: (cb: (err?: unknown) => void) => void;
+};
+/**
+ * Wraps an MCP client's server-push notifications as a reactive source.
+ *
+ * @category extra
+ */
+declare function fromMCP<T = unknown>(client: MCPClientLike, opts?: FromMCPOptions): Node<T>;
+/** Git hook type for {@link fromGitHook}. */
+type GitHookType = "post-commit" | "post-merge" | "post-checkout" | "post-rewrite";
+/** Structured git event emitted by {@link fromGitHook}. */
+type GitEvent = {
+    hook: GitHookType;
+    commit: string;
+    files: string[];
+    message: string;
+    author: string;
+    timestamp_ns: number;
+};
+/** Options for {@link fromGitHook}. */
+type FromGitHookOptions = ExtraOpts$1 & {
+    pollMs?: number;
+    include?: string[];
+    exclude?: string[];
+};
+/**
+ * Git change detection as a reactive source.
+ *
+ * @category extra
+ */
+declare function fromGitHook(repoPath: string, opts?: FromGitHookOptions): Node<GitEvent>;
+/** Standard handler triple for adapters that accept injected registrations. */
+type AdapterHandlers<T> = {
+    emit: (payload: T) => void;
+    error: (err: unknown) => void;
+    complete: () => void;
+};
+/** Structured OTel span. */
+type OTelSpan = {
+    traceId: string;
+    spanId: string;
+    operationName: string;
+    serviceName: string;
+    startTimeNs: number;
+    endTimeNs: number;
+    status: "OK" | "ERROR" | "UNSET";
+    attributes: Record<string, unknown>;
+    events: Array<{
+        name: string;
+        timestampNs: number;
+        attributes?: Record<string, unknown>;
+    }>;
+};
+/** Structured OTel metric data point. */
+type OTelMetric = {
+    name: string;
+    description?: string;
+    unit?: string;
+    type: "gauge" | "sum" | "histogram" | "summary";
+    value: number;
+    attributes: Record<string, unknown>;
+    timestampNs: number;
+};
+/** Structured OTel log record. */
+type OTelLog = {
+    timestampNs: number;
+    severityNumber?: number;
+    severityText?: string;
+    body: unknown;
+    attributes: Record<string, unknown>;
+    traceId?: string;
+    spanId?: string;
+};
+/** Registration callback for the OTLP/HTTP receiver. */
+type OTelRegister = (handlers: {
+    onTraces: (spans: OTelSpan[]) => void;
+    onMetrics: (metrics: OTelMetric[]) => void;
+    onLogs: (logs: OTelLog[]) => void;
+    onError: (err: unknown) => void;
+}) => (() => void) | undefined;
+/** Options for {@link fromOTel}. */
+type FromOTelOptions = ExtraOpts$1 & {};
+/** Bundle returned by {@link fromOTel}. */
+type OTelBundle = {
+    traces: Node<OTelSpan>;
+    metrics: Node<OTelMetric>;
+    logs: Node<OTelLog>;
+};
+/**
+ * OTLP/HTTP receiver — accepts traces, metrics, and logs as separate reactive nodes.
+ *
+ * The caller owns the HTTP server. `fromOTel` receives a `register` callback that
+ * wires OTLP POST endpoints to the three signal handlers. Each signal type gets
+ * its own `Node` so downstream can subscribe selectively.
+ *
+ * @param register - Wires OTLP HTTP routes to `onTraces`, `onMetrics`, `onLogs` handlers.
+ * @param opts - Optional producer options.
+ * @returns {@link OTelBundle} — `{ traces, metrics, logs }` nodes.
+ *
+ * @example
+ * ```ts
+ * import express from "express";
+ * import { fromOTel } from "@graphrefly/graphrefly-ts";
+ *
+ * const app = express();
+ * app.use(express.json());
+ *
+ * const otel = fromOTel(({ onTraces, onMetrics, onLogs }) => {
+ *   app.post("/v1/traces", (req, res) => { onTraces(req.body.resourceSpans ?? []); res.sendStatus(200); });
+ *   app.post("/v1/metrics", (req, res) => { onMetrics(req.body.resourceMetrics ?? []); res.sendStatus(200); });
+ *   app.post("/v1/logs", (req, res) => { onLogs(req.body.resourceLogs ?? []); res.sendStatus(200); });
+ *   return () => {};
+ * });
+ * ```
+ *
+ * @category extra
+ */
+declare function fromOTel(register: OTelRegister, opts?: FromOTelOptions): OTelBundle;
+/** Parsed syslog message (RFC 5424). */
+type SyslogMessage = {
+    facility: number;
+    severity: number;
+    timestamp: string;
+    hostname: string;
+    appName: string;
+    procId: string;
+    msgId: string;
+    message: string;
+    timestampNs: number;
+};
+/** Registration callback for syslog receiver. */
+type SyslogRegister = (handlers: AdapterHandlers<SyslogMessage>) => (() => void) | undefined;
+/** Options for {@link fromSyslog}. */
+type FromSyslogOptions = ExtraOpts$1 & {};
+/**
+ * RFC 5424 syslog receiver as a reactive source.
+ *
+ * The caller owns the UDP/TCP socket. `fromSyslog` receives a `register` callback
+ * that wires socket data events to the `emit` handler with parsed syslog messages.
+ *
+ * @param register - Wires socket to emit/error/complete handlers.
+ * @param opts - Optional producer options.
+ * @returns `Node<SyslogMessage>` — one `DATA` per syslog message.
+ *
+ * @example
+ * ```ts
+ * import dgram from "node:dgram";
+ * import { fromSyslog, parseSyslog } from "@graphrefly/graphrefly-ts";
+ *
+ * const server = dgram.createSocket("udp4");
+ * const syslog$ = fromSyslog(({ emit, error }) => {
+ *   server.on("message", (buf) => {
+ *     try { emit(parseSyslog(buf.toString())); }
+ *     catch (e) { error(e); }
+ *   });
+ *   server.bind(514);
+ *   return () => server.close();
+ * });
+ * ```
+ *
+ * @category extra
+ */
+declare function fromSyslog(register: SyslogRegister, opts?: FromSyslogOptions): Node<SyslogMessage>;
+/**
+ * Parses a raw RFC 5424 syslog line into a structured {@link SyslogMessage}.
+ *
+ * Format: `<PRI>VERSION TIMESTAMP HOSTNAME APP-NAME PROCID MSGID MSG`
+ *
+ * @category extra
+ */
+declare function parseSyslog(raw: string): SyslogMessage;
+/** Parsed StatsD metric. */
+type StatsDMetric = {
+    name: string;
+    value: number;
+    type: "counter" | "gauge" | "timer" | "histogram" | "set" | "distribution";
+    sampleRate?: number;
+    tags: Record<string, string>;
+    timestampNs: number;
+};
+/** Registration callback for StatsD receiver. */
+type StatsDRegister = (handlers: AdapterHandlers<StatsDMetric>) => (() => void) | undefined;
+/** Options for {@link fromStatsD}. */
+type FromStatsDOptions = ExtraOpts$1 & {};
+/**
+ * StatsD/DogStatsD UDP receiver as a reactive source.
+ *
+ * The caller owns the UDP socket. `fromStatsD` receives a `register` callback
+ * that wires datagrams to the `emit` handler with parsed metrics.
+ *
+ * @param register - Wires socket to emit/error/complete handlers.
+ * @param opts - Optional producer options.
+ * @returns `Node<StatsDMetric>` — one `DATA` per metric line.
+ *
+ * @example
+ * ```ts
+ * import dgram from "node:dgram";
+ * import { fromStatsD, parseStatsD } from "@graphrefly/graphrefly-ts";
+ *
+ * const server = dgram.createSocket("udp4");
+ * const stats$ = fromStatsD(({ emit, error }) => {
+ *   server.on("message", (buf) => {
+ *     for (const line of buf.toString().split("\\n")) {
+ *       if (line.trim()) {
+ *         try { emit(parseStatsD(line)); }
+ *         catch (e) { error(e); }
+ *       }
+ *     }
+ *   });
+ *   server.bind(8125);
+ *   return () => server.close();
+ * });
+ * ```
+ *
+ * @category extra
+ */
+declare function fromStatsD(register: StatsDRegister, opts?: FromStatsDOptions): Node<StatsDMetric>;
+/**
+ * Parses a raw StatsD/DogStatsD line into a structured {@link StatsDMetric}.
+ *
+ * Format: `metric.name:value|type|@sampleRate|#tag1:val1,tag2:val2`
+ *
+ * @category extra
+ */
+declare function parseStatsD(line: string): StatsDMetric;
+/** Parsed Prometheus metric. */
+type PrometheusMetric = {
+    name: string;
+    labels: Record<string, string>;
+    value: number;
+    timestampMs?: number;
+    type?: "counter" | "gauge" | "histogram" | "summary" | "untyped";
+    help?: string;
+    timestampNs: number;
+};
+/** Options for {@link fromPrometheus}. */
+type FromPrometheusOptions = AsyncSourceOpts & {
+    /** Scrape interval in nanoseconds. Default `15 * NS_PER_SEC` (15s). */
+    intervalNs?: number;
+    /** Request headers for the scrape. */
+    headers?: Record<string, string>;
+    /** Request timeout in nanoseconds. Default `10 * NS_PER_SEC` (10s). */
+    timeoutNs?: number;
+};
+/**
+ * Scrapes a Prometheus `/metrics` endpoint on a reactive timer interval.
+ *
+ * Each scrape parses the exposition format and emits one `DATA` per metric line.
+ * Uses `fromTimer` semantics internally (reactive timer source, not polling).
+ *
+ * @param endpoint - URL of the Prometheus metrics endpoint.
+ * @param opts - Scrape interval, headers, timeout.
+ * @returns `Node<PrometheusMetric>` — one `DATA` per metric per scrape.
+ *
+ * @example
+ * ```ts
+ * import { fromPrometheus } from "@graphrefly/graphrefly-ts";
+ *
+ * const prom$ = fromPrometheus("http://localhost:9090/metrics", { intervalNs: 30 * NS_PER_SEC });
+ * ```
+ *
+ * @category extra
+ */
+declare function fromPrometheus(endpoint: string, opts?: FromPrometheusOptions): Node<PrometheusMetric>;
+/**
+ * Parses Prometheus exposition format text into structured metrics.
+ *
+ * @category extra
+ */
+declare function parsePrometheusText(text: string): PrometheusMetric[];
+/** Duck-typed Kafka consumer (compatible with kafkajs, confluent-kafka, Pulsar KoP). */
+type KafkaConsumerLike = {
+    subscribe(opts: {
+        topic: string;
+        fromBeginning?: boolean;
+    }): Promise<void>;
+    run(opts: {
+        eachMessage: (payload: {
+            topic: string;
+            partition: number;
+            message: {
+                key: Buffer | null;
+                value: Buffer | null;
+                headers?: Record<string, Buffer | string | undefined>;
+                offset: string;
+                timestamp: string;
+            };
+        }) => Promise<void>;
+    }): Promise<void>;
+    disconnect(): Promise<void>;
+};
+/** Duck-typed Kafka producer. */
+type KafkaProducerLike = {
+    send(record: {
+        topic: string;
+        messages: Array<{
+            key?: string | Buffer | null;
+            value: string | Buffer | null;
+            headers?: Record<string, string | Buffer>;
+        }>;
+    }): Promise<void>;
+    disconnect(): Promise<void>;
+};
+/** Structured Kafka message. */
+type KafkaMessage<T = unknown> = {
+    topic: string;
+    partition: number;
+    key: string | null;
+    value: T;
+    headers: Record<string, string>;
+    offset: string;
+    timestamp: string;
+    timestampNs: number;
+};
+/** Options for {@link fromKafka}. */
+type FromKafkaOptions = ExtraOpts$1 & {
+    /** Start from beginning of topic. Default: `false`. */
+    fromBeginning?: boolean;
+    /** Deserialize message value. Default: `JSON.parse(buffer.toString())`. */
+    deserialize?: (value: Buffer | null) => unknown;
+};
+/**
+ * Kafka consumer as a reactive source.
+ *
+ * Wraps a KafkaJS-compatible consumer. Each message becomes a `DATA` emission.
+ * Compatible with Pulsar via KoP (Kafka-on-Pulsar).
+ *
+ * @param consumer - KafkaJS-compatible consumer instance (caller owns connect/disconnect lifecycle).
+ * @param topic - Topic to consume from.
+ * @param opts - Deserialization and source options.
+ * @returns `Node<KafkaMessage<T>>` — one `DATA` per Kafka message.
+ *
+ * @example
+ * ```ts
+ * import { Kafka } from "kafkajs";
+ * import { fromKafka } from "@graphrefly/graphrefly-ts";
+ *
+ * const kafka = new Kafka({ brokers: ["localhost:9092"] });
+ * const consumer = kafka.consumer({ groupId: "my-group" });
+ * await consumer.connect();
+ *
+ * const events$ = fromKafka(consumer, "events", { deserialize: (buf) => JSON.parse(buf!.toString()) });
+ * ```
+ *
+ * @category extra
+ */
+declare function fromKafka<T = unknown>(consumer: KafkaConsumerLike, topic: string, opts?: FromKafkaOptions): Node<KafkaMessage<T>>;
+/** Options for {@link toKafka}. */
+type ToKafkaOptions<T> = ExtraOpts$1 & {
+    /** Serialize value for Kafka. Default: `JSON.stringify`. */
+    serialize?: (value: T) => string | Buffer;
+    /** Extract message key from value. Default: `null` (no key). */
+    keyExtractor?: (value: T) => string | null;
+    /** Called on serialization or send failures. */
+    onTransportError?: (err: SinkTransportError) => void;
+};
+/**
+ * Kafka producer sink — forwards upstream `DATA` to a Kafka topic.
+ *
+ * @param source - Upstream node to forward.
+ * @param kafkaProducer - KafkaJS-compatible producer instance.
+ * @param topic - Target topic.
+ * @param opts - Serialization and key extraction options.
+ * @returns Unsubscribe function.
+ *
+ * @category extra
+ */
+declare function toKafka<T>(source: Node<T>, kafkaProducer: KafkaProducerLike, topic: string, opts?: ToKafkaOptions<T>): () => void;
+/** Duck-typed Redis client (compatible with ioredis, redis). */
+type RedisClientLike = {
+    xadd(key: string, id: string, ...fieldsAndValues: string[]): Promise<string>;
+    xread(...args: Array<string | number>): Promise<Array<[string, Array<[string, string[]]>]> | null>;
+    disconnect(): void;
+};
+/** Structured Redis Stream entry. */
+type RedisStreamEntry<T = unknown> = {
+    id: string;
+    key: string;
+    data: T;
+    timestampNs: number;
+};
+/** Options for {@link fromRedisStream}. */
+type FromRedisStreamOptions = ExtraOpts$1 & {
+    /** Block timeout in ms for XREAD. Default: `5000`. */
+    blockMs?: number;
+    /** Start ID. Default: `"$"` (new entries only). */
+    startId?: string;
+    /** Parse raw Redis hash fields to structured data. Default: parses `data` field as JSON. */
+    parse?: (fields: string[]) => unknown;
+};
+/**
+ * Redis Streams consumer as a reactive source.
+ *
+ * Uses XREAD with BLOCK to reactively consume stream entries.
+ *
+ * @param client - ioredis/redis-compatible client (caller owns connection).
+ * @param key - Redis stream key.
+ * @param opts - Block timeout, start ID, and parsing options.
+ * @returns `Node<RedisStreamEntry<T>>` — one `DATA` per stream entry.
+ *
+ * @category extra
+ */
+declare function fromRedisStream<T = unknown>(client: RedisClientLike, key: string, opts?: FromRedisStreamOptions): Node<RedisStreamEntry<T>>;
+/** Options for {@link toRedisStream}. */
+type ToRedisStreamOptions<T> = ExtraOpts$1 & {
+    /** Serialize value to Redis hash fields. Default: `["data", JSON.stringify(value)]`. */
+    serialize?: (value: T) => string[];
+    /** Max stream length (MAXLEN ~). Default: no trimming. */
+    maxLen?: number;
+    /** Called on serialization or send failures. */
+    onTransportError?: (err: SinkTransportError) => void;
+};
+/**
+ * Redis Streams producer sink — forwards upstream `DATA` to a Redis stream.
+ *
+ * @param source - Upstream node to forward.
+ * @param client - ioredis/redis-compatible client.
+ * @param key - Redis stream key.
+ * @param opts - Serialization options.
+ * @returns Unsubscribe function.
+ *
+ * @category extra
+ */
+declare function toRedisStream<T>(source: Node<T>, client: RedisClientLike, key: string, opts?: ToRedisStreamOptions<T>): () => void;
+/** Parsed CSV row. */
+type CSVRow = Record<string, string>;
+/** Options for {@link fromCSV}. */
+type FromCSVOptions = ExtraOpts$1 & {
+    /** Column delimiter. Default: `","`. */
+    delimiter?: string;
+    /** Whether the first row is a header. Default: `true`. */
+    hasHeader?: boolean;
+    /** Explicit column names (overrides header row). */
+    columns?: string[];
+    /** Custom line parser (e.g. wrapping a library like `csv-parse`). Overrides built-in parser + delimiter. */
+    parseLine?: (line: string) => string[];
+};
+/**
+ * CSV file/stream ingest for batch replay.
+ *
+ * Reads a CSV from a `ReadableStream<string>` or an `AsyncIterable<string>` of lines,
+ * emitting one `DATA` per row. `COMPLETE` after all rows are emitted.
+ *
+ * @param source - Async iterable of CSV text chunks (lines or multi-line chunks).
+ * @param opts - Delimiter, header, and column options.
+ * @returns `Node<CSVRow>` — one `DATA` per parsed row.
+ *
+ * @example
+ * ```ts
+ * import { createReadStream } from "node:fs";
+ * import { fromCSV } from "@graphrefly/graphrefly-ts";
+ *
+ * const csv$ = fromCSV(createReadStream("data.csv", "utf-8"));
+ * ```
+ *
+ * @category extra
+ */
+declare function fromCSV(source: AsyncIterable<string>, opts?: FromCSVOptions): Node<CSVRow>;
+/** Options for {@link fromNDJSON}. */
+type FromNDJSONOptions = ExtraOpts$1 & {};
+/**
+ * Newline-delimited JSON stream ingest for batch replay.
+ *
+ * Reads an async iterable of text chunks, splits by newline, parses each line
+ * as JSON, and emits one `DATA` per parsed object. `COMPLETE` after stream ends.
+ *
+ * @param source - Async iterable of NDJSON text chunks.
+ * @param opts - Optional producer options.
+ * @returns `Node<T>` — one `DATA` per JSON line.
+ *
+ * @example
+ * ```ts
+ * import { createReadStream } from "node:fs";
+ * import { fromNDJSON } from "@graphrefly/graphrefly-ts";
+ *
+ * const logs$ = fromNDJSON(createReadStream("logs.ndjson", "utf-8"));
+ * ```
+ *
+ * @category extra
+ */
+declare function fromNDJSON<T = unknown>(source: AsyncIterable<string>, opts?: FromNDJSONOptions): Node<T>;
+/** Structured ClickHouse query result row. */
+type ClickHouseRow = Record<string, unknown>;
+/** Duck-typed ClickHouse client. */
+type ClickHouseClientLike = {
+    query(opts: {
+        query: string;
+        format?: string;
+    }): Promise<{
+        json<T = unknown>(): Promise<T[]>;
+    }>;
+};
+/** Options for {@link fromClickHouseWatch}. */
+type FromClickHouseWatchOptions = AsyncSourceOpts & {
+    /** Polling interval in nanoseconds. Default: `5 * NS_PER_SEC` (5s). */
+    intervalNs?: number;
+    /** JSON format to request. Default: `"JSONEachRow"`. */
+    format?: string;
+};
+/**
+ * ClickHouse live materialized view as a reactive source.
+ *
+ * Polls a ClickHouse query on a reactive timer interval and emits new/changed rows.
+ * Uses a timer-driven approach (not busy-wait polling).
+ *
+ * @param client - ClickHouse client instance (caller owns connection).
+ * @param query - SQL query to execute on each interval.
+ * @param opts - Polling interval and format options.
+ * @returns `Node<ClickHouseRow>` — one `DATA` per result row per scrape.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from "@clickhouse/client";
+ * import { fromClickHouseWatch } from "@graphrefly/graphrefly-ts";
+ *
+ * const client = createClient({ url: "http://localhost:8123" });
+ * const rows$ = fromClickHouseWatch(client, "SELECT * FROM errors_mv ORDER BY timestamp DESC LIMIT 100");
+ * ```
+ *
+ * @category extra
+ */
+declare function fromClickHouseWatch(client: ClickHouseClientLike, query: string, opts?: FromClickHouseWatchOptions): Node<ClickHouseRow>;
+
+/**
+ * Watermark-based backpressure controller — reactive PAUSE/RESUME flow control.
+ *
+ * Purely synchronous, event-driven. No timers, no polling, no Promises.
+ * Each controller instance uses a unique lockId so multiple controllers
+ * on the same upstream node do not collide.
+ *
+ * @module
+ */
+
+type WatermarkOptions = {
+    /** Pending count at which PAUSE is sent upstream. */
+    highWaterMark: number;
+    /** Pending count at which RESUME is sent upstream (after being paused). */
+    lowWaterMark: number;
+};
+type WatermarkController = {
+    /** Call when a DATA message is buffered/enqueued. Returns `true` if PAUSE was just sent. */
+    onEnqueue(): boolean;
+    /** Call when a buffered item is consumed. Returns `true` if RESUME was just sent. */
+    onDequeue(): boolean;
+    /** Current un-consumed item count. */
+    readonly pending: number;
+    /** Whether upstream is currently paused by this controller. */
+    readonly paused: boolean;
+    /** Dispose: if paused, sends RESUME to unblock upstream. */
+    dispose(): void;
+};
+/**
+ * Creates a watermark-based backpressure controller.
+ *
+ * @param sendUp - Callback that delivers messages upstream (typically `handle.up`).
+ * @param opts - High/low watermark thresholds (item counts).
+ * @returns A {@link WatermarkController}.
+ *
+ * @example
+ * ```ts
+ * const handle = graph.observe("fast-source");
+ * const wm = createWatermarkController(
+ *   (msgs) => handle.up(msgs),
+ *   { highWaterMark: 64, lowWaterMark: 16 },
+ * );
+ *
+ * // In sink callback:
+ * handle.subscribe((msgs) => {
+ *   for (const msg of msgs) {
+ *     if (msg[0] === DATA) {
+ *       buffer.push(msg[1]);
+ *       wm.onEnqueue();
+ *     }
+ *   }
+ * });
+ *
+ * // When consumer drains:
+ * const item = buffer.shift();
+ * wm.onDequeue();
+ * ```
+ *
+ * @category extra
+ */
+declare function createWatermarkController(sendUp: (messages: Messages) => void, opts: WatermarkOptions): WatermarkController;
+
+/**
+ * Checkpoint adapters and {@link Graph} save/restore helpers (roadmap §3.1).
+ */
+
+/**
+ * Persists {@link GraphPersistSnapshot} blobs (single save/load contract, roadmap §3.1).
+ */
+interface CheckpointAdapter {
+    save(data: GraphPersistSnapshot): void;
+    load(): GraphPersistSnapshot | null;
+}
+/**
+ * In-memory adapter (process-local; useful for tests).
+ *
+ * @category extra
+ */
+declare class MemoryCheckpointAdapter implements CheckpointAdapter {
+    #private;
+    save(data: GraphPersistSnapshot): void;
+    load(): GraphPersistSnapshot | null;
+}
+/**
+ * Stores JSON-cloned snapshots under a key inside a caller-owned record (tests / embedding).
+ *
+ * @category extra
+ */
+declare class DictCheckpointAdapter implements CheckpointAdapter {
+    #private;
+    constructor(storage: Record<string, unknown>, key?: string);
+    save(data: GraphPersistSnapshot): void;
+    load(): GraphPersistSnapshot | null;
+}
+/**
+ * Atomic JSON file persistence (temp file in the target directory, then `rename`).
+ *
+ * @remarks
+ * **Errors:** `load()` returns `null` for missing files, empty files, or invalid JSON (no throw).
+ *
+ * @category extra
+ */
+declare class FileCheckpointAdapter implements CheckpointAdapter {
+    #private;
+    constructor(path: string);
+    save(data: GraphPersistSnapshot): void;
+    load(): GraphPersistSnapshot | null;
+}
+/**
+ * Persists one JSON blob under a fixed key using Node.js `node:sqlite` ({@link DatabaseSync}).
+ *
+ * @remarks
+ * **Runtime:** Requires Node 22.5+ with `node:sqlite` enabled (experimental in some releases). Call `close()` when discarding the adapter.
+ *
+ * @category extra
+ */
+declare class SqliteCheckpointAdapter implements CheckpointAdapter {
+    #private;
+    constructor(path: string, key?: string);
+    save(data: GraphPersistSnapshot): void;
+    load(): GraphPersistSnapshot | null;
+    /** Close the underlying SQLite connection (safe to call more than once). */
+    close(): void;
+}
+/**
+ * Writes {@link Graph.snapshot} through `adapter.save`.
+ *
+ * @param graph - Target graph instance.
+ * @param adapter - Sync persistence backend.
+ * @returns `void` — side-effect only; the snapshot is written to `adapter`.
+ *
+ * @example
+ * ```ts
+ * import { saveGraphCheckpoint, MemoryCheckpointAdapter, Graph } from "@graphrefly/graphrefly-ts";
+ *
+ * const g = new Graph("app");
+ * const adapter = new MemoryCheckpointAdapter();
+ * saveGraphCheckpoint(g, adapter);
+ * ```
+ *
+ * @category extra
+ */
+declare function saveGraphCheckpoint(graph: Graph, adapter: CheckpointAdapter): void;
+/**
+ * Loads a snapshot via `adapter.load` and applies {@link Graph.restore} when data exists.
+ *
+ * @param graph - Graph whose topology matches the snapshot.
+ * @param adapter - Sync persistence backend.
+ * @returns `true` if data was present and `restore` ran; `false` if `load()` returned `null`.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   saveGraphCheckpoint,
+ *   restoreGraphCheckpoint,
+ *   MemoryCheckpointAdapter,
+ *   Graph,
+ * } from "@graphrefly/graphrefly-ts";
+ *
+ * const g = new Graph("app");
+ * const adapter = new MemoryCheckpointAdapter();
+ * saveGraphCheckpoint(g, adapter);
+ *
+ * const g2 = new Graph("app");
+ * restoreGraphCheckpoint(g2, adapter); // true
+ * ```
+ *
+ * @category extra
+ */
+declare function restoreGraphCheckpoint(graph: Graph, adapter: CheckpointAdapter): boolean;
+/**
+ * Minimal JSON-shaped payload for a single node's cached value (custom adapters).
+ *
+ * @param n - Any {@link Node}.
+ * @returns `{ version: 1, value }` from {@link Node.get}.
+ *
+ * @example
+ * ```ts
+ * import { checkpointNodeValue, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const s = state(42);
+ * checkpointNodeValue(s); // { version: 1, value: 42 }
+ * ```
+ *
+ * @category extra
+ */
+declare function checkpointNodeValue<T>(n: Node<T>): {
+    version: number;
+    value: T | undefined;
+};
+type IndexedDbCheckpointSpec = {
+    dbName: string;
+    storeName: string;
+    /** @default "graphrefly_checkpoint" */
+    key?: string;
+    version?: number;
+};
+/**
+ * Wraps an `IDBRequest` as a one-shot reactive source.
+ *
+ * @param req - Request whose callbacks are converted to protocol messages.
+ * @returns `Node<T>` that emits `DATA` once on success, then `COMPLETE`; emits `ERROR` on failure.
+ *
+ * @example
+ * ```ts
+ * import { fromIDBRequest } from "@graphrefly/graphrefly-ts";
+ *
+ * const req = indexedDB.open("myDb", 1);
+ * fromIDBRequest(req).subscribe((msgs) => console.log(msgs));
+ * // Emits [[DATA, IDBDatabase], [COMPLETE]] on success
+ * ```
+ *
+ * @category extra
+ */
+declare function fromIDBRequest<T>(req: IDBRequest<T>): Node<T>;
+/**
+ * Wraps an `IDBTransaction` terminal lifecycle as a one-shot reactive source.
+ *
+ * @param tx - Transaction to observe.
+ * @returns `Node<void>` that emits `DATA` (`undefined`) then `COMPLETE` on success; emits `ERROR` on `error`/`abort`.
+ *
+ * @example
+ * ```ts
+ * import { fromIDBTransaction } from "@graphrefly/graphrefly-ts";
+ *
+ * const db: IDBDatabase = ...; // obtained from indexedDB.open
+ * const tx = db.transaction("store", "readwrite");
+ * fromIDBTransaction(tx).subscribe((msgs) => console.log(msgs));
+ * // Emits [[DATA, undefined], [COMPLETE]] when the transaction commits
+ * ```
+ *
+ * @category extra
+ */
+declare function fromIDBTransaction(tx: IDBTransaction): Node<void>;
+/**
+ * Persists {@link Graph.snapshot} under `spec.key` (browser IndexedDB).
+ *
+ * @param graph - Graph to snapshot.
+ * @param spec - Database name, object store name, optional `key` and schema `version`.
+ * @returns A reactive `Node<void>` that emits `DATA` (`undefined`) then `COMPLETE` on success, or `ERROR` on failure.
+ *
+ * @remarks
+ * **Environment:** Emits `ERROR` if `indexedDB` is undefined (e.g. Node without a polyfill).
+ *
+ * @example
+ * ```ts
+ * import { saveGraphCheckpointIndexedDb, Graph } from "@graphrefly/graphrefly-ts";
+ *
+ * const g = new Graph("app");
+ * const save$ = saveGraphCheckpointIndexedDb(g, {
+ *   dbName: "myApp",
+ *   storeName: "checkpoints",
+ * });
+ * save$.subscribe((msgs) => console.log("saved:", msgs));
+ * ```
+ *
+ * @category extra
+ */
+declare function saveGraphCheckpointIndexedDb(graph: Graph, spec: IndexedDbCheckpointSpec): Node<void>;
+/**
+ * Loads a snapshot from IndexedDB and applies {@link Graph.restore} when present.
+ *
+ * @param graph - Graph whose topology matches the stored snapshot.
+ * @param spec - Same `dbName` / `storeName` / `key` / `version` as save.
+ * @returns A reactive `Node<boolean>`: emits `true` if a snapshot was restored, `false` if missing or not a plain object, then `COMPLETE`; or `ERROR` on I/O failure.
+ *
+ * @example
+ * ```ts
+ * import { restoreGraphCheckpointIndexedDb, Graph } from "@graphrefly/graphrefly-ts";
+ *
+ * const g = new Graph("app");
+ * const restore$ = restoreGraphCheckpointIndexedDb(g, {
+ *   dbName: "myApp",
+ *   storeName: "checkpoints",
+ * });
+ * restore$.subscribe((msgs) => console.log("restored:", msgs));
+ * // Emits [[DATA, true], [COMPLETE]] if a snapshot was found and applied
+ * ```
+ *
+ * @category extra
+ */
+declare function restoreGraphCheckpointIndexedDb(graph: Graph, spec: IndexedDbCheckpointSpec): Node<boolean>;
+
+type ReactiveMapSnapshot<K, V> = Versioned<{
+    map: ReadonlyMap<K, V>;
+}>;
+type ReactiveMapOptions = {
+    /** Optional registry name for `describe()` / debugging. */
+    name?: string;
+    /** When set, evicts least-recently-used keys after inserts that exceed this size. */
+    maxSize?: number;
+    /** Default TTL in seconds. Used when `set` omits per-call `ttl`. */
+    defaultTtl?: number;
+} & Omit<NodeOptions, "initial" | "describeKind" | "equals">;
+type ReactiveMapBundle<K, V> = {
+    /** Emits {@link ReactiveMapSnapshot} on each structural change (two-phase). */
+    node: Node<ReactiveMapSnapshot<K, V>>;
+    get: (key: K) => V | undefined;
+    set: (key: K, value: V, opts?: {
+        ttl?: number;
+    }) => void;
+    delete: (key: K) => void;
+    clear: () => void;
+    has: (key: K) => boolean;
+    readonly size: number;
+    /** Removes expired entries (monotonic clock), emitting if the visible map changes. */
+    pruneExpired: () => void;
+};
+/**
+ * Creates a reactive `Map` with optional per-key TTL and optional LRU max size.
+ *
+ * @param options - Node options plus `maxSize` / `defaultTtl` (seconds).
+ * @returns `ReactiveMapBundle` — imperative `get` / `set` / `delete` / `clear` / `pruneExpired` and a `node` emitting versioned readonly map snapshots.
+ *
+ * @remarks
+ * **TTL:** Expiry is checked on `get`, `has`, `size`, `pruneExpired`, and before each
+ * snapshot emission (expired keys are pruned first). There is no
+ * background timer; monotonic-clock–expired keys may still appear in the last-emitted
+ * snapshot on `node` until a read or `pruneExpired` removes them.
+ * Uses `monotonicNs()` — immune to wall-clock adjustments.
+ *
+ * **LRU:** Uses native `Map` insertion order — `get` / `has` refreshes position; under
+ * `maxSize` pressure the first key in iteration order is evicted. When `maxSize` is
+ * omitted or is less than 1, no size-based eviction runs.
+ *
+ * @example
+ * ```ts
+ * import { reactiveMap } from "@graphrefly/graphrefly-ts";
+ *
+ * const m = reactiveMap<string, number>({ name: "cache", maxSize: 100, defaultTtl: 60 });
+ * m.set("x", 1);
+ * m.node.subscribe((msgs) => {
+ *   console.log(msgs);
+ * });
+ * ```
+ *
+ * @category extra
+ */
+declare function reactiveMap<K, V>(options?: ReactiveMapOptions): ReactiveMapBundle<K, V>;
+
+/**
+ * Composite data patterns (roadmap §3.2b).
+ *
+ * These helpers compose existing primitives (`node`, `switchMap`, `reactiveMap`,
+ * `dynamicNode`, `fromAny`) without introducing new protocol semantics.
+ */
+
+/**
+ * Verification payload shape is intentionally user-defined.
+ */
+type VerifyValue = unknown;
+type VerifiableOptions<TVerify = VerifyValue> = Omit<NodeOptions, "describeKind" | "initial"> & {
+    /** Reactive re-verification trigger. */
+    trigger?: NodeInput<unknown>;
+    /** Re-run verification whenever `source` settles. */
+    autoVerify?: boolean;
+    /** Initial verification companion value. */
+    initialVerified?: TVerify | null;
+};
+type VerifiableBundle<T, TVerify = VerifyValue> = {
+    /** Coerced source node. */
+    node: Node<T>;
+    /** Latest verification result (`null` before first verification). */
+    verified: Node<TVerify | null>;
+    /** Effective trigger node used for verification, if any. */
+    trigger: Node<unknown> | null;
+};
+/**
+ * Composes a value node with a reactive verification companion.
+ *
+ * Uses `switchMap` so newer triggers cancel stale in-flight verification work.
+ */
+declare function verifiable<T, TVerify = VerifyValue>(source: NodeInput<T>, verifyFn: (value: T) => NodeInput<TVerify>, opts?: VerifiableOptions<TVerify>): VerifiableBundle<T, TVerify>;
+type Extraction<TMem> = {
+    upsert: Array<{
+        key: string;
+        value: TMem;
+    }>;
+    remove?: string[];
+};
+type DistillOptions<TMem> = {
+    score: (mem: TMem, context: unknown) => number;
+    cost: (mem: TMem) => number;
+    budget?: number;
+    evict?: (key: string, mem: TMem) => boolean | Node<boolean>;
+    consolidate?: (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
+    consolidateTrigger?: NodeInput<unknown>;
+    context?: NodeInput<unknown>;
+    mapOptions?: ReactiveMapOptions;
+};
+type DistillBundle<TMem> = {
+    store: ReactiveMapBundle<string, TMem>;
+    compact: Node<Array<{
+        key: string;
+        value: TMem;
+        score: number;
+    }>>;
+    size: Node<number>;
+};
+/**
+ * Budget-constrained reactive memory composition.
+ */
+declare function distill<TRaw, TMem>(source: NodeInput<TRaw>, extractFn: (raw: TRaw, existing: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>, opts: DistillOptions<TMem>): DistillBundle<TMem>;
+
+/**
+ * Minimal 5-field cron parser and matcher (minute hour day-of-month month day-of-week).
+ * Ported from callbag-recharge `extra/cron.ts` for `fromCron` (roadmap §2.3).
+ */
+interface CronSchedule {
+    minutes: Set<number>;
+    hours: Set<number>;
+    daysOfMonth: Set<number>;
+    months: Set<number>;
+    daysOfWeek: Set<number>;
+}
+/**
+ * Parses a standard 5-field cron expression into a {@link CronSchedule}.
+ *
+ * Supports `*`, ranges (`1-5`), steps (`*\/5`, `0-30/10`), and comma-separated
+ * lists. Fields are: minute (0–59), hour (0–23), day-of-month (1–31),
+ * month (1–12), day-of-week (0–6, Sunday = 0).
+ *
+ * @param expr - Five-field whitespace-separated cron string (e.g. `"0 9 * * 1-5"`).
+ * @returns Parsed {@link CronSchedule} with one `Set<number>` per field.
+ * @throws Error when the expression does not have exactly 5 fields, contains
+ *   out-of-range values, or uses an invalid step.
+ *
+ * @example
+ * ```ts
+ * import { parseCron } from "@graphrefly/graphrefly-ts";
+ *
+ * const sched = parseCron("0 9 * * 1-5"); // weekdays at 09:00
+ * sched.hours;      // Set { 9 }
+ * sched.daysOfWeek; // Set { 1, 2, 3, 4, 5 }
+ * ```
+ */
+declare function parseCron(expr: string): CronSchedule;
+/**
+ * Returns `true` if `date` satisfies every field of `schedule`.
+ *
+ * @param schedule - Parsed schedule from {@link parseCron}.
+ * @param date - Moment to test (local time via `getMinutes`, `getHours`, etc.).
+ * @returns `true` when all five cron fields match the given date.
+ *
+ * @example
+ * ```ts
+ * import { parseCron, matchesCron } from "@graphrefly/graphrefly-ts";
+ *
+ * const sched = parseCron("30 8 * * 1"); // Mondays at 08:30
+ * const monday = new Date("2026-03-30T08:30:00"); // a Monday
+ * matchesCron(sched, monday); // true
+ * ```
+ */
+declare function matchesCron(schedule: CronSchedule, date: Date): boolean;
+
+/**
+ * Tier 1 sync operators (roadmap §2.1) and Tier 2 async/dynamic operators (roadmap §2.2) —
+ * each returns a {@link Node} built with {@link node} (or {@link producer} for cold sources).
+ */
+
+type ExtraOpts = Omit<NodeOptions, "describeKind">;
+/**
+ * Maps each settled value from `source` through `project`.
+ *
+ * @param source - Upstream node.
+ * @param project - Transform for each value.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<R>` - Derived node emitting mapped values.
+ *
+ * @example
+ * ```ts
+ * import { map, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = map(state(2), (x) => x * 3);
+ * ```
+ *
+ * @category extra
+ */
+declare function map<T, R>(source: Node<T>, project: (value: T) => R, opts?: ExtraOpts): Node<R>;
+/**
+ * Forwards values that satisfy `predicate`; otherwise emits `RESOLVED` with no `DATA` (two-phase semantics).
+ *
+ * @param source - Upstream node.
+ * @param predicate - Inclusion test.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Filtered node.
+ *
+ * @example
+ * ```ts
+ * import { filter, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = filter(state(1), (x) => x > 0);
+ * ```
+ *
+ * @category extra
+ */
+declare function filter<T>(source: Node<T>, predicate: (value: T) => boolean, opts?: ExtraOpts): Node<T>;
+/**
+ * Folds each upstream value into an accumulator; emits the new accumulator every time.
+ *
+ * Unlike RxJS, `seed` is always required — there is no seedless mode where the first
+ * value silently becomes the accumulator.
+ *
+ * @param source - Upstream node.
+ * @param reducer - `(acc, value) => nextAcc`.
+ * @param seed - Initial accumulator (required).
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<R>` - Scan node.
+ *
+ * @example
+ * ```ts
+ * import { scan, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = scan(state(1), (a, x) => a + x, 0);
+ * ```
+ *
+ * @category extra
+ */
+declare function scan<T, R>(source: Node<T>, reducer: (acc: R, value: T) => R, seed: R, opts?: ExtraOpts): Node<R>;
+/**
+ * Reduces to one value emitted when `source` completes; if no `DATA` arrived, emits `seed`.
+ *
+ * Unlike RxJS, `seed` is always required. If the source completes without emitting
+ * DATA, the seed value is emitted (RxJS would throw without a seed).
+ *
+ * @param source - Upstream node.
+ * @param reducer - `(acc, value) => nextAcc`.
+ * @param seed - Empty-completion default and initial accumulator (required).
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<R>` - Node that emits once on completion.
+ *
+ * @example
+ * ```ts
+ * import { reduce, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = reduce(state(1), (a, x) => a + x, 0);
+ * ```
+ *
+ * @category extra
+ */
+declare function reduce<T, R>(source: Node<T>, reducer: (acc: R, value: T) => R, seed: R, opts?: ExtraOpts): Node<R>;
+/**
+ * Emits at most `count` **`DATA`** values, then **`COMPLETE`**. `RESOLVED` does not advance the counter.
+ *
+ * @param source - Upstream node.
+ * @param count - Maximum `DATA` emissions (≤0 completes immediately).
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Limited stream.
+ *
+ * @example
+ * ```ts
+ * import { take, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = take(state(0), 3);
+ * ```
+ *
+ * @category extra
+ */
+declare function take<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T>;
+/**
+ * Skips the first `count` **`DATA`** emissions. `RESOLVED` does not advance the counter.
+ *
+ * @param source - Upstream node.
+ * @param count - Number of `DATA` values to drop.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Skipped stream.
+ *
+ * @example
+ * ```ts
+ * import { skip, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = skip(state(0), 2);
+ * ```
+ *
+ * @category extra
+ */
+declare function skip<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T>;
+/**
+ * Emits while `predicate` holds; on first false, sends **`COMPLETE`**.
+ *
+ * @param source - Upstream node.
+ * @param predicate - Continuation test.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Truncated stream.
+ *
+ * @example
+ * ```ts
+ * import { takeWhile, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = takeWhile(state(1), (x) => x < 10);
+ * ```
+ *
+ * @category extra
+ */
+declare function takeWhile<T>(source: Node<T>, predicate: (value: T) => boolean, opts?: ExtraOpts): Node<T>;
+/**
+ * Forwards `source` until `notifier` matches `predicate` (default: notifier **`DATA`**), then **`COMPLETE`**.
+ *
+ * @param source - Main upstream.
+ * @param notifier - Triggers completion when `predicate(msg)` is true.
+ * @param opts - Optional {@link NodeOptions}, plus `predicate` for custom notifier matching.
+ * @returns `Node<T>` - Truncated stream.
+ *
+ * @example
+ * ```ts
+ * import { producer, takeUntil, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const src = state(1);
+ * const stop = producer((_d, a) => a.emit(undefined));
+ * const n = takeUntil(src, stop);
+ * ```
+ *
+ * @category extra
+ */
+declare function takeUntil<T>(source: Node<T>, notifier: Node, opts?: ExtraOpts & {
+    predicate?: (msg: Message) => boolean;
+}): Node<T>;
+/**
+ * Emits the first **`DATA`** then **`COMPLETE`** (same as `take(source, 1)`).
+ *
+ * @param source - Upstream node.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Single-value stream.
+ *
+ * @example
+ * ```ts
+ * import { first, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = first(state(42));
+ * ```
+ *
+ * @category extra
+ */
+declare function first<T>(source: Node<T>, opts?: ExtraOpts): Node<T>;
+/**
+ * Buffers values and emits the last **`DATA`** on **`COMPLETE`**; optional `defaultValue` if none arrived.
+ *
+ * @param source - Upstream node.
+ * @param options - Optional {@link NodeOptions} and `defaultValue` when empty.
+ * @returns `Node<T>` - Last-or-default node.
+ *
+ * @example
+ * ```ts
+ * import { last, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = last(state(1), { defaultValue: 0 });
+ * ```
+ *
+ * @category extra
+ */
+declare function last<T>(source: Node<T>, options?: ExtraOpts & {
+    defaultValue?: T;
+}): Node<T>;
+/**
+ * Emits the first value matching `predicate`, then **`COMPLETE`**.
+ *
+ * @param source - Upstream node.
+ * @param predicate - Match test.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - First-match stream.
+ *
+ * @example
+ * ```ts
+ * import { find, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = find(state(1), (x) => x > 0);
+ * ```
+ *
+ * @category extra
+ */
+declare function find<T>(source: Node<T>, predicate: (value: T) => boolean, opts?: ExtraOpts): Node<T>;
+/**
+ * Emits the `index`th **`DATA`** (zero-based), then **`COMPLETE`**.
+ *
+ * @param source - Upstream node.
+ * @param index - Zero-based emission index.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Single indexed value.
+ *
+ * @example
+ * ```ts
+ * import { elementAt, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = elementAt(state(0), 2);
+ * ```
+ *
+ * @category extra
+ */
+declare function elementAt<T>(source: Node<T>, index: number, opts?: ExtraOpts): Node<T>;
+/**
+ * Prepends `initial` as **`DATA`**, then forwards every value from `source`.
+ *
+ * @param source - Upstream node.
+ * @param initial - Value emitted before upstream.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Prefixed stream.
+ *
+ * @example
+ * ```ts
+ * import { startWith, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = startWith(state(2), 0);
+ * ```
+ *
+ * @category extra
+ */
+declare function startWith<T>(source: Node<T>, initial: T, opts?: ExtraOpts): Node<T>;
+/**
+ * Observer shape for {@link tap} — side effects for data, error, and/or complete.
+ */
+type TapObserver<T> = {
+    data?: (value: T) => void;
+    error?: (err: unknown) => void;
+    complete?: () => void;
+};
+/**
+ * Invokes side effects; values pass through unchanged.
+ *
+ * Accepts either a function (called on each DATA) or an observer object
+ * `{ data?, error?, complete? }` for lifecycle-aware side effects.
+ *
+ * @param source - Upstream node.
+ * @param fnOrObserver - Side effect function or observer object.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Passthrough node.
+ *
+ * @example
+ * ```ts
+ * import { tap, state } from "@graphrefly/graphrefly-ts";
+ *
+ * // Function form (DATA only)
+ * tap(state(1), (x) => console.log(x));
+ *
+ * // Observer form (DATA + ERROR + COMPLETE)
+ * tap(state(1), { data: console.log, error: console.error, complete: () => console.log("done") });
+ * ```
+ *
+ * @category extra
+ */
+declare function tap<T>(source: Node<T>, fnOrObserver: ((value: T) => void) | TapObserver<T>, opts?: ExtraOpts): Node<T>;
+/**
+ * Suppresses adjacent duplicates using `equals` (default `Object.is`).
+ *
+ * @param source - Upstream node.
+ * @param equals - Optional equality for consecutive values.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Deduped stream.
+ *
+ * @example
+ * ```ts
+ * import { distinctUntilChanged, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = distinctUntilChanged(state(1));
+ * ```
+ *
+ * @category extra
+ */
+declare function distinctUntilChanged<T>(source: Node<T>, equals?: (a: T, b: T) => boolean, opts?: ExtraOpts): Node<T>;
+/**
+ * Emits `[previous, current]` pairs starting after the second value (first pair uses `RESOLVED` only).
+ *
+ * @param source - Upstream node.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<readonly [T, T]>` - Pair stream.
+ *
+ * @example
+ * ```ts
+ * import { pairwise, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = pairwise(state(0));
+ * ```
+ *
+ * @category extra
+ */
+declare function pairwise<T>(source: Node<T>, opts?: ExtraOpts): Node<readonly [T, T]>;
+/**
+ * Combines the latest value from each dependency whenever any dep settles (combineLatest).
+ *
+ * @param sources - Nodes to combine (variadic).
+ * @returns `Node<T>` - Tuple of latest values.
+ *
+ * @example
+ * ```ts
+ * import { combine, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = combine(state(1), state("a"));
+ * ```
+ *
+ * @remarks
+ * Unlike RxJS `combineLatest`, this is named `combine`. Use the {@link combineLatest} alias
+ * if you prefer the RxJS name. Seed is always required for `scan`/`reduce` (no seedless mode).
+ *
+ * @category extra
+ */
+declare function combine<const T extends readonly unknown[]>(...sources: {
+    [K in keyof T]: Node<T[K]>;
+}): Node<T>;
+/**
+ * When `primary` settles, emits `[primary, latestSecondary]`. `secondary` alone updates cache only.
+ *
+ * @param primary - Main stream.
+ * @param secondary - Latest value is paired on each primary emission.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<readonly [A, B]>` - Paired stream.
+ *
+ * @example
+ * ```ts
+ * import { state, withLatestFrom } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = withLatestFrom(state(1), state("x"));
+ * ```
+ *
+ * @category extra
+ */
+declare function withLatestFrom<A, B>(primary: Node<A>, secondary: Node<B>, opts?: ExtraOpts): Node<readonly [A, B]>;
+/**
+ * Merges **`DATA`** from any source with correct two-phase dirty tracking. **`COMPLETE`** after **all** sources complete (spec §1.3.5).
+ *
+ * @param sources - Nodes to merge (variadic; empty completes immediately).
+ * @returns `Node<T>` - Merged stream.
+ *
+ * @remarks
+ * **Ordering:** DIRTY/RESOLVED rules follow multi-source semantics in `~/src/graphrefly/GRAPHREFLY-SPEC.md`.
+ *
+ * @example
+ * ```ts
+ * import { merge, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = merge(state(1), state(2));
+ * ```
+ *
+ * @category extra
+ */
+declare function merge<T>(...sources: readonly Node<T>[]): Node<T>;
+/**
+ * Zips one **`DATA`** from each source per cycle into a tuple. Only **`DATA`** enqueues (spec §1.3.3).
+ *
+ * @param sources - Nodes to zip (variadic).
+ * @returns `Node<T>` - Zipped tuples.
+ *
+ * @example
+ * ```ts
+ * import { state, zip } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = zip(state(1), state(2));
+ * ```
+ *
+ * @category extra
+ */
+declare function zip<const T extends readonly unknown[]>(...sources: {
+    [K in keyof T]: Node<T[K]>;
+}): Node<T>;
+/**
+ * Plays all of `firstSrc`, then all of `secondSrc`. **`DATA`** from `secondSrc` during phase one is buffered until handoff.
+ *
+ * @param firstSrc - First segment.
+ * @param secondSrc - Second segment.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Concatenated stream.
+ *
+ * @example
+ * ```ts
+ * import { concat, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = concat(state(1), state(2));
+ * ```
+ *
+ * @category extra
+ */
+declare function concat<T>(firstSrc: Node<T>, secondSrc: Node<T>, opts?: ExtraOpts): Node<T>;
+/**
+ * First source to emit **`DATA`** wins; later traffic follows only the winner (Rx-style `race`).
+ *
+ * @param sources - Contestants (variadic; empty completes immediately; one node is identity).
+ * @returns `Node<T>` - Winning stream.
+ *
+ * @example
+ * ```ts
+ * import { race, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = race(state(1), state(2));
+ * ```
+ *
+ * @category extra
+ */
+declare function race<T>(...sources: readonly Node<T>[]): Node<T>;
+/**
+ * Maps each settled value to an inner node; unsubscribes the previous inner (Rx-style `switchMap`).
+ *
+ * @param source - Upstream node.
+ * @param project - Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via {@link fromAny}.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<R>` - Emissions from the active inner subscription.
+ * @example
+ * ```ts
+ * import { switchMap, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const src = state(0);
+ * switchMap(src, (n) => state((n as number) * 2));
+ * ```
+ *
+ * @category extra
+ */
+declare function switchMap<T, R>(source: Node<T>, project: (value: T) => NodeInput<R>, opts?: ExtraOpts): Node<R>;
+/**
+ * Like {@link switchMap}, but ignores outer `DATA` while an inner subscription is active (`exhaustMap`).
+ *
+ * @param source - Upstream node.
+ * @param project - Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via {@link fromAny}.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<R>` - Emissions from the active inner while it runs.
+ * @example
+ * ```ts
+ * import { exhaustMap, state } from "@graphrefly/graphrefly-ts";
+ *
+ * exhaustMap(state(0), () => state(1));
+ * ```
+ *
+ * @category extra
+ */
+declare function exhaustMap<T, R>(source: Node<T>, project: (value: T) => NodeInput<R>, opts?: ExtraOpts): Node<R>;
+/**
+ * Enqueues each outer value and subscribes to inners one at a time (`concatMap`).
+ *
+ * @param source - Upstream node.
+ * @param project - Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via {@link fromAny}.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<R>` - Sequential concatenation of inner streams.
+ * @example
+ * ```ts
+ * import { concatMap, state } from "@graphrefly/graphrefly-ts";
+ *
+ * concatMap(state(0), (n) => state((n as number) + 1));
+ * ```
+ *
+ * @category extra
+ */
+declare function concatMap<T, R>(source: Node<T>, project: (value: T) => NodeInput<R>, opts?: ExtraOpts & {
+    maxBuffer?: number;
+}): Node<R>;
+/** Options for {@link mergeMap}. */
+type MergeMapOptions = ExtraOpts & {
+    /** Maximum number of concurrent inner subscriptions. Default: `Infinity` (unbounded). */
+    concurrent?: number;
+};
+/**
+ * Subscribes to inner nodes in parallel (up to `concurrent`) and merges outputs (`mergeMap` / `flatMap`).
+ *
+ * @param source - Upstream node.
+ * @param project - Maps each outer value to an inner source shape (`Node`, scalar, `PromiseLike`, `Iterable`, or `AsyncIterable`) coerced via {@link fromAny}.
+ * @param opts - Optional options including `concurrent` limit.
+ * @returns `Node<R>` - Merged output of all active inners; completes when the outer and every inner complete.
+ * @example
+ * ```ts
+ * import { mergeMap, state } from "@graphrefly/graphrefly-ts";
+ *
+ * // Unbounded (default)
+ * mergeMap(state(0), (n) => state((n as number) + 1));
+ *
+ * // Limited concurrency
+ * mergeMap(state(0), (n) => state((n as number) + 1), { concurrent: 3 });
+ * ```
+ *
+ * @category extra
+ */
+declare function mergeMap<T, R>(source: Node<T>, project: (value: T) => NodeInput<R>, opts?: MergeMapOptions): Node<R>;
+/**
+ * RxJS-named alias for {@link mergeMap} — projects each `DATA` to an inner node and merges outputs.
+ *
+ * @param source - Upstream node.
+ * @param project - Returns an inner `Node<R>` per value.
+ * @param opts - Optional concurrency cap and node options (excluding `describeKind`).
+ * @returns Merged projection; behavior matches `mergeMap`.
+ *
+ * @example
+ * ```ts
+ * import { flatMap, state } from "@graphrefly/graphrefly-ts";
+ *
+ * flatMap(state(0), (n) => state(n));
+ * ```
+ *
+ * @category extra
+ */
+declare const flatMap: typeof mergeMap;
+/**
+ * Delays phase-2 emissions by `ms` (timers). `DIRTY` still forwards immediately.
+ *
+ * @param source - Upstream node.
+ * @param ms - Delay in milliseconds.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Same values, shifted in time.
+ * @example
+ * ```ts
+ * import { delay, state } from "@graphrefly/graphrefly-ts";
+ *
+ * delay(state(1), 100);
+ * ```
+ *
+ * @category extra
+ */
+declare function delay<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T>;
+/**
+ * Emits the latest value only after `ms` quiet time since the last trigger (`debounce`).
+ *
+ * @param source - Upstream node.
+ * @param ms - Quiet window in milliseconds.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Debounced stream.
+ * @example
+ * ```ts
+ * import { debounce, state } from "@graphrefly/graphrefly-ts";
+ *
+ * debounce(state(0), 50);
+ * ```
+ *
+ * @category extra
+ */
+declare function debounce<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T>;
+type ThrottleOptions = {
+    leading?: boolean;
+    trailing?: boolean;
+};
+/**
+ * Rate-limits emissions to at most once per `ms` window (`throttleTime`).
+ *
+ * @param source - Upstream node.
+ * @param ms - Minimum spacing in milliseconds.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`) plus `leading` / `trailing`.
+ * @returns `Node<T>` - Throttled stream.
+ * @example
+ * ```ts
+ * import { throttle, state } from "@graphrefly/graphrefly-ts";
+ *
+ * throttle(state(0), 1_000, { trailing: false });
+ * ```
+ *
+ * @category extra
+ */
+declare function throttle<T>(source: Node<T>, ms: number, opts?: ExtraOpts & ThrottleOptions): Node<T>;
+/**
+ * Emits the most recent source value whenever `notifier` settles (`sample`).
+ *
+ * @param source - Node whose latest value is sampled.
+ * @param notifier - When this node settles (`DATA` / `RESOLVED`), a sample is taken.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Sampled snapshots of `source`.
+ * @remarks **Undefined payload:** If `T` includes `undefined`, `get() === undefined` is treated as “no snapshot” and the operator emits `RESOLVED` instead of `DATA`.
+ * @example
+ * ```ts
+ * import { sample, state } from "@graphrefly/graphrefly-ts";
+ *
+ * sample(state(1), state(0));
+ * ```
+ *
+ * @category extra
+ */
+declare function sample<T>(source: Node<T>, notifier: Node<unknown>, opts?: ExtraOpts): Node<T>;
+/**
+ * After each source `DATA`, waits `ms` then emits the latest value if another `DATA` has not arrived (`auditTime` / trailing window).
+ *
+ * @param source - Upstream node.
+ * @param ms - Window in milliseconds after each `DATA`.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Trailing-edge sampled stream.
+ * @example
+ * ```ts
+ * import { audit, state } from "@graphrefly/graphrefly-ts";
+ *
+ * audit(state(0), 100);
+ * ```
+ *
+ * @category extra
+ */
+declare function audit<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T>;
+/**
+ * Errors if no `DATA` arrives within `ms` after subscribe or after the previous `DATA`.
+ *
+ * @param source - Upstream node.
+ * @param ms - Idle budget in milliseconds.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`) and `with` for a custom error payload.
+ * @returns `Node<T>` - Pass-through with idle watchdog.
+ * @example
+ * ```ts
+ * import { timeout, state } from "@graphrefly/graphrefly-ts";
+ *
+ * timeout(state(0), 5_000);
+ * ```
+ *
+ * @category extra
+ */
+declare function timeout<T>(source: Node<T>, ms: number, opts?: ExtraOpts & {
+    with?: unknown;
+}): Node<T>;
+/**
+ * Buffers source `DATA` values; flushes an array when `notifier` settles (`buffer`).
+ *
+ * @param source - Upstream node.
+ * @param notifier - Flush trigger on each settlement.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T[]>` - Emits buffered arrays (may be empty-handled via `RESOLVED` when nothing buffered).
+ * @example
+ * ```ts
+ * import { buffer, state } from "@graphrefly/graphrefly-ts";
+ *
+ * buffer(state(0), state(0));
+ * ```
+ *
+ * @category extra
+ */
+declare function buffer<T>(source: Node<T>, notifier: Node<unknown>, opts?: ExtraOpts): Node<T[]>;
+/**
+ * Batches consecutive `DATA` values into arrays of length `count` (`bufferCount` / `windowCount`).
+ *
+ * @param source - Upstream node.
+ * @param count - Buffer size before emit; must be > 0.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T[]>` - Emits fixed-size arrays; remainder flushes on `COMPLETE`.
+ * @example
+ * ```ts
+ * import { bufferCount, state } from "@graphrefly/graphrefly-ts";
+ *
+ * bufferCount(state(0), 3);
+ * ```
+ *
+ * @category extra
+ */
+declare function bufferCount<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T[]>;
+/**
+ * Splits source `DATA` into sub-nodes of `count` values each. Each sub-node completes after `count` items or when source completes.
+ *
+ * @param source - Upstream node.
+ * @param count - Items per window.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<Node<T>>` - Each emission is a sub-node carrying that window's values.
+ *
+ * @example
+ * ```ts
+ * import { windowCount, state } from "@graphrefly/graphrefly-ts";
+ *
+ * windowCount(state(0), 3);
+ * ```
+ *
+ * @category extra
+ */
+declare function windowCount<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<Node<T>>;
+/**
+ * Flushes buffered `DATA` values every `ms` (`bufferTime` / `windowTime`).
+ *
+ * @param source - Upstream node.
+ * @param ms - Flush interval in milliseconds.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T[]>` - Time-windowed batches.
+ * @example
+ * ```ts
+ * import { bufferTime, state } from "@graphrefly/graphrefly-ts";
+ *
+ * bufferTime(state(0), 250);
+ * ```
+ *
+ * @category extra
+ */
+declare function bufferTime<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<T[]>;
+/**
+ * Splits source `DATA` into time-windowed sub-nodes; each window lasts `ms`.
+ *
+ * @param source - Upstream node.
+ * @param ms - Window duration in milliseconds.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<Node<T>>` - Each emission is a sub-node carrying that window's values.
+ *
+ * @example
+ * ```ts
+ * import { windowTime, state } from "@graphrefly/graphrefly-ts";
+ *
+ * windowTime(state(0), 500);
+ * ```
+ *
+ * @category extra
+ */
+declare function windowTime<T>(source: Node<T>, ms: number, opts?: ExtraOpts): Node<Node<T>>;
+/**
+ * Splits source `DATA` into sub-nodes, opening a new window each time `notifier` emits `DATA`.
+ *
+ * @param source - Upstream node.
+ * @param notifier - Each `DATA` from `notifier` closes the current window and opens a new one.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<Node<T>>` - Each emission is a sub-node carrying that window's values.
+ *
+ * @example
+ * ```ts
+ * import { state, window } from "@graphrefly/graphrefly-ts";
+ *
+ * window(state(0), state(0));
+ * ```
+ *
+ * @category extra
+ */
+declare function window<T>(source: Node<T>, notifier: Node<unknown>, opts?: ExtraOpts): Node<Node<T>>;
+/**
+ * Increments on each tick (`interval`); uses `setInterval` via {@link producer}.
+ *
+ * @param periodMs - Time between ticks.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<number>` - Emits `0`, `1`, `2`, … while subscribed.
+ * @example
+ * ```ts
+ * import { interval } from "@graphrefly/graphrefly-ts";
+ *
+ * interval(1_000);
+ * ```
+ *
+ * @category extra
+ */
+declare function interval(periodMs: number, opts?: ExtraOpts): Node<number>;
+/**
+ * Subscribes to `source` repeatedly (`count` times, sequentially). Best with a fresh or `resubscribable` source.
+ *
+ * @param source - Upstream node to replay.
+ * @param count - Number of subscription rounds.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Forwards each round then completes after the last inner `COMPLETE`.
+ * @example
+ * ```ts
+ * import { repeat, state } from "@graphrefly/graphrefly-ts";
+ *
+ * repeat(state(1, { resubscribable: true }), 2);
+ * ```
+ *
+ * @category extra
+ */
+declare function repeat<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T>;
+/**
+ * While `PAUSE` is in effect, buffers `DIRTY` / `DATA` / `RESOLVED`; flushes on `RESUME`.
+ *
+ * @param source - Upstream node.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Pass-through with pause buffering.
+ * @example
+ * ```ts
+ * import { pausable, state, PAUSE, RESUME } from "@graphrefly/graphrefly-ts";
+ *
+ * const s = state(0);
+ * pausable(s);
+ * s.down([[PAUSE]]);
+ * s.down([[RESUME]]);
+ * ```
+ *
+ * @category extra
+ */
+declare function pausable<T>(source: Node<T>, opts?: ExtraOpts): Node<T>;
+/**
+ * Replaces an upstream `ERROR` with a recovered value (`catchError`-style).
+ *
+ * @param source - Upstream node.
+ * @param recover - Maps the error payload to a replacement value; if it throws, `ERROR` is forwarded.
+ * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
+ * @returns `Node<T>` - Recovered stream.
+ * @example
+ * ```ts
+ * import { rescue, state } from "@graphrefly/graphrefly-ts";
+ *
+ * rescue(state(0), () => 0);
+ * ```
+ *
+ * @category extra
+ */
+declare function rescue<T>(source: Node<T>, recover: (err: unknown) => T, opts?: ExtraOpts): Node<T>;
+/**
+ * Forwards upstream `DATA` only while `control.get()` is truthy; when closed, emits `RESOLVED`
+ * instead of repeating the last value (value-level gate). For protocol pause/resume, use {@link pausable}.
+ *
+ * @param source - Upstream value node.
+ * @param control - Boolean node; when falsy, output stays “closed” for that tick.
+ * @param opts - Optional node options (excluding `describeKind`).
+ * @returns `Node<T>` gated by `control`.
+ *
+ * @example
+ * ```ts
+ * import { gate, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const data = state(1);
+ * const open = state(true);
+ * gate(data, open);
+ * ```
+ *
+ * @category extra
+ */
+declare function gate<T>(source: Node<T>, control: Node<boolean>, opts?: ExtraOpts): Node<T>;
+/**
+ * RxJS-named alias for {@link combine} — emits when any dep updates with latest tuple of values.
+ *
+ * @param sources - Upstream nodes as separate arguments (same calling shape as `combine`).
+ * @returns Combined node; signature matches `combine`.
+ *
+ * @example
+ * ```ts
+ * import { combineLatest, state } from "@graphrefly/graphrefly-ts";
+ *
+ * const n = combineLatest(state(1), state("a"));
+ * ```
+ *
+ * @category extra
+ */
+declare const combineLatest: typeof combine;
+/**
+ * RxJS-named alias for {@link debounce} — drops rapid `DATA` until `ms` of quiet.
+ *
+ * @param source - Upstream node.
+ * @param ms - Quiet period in milliseconds.
+ * @param opts - Optional node options (excluding `describeKind`).
+ * @returns Debounced node; behavior matches `debounce`.
+ *
+ * @example
+ * ```ts
+ * import { debounceTime, state } from "@graphrefly/graphrefly-ts";
+ *
+ * debounceTime(state(0), 100);
+ * ```
+ *
+ * @category extra
+ */
+declare const debounceTime: typeof debounce;
+/**
+ * RxJS-named alias for {@link throttle} — emits on leading/trailing edges within `ms`.
+ *
+ * @param source - Upstream node.
+ * @param ms - Minimum spacing in milliseconds.
+ * @param opts - Optional throttle shape (`leading` / `trailing`) and node options.
+ * @returns Throttled node; behavior matches `throttle`.
+ *
+ * @example
+ * ```ts
+ * import { throttleTime, state } from "@graphrefly/graphrefly-ts";
+ *
+ * throttleTime(state(0), 100);
+ * ```
+ *
+ * @category extra
+ */
+declare const throttleTime: typeof throttle;
+/**
+ * RxJS-named alias for {@link rescue} — replaces upstream `ERROR` with a recovered value.
+ *
+ * @param source - Upstream node.
+ * @param recover - Maps error payload to replacement value.
+ * @param opts - Optional node options (excluding `describeKind`).
+ * @returns Recovered stream; behavior matches `rescue`.
+ *
+ * @example
+ * ```ts
+ * import { catchError, state } from "@graphrefly/graphrefly-ts";
+ *
+ * catchError(state(0), () => 0);
+ * ```
+ *
+ * @category extra
+ */
+declare const catchError: typeof rescue;
+
+/**
+ * Lazy per-topic manual nodes (roadmap §3.2) — create topics on first access, publish with two-phase push.
+ */
+
+/**
+ * In-memory lazy topic registry: each topic is an independent {@link state} node.
+ *
+ * @category extra
+ */
+interface PubSubHub {
+    /**
+     * Returns the topic node, creating it on first use.
+     *
+     * @param name - Topic key.
+     * @returns `Node` whose value is the last published payload (initially `undefined`).
+     */
+    topic(name: string): Node<unknown>;
+    /**
+     * Pushes a value to the topic (two-phase `DIRTY` then `DATA`, matching other manual sources here).
+     *
+     * @param name - Topic key.
+     * @param value - Payload.
+     */
+    publish(name: string, value: unknown): void;
+    /**
+     * Removes a topic and tears down its node. Returns `true` if the topic existed.
+     *
+     * @param name - Topic key.
+     */
+    removeTopic(name: string): boolean;
+}
+/**
+ * Creates an empty {@link PubSubHub} for lazy topic nodes.
+ *
+ * @returns A new hub with no topics until {@link PubSubHub.topic} or {@link PubSubHub.publish} runs.
+ *
+ * @example
+ * ```ts
+ * import { pubsub } from "@graphrefly/graphrefly-ts";
+ *
+ * const hub = pubsub();
+ * const t = hub.topic("events");
+ * t.subscribe((msgs) => console.log(msgs));
+ * hub.publish("events", { ok: true });
+ * hub.removeTopic("events"); // tears down the node
+ * ```
+ *
+ * @category extra
+ */
+declare function pubsub(): PubSubHub;
+
+type IndexRow<K, V = unknown> = {
+    readonly primary: K;
+    readonly secondary: unknown;
+    readonly value: V;
+};
+type ReactiveIndexSnapshot<K, V = unknown> = Versioned<{
+    rows: readonly IndexRow<K, V>[];
+}>;
+type ReactiveIndexOptions = {
+    name?: string;
+};
+type ReactiveIndexBundle<K, V = unknown> = {
+    /** Rows sorted by `(secondary, primary)`; versioned snapshots. */
+    readonly ordered: Node<ReactiveIndexSnapshot<K, V>>;
+    /** Map from primary key to stored value. */
+    readonly byPrimary: Node<ReadonlyMap<K, V>>;
+    upsert: (primary: K, secondary: unknown, value: V) => void;
+    delete: (primary: K) => void;
+    clear: () => void;
+};
+/**
+ * Creates a reactive index: unique primary key per row, rows sorted by `(secondary, primary)` for ordered scans.
+ *
+ * @param options - Optional `name` for `describe()` / debugging.
+ * @returns Bundle with `ordered` (versioned rows), `byPrimary` (map), and imperative `upsert` / `delete` / `clear`.
+ *
+ * @remarks
+ * **Ordering:** `secondary` and `primary` are compared via a small total order: same primitive `typeof` uses
+ * numeric/string/boolean/bigint comparison; mixed or object keys fall back to `String(a).localeCompare(String(b))`
+ * (not identical to Python’s rich comparison for exotic types).
+ *
+ * @example
+ * ```ts
+ * import { reactiveIndex } from "@graphrefly/graphrefly-ts";
+ *
+ * const idx = reactiveIndex<string, string>();
+ * idx.upsert("id1", 10, "row-a");
+ * idx.upsert("id2", 5, "row-b");
+ * ```
+ *
+ * @category extra
+ */
+declare function reactiveIndex<K, V = unknown>(options?: ReactiveIndexOptions): ReactiveIndexBundle<K, V>;
+
+type ReactiveListSnapshot<T> = Versioned<{
+    items: readonly T[];
+}>;
+type ReactiveListOptions = {
+    name?: string;
+};
+type ReactiveListBundle<T> = {
+    /** Emits {@link ReactiveListSnapshot} on each structural change (two-phase). */
+    readonly items: Node<ReactiveListSnapshot<T>>;
+    append: (value: T) => void;
+    insert: (index: number, value: T) => void;
+    pop: (index?: number) => T;
+    clear: () => void;
+};
+/**
+ * Creates a reactive list with versioned immutable array snapshots.
+ *
+ * @param initial - Optional initial items (copied).
+ * @param options - Optional `name` for `describe()` / debugging.
+ * @returns Bundle with `items` (state node) and `append` / `insert` / `pop` / `clear`.
+ *
+ * @example
+ * ```ts
+ * import { reactiveList } from "@graphrefly/graphrefly-ts";
+ *
+ * const list = reactiveList<string>(["a"], { name: "queue" });
+ * list.append("b");
+ * ```
+ *
+ * @category extra
+ */
+declare function reactiveList<T>(initial?: readonly T[], options?: ReactiveListOptions): ReactiveListBundle<T>;
+
+/**
+ * WorkerTransport — normalized message channel for all worker types.
+ *
+ * Abstracts Worker, SharedWorker, ServiceWorker, BroadcastChannel, and
+ * MessagePort behind a uniform post/listen/terminate interface.
+ */
+/** Normalized bidirectional message channel. */
+interface WorkerTransport {
+    /** Send data to the other side. Optional transferables for zero-copy. */
+    post(data: unknown, transfer?: Transferable[]): void;
+    /** Listen for incoming messages. Returns unsubscribe function. */
+    listen(handler: (data: unknown) => void): () => void;
+    /** Terminate the connection (if supported by the underlying transport). */
+    terminate?(): void;
+}
+/**
+ * Auto-detect transport type and create a normalized WorkerTransport.
+ *
+ * Supports:
+ * - `Worker` — direct postMessage/onmessage
+ * - `SharedWorker` — port-based postMessage/onmessage
+ * - `ServiceWorker` — postMessage via controller, listen via navigator.serviceWorker
+ * - `BroadcastChannel` — postMessage/onmessage (no Transferable support)
+ * - `MessagePort` — direct postMessage/onmessage (worker-side SharedWorker port)
+ */
+declare function createTransport(target: unknown): WorkerTransport;
+
+/**
+ * workerBridge — main-thread reactive node bridge to a worker.
+ *
+ * Creates proxy nodes for imported worker nodes, subscribes to exposed
+ * nodes and sends values across the wire. Uses derived() + effect() for
+ * natural batch coalescing via two-phase push + bitmask resolution.
+ *
+ * Wire filtering: messages with {@link messageTier} >= 2 cross the wire.
+ * DATA values go through the coalescing path; RESOLVED, COMPLETE, ERROR,
+ * TEARDOWN, and unknown {@link Symbol.for} types go through the signal
+ * subscription. Tier 0–1 (DIRTY, INVALIDATE, PAUSE, RESUME) stay local.
+ *
+ * Handshake:
+ *   1. Main creates bridge, starts listening
+ *   2. Worker sends { t: 'r', stores: { name: initialValue, ... } }
+ *   3. Main creates proxy nodes, marks meta.status "connected"
+ *   4. Main sends { t: 'i', stores: { name: currentValue, ... } }
+ *   5. Bidirectional value flow begins
+ */
+
+interface WorkerBridgeOptions<TExpose extends Record<string, Node<any>>, TImport extends readonly string[]> {
+    /** Nodes to send to the worker. */
+    expose?: TExpose;
+    /** Node names the worker will provide. */
+    import?: TImport;
+    /** Per-node transferable extractors for zero-copy ArrayBuffer passing. */
+    transfer?: Partial<Record<keyof TExpose, (value: any) => Transferable[]>>;
+    /** Debug name. */
+    name?: string;
+    /**
+     * Handshake timeout in milliseconds. If the worker doesn't send READY
+     * within this window, `meta.status` transitions to `"closed"` and
+     * `meta.error` is set. Default: no timeout.
+     */
+    timeoutMs?: number;
+}
+/** Proxy nodes created from imported worker node names. */
+type ImportedNodes<T extends readonly string[]> = {
+    readonly [K in T[number]]: Node<any>;
+};
+type WorkerBridge<_TExpose extends Record<string, Node<any>>, TImport extends readonly string[]> = ImportedNodes<TImport> & {
+    /** Connection status meta node. */
+    meta: {
+        status: Node<"connecting" | "connected" | "closed">;
+        error: Node<Error | null>;
+    };
+    /** Destroy the bridge: sends TEARDOWN, disconnects, terminates worker. */
+    destroy(): void;
+};
+declare function workerBridge<TExpose extends Record<string, Node<any>>, TImport extends readonly string[]>(target: unknown | WorkerTransport, opts: WorkerBridgeOptions<TExpose, TImport>): WorkerBridge<TExpose, TImport>;
+
+/**
+ * Wire protocol for worker bridge communication.
+ *
+ * Messages with {@link messageTier} >= 2 cross the wire (DATA values via
+ * coalescing, RESOLVED/COMPLETE/TEARDOWN as signals, ERROR as serialized
+ * payloads). Tier 0–1 (DIRTY, INVALIDATE, PAUSE, RESUME) stay local to
+ * each side's reactive graph.
+ *
+ * Lifecycle signals serialize as string names since Symbols can't survive
+ * structured clone. Unknown {@link Symbol.for} symbols are round-tripped
+ * via their registered key.
+ */
+/** Value update — one node changed. */
+interface ValueMessage {
+    t: "v";
+    /** Node name. */
+    s: string;
+    /** Serialized value. */
+    d: unknown;
+}
+/** Lifecycle signal — serialized symbol name. */
+interface SignalMessage {
+    t: "s";
+    /** Node name, or `"*"` for bridge-wide. */
+    s: string;
+    /** Signal name string (e.g. "TEARDOWN"). */
+    sig: string;
+    /** Optional payload for custom symbols (spec §1.3.6 forward unchanged). */
+    d?: unknown;
+}
+/** Ready — worker declares its exported nodes with initial values. */
+interface ReadyMessage {
+    t: "r";
+    stores: Record<string, unknown>;
+}
+/** Init — main sends initial values of its exposed nodes. */
+interface InitMessage {
+    t: "i";
+    stores: Record<string, unknown>;
+}
+/** Batch value update — multiple nodes changed in one reactive cycle. */
+interface BatchMessage {
+    t: "b";
+    u: Record<string, unknown>;
+    /** V0 versions per node for delta sync — peer skips if version <= lastSeen (§6.0b). */
+    v?: Record<string, number>;
+}
+/** Error payload — serialized since Error objects don't survive structured clone. */
+interface ErrorMessage {
+    t: "e";
+    /** Node name. */
+    s: string;
+    /** Serialized error. */
+    err: {
+        message: string;
+        name: string;
+        stack?: string;
+    };
+}
+type BridgeMessage = ValueMessage | SignalMessage | ReadyMessage | InitMessage | BatchMessage | ErrorMessage;
+/**
+ * Serialize a message type symbol to a string for structured clone transfer.
+ *
+ * Known GraphReFly symbols map to their canonical names. Unknown symbols
+ * registered via {@link Symbol.for} use their registered key. Unregistered
+ * symbols return `"UNKNOWN"`.
+ */
+declare function signalToName(s: symbol): string;
+/**
+ * Deserialize a string back to a message type symbol.
+ *
+ * Known GraphReFly names map to their canonical symbols. Other non-empty
+ * strings are reconstructed via {@link Symbol.for} (round-trip safe for
+ * custom message types). Returns `undefined` for `"UNKNOWN"`.
+ */
+declare function nameToSignal(name: string): symbol | undefined;
+/** Serialize an error for structured clone transfer. */
+declare function serializeError(err: unknown): {
+    message: string;
+    name: string;
+    stack?: string;
+};
+/** Deserialize an error payload back to an Error object. */
+declare function deserializeError(payload: {
+    message: string;
+    name: string;
+    stack?: string;
+}): Error;
+
+/**
+ * workerSelf — worker-side reactive node bridge.
+ *
+ * Mirror of workerBridge() for the worker side. Creates proxy nodes for
+ * imports from main thread, exposes local nodes via the same wire protocol.
+ * Uses derived() + effect() for batch coalescing.
+ *
+ * Wire filtering: messages with {@link messageTier} >= 2 cross the wire.
+ * DATA values go through the coalescing path; RESOLVED, COMPLETE, ERROR,
+ * TEARDOWN, and unknown {@link Symbol.for} types go through the signal
+ * subscription. Tier 0–1 (DIRTY, INVALIDATE, PAUSE, RESUME) stay local.
+ *
+ * Handshake (worker perspective):
+ *   1. workerSelf() called — creates proxy nodes for imports
+ *   2. Runs expose factory with proxy nodes -> gets nodes to expose
+ *   3. Sends { t: 'r', stores: { name: initialValue, ... } } to main
+ *   4. Receives { t: 'i', stores: { name: value, ... } } from main
+ *   5. Updates proxy nodes -> triggers local effects
+ */
+
+interface WorkerSelfOptions<TImport extends readonly string[]> {
+    /** Node names that the main thread will provide. */
+    import?: TImport;
+    /** Factory that receives imported proxy nodes and returns nodes to expose. */
+    expose: (imported: WorkerImported<TImport>) => Record<string, Node<any>>;
+    /** Per-node transferable extractors for zero-copy ArrayBuffer passing. */
+    transfer?: Record<string, (value: any) => Transferable[]>;
+}
+/** Proxy nodes available inside the worker from main-thread exposed nodes. */
+type WorkerImported<T extends readonly string[]> = {
+    readonly [K in T[number]]: Node<any>;
+};
+interface WorkerSelfHandle {
+    /** Dispose all subscriptions and stop the bridge. */
+    destroy(): void;
+}
+declare function workerSelf<TImport extends readonly string[]>(target: unknown | WorkerTransport, opts: WorkerSelfOptions<TImport>): WorkerSelfHandle;
+
+/**
+ * Extra layer: operators, sources, sinks (Phase 2+).
+ */
+
+type index_AdapterHandlers<T> = AdapterHandlers<T>;
+type index_AsyncSourceOpts = AsyncSourceOpts;
+type index_BackoffPreset = BackoffPreset;
+type index_BackoffStrategy = BackoffStrategy;
+type index_BatchMessage = BatchMessage;
+type index_BridgeMessage = BridgeMessage;
+type index_CSVRow = CSVRow;
+type index_CheckpointAdapter = CheckpointAdapter;
+type index_CircuitBreaker = CircuitBreaker;
+type index_CircuitBreakerOptions = CircuitBreakerOptions;
+type index_CircuitOpenError = CircuitOpenError;
+declare const index_CircuitOpenError: typeof CircuitOpenError;
+type index_CircuitState = CircuitState;
+type index_ClickHouseClientLike = ClickHouseClientLike;
+type index_ClickHouseRow = ClickHouseRow;
+type index_CronSchedule = CronSchedule;
+type index_DictCheckpointAdapter = DictCheckpointAdapter;
+declare const index_DictCheckpointAdapter: typeof DictCheckpointAdapter;
+type index_DistillBundle<TMem> = DistillBundle<TMem>;
+type index_DistillOptions<TMem> = DistillOptions<TMem>;
+type index_ErrorMessage = ErrorMessage;
+type index_EventTargetLike = EventTargetLike;
+type index_ExponentialBackoffOptions = ExponentialBackoffOptions;
+type index_Extraction<TMem> = Extraction<TMem>;
+type index_FSEvent = FSEvent;
+type index_FSEventType = FSEventType;
+type index_FileCheckpointAdapter = FileCheckpointAdapter;
+declare const index_FileCheckpointAdapter: typeof FileCheckpointAdapter;
+type index_FromCSVOptions = FromCSVOptions;
+type index_FromClickHouseWatchOptions = FromClickHouseWatchOptions;
+type index_FromCronOptions = FromCronOptions;
+type index_FromFSWatchOptions = FromFSWatchOptions;
+type index_FromGitHookOptions = FromGitHookOptions;
+type index_FromHTTPOptions = FromHTTPOptions;
+type index_FromKafkaOptions = FromKafkaOptions;
+type index_FromMCPOptions = FromMCPOptions;
+type index_FromNDJSONOptions = FromNDJSONOptions;
+type index_FromOTelOptions = FromOTelOptions;
+type index_FromPrometheusOptions = FromPrometheusOptions;
+type index_FromRedisStreamOptions = FromRedisStreamOptions;
+type index_FromStatsDOptions = FromStatsDOptions;
+type index_FromSyslogOptions = FromSyslogOptions;
+type index_GitEvent = GitEvent;
+type index_GitHookType = GitHookType;
+type index_HTTPBundle<T> = HTTPBundle<T>;
+type index_IndexRow<K, V = unknown> = IndexRow<K, V>;
+type index_IndexedDbCheckpointSpec = IndexedDbCheckpointSpec;
+type index_InitMessage = InitMessage;
+type index_JitterMode = JitterMode;
+type index_KafkaConsumerLike = KafkaConsumerLike;
+type index_KafkaMessage<T = unknown> = KafkaMessage<T>;
+type index_KafkaProducerLike = KafkaProducerLike;
+type index_MCPClientLike = MCPClientLike;
+type index_MemoryCheckpointAdapter = MemoryCheckpointAdapter;
+declare const index_MemoryCheckpointAdapter: typeof MemoryCheckpointAdapter;
+type index_MergeMapOptions = MergeMapOptions;
+declare const index_NS_PER_MS: typeof NS_PER_MS;
+declare const index_NS_PER_SEC: typeof NS_PER_SEC;
+type index_NodeInput<T> = NodeInput<T>;
+type index_OTelBundle = OTelBundle;
+type index_OTelLog = OTelLog;
+type index_OTelMetric = OTelMetric;
+type index_OTelRegister = OTelRegister;
+type index_OTelSpan = OTelSpan;
+type index_PrometheusMetric = PrometheusMetric;
+type index_PubSubHub = PubSubHub;
+type index_ReactiveIndexBundle<K, V = unknown> = ReactiveIndexBundle<K, V>;
+type index_ReactiveIndexOptions = ReactiveIndexOptions;
+type index_ReactiveIndexSnapshot<K, V = unknown> = ReactiveIndexSnapshot<K, V>;
+type index_ReactiveListBundle<T> = ReactiveListBundle<T>;
+type index_ReactiveListOptions = ReactiveListOptions;
+type index_ReactiveListSnapshot<T> = ReactiveListSnapshot<T>;
+declare const index_ReactiveLogBundle: typeof ReactiveLogBundle;
+declare const index_ReactiveLogOptions: typeof ReactiveLogOptions;
+declare const index_ReactiveLogSnapshot: typeof ReactiveLogSnapshot;
+type index_ReactiveMapBundle<K, V> = ReactiveMapBundle<K, V>;
+type index_ReactiveMapOptions = ReactiveMapOptions;
+type index_ReactiveMapSnapshot<K, V> = ReactiveMapSnapshot<K, V>;
+type index_ReadyMessage = ReadyMessage;
+type index_RedisClientLike = RedisClientLike;
+type index_RedisStreamEntry<T = unknown> = RedisStreamEntry<T>;
+type index_RetryOptions = RetryOptions;
+type index_SignalMessage = SignalMessage;
+type index_SinkTransportError = SinkTransportError;
+type index_SqliteCheckpointAdapter = SqliteCheckpointAdapter;
+declare const index_SqliteCheckpointAdapter: typeof SqliteCheckpointAdapter;
+type index_StatsDMetric = StatsDMetric;
+type index_StatsDRegister = StatsDRegister;
+type index_StatusValue = StatusValue;
+type index_SyslogMessage = SyslogMessage;
+type index_SyslogRegister = SyslogRegister;
+type index_TapObserver<T> = TapObserver<T>;
+type index_ThrottleOptions = ThrottleOptions;
+type index_ToKafkaOptions<T> = ToKafkaOptions<T>;
+type index_ToRedisStreamOptions<T> = ToRedisStreamOptions<T>;
+type index_ToSSEOptions = ToSSEOptions;
+type index_ToWebSocketOptions<T> = ToWebSocketOptions<T>;
+type index_ToWebSocketTransportError = ToWebSocketTransportError;
+type index_TokenBucket = TokenBucket;
+type index_ValueMessage = ValueMessage;
+type index_VerifiableBundle<T, TVerify = VerifyValue> = VerifiableBundle<T, TVerify>;
+type index_VerifiableOptions<TVerify = VerifyValue> = VerifiableOptions<TVerify>;
+type index_VerifyValue = VerifyValue;
+type index_WatermarkController = WatermarkController;
+type index_WatermarkOptions = WatermarkOptions;
+type index_WebSocketLike = WebSocketLike;
+type index_WebSocketMessageEventLike = WebSocketMessageEventLike;
+type index_WebSocketRegister<T> = WebSocketRegister<T>;
+type index_WebhookRegister<T> = WebhookRegister<T>;
+type index_WithBreakerBundle<T> = WithBreakerBundle<T>;
+type index_WithStatusBundle<T> = WithStatusBundle<T>;
+type index_WorkerBridge<_TExpose extends Record<string, Node<any>>, TImport extends readonly string[]> = WorkerBridge<_TExpose, TImport>;
+type index_WorkerBridgeOptions<TExpose extends Record<string, Node<any>>, TImport extends readonly string[]> = WorkerBridgeOptions<TExpose, TImport>;
+type index_WorkerSelfHandle = WorkerSelfHandle;
+type index_WorkerSelfOptions<TImport extends readonly string[]> = WorkerSelfOptions<TImport>;
+type index_WorkerTransport = WorkerTransport;
+declare const index_audit: typeof audit;
+declare const index_buffer: typeof buffer;
+declare const index_bufferCount: typeof bufferCount;
+declare const index_bufferTime: typeof bufferTime;
+declare const index_cached: typeof cached;
+declare const index_catchError: typeof catchError;
+declare const index_checkpointNodeValue: typeof checkpointNodeValue;
+declare const index_circuitBreaker: typeof circuitBreaker;
+declare const index_combine: typeof combine;
+declare const index_combineLatest: typeof combineLatest;
+declare const index_concat: typeof concat;
+declare const index_concatMap: typeof concatMap;
+declare const index_constant: typeof constant;
+declare const index_createTransport: typeof createTransport;
+declare const index_createWatermarkController: typeof createWatermarkController;
+declare const index_debounce: typeof debounce;
+declare const index_debounceTime: typeof debounceTime;
+declare const index_decorrelatedJitter: typeof decorrelatedJitter;
+declare const index_delay: typeof delay;
+declare const index_deserializeError: typeof deserializeError;
+declare const index_distill: typeof distill;
+declare const index_distinctUntilChanged: typeof distinctUntilChanged;
+declare const index_elementAt: typeof elementAt;
+declare const index_empty: typeof empty;
+declare const index_escapeRegexChar: typeof escapeRegexChar;
+declare const index_exhaustMap: typeof exhaustMap;
+declare const index_exponential: typeof exponential;
+declare const index_fibonacci: typeof fibonacci;
+declare const index_filter: typeof filter;
+declare const index_find: typeof find;
+declare const index_first: typeof first;
+declare const index_firstValueFrom: typeof firstValueFrom;
+declare const index_flatMap: typeof flatMap;
+declare const index_forEach: typeof forEach;
+declare const index_fromAny: typeof fromAny;
+declare const index_fromAsyncIter: typeof fromAsyncIter;
+declare const index_fromCSV: typeof fromCSV;
+declare const index_fromClickHouseWatch: typeof fromClickHouseWatch;
+declare const index_fromCron: typeof fromCron;
+declare const index_fromEvent: typeof fromEvent;
+declare const index_fromFSWatch: typeof fromFSWatch;
+declare const index_fromGitHook: typeof fromGitHook;
+declare const index_fromHTTP: typeof fromHTTP;
+declare const index_fromIDBRequest: typeof fromIDBRequest;
+declare const index_fromIDBTransaction: typeof fromIDBTransaction;
+declare const index_fromIter: typeof fromIter;
+declare const index_fromKafka: typeof fromKafka;
+declare const index_fromMCP: typeof fromMCP;
+declare const index_fromNDJSON: typeof fromNDJSON;
+declare const index_fromOTel: typeof fromOTel;
+declare const index_fromPrometheus: typeof fromPrometheus;
+declare const index_fromPromise: typeof fromPromise;
+declare const index_fromRedisStream: typeof fromRedisStream;
+declare const index_fromStatsD: typeof fromStatsD;
+declare const index_fromSyslog: typeof fromSyslog;
+declare const index_fromTimer: typeof fromTimer;
+declare const index_fromWebSocket: typeof fromWebSocket;
+declare const index_fromWebhook: typeof fromWebhook;
+declare const index_gate: typeof gate;
+declare const index_globToRegExp: typeof globToRegExp;
+declare const index_interval: typeof interval;
+declare const index_last: typeof last;
+declare const index_linear: typeof linear;
+declare const index_logSlice: typeof logSlice;
+declare const index_map: typeof map;
+declare const index_matchesAnyPattern: typeof matchesAnyPattern;
+declare const index_matchesCron: typeof matchesCron;
+declare const index_merge: typeof merge;
+declare const index_mergeMap: typeof mergeMap;
+declare const index_nameToSignal: typeof nameToSignal;
+declare const index_never: typeof never;
+declare const index_observeGraph$: typeof observeGraph$;
+declare const index_observeNode$: typeof observeNode$;
+declare const index_of: typeof of;
+declare const index_pairwise: typeof pairwise;
+declare const index_parseCron: typeof parseCron;
+declare const index_parsePrometheusText: typeof parsePrometheusText;
+declare const index_parseStatsD: typeof parseStatsD;
+declare const index_parseSyslog: typeof parseSyslog;
+declare const index_pausable: typeof pausable;
+declare const index_pubsub: typeof pubsub;
+declare const index_race: typeof race;
+declare const index_rateLimiter: typeof rateLimiter;
+declare const index_reactiveIndex: typeof reactiveIndex;
+declare const index_reactiveList: typeof reactiveList;
+declare const index_reactiveLog: typeof reactiveLog;
+declare const index_reactiveMap: typeof reactiveMap;
+declare const index_reduce: typeof reduce;
+declare const index_repeat: typeof repeat;
+declare const index_replay: typeof replay;
+declare const index_rescue: typeof rescue;
+declare const index_resolveBackoffPreset: typeof resolveBackoffPreset;
+declare const index_restoreGraphCheckpoint: typeof restoreGraphCheckpoint;
+declare const index_restoreGraphCheckpointIndexedDb: typeof restoreGraphCheckpointIndexedDb;
+declare const index_retry: typeof retry;
+declare const index_sample: typeof sample;
+declare const index_saveGraphCheckpoint: typeof saveGraphCheckpoint;
+declare const index_saveGraphCheckpointIndexedDb: typeof saveGraphCheckpointIndexedDb;
+declare const index_scan: typeof scan;
+declare const index_serializeError: typeof serializeError;
+declare const index_share: typeof share;
+declare const index_shareReplay: typeof shareReplay;
+declare const index_signalToName: typeof signalToName;
+declare const index_skip: typeof skip;
+declare const index_startWith: typeof startWith;
+declare const index_switchMap: typeof switchMap;
+declare const index_take: typeof take;
+declare const index_takeUntil: typeof takeUntil;
+declare const index_takeWhile: typeof takeWhile;
+declare const index_tap: typeof tap;
+declare const index_throttle: typeof throttle;
+declare const index_throttleTime: typeof throttleTime;
+declare const index_throwError: typeof throwError;
+declare const index_timeout: typeof timeout;
+declare const index_toArray: typeof toArray;
+declare const index_toKafka: typeof toKafka;
+declare const index_toMessages$: typeof toMessages$;
+declare const index_toObservable: typeof toObservable;
+declare const index_toRedisStream: typeof toRedisStream;
+declare const index_toSSE: typeof toSSE;
+declare const index_toWebSocket: typeof toWebSocket;
+declare const index_tokenBucket: typeof tokenBucket;
+declare const index_tokenTracker: typeof tokenTracker;
+declare const index_verifiable: typeof verifiable;
+declare const index_window: typeof window;
+declare const index_windowCount: typeof windowCount;
+declare const index_windowTime: typeof windowTime;
+declare const index_withBreaker: typeof withBreaker;
+declare const index_withLatestFrom: typeof withLatestFrom;
+declare const index_withMaxAttempts: typeof withMaxAttempts;
+declare const index_withStatus: typeof withStatus;
+declare const index_workerBridge: typeof workerBridge;
+declare const index_workerSelf: typeof workerSelf;
+declare const index_zip: typeof zip;
+declare namespace index {
+  export { type index_AdapterHandlers as AdapterHandlers, type index_AsyncSourceOpts as AsyncSourceOpts, type index_BackoffPreset as BackoffPreset, type index_BackoffStrategy as BackoffStrategy, type index_BatchMessage as BatchMessage, type index_BridgeMessage as BridgeMessage, type index_CSVRow as CSVRow, type index_CheckpointAdapter as CheckpointAdapter, type index_CircuitBreaker as CircuitBreaker, type index_CircuitBreakerOptions as CircuitBreakerOptions, index_CircuitOpenError as CircuitOpenError, type index_CircuitState as CircuitState, type index_ClickHouseClientLike as ClickHouseClientLike, type index_ClickHouseRow as ClickHouseRow, type index_CronSchedule as CronSchedule, index_DictCheckpointAdapter as DictCheckpointAdapter, type index_DistillBundle as DistillBundle, type index_DistillOptions as DistillOptions, type index_ErrorMessage as ErrorMessage, type index_EventTargetLike as EventTargetLike, type index_ExponentialBackoffOptions as ExponentialBackoffOptions, type index_Extraction as Extraction, type index_FSEvent as FSEvent, type index_FSEventType as FSEventType, index_FileCheckpointAdapter as FileCheckpointAdapter, type index_FromCSVOptions as FromCSVOptions, type index_FromClickHouseWatchOptions as FromClickHouseWatchOptions, type index_FromCronOptions as FromCronOptions, type index_FromFSWatchOptions as FromFSWatchOptions, type index_FromGitHookOptions as FromGitHookOptions, type index_FromHTTPOptions as FromHTTPOptions, type index_FromKafkaOptions as FromKafkaOptions, type index_FromMCPOptions as FromMCPOptions, type index_FromNDJSONOptions as FromNDJSONOptions, type index_FromOTelOptions as FromOTelOptions, type index_FromPrometheusOptions as FromPrometheusOptions, type index_FromRedisStreamOptions as FromRedisStreamOptions, type index_FromStatsDOptions as FromStatsDOptions, type index_FromSyslogOptions as FromSyslogOptions, type index_GitEvent as GitEvent, type index_GitHookType as GitHookType, type index_HTTPBundle as HTTPBundle, type index_IndexRow as IndexRow, type index_IndexedDbCheckpointSpec as IndexedDbCheckpointSpec, type index_InitMessage as InitMessage, type index_JitterMode as JitterMode, type index_KafkaConsumerLike as KafkaConsumerLike, type index_KafkaMessage as KafkaMessage, type index_KafkaProducerLike as KafkaProducerLike, type index_MCPClientLike as MCPClientLike, index_MemoryCheckpointAdapter as MemoryCheckpointAdapter, type index_MergeMapOptions as MergeMapOptions, index_NS_PER_MS as NS_PER_MS, index_NS_PER_SEC as NS_PER_SEC, type index_NodeInput as NodeInput, type index_OTelBundle as OTelBundle, type index_OTelLog as OTelLog, type index_OTelMetric as OTelMetric, type index_OTelRegister as OTelRegister, type index_OTelSpan as OTelSpan, type index_PrometheusMetric as PrometheusMetric, type index_PubSubHub as PubSubHub, type index_ReactiveIndexBundle as ReactiveIndexBundle, type index_ReactiveIndexOptions as ReactiveIndexOptions, type index_ReactiveIndexSnapshot as ReactiveIndexSnapshot, type index_ReactiveListBundle as ReactiveListBundle, type index_ReactiveListOptions as ReactiveListOptions, type index_ReactiveListSnapshot as ReactiveListSnapshot, index_ReactiveLogBundle as ReactiveLogBundle, index_ReactiveLogOptions as ReactiveLogOptions, index_ReactiveLogSnapshot as ReactiveLogSnapshot, type index_ReactiveMapBundle as ReactiveMapBundle, type index_ReactiveMapOptions as ReactiveMapOptions, type index_ReactiveMapSnapshot as ReactiveMapSnapshot, type index_ReadyMessage as ReadyMessage, type index_RedisClientLike as RedisClientLike, type index_RedisStreamEntry as RedisStreamEntry, type index_RetryOptions as RetryOptions, type index_SignalMessage as SignalMessage, type index_SinkTransportError as SinkTransportError, index_SqliteCheckpointAdapter as SqliteCheckpointAdapter, type index_StatsDMetric as StatsDMetric, type index_StatsDRegister as StatsDRegister, type index_StatusValue as StatusValue, type index_SyslogMessage as SyslogMessage, type index_SyslogRegister as SyslogRegister, type index_TapObserver as TapObserver, type index_ThrottleOptions as ThrottleOptions, type index_ToKafkaOptions as ToKafkaOptions, type index_ToRedisStreamOptions as ToRedisStreamOptions, type index_ToSSEOptions as ToSSEOptions, type index_ToWebSocketOptions as ToWebSocketOptions, type index_ToWebSocketTransportError as ToWebSocketTransportError, type index_TokenBucket as TokenBucket, type index_ValueMessage as ValueMessage, type index_VerifiableBundle as VerifiableBundle, type index_VerifiableOptions as VerifiableOptions, type index_VerifyValue as VerifyValue, type index_WatermarkController as WatermarkController, type index_WatermarkOptions as WatermarkOptions, type index_WebSocketLike as WebSocketLike, type index_WebSocketMessageEventLike as WebSocketMessageEventLike, type index_WebSocketRegister as WebSocketRegister, type index_WebhookRegister as WebhookRegister, type index_WithBreakerBundle as WithBreakerBundle, type index_WithStatusBundle as WithStatusBundle, type index_WorkerBridge as WorkerBridge, type index_WorkerBridgeOptions as WorkerBridgeOptions, type index_WorkerSelfHandle as WorkerSelfHandle, type index_WorkerSelfOptions as WorkerSelfOptions, type index_WorkerTransport as WorkerTransport, index_audit as audit, index_buffer as buffer, index_bufferCount as bufferCount, index_bufferTime as bufferTime, index_cached as cached, index_catchError as catchError, index_checkpointNodeValue as checkpointNodeValue, index_circuitBreaker as circuitBreaker, index_combine as combine, index_combineLatest as combineLatest, index_concat as concat, index_concatMap as concatMap, index_constant as constant, index_createTransport as createTransport, index_createWatermarkController as createWatermarkController, index_debounce as debounce, index_debounceTime as debounceTime, index_decorrelatedJitter as decorrelatedJitter, index_delay as delay, index_deserializeError as deserializeError, index_distill as distill, index_distinctUntilChanged as distinctUntilChanged, index_elementAt as elementAt, index_empty as empty, index_escapeRegexChar as escapeRegexChar, index_exhaustMap as exhaustMap, index_exponential as exponential, index_fibonacci as fibonacci, index_filter as filter, index_find as find, index_first as first, index_firstValueFrom as firstValueFrom, index_flatMap as flatMap, index_forEach as forEach, index_fromAny as fromAny, index_fromAsyncIter as fromAsyncIter, index_fromCSV as fromCSV, index_fromClickHouseWatch as fromClickHouseWatch, index_fromCron as fromCron, index_fromEvent as fromEvent, index_fromFSWatch as fromFSWatch, index_fromGitHook as fromGitHook, index_fromHTTP as fromHTTP, index_fromIDBRequest as fromIDBRequest, index_fromIDBTransaction as fromIDBTransaction, index_fromIter as fromIter, index_fromKafka as fromKafka, index_fromMCP as fromMCP, index_fromNDJSON as fromNDJSON, index_fromOTel as fromOTel, index_fromPrometheus as fromPrometheus, index_fromPromise as fromPromise, index_fromRedisStream as fromRedisStream, index_fromStatsD as fromStatsD, index_fromSyslog as fromSyslog, index_fromTimer as fromTimer, index_fromWebSocket as fromWebSocket, index_fromWebhook as fromWebhook, index_gate as gate, index_globToRegExp as globToRegExp, index_interval as interval, index_last as last, index_linear as linear, index_logSlice as logSlice, index_map as map, index_matchesAnyPattern as matchesAnyPattern, index_matchesCron as matchesCron, index_merge as merge, index_mergeMap as mergeMap, index_nameToSignal as nameToSignal, index_never as never, index_observeGraph$ as observeGraph$, index_observeNode$ as observeNode$, index_of as of, index_pairwise as pairwise, index_parseCron as parseCron, index_parsePrometheusText as parsePrometheusText, index_parseStatsD as parseStatsD, index_parseSyslog as parseSyslog, index_pausable as pausable, index_pubsub as pubsub, index_race as race, index_rateLimiter as rateLimiter, index_reactiveIndex as reactiveIndex, index_reactiveList as reactiveList, index_reactiveLog as reactiveLog, index_reactiveMap as reactiveMap, index_reduce as reduce, index_repeat as repeat, index_replay as replay, index_rescue as rescue, index_resolveBackoffPreset as resolveBackoffPreset, index_restoreGraphCheckpoint as restoreGraphCheckpoint, index_restoreGraphCheckpointIndexedDb as restoreGraphCheckpointIndexedDb, index_retry as retry, index_sample as sample, index_saveGraphCheckpoint as saveGraphCheckpoint, index_saveGraphCheckpointIndexedDb as saveGraphCheckpointIndexedDb, index_scan as scan, index_serializeError as serializeError, index_share as share, index_shareReplay as shareReplay, index_signalToName as signalToName, index_skip as skip, index_startWith as startWith, index_switchMap as switchMap, index_take as take, index_takeUntil as takeUntil, index_takeWhile as takeWhile, index_tap as tap, index_throttle as throttle, index_throttleTime as throttleTime, index_throwError as throwError, index_timeout as timeout, index_toArray as toArray, index_toKafka as toKafka, index_toMessages$ as toMessages$, index_toObservable as toObservable, index_toRedisStream as toRedisStream, index_toSSE as toSSE, index_toWebSocket as toWebSocket, index_tokenBucket as tokenBucket, index_tokenTracker as tokenTracker, index_verifiable as verifiable, index_window as window, index_windowCount as windowCount, index_windowTime as windowTime, index_withBreaker as withBreaker, index_withLatestFrom as withLatestFrom, index_withMaxAttempts as withMaxAttempts, index_withStatus as withStatus, index_workerBridge as workerBridge, index_workerSelf as workerSelf, index_zip as zip };
+}
+
+export { MemoryCheckpointAdapter as $, type AdapterHandlers as A, type BackoffPreset as B, type CSVRow as C, type DistillBundle as D, type Extraction as E, type FSEvent as F, type FromKafkaOptions as G, type FromMCPOptions as H, type FromNDJSONOptions as I, type FromOTelOptions as J, type FromPrometheusOptions as K, type FromRedisStreamOptions as L, type FromStatsDOptions as M, type NodeInput as N, type FromSyslogOptions as O, type GitEvent as P, type GitHookType as Q, type ReactiveListSnapshot as R, type HTTPBundle as S, type IndexRow as T, type IndexedDbCheckpointSpec as U, type InitMessage as V, type JitterMode as W, type KafkaConsumerLike as X, type KafkaMessage as Y, type KafkaProducerLike as Z, type MCPClientLike as _, type ReactiveMapSnapshot as a, combineLatest as a$, type MergeMapOptions as a0, NS_PER_MS as a1, NS_PER_SEC as a2, type OTelBundle as a3, type OTelLog as a4, type OTelMetric as a5, type OTelRegister as a6, type OTelSpan as a7, type PrometheusMetric as a8, type PubSubHub as a9, type TokenBucket as aA, type ValueMessage as aB, type VerifiableBundle as aC, type VerifiableOptions as aD, type VerifyValue as aE, type WatermarkController as aF, type WatermarkOptions as aG, type WebSocketLike as aH, type WebSocketMessageEventLike as aI, type WebSocketRegister as aJ, type WebhookRegister as aK, type WithBreakerBundle as aL, type WithStatusBundle as aM, type WorkerBridge as aN, type WorkerBridgeOptions as aO, type WorkerSelfHandle as aP, type WorkerSelfOptions as aQ, type WorkerTransport as aR, audit as aS, buffer as aT, bufferCount as aU, bufferTime as aV, cached as aW, catchError as aX, checkpointNodeValue as aY, circuitBreaker as aZ, combine as a_, type ReactiveIndexBundle as aa, type ReactiveIndexOptions as ab, type ReactiveIndexSnapshot as ac, type ReactiveListBundle as ad, type ReactiveListOptions as ae, type ReactiveMapBundle as af, type ReactiveMapOptions as ag, type ReadyMessage as ah, type RedisClientLike as ai, type RedisStreamEntry as aj, type RetryOptions as ak, type SignalMessage as al, type SinkTransportError as am, SqliteCheckpointAdapter as an, type StatsDMetric as ao, type StatsDRegister as ap, type StatusValue as aq, type SyslogMessage as ar, type SyslogRegister as as, type TapObserver as at, type ThrottleOptions as au, type ToKafkaOptions as av, type ToRedisStreamOptions as aw, type ToSSEOptions as ax, type ToWebSocketOptions as ay, type ToWebSocketTransportError as az, type AsyncSourceOpts as b, parseCron as b$, concat as b0, concatMap as b1, constant as b2, createTransport as b3, createWatermarkController as b4, debounce as b5, debounceTime as b6, decorrelatedJitter as b7, delay as b8, deserializeError as b9, fromIter as bA, fromKafka as bB, fromMCP as bC, fromNDJSON as bD, fromOTel as bE, fromPrometheus as bF, fromPromise as bG, fromRedisStream as bH, fromStatsD as bI, fromSyslog as bJ, fromTimer as bK, fromWebSocket as bL, fromWebhook as bM, gate as bN, globToRegExp as bO, interval as bP, last as bQ, linear as bR, map as bS, matchesAnyPattern as bT, matchesCron as bU, merge as bV, mergeMap as bW, nameToSignal as bX, never as bY, of as bZ, pairwise as b_, distill as ba, distinctUntilChanged as bb, elementAt as bc, empty as bd, escapeRegexChar as be, exhaustMap as bf, exponential as bg, index as bh, fibonacci as bi, filter as bj, find as bk, first as bl, firstValueFrom as bm, flatMap as bn, forEach as bo, fromAny as bp, fromAsyncIter as bq, fromCSV as br, fromClickHouseWatch as bs, fromCron as bt, fromEvent as bu, fromFSWatch as bv, fromGitHook as bw, fromHTTP as bx, fromIDBRequest as by, fromIDBTransaction as bz, type BackoffStrategy as c, parsePrometheusText as c0, parseStatsD as c1, parseSyslog as c2, pausable as c3, pubsub as c4, race as c5, rateLimiter as c6, reactiveIndex as c7, reactiveList as c8, reactiveMap as c9, timeout as cA, toArray as cB, toKafka as cC, toRedisStream as cD, toSSE as cE, toWebSocket as cF, tokenBucket as cG, tokenTracker as cH, verifiable as cI, window as cJ, windowCount as cK, windowTime as cL, withBreaker as cM, withLatestFrom as cN, withMaxAttempts as cO, withStatus as cP, workerBridge as cQ, workerSelf as cR, zip as cS, reduce as ca, repeat as cb, replay as cc, rescue as cd, resolveBackoffPreset as ce, restoreGraphCheckpoint as cf, restoreGraphCheckpointIndexedDb as cg, retry as ch, sample as ci, saveGraphCheckpoint as cj, saveGraphCheckpointIndexedDb as ck, scan as cl, serializeError as cm, share as cn, shareReplay as co, signalToName as cp, skip as cq, startWith as cr, switchMap as cs, take as ct, takeUntil as cu, takeWhile as cv, tap as cw, throttle as cx, throttleTime as cy, throwError as cz, type BatchMessage as d, type BridgeMessage as e, type CheckpointAdapter as f, type CircuitBreaker as g, type CircuitBreakerOptions as h, CircuitOpenError as i, type CircuitState as j, type ClickHouseClientLike as k, type ClickHouseRow as l, type CronSchedule as m, DictCheckpointAdapter as n, type DistillOptions as o, type ErrorMessage as p, type EventTargetLike as q, type ExponentialBackoffOptions as r, type FSEventType as s, FileCheckpointAdapter as t, type FromCSVOptions as u, type FromClickHouseWatchOptions as v, type FromCronOptions as w, type FromFSWatchOptions as x, type FromGitHookOptions as y, type FromHTTPOptions as z };