@graphrefly/graphrefly 0.26.0 → 0.28.0

package/dist/{index-DdD5MVDL.d.ts → index-ZftwfxJM.d.ts}

@@ -1,7 +1,14 @@
-import { a as NodeOptions, N as Node, M as Message, t as Messages, a6 as VersioningLevel } from './node-C_IBuvX2.js';
-import { AsyncSourceOpts, NodeInput, EventTargetLike, FromCronOptions, ReactiveCounterBundle, cached, empty, escapeRegexChar, firstValueFrom, firstWhere, forEach, fromAny, fromAsyncIter, fromCron, fromEvent, fromIter, fromPromise, fromRaf, fromTimer, globToRegExp, keepalive, matchesAnyPattern, never, of, reactiveCounter, replay, share, shareReplay, throwError, toArray } from './extra/sources.js';
-import { a as StorageTier, I as IndexedDbStorageSpec, S as StorageHandle, d as dictStorage, f as fileStorage, b as fromIDBRequest, c as fromIDBTransaction, i as indexedDbStorage, m as memoryStorage, s as sqliteStorage } from './storage-BMycWEh2.js';
-import { T as ToObservableOptions, t as toObservable } from './observable-DCk45RH5.js';
+import { N as NodeOptions, a as Node, M as Message, b as Messages } from './node-Cc1TniY8.js';
+import { d as BackoffStrategy, B as BackoffPreset, v as retrySource, k as WithStatusBundle, e as CircuitBreaker, a as CircuitBreakerOptions, f as CircuitOpenError, C as CircuitState, E as ExponentialBackoffOptions, F as FallbackInput, J as JitterMode, N as NS_PER_MS, c as NS_PER_SEC, R as RateLimiterOptions, g as RateLimiterOverflowError, h as RateLimiterOverflowPolicy, b as RetryOptions, i as RetrySourceOptions, S as StatusValue, T as TimeoutError, j as TokenBucket, W as WithBreakerBundle, l as circuitBreaker, m as constant, n as decorrelatedJitter, o as exponential, p as fallback, q as fibonacci, r as linear, s as rateLimiter, t as resolveBackoffPreset, u as retry, w as timeout, x as tokenBucket, y as withBreaker, z as withMaxAttempts, A as withStatus } from './resilience-CGRzhnD3.js';
+import { AsyncSourceOpts, NodeInput, EventTargetLike, FromCronOptions, ReactiveCounterBundle, awaitSettled, cached, empty, escapeRegexChar, firstValueFrom, firstWhere, forEach, fromAny, fromAsyncIter, fromCron, fromEvent, fromIter, fromPromise, fromRaf, fromTimer, globToRegExp, keepalive, matchesAnyPattern, never, of, reactiveCounter, replay, share, shareReplay, throwError, toArray } from './extra/sources.js';
+import { StorageTier, StorageHandle, dictStorage, memoryStorage, sortJsonValue, stableJsonString } from './extra/storage-core.js';
+import { D as DistillBundle, a as DistillOptions, E as Extraction, V as VerifiableBundle, b as VerifiableOptions, c as VerifyValue, d as distill, v as verifiable } from './composite-BhbKHbOS.js';
+import { T as ToObservableOptions, t as toObservable } from './observable-Ct-gJ9jI.js';
+import { MergeMapOptions, TapObserver, ThrottleOptions, audit, buffer, bufferCount, bufferTime, catchError, combine, combineLatest, concat, concatMap, debounce, debounceTime, delay, distinctUntilChanged, elementAt, exhaustMap, filter, find, first, flatMap, interval, last, map, merge, mergeMap, pairwise, pausable, race, reduce, repeat, rescue, sample, scan, skip, switchMap, take, takeUntil, takeWhile, tap, throttle, throttleTime, valve, window, windowCount, windowTime, withLatestFrom, zip } from './extra/operators.js';
+import { IndexBackend, IndexRow, ListBackend, NativeIndexBackend, NativeListBackend, ReactiveIndexBundle, ReactiveIndexOptions, ReactiveListBundle, ReactiveListOptions, UpsertOptions, reactiveIndex, reactiveList } from './extra/reactive.js';
+import { L as LogBackend, N as NativeLogBackend, R as ReactiveLogBundle, a as ReactiveLogOptions, r as reactiveLog } from './reactive-log-YuH9VYN8.js';
+import { M as MapBackend, N as NativeMapBackend, b as NativeMapBackendOptions, R as ReactiveMapBundle, a as ReactiveMapOptions, r as reactiveMap } from './reactive-map-CdbNoSgP.js';
+import { a as GraphOptions, G as Graph } from './graph-BZGRXwOm.js';
 
 /**
  * External-register helpers — the common `register({emit, error, complete})`
@@ -22,7 +29,7 @@ import { T as ToObservableOptions, t as toObservable } from './observable-DCk45R
  *   torn down.
  */
 
-type ExtraOpts$3 = Omit<NodeOptions<unknown>, "describeKind">;
+type ExtraOpts$1 = Omit<NodeOptions<unknown>, "describeKind">;
 /**
  * Standard emit-triad passed to a single-channel external registrar.
  *
@@ -85,7 +92,7 @@ type ExternalRegister<H> = (handlers: H) => (() => void) | undefined;
  *
  * @category extra
  */
-declare function externalProducer<T = unknown>(register: ExternalRegister<EmitTriad<T>>, opts?: ExtraOpts$3): Node<T>;
+declare function externalProducer<T = unknown>(register: ExternalRegister<EmitTriad<T>>, opts?: ExtraOpts$1): Node<T>;
 /**
  * Options for {@link externalBundle}.
  *
@@ -96,7 +103,7 @@ type ExternalBundleOptions<TChannels extends Record<string, unknown>> = {
     name?: string;
     /** Per-channel node options (equals, resubscribable, ...). */
     channelOpts?: {
-        [K in keyof TChannels]?: ExtraOpts$3;
+        [K in keyof TChannels]?: ExtraOpts$1;
     };
 };
 /**
@@ -138,159 +145,6 @@ declare function externalBundle<TChannels extends Record<string, unknown>>(regis
     dispose(): void;
 };
 
-/**
- * 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;
-
 /**
  * {@link reactiveSink} — canonical sink factory for Wave 5 adapters.
  *
@@ -472,335 +326,6 @@ type ReactiveSinkConfig<T, Ctx = unknown> = ReactiveSinkOptions<T> & {
  */
 declare function reactiveSink<T, Ctx = unknown>(source: Node<T>, config: ReactiveSinkConfig<T, Ctx>): ReactiveSinkHandle<T>;
 
-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(
- *   (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>;
-/**
- * Options for {@link retrySource}. Superset of {@link RetryOptions} with an
- * optional `initial` forwarded to the outer node cache.
- *
- * @category extra
- */
-type RetrySourceOptions<T> = RetryOptions & {
-    /** Initial cache value for the outer node (forwarded to `NodeOptions.initial`). */
-    initial?: T;
-};
-/**
- * Fresh-instance variant of {@link retry}: invokes the `factory` to build a
- * new `Node<T>` on every connect / reconnect. Unlike {@link retry}, which
- * re-subscribes to the same node (requiring `resubscribable: true`), this
- * creates a new source per attempt — ideal for producers that capture
- * per-attempt resources (sockets, clients, file handles) that become unusable
- * after an error.
- *
- * Synchronous exceptions thrown by `factory` are treated as terminal ERROR
- * and run through the same retry pipeline as inner-node ERROR.
- *
- * @param factory - Called to build a fresh source per attempt.
- * @param opts - `count` caps attempts; `backoff` supplies delay (ns) or preset.
- * @returns Node that retries by rebuilding the source.
- *
- * @example
- * ```ts
- * import { NS_PER_SEC, exponential, retrySource, fromWebSocket } from "@graphrefly/graphrefly-ts";
- *
- * // Each reconnect opens a fresh WebSocket:
- * const connected$ = retrySource(
- *   () => fromWebSocket(new WebSocket("wss://example/stream")),
- *   { count: 10, backoff: exponential({ baseNs: 1 * NS_PER_SEC }) },
- * );
- * ```
- *
- * @category extra
- */
-declare function retrySource<T>(factory: () => Node<T>, opts?: RetrySourceOptions<T>): 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;
-type RateLimiterOverflowPolicy = "drop-oldest" | "drop-newest" | "error";
-type RateLimiterOptions = {
-    /** Maximum `DATA` emissions per window (must be > 0). */
-    maxEvents: number;
-    /** Window length in nanoseconds (must be > 0). */
-    windowNs: number;
-    /** Cap on items queued while waiting for token refill (must be >= 1). Unbounded if omitted. */
-    maxBuffer?: number;
-    /** Overflow policy when `maxBuffer` is exceeded. Default: `"drop-newest"`. */
-    onOverflow?: RateLimiterOverflowPolicy;
-};
-/**
- * Thrown by {@link rateLimiter} when `onOverflow: "error"` and the pending buffer is full.
- *
- * @category extra
- */
-declare class RateLimiterOverflowError extends Error {
-    name: string;
-    constructor(maxBuffer: number);
-}
-/**
- * Token-bucket rate limiter: at most `maxEvents` `DATA` values per `windowNs`.
- *
- * Uses {@link tokenBucket} internally (capacity = `maxEvents`, refill = `maxEvents / windowSeconds`).
- * Excess items are queued FIFO until a token is available. The queue may be bounded via
- * `maxBuffer` with a configurable overflow policy.
- *
- * @param source - Upstream node.
- * @param opts - Rate + optional bounded-buffer configuration.
- * @returns Node that emits DATA at most `maxEvents` per `windowNs`.
- *
- * @remarks
- * **Terminal:** `COMPLETE` / `ERROR` cancel the refill timer, drop the pending queue, and propagate.
- *
- * @example
- * ```ts
- * import { rateLimiter, state, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
- *
- * const src = state(0);
- * // Allow at most 5 DATA values per second; queue up to 100 excess items, drop newest beyond.
- * const limited = rateLimiter(src, { maxEvents: 5, windowNs: NS_PER_SEC, maxBuffer: 100 });
- * ```
- *
- * @category extra
- */
-declare function rateLimiter<T>(source: Node<T>, opts: RateLimiterOptions): 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>;
-/**
- * Thrown by {@link timeout} when no `DATA` arrives within the deadline.
- *
- * @category extra
- */
-declare class TimeoutError extends Error {
-    name: string;
-    constructor(ns: number);
-}
-/** Inputs accepted by {@link fallback}. */
-type FallbackInput<T> = T | Node<T> | PromiseLike<T> | AsyncIterable<T>;
-/**
- * On upstream terminal `ERROR`, switch to a fallback source instead of propagating the error.
- *
- * Accepts any of:
- * - **scalar value** — emits `[[DATA, fb], [COMPLETE]]`
- * - **`Node<T>`** — subscribes and forwards all messages (push-on-subscribe delivers current cache)
- * - **`Promise<T>` / thenable** — resolves into a one-shot `DATA` then `COMPLETE` (via {@link fromAny})
- * - **`AsyncIterable<T>`** — streams each yielded value as `DATA`, then `COMPLETE` (via {@link fromAny})
- *
- * Non-`Node` inputs are routed through {@link fromAny} so the fallback participates in the
- * reactive protocol uniformly. Bare strings, arrays, and other synchronous scalars are treated
- * as single values (NOT split into characters / elements) to avoid the `fromAny`-on-string
- * iteration gotcha.
- *
- * Composes naturally with {@link retry}:
- * `pipe(source, retry({count:3}), fallback("default"))`.
- *
- * @param source - Upstream node.
- * @param fb - Fallback value, node, promise, or async iterable.
- * @returns Node that replaces errors with the fallback.
- *
- * @example
- * ```ts
- * import { fallback, throwError } from "@graphrefly/graphrefly-ts";
- *
- * const safe = fallback(throwError(new Error("boom")), "default");
- * safe.cache; // "default" after subscribe
- * ```
- *
- * @category extra
- */
-declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>): Node<T>;
-/**
- * Emits `ERROR` with {@link TimeoutError} if no `DATA` arrives within the deadline.
- *
- * The timer starts on subscription and resets on each `DATA`. `DIRTY` does NOT reset
- * the timer. Terminal messages (`COMPLETE`/`ERROR`) cancel the timer.
- *
- * @param source - Upstream node.
- * @param timeoutNs - Deadline in nanoseconds.
- * @returns Node that errors on timeout.
- *
- * @example
- * ```ts
- * import { timeout, never, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
- *
- * const t = timeout(never(), 5 * NS_PER_SEC);
- * // After 5 seconds with no DATA: [[ERROR, TimeoutError]]
- * ```
- *
- * @category extra
- */
-declare function timeout<T>(source: Node<T>, timeoutNs: number): Node<T>;
-
 /**
  * Protocol, system, and ingest adapters (roadmap §5.2, §5.2c).
  *
@@ -825,7 +350,7 @@ type SinkHandle = {
     /** Manually drain the internal buffer (buffered sinks only). */
     flush?: () => Promise<void>;
 };
-type ExtraOpts$2 = Omit<NodeOptions, "describeKind">;
+type ExtraOpts = Omit<NodeOptions, "describeKind">;
 /** WebSocket-like transport accepted by {@link fromWebSocket} / {@link toWebSocket}. */
 type WebSocketLike = {
     send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
@@ -845,11 +370,11 @@ type WebSocketRegister<T> = (emit: (payload: T) => void, error: (err: unknown) =
  *
  * @category extra
  */
-declare function fromWebSocket<T = unknown>(socket: WebSocketLike, opts?: ExtraOpts$2 & {
+declare function fromWebSocket<T = unknown>(socket: WebSocketLike, opts?: ExtraOpts & {
     parse?: (payload: unknown, event: unknown) => T;
     closeOnTeardown?: boolean;
 }): Node<T>;
-declare function fromWebSocket<T = unknown>(register: WebSocketRegister<T>, opts?: ExtraOpts$2 & {
+declare function fromWebSocket<T = unknown>(register: WebSocketRegister<T>, opts?: ExtraOpts & {
     parse?: (payload: unknown, event: unknown) => T;
     closeOnTeardown?: boolean;
 }): Node<T>;
@@ -915,7 +440,7 @@ type WebhookRegister<T> = ExternalRegister<EmitTriad<T>>;
  *
  * @category extra
  */
-declare function fromWebhook<T = unknown>(register: WebhookRegister<T>, opts?: ExtraOpts$2): Node<T>;
+declare function fromWebhook<T = unknown>(register: WebhookRegister<T>, opts?: ExtraOpts): Node<T>;
 /**
  * Options for {@link fromHTTP}.
  *
@@ -972,7 +497,7 @@ type HTTPBundle<T> = WithStatusBundle<T> & {
  */
 declare function fromHTTP<T = any>(url: string, opts?: FromHTTPOptions): HTTPBundle<T>;
 /** Options for {@link toHTTP}. */
-type ToHTTPOptions<T> = ExtraOpts$2 & {
+type ToHTTPOptions<T> = ExtraOpts & {
     /** HTTP method. Default: `"POST"`. */
     method?: string;
     /** Request headers applied to every call. Caller sets Content-Type. */
@@ -1063,7 +588,7 @@ type SSEEvent<T = string> = {
     retry?: number;
 };
 /** Options for {@link fromSSE}. */
-type FromSSEOptions<T = string> = ExtraOpts$2 & {
+type FromSSEOptions<T = string> = ExtraOpts & {
     /** Parse the raw `data:` payload. Default: identity (string). */
     parse?: (raw: string) => T;
 };
@@ -1078,7 +603,7 @@ type FromSSEOptions<T = string> = ExtraOpts$2 & {
  */
 declare function fromSSE<T = string>(source: ReadableStream<Uint8Array> | Response | AsyncIterable<Uint8Array>, opts?: FromSSEOptions<T>): Node<SSEEvent<T>>;
 /** Options for {@link fromHTTPStream}. */
-type FromHTTPStreamOptions = ExtraOpts$2 & {
+type FromHTTPStreamOptions = ExtraOpts & {
     method?: string;
     headers?: Record<string, string>;
     body?: unknown;
@@ -1147,7 +672,7 @@ type ToWebSocketOptions<T> = {
  */
 declare function toWebSocket<T>(source: Node<T>, socket: WebSocketLike, opts?: ToWebSocketOptions<T>): ReactiveSinkHandle<T>;
 /** Options for {@link fromWebSocketReconnect}. */
-type FromWebSocketReconnectOptions<T> = ExtraOpts$2 & {
+type FromWebSocketReconnectOptions<T> = ExtraOpts & {
     /** Optional parser applied to incoming messages. */
     parse?: (payload: unknown, event: unknown) => T;
     /** Max reconnect attempts. Default: `Infinity` (implied when `backoff` is set). */
@@ -1190,7 +715,7 @@ type MCPClientLike = {
     setNotificationHandler(method: string, handler: (notification: unknown) => void): void;
 };
 /** Options for {@link fromMCP}. */
-type FromMCPOptions = ExtraOpts$2 & {
+type FromMCPOptions = ExtraOpts & {
     /** MCP notification method to subscribe to. Default `"notifications/message"`. */
     method?: string;
     onDisconnect?: (cb: (err?: unknown) => void) => void;
@@ -1201,36 +726,6 @@ type FromMCPOptions = ExtraOpts$2 & {
  * @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$2 & {
-    pollMs?: number;
-    include?: string[];
-    exclude?: string[];
-    /**
-     * Maximum consecutive poll errors before terminating the source. Prevents
-     * error storms when the repository is unavailable (e.g. deleted, corrupt,
-     * permissions lost). Default: `1` (terminate on first error — preserves pre-switchMap back-compat). Raise it (or set `Infinity`) to keep retrying
-     * indefinitely (legacy behavior).
-     */
-    maxConsecutiveErrors?: number;
-};
-/**
- * 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. Alias of {@link EmitTriad}. */
 type AdapterHandlers<T> = EmitTriad<T>;
 /**
@@ -1328,7 +823,7 @@ type OTelRegister = (handlers: {
     onError: (err: unknown) => void;
 }) => (() => void) | undefined;
 /** Options for {@link fromOTel}. */
-type FromOTelOptions = ExtraOpts$2 & {};
+type FromOTelOptions = ExtraOpts & {};
 /** Bundle returned by {@link fromOTel}. */
 type OTelBundle = {
     traces: Node<OTelSpan>;
@@ -1382,7 +877,7 @@ type SyslogMessage = {
 /** Registration callback for syslog receiver. Alias of {@link ExternalRegister} over {@link EmitTriad}. */
 type SyslogRegister = ExternalRegister<EmitTriad<SyslogMessage>>;
 /** Options for {@link fromSyslog}. */
-type FromSyslogOptions = ExtraOpts$2 & {};
+type FromSyslogOptions = ExtraOpts & {};
 /**
  * RFC 5424 syslog receiver as a reactive source.
  *
@@ -1432,7 +927,7 @@ type StatsDMetric = {
 /** Registration callback for StatsD receiver. Alias of {@link ExternalRegister} over {@link EmitTriad}. */
 type StatsDRegister = ExternalRegister<EmitTriad<StatsDMetric>>;
 /** Options for {@link fromStatsD}. */
-type FromStatsDOptions = ExtraOpts$2 & {};
+type FromStatsDOptions = ExtraOpts & {};
 /**
  * StatsD/DogStatsD UDP receiver as a reactive source.
  *
@@ -1570,7 +1065,7 @@ type KafkaMessage<T = unknown> = {
     timestampNs: number;
 };
 /** Options for {@link fromKafka}. */
-type FromKafkaOptions = ExtraOpts$2 & {
+type FromKafkaOptions = ExtraOpts & {
     /** Start from beginning of topic. Default: `false`. */
     fromBeginning?: boolean;
     /** Deserialize message value. Default: `JSON.parse(buffer.toString())`. */
@@ -1603,7 +1098,7 @@ type FromKafkaOptions = ExtraOpts$2 & {
  */
 declare function fromKafka<T = unknown>(consumer: KafkaConsumerLike, topic: string, opts?: FromKafkaOptions): Node<KafkaMessage<T>>;
 /** Options for {@link toKafka}. */
-type ToKafkaOptions<T> = ExtraOpts$2 & {
+type ToKafkaOptions<T> = ExtraOpts & {
     /** Serialize value for Kafka. Default: `JSON.stringify`. */
     serialize?: (value: T) => string | Buffer;
     /** Extract message key from value. Default: `null` (no key). */
@@ -1637,7 +1132,7 @@ type RedisStreamEntry<T = unknown> = {
     timestampNs: number;
 };
 /** Options for {@link fromRedisStream}. */
-type FromRedisStreamOptions = ExtraOpts$2 & {
+type FromRedisStreamOptions = ExtraOpts & {
     /** Block timeout in ms for XREAD. Default: `5000`. */
     blockMs?: number;
     /** Start ID. Default: `"$"` (new entries only). */
@@ -1669,7 +1164,7 @@ type FromRedisStreamOptions = ExtraOpts$2 & {
  */
 declare function fromRedisStream<T = unknown>(client: RedisClientLike, key: string, opts?: FromRedisStreamOptions): Node<RedisStreamEntry<T>>;
 /** Options for {@link toRedisStream}. */
-type ToRedisStreamOptions<T> = ExtraOpts$2 & {
+type ToRedisStreamOptions<T> = ExtraOpts & {
     /** Serialize value to Redis hash fields. Default: `["data", JSON.stringify(value)]`. */
     serialize?: (value: T) => string[];
     /** Max stream length (MAXLEN ~). Default: no trimming. */
@@ -1692,7 +1187,7 @@ declare function toRedisStream<T>(source: Node<T>, client: RedisClientLike, key:
 /** Parsed CSV row. */
 type CSVRow = Record<string, string>;
 /** Options for {@link fromCSV}. */
-type FromCSVOptions = ExtraOpts$2 & {
+type FromCSVOptions = ExtraOpts & {
     /** Column delimiter. Default: `","`. */
     delimiter?: string;
     /** Whether the first row is a header. Default: `true`. */
@@ -1749,9 +1244,9 @@ declare function csvRows(source: Node<string>, opts?: FromCSVOptions): Node<CSVR
  *
  * @category extra
  */
-declare function ndjsonRows<T = unknown>(source: Node<string>, opts?: ExtraOpts$2): Node<T>;
+declare function ndjsonRows<T = unknown>(source: Node<string>, opts?: ExtraOpts): Node<T>;
 /** Options for {@link fromNDJSON}. */
-type FromNDJSONOptions = ExtraOpts$2 & {};
+type FromNDJSONOptions = ExtraOpts & {};
 /**
  * Newline-delimited JSON stream ingest for batch replay.
  *
@@ -1857,7 +1352,7 @@ type PulsarMessage<T = unknown> = {
     timestampNs: number;
 };
 /** Options for {@link fromPulsar}. */
-type FromPulsarOptions = ExtraOpts$2 & {
+type FromPulsarOptions = ExtraOpts & {
     /** Deserialize message data. Default: `JSON.parse(buffer.toString())`. */
     deserialize?: (data: Buffer) => unknown;
     /** Acknowledge messages automatically. Default: `true`. */
@@ -1904,7 +1399,7 @@ declare function fromPulsar<T = unknown>(consumer: PulsarConsumerLike, opts: Fro
     autoAck: false;
 }): Node<AckableMessage<PulsarMessage<T>>>;
 /** Options for {@link toPulsar}. */
-type ToPulsarOptions<T> = ExtraOpts$2 & {
+type ToPulsarOptions<T> = ExtraOpts & {
     /** Serialize value for Pulsar. Default: `JSON.stringify` → Buffer. */
     serialize?: (value: T) => Buffer;
     /** Extract partition key from value. Default: none. */
@@ -1957,7 +1452,7 @@ type NATSMessage<T = unknown> = {
     timestampNs: number;
 };
 /** Options for {@link fromNATS}. */
-type FromNATSOptions = ExtraOpts$2 & {
+type FromNATSOptions = ExtraOpts & {
     /** Queue group name for load balancing. */
     queue?: string;
     /** Deserialize message data. Default: `JSON.parse(textDecoder.decode(data))`. */
@@ -1991,7 +1486,7 @@ type FromNATSOptions = ExtraOpts$2 & {
  */
 declare function fromNATS<T = unknown>(client: NATSClientLike, subject: string, opts?: FromNATSOptions): Node<NATSMessage<T>>;
 /** Options for {@link toNATS}. */
-type ToNATSOptions<T> = ExtraOpts$2 & {
+type ToNATSOptions<T> = ExtraOpts & {
     /** Serialize value for NATS. Default: `JSON.stringify` → Uint8Array. */
     serialize?: (value: T) => Uint8Array;
     /** Called on serialization failures. */
@@ -2042,7 +1537,7 @@ type RabbitMQMessage<T = unknown> = {
     timestampNs: number;
 };
 /** Options for {@link fromRabbitMQ}. */
-type FromRabbitMQOptions = ExtraOpts$2 & {
+type FromRabbitMQOptions = ExtraOpts & {
     /** Deserialize message content. Default: `JSON.parse(buffer.toString())`. */
     deserialize?: (content: Buffer) => unknown;
     /** Auto-acknowledge messages. Default: `true`. */
@@ -2091,7 +1586,7 @@ declare function fromRabbitMQ<T = unknown>(channel: RabbitMQChannelLike, queue:
     autoAck: false;
 }): Node<AckableMessage<RabbitMQMessage<T>>>;
 /** Options for {@link toRabbitMQ}. */
-type ToRabbitMQOptions<T> = ExtraOpts$2 & {
+type ToRabbitMQOptions<T> = ExtraOpts & {
     /** Serialize value for RabbitMQ. Default: `Buffer.from(JSON.stringify(value))`. */
     serialize?: (value: T) => Buffer;
     /** Extract routing key from value. Default: `""`. */
@@ -2122,7 +1617,7 @@ type FileWriterLike = {
     end(): void;
 };
 /** Options for {@link toFile}. */
-type ToFileOptions<T> = ExtraOpts$2 & {
+type ToFileOptions<T> = ExtraOpts & {
     /** Serialize a value to a string line. Default: `JSON.stringify(v) + "\n"`. */
     serialize?: (value: T) => string;
     /** `"append"` (default) or `"overwrite"` — controls initial file behavior hint. */
@@ -2148,7 +1643,7 @@ type ToFileOptions<T> = ExtraOpts$2 & {
  */
 declare function toFile<T>(source: Node<T>, writer: FileWriterLike, opts?: ToFileOptions<T>): ReactiveSinkHandle<T>;
 /** Options for {@link toCSV}. */
-type ToCSVOptions<T> = ExtraOpts$2 & {
+type ToCSVOptions<T> = ExtraOpts & {
     /** Column names. Required — determines header row and field order. */
     columns: string[];
     /** Column delimiter. Default: `","`. */
@@ -2183,7 +1678,7 @@ type ClickHouseInsertClientLike = {
     }): Promise<void>;
 };
 /** Options for {@link toClickHouse}. */
-type ToClickHouseOptions<T> = ExtraOpts$2 & {
+type ToClickHouseOptions<T> = ExtraOpts & {
     /** Batch size before auto-flush. Default: `1000`. */
     batchSize?: number;
     /** Flush interval in ms. Default: `5000`. */
@@ -2218,7 +1713,7 @@ type S3ClientLike = {
     }): Promise<unknown>;
 };
 /** Options for {@link toS3}. */
-type ToS3Options<T> = ExtraOpts$2 & {
+type ToS3Options<T> = ExtraOpts & {
     /** Output format. Default: `"ndjson"`. */
     format?: "ndjson" | "json";
     /** Generate the S3 key for each batch. Receives `(seq, wallClockNs)`. Default: ISO timestamp + sequence. */
@@ -2248,7 +1743,7 @@ type PostgresClientLike = {
     query(sql: string, params?: unknown[]): Promise<unknown>;
 };
 /** Options for {@link toPostgres}. */
-type ToPostgresOptions<T> = ExtraOpts$2 & {
+type ToPostgresOptions<T> = ExtraOpts & {
     /** Build the SQL + params for an insert. Default: JSON insert into `table`. */
     toSQL?: (value: T, table: string) => {
         sql: string;
@@ -2273,7 +1768,7 @@ type MongoCollectionLike = {
     insertOne(doc: unknown): Promise<unknown>;
 };
 /** Options for {@link toMongo}. */
-type ToMongoOptions<T> = ExtraOpts$2 & {
+type ToMongoOptions<T> = ExtraOpts & {
     /** Transform value to a MongoDB document. Default: identity. */
     toDocument?: (value: T) => unknown;
     onTransportError?: (err: SinkTransportError) => void;
@@ -2301,7 +1796,7 @@ type LokiClientLike = {
     }): Promise<unknown>;
 };
 /** Options for {@link toLoki}. */
-type ToLokiOptions<T> = ExtraOpts$2 & {
+type ToLokiOptions<T> = ExtraOpts & {
     /** Static labels applied to every log entry. */
     labels?: Record<string, string>;
     /** Extract the log line from a value. Default: `JSON.stringify(v)`. */
@@ -2328,7 +1823,7 @@ type TempoClientLike = {
     }): Promise<unknown>;
 };
 /** Options for {@link toTempo}. */
-type ToTempoOptions<T> = ExtraOpts$2 & {
+type ToTempoOptions<T> = ExtraOpts & {
     /** Transform a value into OTLP resourceSpans entries. */
     toResourceSpans?: (value: T) => unknown[];
     onTransportError?: (err: SinkTransportError) => void;
@@ -2421,7 +1916,7 @@ type SqliteDbLike = {
     query(sql: string, params?: unknown[]): unknown[];
 };
 /** Options for {@link fromSqlite}. */
-type FromSqliteOptions<T> = ExtraOpts$2 & {
+type FromSqliteOptions<T> = ExtraOpts & {
     /** Map a raw row object to the desired type. Default: identity cast. */
     mapRow?: (row: unknown) => T;
     /** Bind parameters for the query. */
@@ -2473,7 +1968,7 @@ type SqliteIterableDbLike = {
  */
 declare function fromSqliteCursor<T = unknown>(db: SqliteIterableDbLike, query: string, opts?: FromSqliteOptions<T>): Node<T>;
 /** Options for {@link toSqlite}. */
-type ToSqliteOptions<T> = ExtraOpts$2 & {
+type ToSqliteOptions<T> = ExtraOpts & {
     /** Build SQL + params for an insert. Default: JSON insert into `(data)` column. */
     toSQL?: (value: T, table: string) => {
         sql: string;
@@ -2529,7 +2024,7 @@ type PrismaModelLike<T = unknown> = {
     findMany(args?: unknown): Promise<T[]>;
 };
 /** Options for {@link fromPrisma}. */
-type FromPrismaOptions<T, U = T> = ExtraOpts$2 & {
+type FromPrismaOptions<T, U = T> = ExtraOpts & {
     /** Prisma `findMany` args (where, orderBy, select, include, take, skip, etc.). */
     args?: unknown;
     /** Map each row to the desired shape. Default: identity cast. */
@@ -2570,7 +2065,7 @@ type DrizzleQueryLike<T = unknown> = {
     execute(): Promise<T[]>;
 };
 /** Options for {@link fromDrizzle}. */
-type FromDrizzleOptions<T, U = T> = ExtraOpts$2 & {
+type FromDrizzleOptions<T, U = T> = ExtraOpts & {
     /** Map each row to the desired shape. Default: identity cast. */
     mapRow?: (row: T) => U;
 };
@@ -2606,7 +2101,7 @@ type KyselyQueryLike<T = unknown> = {
     execute(): Promise<T[]>;
 };
 /** Options for {@link fromKysely}. */
-type FromKyselyOptions<T, U = T> = ExtraOpts$2 & {
+type FromKyselyOptions<T, U = T> = ExtraOpts & {
     /** Map each row to the desired shape. Default: identity cast. */
     mapRow?: (row: T) => U;
 };
@@ -2765,1242 +2260,56 @@ interface CascadingCache<V> {
  */
 declare function cascadingCache<V = unknown>(tiers: readonly StorageTier[], opts?: CascadingCacheOptions): CascadingCache<V>;
 
-type ReactiveMapOptions<K, V> = {
-    /** Optional registry name for `describe()` / debugging. */
-    name?: string;
-    /**
-     * LRU cap. When set, evicts least-recently-used keys after inserts that exceed this size.
-     * Forwarded to the default `NativeMapBackend`. Ignored if a custom `backend` is provided.
-     */
-    maxSize?: number;
-    /**
-     * Default TTL in seconds. Used when `set`/`setMany` omits per-call `ttl`.
-     * Forwarded to the default `NativeMapBackend`. Ignored if a custom `backend` is provided.
-     */
-    defaultTtl?: number;
-    /**
-     * Storage backend. Defaults to `NativeMapBackend`. Users can plug in persistent
-     * (HAMT / Immutable.js) or shared-state backends via the {@link MapBackend} interface.
-     */
-    backend?: MapBackend<K, V>;
-    /**
-     * Optional versioning level for the underlying `entries` state node. Set at
-     * construction time; cannot be changed later. Pass `0` for V0 identity +
-     * monotonic version counter, or `1` for V1 + content-addressed cid.
-     */
-    versioning?: VersioningLevel;
-} & Omit<NodeOptions, "initial" | "describeKind" | "equals" | "versioning">;
-type ReactiveMapBundle<K, V> = {
-    /** Emits `ReadonlyMap<K, V>` on each structural change (two-phase). */
-    entries: Node<ReadonlyMap<K, V>>;
-    /**
-     * Checks existence. O(1) for live keys. If the key is expired, prunes it AND
-     * emits a snapshot so the reactive surface stays consistent with the return
-     * value. Reads on expired keys are therefore **observable side effects**.
-     *
-     * **LRU touch (F4):** When `maxSize` is configured, a live-key `has` also
-     * marks the entry as most-recently-used — which rearranges internal insertion
-     * order without bumping `version` or emitting. If you care about iteration
-     * order in a downstream subscriber, rely on the `entries` snapshot (a fresh
-     * `ReadonlyMap` per mutation) rather than iterating the backend directly.
-     */
-    has: (key: K) => boolean;
-    /**
-     * Gets value. O(1) for live keys. If the key is expired, prunes it AND emits
-     * a snapshot. Reads on expired keys are therefore **observable side effects**.
-     *
-     * **LRU touch (F4):** When `maxSize` is configured, a live-key `get` also
-     * marks the entry as most-recently-used (no version bump, no emission). See
-     * `has` for the full note on iteration order.
-     */
-    get: (key: K) => V | undefined;
-    /**
-     * Sets value with optional TTL (seconds). Throws on `ttl <= 0`. Applies LRU eviction
-     * if `maxSize` is set. Always emits.
-     */
-    set: (key: K, value: V, opts?: {
-        ttl?: number;
-    }) => void;
-    /**
-     * Bulk set — emits one snapshot for the whole batch. Applies `opts.ttl` (falls back
-     * to `defaultTtl`) to every entry. No-op if `entries` is empty.
-     *
-     * **Iterable consumption:** Consumes `entries` once (single-pass). Pass an array
-     * or `Set` for multi-shot consumers. If the iterator throws mid-iteration,
-     * entries already applied remain committed and a snapshot IS emitted (via the
-     * wrapper's finally-block).
-     */
-    setMany: (entries: Iterable<readonly [K, V]>, opts?: {
-        ttl?: number;
-    }) => void;
-    delete: (key: K) => void;
-    /**
-     * Bulk delete — emits one snapshot. No-op if no keys were present.
-     *
-     * **Iterable consumption:** Consumes `keys` once (single-pass).
-     */
-    deleteMany: (keys: Iterable<K>) => void;
-    clear: () => void;
-    /**
-     * Current entry count — O(1), **pure read** (no emission). May include
-     * expired entries on TTL maps until a mutation or explicit
-     * `pruneExpired()` / `has(key)` / `get(key)` prunes them. Call
-     * `pruneExpired()` first if you need a live count.
-     */
-    readonly size: number;
-    /** Explicitly prunes all expired entries. Emits if any were removed. */
-    pruneExpired: () => void;
-    /**
-     * Releases any internal keepalive subscriptions so the bundle can be
-     * GC'd. `reactiveMap` currently holds none (the `entries` node lives only
-     * as long as external subscribers keep it alive), so `dispose()` is a
-     * no-op today — exposed for API parity with `reactiveIndex.dispose` /
-     * `reactiveList.dispose` / `reactiveLog.dispose`. Idempotent. D6(a).
-     */
-    dispose: () => void;
-};
-/**
- * Storage contract for {@link reactiveMap}. Implementations own the mutable state,
- * including optional TTL and LRU semantics, and expose a monotonic `version` counter
- * that increments on every change to visible state.
- *
- * The reactive layer reads `version` before and after each backend call; when it
- * advances, a snapshot is emitted. Reads (`has`, `get`) may internally prune the
- * target key if expired and advance `version` — in which case the layer emits so
- * subscribers see state consistent with the read's return value.
- *
- * @remarks Post-1.0 op-log changesets will extend this interface with a
- * `changesSince(version: number): Iterable<Change>` method. Current consumers
- * should treat all methods here as stable.
- *
- * @category extra
- */
-interface MapBackend<K, V> {
-    /** Monotonic mutation counter; increments on every visible state change. */
-    readonly version: number;
-    /** Raw entry count (may include expired entries until a read / prune removes them). */
-    readonly size: number;
-    /** Checks existence. May prune target key if expired; advances `version` if pruned. */
-    has(key: K): boolean;
-    /** Gets value. May prune target key if expired; advances `version` if pruned. */
-    get(key: K): V | undefined;
-    /**
-     * Sets a value with optional TTL (seconds). Throws `RangeError` if `ttl <= 0`.
-     * Applies LRU eviction if `maxSize` is configured. Advances `version`.
-     *
-     * **Atomicity contract:** Either fully succeeds or throws before any state
-     * change; `version` advances only on success.
-     */
-    set(key: K, value: V, ttl?: number): void;
-    /**
-     * Atomic bulk set. Pre-validates TTL once, then applies all entries. Advances
-     * `version` at most once (even for N entries). No-op if iterable is empty.
-     *
-     * **Consumes `entries` once** — pass an array if you want repeatability.
-     *
-     * **Atomicity contract:** TTL validation throws before any mutation. If the
-     * iterable itself throws mid-iteration, entries committed before the throw
-     * remain persisted AND `version` is bumped once (surfaced via finally) so
-     * the reactive wrapper emits a snapshot reflecting the partial state. "At
-     * most once" invariant is preserved.
-     */
-    setMany(entries: Iterable<readonly [K, V]>, ttl?: number): void;
-    /** Removes a key. Returns `true` if the key existed. Advances `version` only if true. */
-    delete(key: K): boolean;
-    /**
-     * Atomic bulk delete. Returns count removed. Advances `version` at most once
-     * (even for N keys). No-op if no keys were present. Consumes `keys` once.
-     */
-    deleteMany(keys: Iterable<K>): number;
-    /** Removes all entries. Returns count removed. Advances `version` only if non-zero. */
-    clear(): number;
-    /** Removes all expired entries. Returns count removed. Advances `version` only if non-zero. */
-    pruneExpired(): number;
-    /** Fresh snapshot of non-expired entries (does NOT mutate state). */
-    toMap(): ReadonlyMap<K, V>;
-}
-type NativeMapBackendOptions = {
-    maxSize?: number;
-    /** Default TTL in seconds. */
-    defaultTtl?: number;
-};
-/**
- * Default `Map<K, {value, expiresAt}>` backend with optional per-key TTL and LRU cap.
- *
- * **Complexity:**
- * - `has`, `get`, `delete`, `size`: O(1)
- * - `set`: O(1) amortized (LRU touch + eviction)
- * - `pruneExpired`, `toMap`: O(n)
- *
- * LRU order uses native `Map` insertion order. `get` / `has` on a live key "touches"
- * it by delete-then-reinsert (moving it to the end). This touch does NOT advance
- * `version` — it's an internal optimization; the externally visible snapshot
- * preserves iteration order as of the last mutation. **Note:** because touch
- * reorders the internal `_store` without emitting, an in-process consumer iterating
- * `_store` directly (custom subclasses) could observe changing order; external
- * subscribers only see `toMap()` snapshots which are defensively copied and stable.
- *
- * @category extra
- */
-declare class NativeMapBackend<K, V> implements MapBackend<K, V> {
-    private _version;
-    private readonly _store;
-    private readonly _maxSize?;
-    private readonly _defaultTtl?;
-    constructor(options?: NativeMapBackendOptions);
-    get version(): number;
-    get size(): number;
-    has(key: K): boolean;
-    get(key: K): V | undefined;
-    set(key: K, value: V, ttl?: number): void;
-    setMany(entries: Iterable<readonly [K, V]>, ttl?: number): void;
-    delete(key: K): boolean;
-    deleteMany(keys: Iterable<K>): number;
-    clear(): number;
-    pruneExpired(): number;
-    toMap(): ReadonlyMap<K, V>;
-    private _resolveExpiresAt;
-    private _isExpired;
-    private _touchLru;
-    private _evictLruWhileOver;
-}
-/**
- * Creates a reactive `Map` with optional per-key TTL and optional LRU max size.
- *
- * @param options - `name`, `maxSize`, `defaultTtl` (seconds), or custom `backend`.
- * @returns `ReactiveMapBundle` — imperative methods (`has`/`get`/`set`/`setMany`/`delete`/
- *   `deleteMany`/`clear`/`pruneExpired`), reactive `entries` node, and O(1)-ish `size`.
- *
- * @remarks
- * **TTL:** Expiry is checked on `get`, `has`, `size`, `pruneExpired`, and before each
- * snapshot emission (expired keys are pruned first). Reads that discover expired keys
- * emit a snapshot so subscribers see state consistent with the read's return value.
- * There is no background timer; monotonic-clock expiry is immune to wall-clock changes.
- *
- * **LRU:** Uses native `Map` insertion order — `get` / `has` refreshes position via
- * delete-then-reinsert; under `maxSize` pressure the first key in iteration order is
- * evicted. LRU touching does NOT trigger emission (internal optimization).
- *
- * **Backend:** The default {@link NativeMapBackend} owns LRU/TTL. For persistent /
- * HAMT / shared-state semantics plug in a custom {@link MapBackend}. `maxSize` and
- * `defaultTtl` on the options object are only applied to the default backend — if
- * you supply `backend`, configure those on your backend directly.
- *
- * @example
- * ```ts
- * import { reactiveMap } from "@graphrefly/graphrefly-ts";
- *
- * const m = reactiveMap<string, number>({ name: "cache", maxSize: 100, defaultTtl: 60 });
- * m.set("x", 1);
- * m.setMany([["y", 2], ["z", 3]]);
- * m.entries.subscribe((msgs) => { console.log(msgs); });
- * ```
- *
- * @category extra
- */
-declare function reactiveMap<K, V>(options?: ReactiveMapOptions<K, V>): 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<string, TMem>;
-};
-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).
- *
- * v5 foundation redesign: all operators use `actions.emit()` for value emission,
- * `ctx.store` for persistent state, `ctx.terminalDeps` for terminal handling,
- * and `data[i]` batch shape for DATA vs RESOLVED discrimination. `onMessage`
- * and `onResubscribe` are removed.
- */
-
-type ExtraOpts$1 = Omit<NodeOptions<unknown>, "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$1): 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$1): 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$1): 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$1): 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$1): 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$1): 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$1): 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$1 & {
-    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$1): 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$1 & {
-    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$1): 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$1): 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$1): 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$1): 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$1): 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$1): 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$1): 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$1): 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$1): 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$1 & {
-    maxBuffer?: number;
-}): Node<R>;
-/** Options for {@link mergeMap}. */
-type MergeMapOptions = ExtraOpts$1 & {
-    /** 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.
- *
- * @remarks
- * **ERROR handling:** An `ERROR` from the outer source cancels all active inner
- * subscriptions and propagates the error downstream. An `ERROR` from an inner
- * subscription propagates downstream immediately but does **not** cancel sibling
- * inner subscriptions — other active inners continue until they complete or the
- * outer errors/completes. This is intentional: for parallel work, isolating
- * failures per-inner is more useful than Rx-style "first error cancels all."
- *
- * @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$1): 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$1): 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$1 & ThrottleOptions): Node<T>;
-/**
- * Emits the most recent source value whenever `notifier` emits `DATA` (`sample`).
- *
- * Source `COMPLETE` stops sampling (clears held value); notifier `COMPLETE` terminates the
- * operator. `ERROR` from either dep terminates immediately. At most one terminal message is
- * emitted downstream (latch). Supports `resubscribable` — `ctx.store` resets automatically.
- *
- * @param source - Node whose latest value is sampled.
- * @param notifier - When this node emits `DATA`, a sample is taken.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Sampled snapshots of `source`.
- * @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$1): 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$1): 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$1): 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$1): 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$1): 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$1): 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$1): 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$1): 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$1): 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$1): Node<T>;
-/**
- * Identity passthrough — `pausable()` has been promoted to default node behavior in v5 (§4).
- *
- * @deprecated Default node behavior now handles PAUSE/RESUME. This operator is a no-op
- * identity passthrough kept only for migration compatibility.
- *
- * @param source - Upstream node.
- * @param opts - Optional {@link NodeOptions} (excluding `describeKind`).
- * @returns `Node<T>` - Pass-through (identity).
- * @example
- * ```ts
- * import { pausable, state } from "@graphrefly/graphrefly-ts";
- *
- * // No longer needed — default nodes handle PAUSE/RESUME.
- * const s = state(0);
- * pausable(s); // identity passthrough
- * ```
- *
- * @category extra
- */
-declare function pausable<T>(source: Node<T>, opts?: ExtraOpts$1): 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$1): Node<T>;
-/**
- * Forwards upstream `DATA` only while `control.get()` is truthy; when closed, emits `RESOLVED`
- * instead of repeating the last value (value-level valve). For protocol pause/resume, use default
- * node PAUSE/RESUME behavior.
- *
- * @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 { valve, state } from "@graphrefly/graphrefly-ts";
- *
- * const data = state(1);
- * const open = state(true);
- * valve(data, open);
- * ```
- *
- * @category extra
- */
-declare function valve<T>(source: Node<T>, control: Node<boolean>, opts?: ExtraOpts$1): 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
+ * 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).
  */
-declare const combineLatest: typeof combine;
+interface CronSchedule {
+    minutes: Set<number>;
+    hours: Set<number>;
+    daysOfMonth: Set<number>;
+    months: Set<number>;
+    daysOfWeek: Set<number>;
+}
 /**
- * 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);
- * ```
+ * Parses a standard 5-field cron expression into a {@link CronSchedule}.
  *
- * @category extra
- */
-declare const debounceTime: typeof debounce;
-/**
- * RxJS-named alias for {@link throttle} — emits on leading/trailing edges within `ms`.
+ * 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 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`.
+ * @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 { throttleTime, state } from "@graphrefly/graphrefly-ts";
+ * import { parseCron } from "@graphrefly/graphrefly-ts";
  *
- * throttleTime(state(0), 100);
+ * const sched = parseCron("0 9 * * 1-5"); // weekdays at 09:00
+ * sched.hours;      // Set { 9 }
+ * sched.daysOfWeek; // Set { 1, 2, 3, 4, 5 }
  * ```
- *
- * @category extra
  */
-declare const throttleTime: typeof throttle;
+declare function parseCron(expr: string): CronSchedule;
 /**
- * RxJS-named alias for {@link rescue} — replaces upstream `ERROR` with a recovered value.
+ * Returns `true` if `date` satisfies every field of `schedule`.
  *
- * @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`.
+ * @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 { catchError, state } from "@graphrefly/graphrefly-ts";
+ * import { parseCron, matchesCron } from "@graphrefly/graphrefly-ts";
  *
- * catchError(state(0), () => 0);
+ * 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
  * ```
- *
- * @category extra
  */
-declare const catchError: typeof rescue;
+declare function matchesCron(schedule: CronSchedule, date: Date): boolean;
 
 /**
  * Lazy per-topic state hub (roadmap §3.2) — lightweight last-value broadcasts.
@@ -4133,571 +2442,108 @@ interface PubSubHub {
  */
 declare function pubsub(options?: PubSubHubOptions): PubSubHub;
 
-type IndexRow<K, V = unknown> = {
-    readonly primary: K;
-    readonly secondary: unknown;
-    readonly value: V;
-};
-type ReactiveIndexOptions<K, V = unknown> = {
-    /** Optional registry name for `describe()` / debugging. */
-    name?: string;
-    /**
-     * Storage backend. Defaults to `NativeIndexBackend` (flat array + parallel `Map<K,IndexRow>`).
-     * Users can plug in persistent / B-tree backends via the {@link IndexBackend} interface.
-     */
-    backend?: IndexBackend<K, V>;
-    /**
-     * Optional versioning level for the underlying `ordered` state node. Set at
-     * construction time; cannot be changed later. Pass `0` for V0 identity +
-     * monotonic version counter, or `1` for V1 + content-addressed cid.
-     * (The `byPrimary` derived node inherits through the dep graph.)
-     */
-    versioning?: VersioningLevel;
-    /**
-     * Default row-equality used to short-circuit idempotent upserts. When
-     * provided, every `upsert` / `upsertMany` that finds an existing primary
-     * compares the stored and candidate rows via `equals(existing, next)` —
-     * on `true` the call is a no-op (no version bump, no emission). Per-call
-     * `UpsertOptions.equals` overrides this default. Analogous to
-     * `NodeOptions.equals` on the core `node()` primitive.
-     */
-    equals?: (existing: IndexRow<K, V>, next: IndexRow<K, V>) => boolean;
-};
-type ReactiveIndexBundle<K, V = unknown> = {
-    /** Rows sorted by `(secondary, primary)`. */
-    readonly ordered: Node<readonly IndexRow<K, V>[]>;
-    /** Map from primary key to stored value. */
-    readonly byPrimary: Node<ReadonlyMap<K, V>>;
-    /** O(1) primary-key existence check. */
-    has: (primary: K) => boolean;
-    /** O(1) value lookup by primary key. */
-    get: (primary: K) => V | undefined;
-    /** Number of rows currently in the index (O(1)). */
-    readonly size: number;
-    /**
-     * Upserts a row. When `opts.equals(existing, next)` returns `true` for an
-     * existing primary key, the upsert is a no-op (no version bump, no emission).
-     * Useful for idempotent writes.
-     *
-     * @returns `true` if a new row was inserted (primary key was absent),
-     *   `false` if the primary key was already present (updated in place OR
-     *   skipped idempotently via `opts.equals`). D5(a).
-     */
-    upsert: (primary: K, secondary: unknown, value: V, opts?: UpsertOptions<K, V>) => boolean;
-    /**
-     * Bulk upsert — emits one snapshot for the whole batch. `opts.equals` applied
-     * per-row. No-op if empty or all rows skipped.
-     *
-     * **Iterable consumption:** Consumes `rows` once (single-pass).
-     */
-    upsertMany: (rows: Iterable<{
-        primary: K;
-        secondary: unknown;
-        value: V;
-    }>, opts?: UpsertOptions<K, V>) => void;
-    delete: (primary: K) => void;
-    /**
-     * Bulk delete — emits one snapshot for the whole batch. No-op if nothing was removed.
-     *
-     * **Iterable consumption:** Consumes `primaries` once (single-pass).
-     */
-    deleteMany: (primaries: Iterable<K>) => void;
-    clear: () => void;
-    /**
-     * Releases internal keepalive subscriptions (on `byPrimary`) so the bundle
-     * can be GC'd. Safe to call more than once (subsequent calls are no-ops).
-     * Subsequent mutations after `dispose()` still execute on the backend but
-     * `byPrimary` may stop updating if no external subscriber is attached.
-     * D6(a).
-     */
-    dispose: () => void;
-};
-/**
- * Storage contract for {@link reactiveIndex}. Implementations own the mutable state and
- * expose a monotonic `version` counter that increments on every structural change.
- *
- * The reactive layer reads `version` to decide when to emit; it does not inspect
- * internal representation. Users can plug in B-tree / skip-list / persistent backends
- * without touching the reactive emission logic.
- *
- * @remarks Post-1.0 op-log changesets will extend this interface with a
- * `changesSince(version: number): Iterable<Change>` method. Current consumers
- * should treat all methods here as stable.
- *
- * @category extra
- */
-/**
- * Optional per-call options for {@link IndexBackend.upsert} and bulk upsert.
- *
- * @category extra
- */
-type UpsertOptions<K, V> = {
-    /**
-     * Skip the upsert if an existing row is considered equal to the proposed row.
-     * Default: no skip — every upsert advances `version`. Provide for idempotent
-     * keys (e.g., `(a, b) => a.secondary === b.secondary && a.value === b.value`).
-     */
-    equals?: (existing: IndexRow<K, V>, next: IndexRow<K, V>) => boolean;
-};
-interface IndexBackend<K, V = unknown> {
-    /** Monotonic mutation counter; increments on every upsert/delete/clear that changes state. */
-    readonly version: number;
-    /** Number of rows currently stored. */
-    readonly size: number;
-    /** O(1) primary-key existence check. */
-    has(primary: K): boolean;
-    /** Value lookup by primary key. */
-    get(primary: K): V | undefined;
-    /**
-     * Insert or replace a row. Returns `true` if a row was inserted (primary
-     * didn't exist), `false` otherwise (updated OR skipped via `opts.equals`).
-     *
-     * **Atomicity contract:** Either fully succeeds or throws before any state
-     * change; `version` advances only on state change.
-     */
-    upsert(primary: K, secondary: unknown, value: V, opts?: UpsertOptions<K, V>): boolean;
-    /**
-     * Atomic bulk upsert. Returns the number of rows that caused a state change
-     * (inserts + non-skipped updates). Advances `version` at most once.
-     * No-op if iterable is empty or all rows skipped by `opts.equals`.
-     *
-     * **Consumes `rows` once** — pass an array for multi-shot consumers.
-     */
-    upsertMany(rows: Iterable<{
-        primary: K;
-        secondary: unknown;
-        value: V;
-    }>, opts?: UpsertOptions<K, V>): number;
-    /** Remove a row by primary key. Returns `true` if the row existed. Advances `version` only if true. */
-    delete(primary: K): boolean;
-    /**
-     * Atomic bulk delete. Returns count removed. Advances `version` at most once.
-     * No-op if no keys were present. Consumes `primaries` once.
-     */
-    deleteMany(primaries: Iterable<K>): number;
-    /** Remove all rows. Returns the number removed. Advances `version` only if non-zero. */
-    clear(): number;
-    /** Rows in sorted `(secondary, primary)` order — fresh snapshot suitable for emission. */
-    toArray(): readonly IndexRow<K, V>[];
-    /** Primary-key → value map — fresh snapshot. */
-    toPrimaryMap(): ReadonlyMap<K, V>;
-}
-/**
- * Default flat-array backend. Maintains `buf: IndexRow[]` sorted by `(secondary, primary)`
- * and a parallel `Map<K, IndexRow>` for O(1) primary-key lookup.
- *
- * **Complexity:**
- * - `has`, `get`: O(1)
- * - `upsert`: up to 2× O(log n) bisect (locate old + locate new) + up to 2× O(n) splice (remove-old + insert-new) = O(n)
- * - `upsertMany(k rows)`: O(k log n) bisect + O(k·n) splice worst case; single version bump
- * - `delete`: O(log n) bisect + O(n) splice = O(n)
- * - `deleteMany(k keys)`: O(k log n) + O(k·n) splice worst case; single version bump
- * - `clear`: O(1)
- * - `toArray`, `toPrimaryMap`: O(n)
- *
- * @category extra
- */
-declare class NativeIndexBackend<K, V = unknown> implements IndexBackend<K, V> {
-    private _version;
-    private readonly _buf;
-    private readonly _byPrimary;
-    get version(): number;
-    get size(): number;
-    has(primary: K): boolean;
-    get(primary: K): V | undefined;
-    upsert(primary: K, secondary: unknown, value: V, opts?: UpsertOptions<K, V>): boolean;
-    upsertMany(rows: Iterable<{
-        primary: K;
-        secondary: unknown;
-        value: V;
-    }>, opts?: UpsertOptions<K, V>): number;
-    delete(primary: K): boolean;
-    deleteMany(primaries: Iterable<K>): number;
-    clear(): number;
-    toArray(): readonly IndexRow<K, V>[];
-    toPrimaryMap(): ReadonlyMap<K, V>;
-}
 /**
- * Creates a reactive index: unique primary key per row, rows sorted by `(secondary, primary)` for ordered scans.
+ * `singleFromAny` — keyed promise/Node de-duplication ("singleflight").
  *
- * @param options - Optional `name` for `describe()` / debugging, and optional `backend` (see {@link IndexBackend}).
- * @returns Bundle with `ordered` (sorted rows), `byPrimary` (map), O(1) `has` / `get` / `size`,
- *   imperative `upsert` / `upsertMany` / `delete` / `deleteMany` / `clear`.
+ * Given a `factory: (key) => NodeInput<T>`, returns a callable that dedupes
+ * concurrent invocations sharing the same key — all callers with the same
+ * key while a request is in-flight receive the same `Promise<T>`. Once the
+ * underlying source settles (DATA, ERROR, or COMPLETE), the cache entry is
+ * cleared so the next call re-invokes the factory.
  *
- * @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).
+ * This is the classic "singleflight" pattern from Go, generalised over the
+ * library's `NodeInput<T>` bridge so callers can pass Promise-returning
+ * factories, Node-returning factories, or plain value factories with
+ * identical semantics.
  *
- * **Backend:** The default {@link NativeIndexBackend} offers O(1) primary-key lookups and O(n) upserts.
- * For scale beyond a few thousand rows, supply a user-pluggable persistent/B-tree backend via the
- * `backend` option — reactive emission semantics are unchanged.
+ * Use cases:
+ * - `withReplayCache` cache-miss thundering-herd dedup
+ * - Shared HTTP fetches keyed by URL
+ * - Expensive compute keyed by request fingerprint
  *
  * @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");
+ * const fetchUser = singleFromAny<string, User>((id) => fetch(`/users/${id}`).then(r => r.json()));
+ * // Two concurrent callers with id="42" → one underlying fetch, two Promises resolving to the same User.
+ * const [a, b] = await Promise.all([fetchUser("42"), fetchUser("42")]);
  * ```
  *
  * @category extra
  */
-declare function reactiveIndex<K, V = unknown>(options?: ReactiveIndexOptions<K, V>): ReactiveIndexBundle<K, V>;
 
-type ReactiveListOptions<T> = {
-    name?: string;
+interface SingleFromAnyOptions<K> {
     /**
-     * Storage backend. Defaults to `NativeListBackend` (flat mutable array).
-     * Users can plug in persistent / RRB-tree backends via the {@link ListBackend} interface.
+     * Convert a typed key into a cache-string. Defaults to `String(key)`, which
+     * works for primitive keys; callers with object keys should provide a
+     * stable serializer (e.g., canonical JSON).
      */
-    backend?: ListBackend<T>;
-    /**
-     * Optional versioning level for the underlying `items` state node. Set at
-     * construction time; cannot be changed later. Pass `0` for V0 identity +
-     * monotonic version counter, or `1` for V1 + content-addressed cid.
-     */
-    versioning?: VersioningLevel;
-};
-type ReactiveListBundle<T> = {
-    /** Emits `readonly T[]` on each structural change (two-phase). */
-    readonly items: Node<readonly T[]>;
-    /** Current entry count (O(1)). */
-    readonly size: number;
-    /** Positional access (O(1)); supports negative indices (Python-style). Returns `undefined` on out-of-range. */
-    at: (index: number) => T | undefined;
-    append: (value: T) => void;
-    /** Push all values, emit one snapshot. No-op if `values` is empty. */
-    appendMany: (values: readonly T[]) => void;
-    /** Insert a value at `index`. Throws `RangeError` on out-of-range. */
-    insert: (index: number, value: T) => void;
-    /** Insert all values at `index` as one bulk op; emits one snapshot. No-op if `values` is empty. */
-    insertMany: (index: number, values: readonly T[]) => void;
-    /** Remove and return the value at `index` (default: last). Negative indices Python-style. Throws on empty / out-of-range. */
-    pop: (index?: number) => T;
-    clear: () => void;
-    /**
-     * Releases any internal keepalive subscriptions so the bundle can be
-     * GC'd. `reactiveList` currently holds none (no internal derived nodes),
-     * so `dispose()` is a no-op today — exposed for API parity with
-     * `reactiveIndex.dispose` / `reactiveMap.dispose` / `reactiveLog.dispose`.
-     * Idempotent. D6(a).
-     */
-    dispose: () => void;
-};
-/**
- * Storage contract for {@link reactiveList}. Implementations own the mutable state
- * and expose a monotonic `version` counter that increments on every structural change.
- *
- * The reactive layer reads `version` before and after each backend call; when it
- * advances, a snapshot is emitted.
- *
- * @remarks Post-1.0 op-log changesets will extend this interface with a
- * `changesSince(version: number): Iterable<Change>` method. Current consumers
- * should treat all methods here as stable.
- *
- * @category extra
- */
-interface ListBackend<T> {
-    /** Monotonic mutation counter; increments on every structural change. */
-    readonly version: number;
-    /** Number of items currently stored. */
-    readonly size: number;
-    /** Positional access; `undefined` on out-of-range. */
-    at(index: number): T | undefined;
-    /** Append a single value. Advances `version`. */
-    append(value: T): void;
-    /** Append a batch. Advances `version` once. No-op if empty. */
-    appendMany(values: readonly T[]): void;
-    /** Insert at index; throws `RangeError` on out-of-range `0 <= index <= size`. Advances `version`. */
-    insert(index: number, value: T): void;
-    /** Bulk insert at index; throws on out-of-range. Advances `version` once. No-op if `values` empty. */
-    insertMany(index: number, values: readonly T[]): void;
-    /** Remove and return value at index; throws on empty / out-of-range. Advances `version`. */
-    pop(index: number): T;
-    /** Clear all entries. Returns count removed. Advances `version` only if non-zero. */
-    clear(): number;
-    /** Full snapshot as a fresh array. */
-    toArray(): readonly T[];
+    keyFn?: (key: K) => string;
 }
 /**
- * Default mutable-array backend.
+ * Dedupe concurrent `factory(key)` invocations. Returns a bound callable.
  *
- * **Complexity:**
- * - `at`, `size`: O(1)
- * - `append`: O(1) amortized
- * - `appendMany(values)`, `insertMany(index, values)`: O(n + k) where k = values.length
- * - `insert`, `pop` (middle): O(n) due to splice
- * - `pop` (last): O(1)
- * - `clear`: O(1)
- * - `toArray`: O(n)
- *
- * @category extra
+ * @param factory - Produces a `NodeInput<T>` for each unique key.
+ * @param opts - Optional key-stringification.
+ * @returns A function `(key: K) => Promise<T>` whose inflight results are shared per key.
  */
-declare class NativeListBackend<T> implements ListBackend<T> {
-    private _version;
-    private readonly _buf;
-    constructor(initial?: readonly T[]);
-    get version(): number;
-    get size(): number;
-    at(index: number): T | undefined;
-    append(value: T): void;
-    appendMany(values: readonly T[]): void;
-    insert(index: number, value: T): void;
-    insertMany(index: number, values: readonly T[]): void;
-    pop(index: number): T;
-    clear(): number;
-    toArray(): readonly T[];
-}
+declare function singleFromAny<K, T>(factory: (key: K) => NodeInput<T>, opts?: SingleFromAnyOptions<K>): (key: K) => Promise<T>;
 /**
- * Creates a reactive list with immutable array snapshots.
- *
- * @param initial - Optional initial items (copied).
- * @param options - Optional `name` for `describe()` / debugging, or pluggable `backend`.
- * @returns Bundle with `items` (state node), `size` / `at`, `append` / `appendMany` / `insert` /
- *   `insertMany` / `pop` / `clear`.
- *
- * @remarks
- * **No `maxSize`:** insert/pop-anywhere semantics make eviction-under-cap ambiguous.
- * For bounded append-heavy workloads use `reactiveLog` (head-trim is well-defined for
- * append-only).
+ * Reactive variant: returns a bound callable that hands out `Node<T>` values.
+ * All concurrent callers with the same key during an in-flight source share
+ * the same Node. When the underlying source **terminally** settles (ERROR
+ * or COMPLETE), the Node is removed from the cache so the next call
+ * re-invokes `factory`. DATA is NOT terminal — callers subscribing after
+ * the first DATA still receive the shared Node (and push-on-subscribe per
+ * the spec's cached-DATA contract).
  *
- * **Backend:** Default {@link NativeListBackend}. For persistent / RRB-tree semantics
- * supply a custom {@link ListBackend}. If you provide a `backend`, `initial` is ignored
- * — seed the backend directly.
- *
- * @example
- * ```ts
- * import { reactiveList } from "@graphrefly/graphrefly-ts";
- *
- * const list = reactiveList<string>(["a"], { name: "queue" });
- * list.append("b");
- * list.insertMany(1, ["x", "y"]);
- * ```
+ * Use when downstream wants reactive subscription (not a one-shot Promise).
  *
  * @category extra
  */
-declare function reactiveList<T>(initial?: readonly T[], options?: ReactiveListOptions<T>): ReactiveListBundle<T>;
+declare function singleNodeFromAny<K, T>(factory: (key: K) => NodeInput<T>, opts?: SingleFromAnyOptions<K>): (key: K) => Node<T>;
 
-type ReactiveLogOptions<T> = {
-    name?: string;
-    maxSize?: number;
-    /**
-     * Optional versioning level for the underlying `entries` state node. Set
-     * at construction time; cannot be changed later. Pass `0` for V0 identity
-     * + monotonic version counter, or `1` for V1 + content-addressed cid.
-     */
-    versioning?: VersioningLevel;
-    /**
-     * Storage backend. Defaults to `NativeLogBackend` (ring buffer if `maxSize` is set,
-     * flat array otherwise). Users can plug in persistent / RRB-tree backends via
-     * the {@link LogBackend} interface.
-     */
-    backend?: LogBackend<T>;
-};
-type ReactiveLogBundle<T> = {
-    /** Emits `readonly T[]` on each append/clear/trim (two-phase). */
-    readonly entries: Node<readonly T[]>;
-    /** Current entry count (O(1)). */
-    readonly size: number;
-    /** Positional access (O(1)); returns `undefined` on out-of-range. Supports negative indices (Python-style). */
-    at: (index: number) => T | undefined;
-    append: (value: T) => void;
-    /**
-     * Push all values, emit one snapshot. No-op if `values` is empty.
-     * **Iterable consumption:** `values` is a `readonly T[]` — safe to pass arrays.
-     */
-    appendMany: (values: readonly T[]) => void;
-    clear: () => void;
-    /** Remove the first `n` entries (clamped to `size`). Throws on non-integer or negative `n`. */
-    trimHead: (n: number) => void;
-    /**
-     * Last `n` entries (or fewer) as a derived reactive view. Memoized with
-     * an LRU cache (default cap 64) — repeat calls with the same `n` return
-     * the same node. Throws on non-integer or negative `n`.
-     *
-     * **LRU eviction contract (D3(b)):** when a 65th distinct `n` is passed,
-     * the least-recently-used cached view is evicted and its keepalive is
-     * disposed. External holders of the evicted node will NOT receive further
-     * updates — re-call `tail(n)` for a fresh node, or dispose proactively
-     * via {@link disposeTail} / {@link disposeAllViews}. To avoid surprise:
-     * resolve `tail(n)` at the point of use rather than caching the returned
-     * node across many distinct `n`s.
-     */
-    tail: (n: number) => Node<readonly T[]>;
-    /**
-     * Reactive view of `entries.slice(start, stop)` — non-negative integer
-     * `start`, non-negative integer `stop` (exclusive) or `undefined` (to end).
-     * Memoized with an LRU cache (default cap 64) — repeat calls with the
-     * same `(start, stop)` return the same node.
-     *
-     * Throws on non-integer `start`, negative `start`, non-integer `stop`, or
-     * negative `stop` (P4 — the backend cannot cheaply honor JS-style
-     * negative `stop` without scanning length; disallowed for a consistent
-     * contract between backend, derived recomputation, and cached initial).
-     *
-     * **LRU eviction contract (D3(b)):** same as {@link tail} — past 64
-     * distinct `(start, stop)` pairs, the oldest cached view is evicted and
-     * its keepalive disposed. External holders stop receiving updates.
-     */
-    slice: (start: number, stop?: number) => Node<readonly T[]>;
-    /**
-     * Releases the cached `tail(n)` view if present (disposes its keepalive
-     * subscription). Subsequent `tail(n)` calls create a fresh node. No-op if
-     * `n` was not cached. Returns `true` if a view was disposed.
-     */
-    disposeTail: (n: number) => boolean;
-    /**
-     * Releases the cached `slice(start, stop?)` view if present. No-op if not cached.
-     */
-    disposeSlice: (start: number, stop?: number) => boolean;
-    /** Releases all cached tail/slice views and their keepalive subscriptions. */
-    disposeAllViews: () => void;
-    /**
-     * Releases all internal keepalive subscriptions so the bundle can be
-     * GC'd — currently equivalent to {@link disposeAllViews}, but exposed as
-     * a uniform API across all reactive data structures for lifecycle
-     * symmetry (mirrors `reactiveMap.dispose` / `reactiveList.dispose` /
-     * `reactiveIndex.dispose`). Idempotent. D6(a).
-     */
-    dispose: () => void;
-};
-/**
- * Storage contract for {@link reactiveLog}. Implementations own the mutable state and
- * expose a monotonic `version` counter that increments on every structural change.
- *
- * The reactive layer reads `version` to decide when to emit; it does not inspect
- * internal representation. Users can plug in persistent / ring-buffer / skip-list
- * backends without touching the reactive emission logic.
- *
- * @remarks Post-1.0 op-log changesets will extend this interface with a
- * `changesSince(version: number): Iterable<Change>` method. Current consumers
- * should treat all methods here as stable.
- *
- * @category extra
- */
-interface LogBackend<T> {
-    /** Monotonic mutation counter; increments on every append/trim/clear that changes state. */
-    readonly version: number;
-    /** Number of entries currently stored. */
-    readonly size: number;
-    /** O(1) positional access; returns `undefined` on out-of-range. */
-    at(index: number): T | undefined;
-    /** Append a value. Applies `maxSize` head-drop if configured. Advances `version`. */
-    append(value: T): void;
-    /** Append a batch; advances `version` once. No-op if `values.length === 0`. */
-    appendMany(values: readonly T[]): void;
-    /** Remove all entries. Returns count removed. Advances `version` only if non-zero. */
-    clear(): number;
-    /** Remove the first `n` entries (clamped). Returns count removed. Throws on negative `n`. */
-    trimHead(n: number): number;
-    /** Fresh snapshot array for `[start, stop)`. Throws on negative `start`. */
-    slice(start: number, stop?: number): readonly T[];
-    /** Last `n` entries as a fresh array. Throws on negative `n`. */
-    tail(n: number): readonly T[];
-    /** Full snapshot as a fresh array. */
-    toArray(): readonly T[];
-}
-/**
- * Default append-only log backend.
- *
- * - When `maxSize` is set: uses a **ring buffer** with `_head` index and circular
- *   modular arithmetic. Append and trim become O(1); snapshot is O(size) unrolling.
- * - When `maxSize` is unset: uses a flat array with standard push/splice.
- *
- * `appendMany` pre-trims oversize input: if `values.length > maxSize`, only the
- * tail of `values` is pushed (the rest would be immediately evicted).
- *
- * @category extra
- */
-declare class NativeLogBackend<T> implements LogBackend<T> {
-    private _version;
-    private readonly _maxSize?;
-    private readonly _buf;
-    private _head;
-    private _size;
-    constructor(initial?: readonly T[], maxSize?: number);
-    get version(): number;
-    get size(): number;
-    at(index: number): T | undefined;
-    append(value: T): void;
-    appendMany(values: readonly T[]): void;
-    clear(): number;
-    trimHead(n: number): number;
-    slice(start: number, stop?: number): readonly T[];
-    tail(n: number): readonly T[];
-    toArray(): readonly T[];
-    /** Internal append without version bump — used by `appendMany`. */
-    private _rawAppend;
-}
 /**
- * Creates an append-only reactive log with immutable array snapshots.
+ * stratify — reactive branch routing over a classifier rule set.
  *
- * @param initial - Optional seed entries (copied; pre-trimmed to `maxSize` if set).
- * @param options - `name`, `maxSize`, and optional pluggable `backend`.
- * @returns Bundle with `entries` (state node), `append`/`appendMany`/`clear`/`trimHead`,
- *   `size` / `at`, and memoized derived views `tail(n)` / `slice(start, stop?)`.
+ * Protocol-level primitive (no domain assumptions) that routes a source value
+ * to independent branch subgraphs. Rules are reactive — update the `"rules"`
+ * state node to rewrite classification at runtime. Rule updates affect
+ * **future items only** (streaming semantics, not retroactive).
  *
- * @remarks
- * **Backend:** The default {@link NativeLogBackend} uses a ring buffer when `maxSize`
- * is set (O(1) append + trim) and a flat array otherwise. For persistent/structural-
- * sharing semantics plug in a custom {@link LogBackend}.
- *
- * **`initial` + custom `backend` (F5):** When you supply `options.backend`, the
- * `initial` argument is IGNORED — seed the backend yourself before passing it in.
- * The `initial` seed only applies to the default `NativeLogBackend`.
- *
- * **Memoized views:** {@link ReactiveLogBundle.tail} and {@link ReactiveLogBundle.slice}
- * cache derived nodes per-argument. Repeat calls with the same `n` / `(start, stop)`
- * return the same node, bounding keepalive-subscription count to one per unique argument.
- *
- * @example
- * ```ts
- * import { reactiveLog } from "@graphrefly/graphrefly-ts";
- *
- * const lg = reactiveLog<number>([1, 2], { name: "audit", maxSize: 100 });
- * lg.append(3);
- * lg.entries.subscribe((msgs) => console.log(msgs));
- * const last5 = lg.tail(5);          // derived node
- * const window = lg.slice(10, 20);   // derived node
- * ```
- *
- * @category extra
- */
-declare function reactiveLog<T>(initial?: readonly T[], options?: ReactiveLogOptions<T>): ReactiveLogBundle<T>;
-
-/**
- * Filesystem-watching source. Isolated from `./sources.ts` so bundlers
- * targeting the browser can import browser-safe sources (`fromTimer`,
- * `fromRaf`, etc.) without pulling in `node:fs`/`node:path`.
+ * @module
  */
 
-type ExtraOpts = Omit<NodeOptions<unknown>, "describeKind">;
-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;
+/** A single routing rule for {@link stratify}. */
+type StratifyRule<T> = {
+    /** Branch name (used as node name under `branch/<name>`). */
+    name: string;
+    /** Classifier: returns `true` if the value belongs to this branch. */
+    classify: (value: T) => boolean;
+    /** Optional operator chain applied to the branch after classification. */
+    ops?: (n: Node<T>) => Node;
 };
-type FromFSWatchOptions = ExtraOpts & {
-    recursive?: boolean;
-    debounce?: number;
-    include?: string[];
-    exclude?: string[];
+/** Options for {@link stratify}. */
+type StratifyOptions = GraphOptions & {
+    meta?: Record<string, unknown>;
 };
 /**
- * Watches filesystem paths and emits debounced change events.
+ * Route input to different branches based on classifier functions.
+ *
+ * Each branch gets an independent operator chain. Branch nodes are structural —
+ * created at construction time and persist for the graph's lifetime. If a rule
+ * name is removed from the rules array, the corresponding branch silently
+ * drops items (classifier not found). To tear down a dead branch, call
+ * `graph.remove("branch/<name>")`.
  *
- * Uses `fs.watch` only (no polling fallback). Teardown closes all watchers.
+ * @param name - Graph name.
+ * @param source - Input node (registered as `"source"`).
+ * @param rules - Initial routing rules.
+ * @param opts - Optional graph/meta options.
+ * @returns Graph with `"source"`, `"rules"`, and `"branch/<name>"` nodes.
  *
  * @category extra
  */
-declare function fromFSWatch(paths: string | string[], opts?: FromFSWatchOptions): Node<FSEvent>;
+declare function stratify<T>(name: string, source: Node<T>, rules: ReadonlyArray<StratifyRule<T>>, opts?: StratifyOptions): Graph;
 
 /**
  * Creates a resettable deadline timer for internal timeout, retry, and rate-limiting use.
@@ -4945,8 +2791,8 @@ declare function workerSelf<TImport extends readonly string[]>(target: unknown |
 type index_AckableMessage<T> = AckableMessage<T>;
 type index_AdapterHandlers<T> = AdapterHandlers<T>;
 declare const index_AsyncSourceOpts: typeof AsyncSourceOpts;
-type index_BackoffPreset = BackoffPreset;
-type index_BackoffStrategy = BackoffStrategy;
+declare const index_BackoffPreset: typeof BackoffPreset;
+declare const index_BackoffStrategy: typeof BackoffStrategy;
 type index_BatchMessage = BatchMessage;
 type index_BridgeMessage = BridgeMessage;
 type index_BufferedSinkHandle = BufferedSinkHandle;
@@ -4957,35 +2803,30 @@ type index_CascadingCache<V> = CascadingCache<V>;
 type index_CascadingCacheOptions = CascadingCacheOptions;
 type index_CheckpointToRedisOptions = CheckpointToRedisOptions;
 type index_CheckpointToS3Options = CheckpointToS3Options;
-type index_CircuitBreaker = CircuitBreaker;
-type index_CircuitBreakerOptions = CircuitBreakerOptions;
-type index_CircuitOpenError = CircuitOpenError;
+declare const index_CircuitBreaker: typeof CircuitBreaker;
+declare const index_CircuitBreakerOptions: typeof CircuitBreakerOptions;
 declare const index_CircuitOpenError: typeof CircuitOpenError;
-type index_CircuitState = CircuitState;
+declare const index_CircuitState: typeof CircuitState;
 type index_ClickHouseClientLike = ClickHouseClientLike;
 type index_ClickHouseInsertClientLike = ClickHouseInsertClientLike;
 type index_ClickHouseRow = ClickHouseRow;
 type index_CronSchedule = CronSchedule;
-type index_DistillBundle<TMem> = DistillBundle<TMem>;
-type index_DistillOptions<TMem> = DistillOptions<TMem>;
+declare const index_DistillBundle: typeof DistillBundle;
+declare const index_DistillOptions: typeof DistillOptions;
 type index_DrizzleQueryLike<T = unknown> = DrizzleQueryLike<T>;
 type index_EmitTriad<T> = EmitTriad<T>;
 type index_ErrorMessage = ErrorMessage;
 declare const index_EventTargetLike: typeof EventTargetLike;
-type index_ExponentialBackoffOptions = ExponentialBackoffOptions;
+declare const index_ExponentialBackoffOptions: typeof ExponentialBackoffOptions;
 type index_ExternalBundleOptions<TChannels extends Record<string, unknown>> = ExternalBundleOptions<TChannels>;
 type index_ExternalRegister<H> = ExternalRegister<H>;
-type index_Extraction<TMem> = Extraction<TMem>;
-type index_FSEvent = FSEvent;
-type index_FSEventType = FSEventType;
-type index_FallbackInput<T> = FallbackInput<T>;
+declare const index_Extraction: typeof Extraction;
+declare const index_FallbackInput: typeof FallbackInput;
 type index_FileWriterLike = FileWriterLike;
 type index_FromCSVOptions = FromCSVOptions;
 type index_FromClickHouseWatchOptions = FromClickHouseWatchOptions;
 declare const index_FromCronOptions: typeof FromCronOptions;
 type index_FromDrizzleOptions<T, U = T> = FromDrizzleOptions<T, U>;
-type index_FromFSWatchOptions = FromFSWatchOptions;
-type index_FromGitHookOptions = FromGitHookOptions;
 type index_FromHTTPOptions = FromHTTPOptions;
 type index_FromHTTPPollOptions = FromHTTPPollOptions;
 type index_FromHTTPStreamOptions = FromHTTPStreamOptions;
@@ -5005,40 +2846,33 @@ type index_FromSqliteOptions<T> = FromSqliteOptions<T>;
 type index_FromStatsDOptions = FromStatsDOptions;
 type index_FromSyslogOptions = FromSyslogOptions;
 type index_FromWebSocketReconnectOptions<T> = FromWebSocketReconnectOptions<T>;
-type index_GitEvent = GitEvent;
-type index_GitHookType = GitHookType;
 type index_HTTPBundle<T> = HTTPBundle<T>;
-type index_IndexBackend<K, V = unknown> = IndexBackend<K, V>;
-type index_IndexRow<K, V = unknown> = IndexRow<K, V>;
-declare const index_IndexedDbStorageSpec: typeof IndexedDbStorageSpec;
+declare const index_IndexBackend: typeof IndexBackend;
+declare const index_IndexRow: typeof IndexRow;
 type index_InitMessage = InitMessage;
-type index_JitterMode = JitterMode;
+declare const index_JitterMode: typeof JitterMode;
 type index_KafkaConsumerLike = KafkaConsumerLike;
 type index_KafkaMessage<T = unknown> = KafkaMessage<T>;
 type index_KafkaProducerLike = KafkaProducerLike;
 type index_KyselyQueryLike<T = unknown> = KyselyQueryLike<T>;
-type index_ListBackend<T> = ListBackend<T>;
-type index_LogBackend<T> = LogBackend<T>;
+declare const index_ListBackend: typeof ListBackend;
+declare const index_LogBackend: typeof LogBackend;
 type index_LokiClientLike = LokiClientLike;
 type index_LokiStream = LokiStream;
 type index_MCPClientLike = MCPClientLike;
-type index_MapBackend<K, V> = MapBackend<K, V>;
-type index_MergeMapOptions = MergeMapOptions;
+declare const index_MapBackend: typeof MapBackend;
+declare const index_MergeMapOptions: typeof MergeMapOptions;
 type index_MongoCollectionLike = MongoCollectionLike;
 type index_NATSClientLike = NATSClientLike;
 type index_NATSMessage<T = unknown> = NATSMessage<T>;
 type index_NATSSubscriptionLike = NATSSubscriptionLike;
 declare const index_NS_PER_MS: typeof NS_PER_MS;
 declare const index_NS_PER_SEC: typeof NS_PER_SEC;
-type index_NativeIndexBackend<K, V = unknown> = NativeIndexBackend<K, V>;
 declare const index_NativeIndexBackend: typeof NativeIndexBackend;
-type index_NativeListBackend<T> = NativeListBackend<T>;
 declare const index_NativeListBackend: typeof NativeListBackend;
-type index_NativeLogBackend<T> = NativeLogBackend<T>;
 declare const index_NativeLogBackend: typeof NativeLogBackend;
-type index_NativeMapBackend<K, V> = NativeMapBackend<K, V>;
 declare const index_NativeMapBackend: typeof NativeMapBackend;
-type index_NativeMapBackendOptions = NativeMapBackendOptions;
+declare const index_NativeMapBackendOptions: typeof NativeMapBackendOptions;
 type index_NativePubSubBackend = NativePubSubBackend;
 declare const index_NativePubSubBackend: typeof NativePubSubBackend;
 declare const index_NodeInput: typeof NodeInput;
@@ -5058,19 +2892,18 @@ type index_PulsarMessage<T = unknown> = PulsarMessage<T>;
 type index_PulsarProducerLike = PulsarProducerLike;
 type index_RabbitMQChannelLike = RabbitMQChannelLike;
 type index_RabbitMQMessage<T = unknown> = RabbitMQMessage<T>;
-type index_RateLimiterOptions = RateLimiterOptions;
-type index_RateLimiterOverflowError = RateLimiterOverflowError;
+declare const index_RateLimiterOptions: typeof RateLimiterOptions;
 declare const index_RateLimiterOverflowError: typeof RateLimiterOverflowError;
-type index_RateLimiterOverflowPolicy = RateLimiterOverflowPolicy;
+declare const index_RateLimiterOverflowPolicy: typeof RateLimiterOverflowPolicy;
 declare const index_ReactiveCounterBundle: typeof ReactiveCounterBundle;
-type index_ReactiveIndexBundle<K, V = unknown> = ReactiveIndexBundle<K, V>;
-type index_ReactiveIndexOptions<K, V = unknown> = ReactiveIndexOptions<K, V>;
-type index_ReactiveListBundle<T> = ReactiveListBundle<T>;
-type index_ReactiveListOptions<T> = ReactiveListOptions<T>;
-type index_ReactiveLogBundle<T> = ReactiveLogBundle<T>;
-type index_ReactiveLogOptions<T> = ReactiveLogOptions<T>;
-type index_ReactiveMapBundle<K, V> = ReactiveMapBundle<K, V>;
-type index_ReactiveMapOptions<K, V> = ReactiveMapOptions<K, V>;
+declare const index_ReactiveIndexBundle: typeof ReactiveIndexBundle;
+declare const index_ReactiveIndexOptions: typeof ReactiveIndexOptions;
+declare const index_ReactiveListBundle: typeof ReactiveListBundle;
+declare const index_ReactiveListOptions: typeof ReactiveListOptions;
+declare const index_ReactiveLogBundle: typeof ReactiveLogBundle;
+declare const index_ReactiveLogOptions: typeof ReactiveLogOptions;
+declare const index_ReactiveMapBundle: typeof ReactiveMapBundle;
+declare const index_ReactiveMapOptions: typeof ReactiveMapOptions;
 type index_ReactiveSinkBackpressureOptions = ReactiveSinkBackpressureOptions;
 type index_ReactiveSinkConfig<T, Ctx = unknown> = ReactiveSinkConfig<T, Ctx>;
 type index_ReactiveSinkHandle<T> = ReactiveSinkHandle<T>;
@@ -5082,11 +2915,12 @@ type index_RedisClientLike = RedisClientLike;
 type index_RedisStreamEntry<T = unknown> = RedisStreamEntry<T>;
 type index_ResettableTimer = ResettableTimer;
 declare const index_ResettableTimer: typeof ResettableTimer;
-type index_RetryOptions = RetryOptions;
-type index_RetrySourceOptions<T> = RetrySourceOptions<T>;
+declare const index_RetryOptions: typeof RetryOptions;
+declare const index_RetrySourceOptions: typeof RetrySourceOptions;
 type index_S3ClientLike = S3ClientLike;
 type index_SSEEvent<T = string> = SSEEvent<T>;
 type index_SignalMessage = SignalMessage;
+type index_SingleFromAnyOptions<K> = SingleFromAnyOptions<K>;
 type index_SinkFailure<T> = SinkFailure<T>;
 type index_SinkHandle = SinkHandle;
 type index_SinkTransportError = SinkTransportError;
@@ -5094,15 +2928,16 @@ type index_SqliteDbLike = SqliteDbLike;
 type index_SqliteIterableDbLike = SqliteIterableDbLike;
 type index_StatsDMetric = StatsDMetric;
 type index_StatsDRegister = StatsDRegister;
-type index_StatusValue = StatusValue;
+declare const index_StatusValue: typeof StatusValue;
 declare const index_StorageHandle: typeof StorageHandle;
 declare const index_StorageTier: typeof StorageTier;
+type index_StratifyOptions = StratifyOptions;
+type index_StratifyRule<T> = StratifyRule<T>;
 type index_SyslogMessage = SyslogMessage;
 type index_SyslogRegister = SyslogRegister;
-type index_TapObserver<T> = TapObserver<T>;
+declare const index_TapObserver: typeof TapObserver;
 type index_TempoClientLike = TempoClientLike;
-type index_ThrottleOptions = ThrottleOptions;
-type index_TimeoutError = TimeoutError;
+declare const index_ThrottleOptions: typeof ThrottleOptions;
 declare const index_TimeoutError: typeof TimeoutError;
 type index_ToCSVOptions<T> = ToCSVOptions<T>;
 type index_ToClickHouseOptions<T> = ToClickHouseOptions<T>;
@@ -5122,26 +2957,27 @@ type index_ToSSEOptions = ToSSEOptions;
 type index_ToSqliteOptions<T> = ToSqliteOptions<T>;
 type index_ToTempoOptions<T> = ToTempoOptions<T>;
 type index_ToWebSocketOptions<T> = ToWebSocketOptions<T>;
-type index_TokenBucket = TokenBucket;
-type index_UpsertOptions<K, V> = UpsertOptions<K, V>;
+declare const index_TokenBucket: typeof TokenBucket;
+declare const index_UpsertOptions: typeof UpsertOptions;
 type index_ValueMessage = ValueMessage;
-type index_VerifiableBundle<T, TVerify = VerifyValue> = VerifiableBundle<T, TVerify>;
-type index_VerifiableOptions<TVerify = VerifyValue> = VerifiableOptions<TVerify>;
-type index_VerifyValue = VerifyValue;
+declare const index_VerifiableBundle: typeof VerifiableBundle;
+declare const index_VerifiableOptions: typeof VerifiableOptions;
+declare const index_VerifyValue: typeof 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>;
+declare const index_WithBreakerBundle: typeof WithBreakerBundle;
+declare const index_WithStatusBundle: typeof WithStatusBundle;
 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_awaitSettled: typeof awaitSettled;
 declare const index_buffer: typeof buffer;
 declare const index_bufferCount: typeof bufferCount;
 declare const index_bufferTime: typeof bufferTime;
@@ -5176,7 +3012,6 @@ declare const index_externalBundle: typeof externalBundle;
 declare const index_externalProducer: typeof externalProducer;
 declare const index_fallback: typeof fallback;
 declare const index_fibonacci: typeof fibonacci;
-declare const index_fileStorage: typeof fileStorage;
 declare const index_filter: typeof filter;
 declare const index_find: typeof find;
 declare const index_first: typeof first;
@@ -5191,13 +3026,9 @@ declare const index_fromClickHouseWatch: typeof fromClickHouseWatch;
 declare const index_fromCron: typeof fromCron;
 declare const index_fromDrizzle: typeof fromDrizzle;
 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_fromHTTPPoll: typeof fromHTTPPoll;
 declare const index_fromHTTPStream: typeof fromHTTPStream;
-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_fromKysely: typeof fromKysely;
@@ -5222,7 +3053,6 @@ declare const index_fromWebSocket: typeof fromWebSocket;
 declare const index_fromWebSocketReconnect: typeof fromWebSocketReconnect;
 declare const index_fromWebhook: typeof fromWebhook;
 declare const index_globToRegExp: typeof globToRegExp;
-declare const index_indexedDbStorage: typeof indexedDbStorage;
 declare const index_interval: typeof interval;
 declare const index_keepalive: typeof keepalive;
 declare const index_last: typeof last;
@@ -5266,8 +3096,12 @@ 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_singleFromAny: typeof singleFromAny;
+declare const index_singleNodeFromAny: typeof singleNodeFromAny;
 declare const index_skip: typeof skip;
-declare const index_sqliteStorage: typeof sqliteStorage;
+declare const index_sortJsonValue: typeof sortJsonValue;
+declare const index_stableJsonString: typeof stableJsonString;
+declare const index_stratify: typeof stratify;
 declare const index_switchMap: typeof switchMap;
 declare const index_take: typeof take;
 declare const index_takeUntil: typeof takeUntil;
@@ -5312,7 +3146,7 @@ declare const index_workerBridge: typeof workerBridge;
 declare const index_workerSelf: typeof workerSelf;
 declare const index_zip: typeof zip;
 declare namespace index {
-  export { type index_AckableMessage as AckableMessage, type index_AdapterHandlers as AdapterHandlers, 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_BufferedSinkHandle as BufferedSinkHandle, type index_BundleTriad as BundleTriad, type index_CSVRow as CSVRow, type index_CacheEvictionPolicy as CacheEvictionPolicy, type index_CascadingCache as CascadingCache, type index_CascadingCacheOptions as CascadingCacheOptions, type index_CheckpointToRedisOptions as CheckpointToRedisOptions, type index_CheckpointToS3Options as CheckpointToS3Options, 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_ClickHouseInsertClientLike as ClickHouseInsertClientLike, type index_ClickHouseRow as ClickHouseRow, type index_CronSchedule as CronSchedule, type index_DistillBundle as DistillBundle, type index_DistillOptions as DistillOptions, type index_DrizzleQueryLike as DrizzleQueryLike, type index_EmitTriad as EmitTriad, type index_ErrorMessage as ErrorMessage, index_EventTargetLike as EventTargetLike, type index_ExponentialBackoffOptions as ExponentialBackoffOptions, type index_ExternalBundleOptions as ExternalBundleOptions, type index_ExternalRegister as ExternalRegister, type index_Extraction as Extraction, type index_FSEvent as FSEvent, type index_FSEventType as FSEventType, type index_FallbackInput as FallbackInput, type index_FileWriterLike as FileWriterLike, type index_FromCSVOptions as FromCSVOptions, type index_FromClickHouseWatchOptions as FromClickHouseWatchOptions, index_FromCronOptions as FromCronOptions, type index_FromDrizzleOptions as FromDrizzleOptions, type index_FromFSWatchOptions as FromFSWatchOptions, type index_FromGitHookOptions as FromGitHookOptions, type index_FromHTTPOptions as FromHTTPOptions, type index_FromHTTPPollOptions as FromHTTPPollOptions, type index_FromHTTPStreamOptions as FromHTTPStreamOptions, type index_FromKafkaOptions as FromKafkaOptions, type index_FromKyselyOptions as FromKyselyOptions, type index_FromMCPOptions as FromMCPOptions, type index_FromNATSOptions as FromNATSOptions, type index_FromNDJSONOptions as FromNDJSONOptions, type index_FromOTelOptions as FromOTelOptions, type index_FromPrismaOptions as FromPrismaOptions, type index_FromPrometheusOptions as FromPrometheusOptions, type index_FromPulsarOptions as FromPulsarOptions, type index_FromRabbitMQOptions as FromRabbitMQOptions, type index_FromRedisStreamOptions as FromRedisStreamOptions, type index_FromSSEOptions as FromSSEOptions, type index_FromSqliteOptions as FromSqliteOptions, type index_FromStatsDOptions as FromStatsDOptions, type index_FromSyslogOptions as FromSyslogOptions, type index_FromWebSocketReconnectOptions as FromWebSocketReconnectOptions, type index_GitEvent as GitEvent, type index_GitHookType as GitHookType, type index_HTTPBundle as HTTPBundle, type index_IndexBackend as IndexBackend, type index_IndexRow as IndexRow, index_IndexedDbStorageSpec as IndexedDbStorageSpec, 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_KyselyQueryLike as KyselyQueryLike, type index_ListBackend as ListBackend, type index_LogBackend as LogBackend, type index_LokiClientLike as LokiClientLike, type index_LokiStream as LokiStream, type index_MCPClientLike as MCPClientLike, type index_MapBackend as MapBackend, type index_MergeMapOptions as MergeMapOptions, type index_MongoCollectionLike as MongoCollectionLike, type index_NATSClientLike as NATSClientLike, type index_NATSMessage as NATSMessage, type index_NATSSubscriptionLike as NATSSubscriptionLike, index_NS_PER_MS as NS_PER_MS, index_NS_PER_SEC as NS_PER_SEC, index_NativeIndexBackend as NativeIndexBackend, index_NativeListBackend as NativeListBackend, index_NativeLogBackend as NativeLogBackend, index_NativeMapBackend as NativeMapBackend, type index_NativeMapBackendOptions as NativeMapBackendOptions, index_NativePubSubBackend as NativePubSubBackend, 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_PostgresClientLike as PostgresClientLike, type index_PrismaModelLike as PrismaModelLike, type index_PrometheusMetric as PrometheusMetric, type index_PubSubBackend as PubSubBackend, type index_PubSubHub as PubSubHub, type index_PubSubHubOptions as PubSubHubOptions, type index_PulsarConsumerLike as PulsarConsumerLike, type index_PulsarMessage as PulsarMessage, type index_PulsarProducerLike as PulsarProducerLike, type index_RabbitMQChannelLike as RabbitMQChannelLike, type index_RabbitMQMessage as RabbitMQMessage, type index_RateLimiterOptions as RateLimiterOptions, index_RateLimiterOverflowError as RateLimiterOverflowError, type index_RateLimiterOverflowPolicy as RateLimiterOverflowPolicy, index_ReactiveCounterBundle as ReactiveCounterBundle, type index_ReactiveIndexBundle as ReactiveIndexBundle, type index_ReactiveIndexOptions as ReactiveIndexOptions, type index_ReactiveListBundle as ReactiveListBundle, type index_ReactiveListOptions as ReactiveListOptions, type index_ReactiveLogBundle as ReactiveLogBundle, type index_ReactiveLogOptions as ReactiveLogOptions, type index_ReactiveMapBundle as ReactiveMapBundle, type index_ReactiveMapOptions as ReactiveMapOptions, type index_ReactiveSinkBackpressureOptions as ReactiveSinkBackpressureOptions, type index_ReactiveSinkConfig as ReactiveSinkConfig, type index_ReactiveSinkHandle as ReactiveSinkHandle, type index_ReactiveSinkOptions as ReactiveSinkOptions, type index_ReactiveSinkRetryOptions as ReactiveSinkRetryOptions, type index_ReadyMessage as ReadyMessage, type index_RedisCheckpointClientLike as RedisCheckpointClientLike, type index_RedisClientLike as RedisClientLike, type index_RedisStreamEntry as RedisStreamEntry, index_ResettableTimer as ResettableTimer, type index_RetryOptions as RetryOptions, type index_RetrySourceOptions as RetrySourceOptions, type index_S3ClientLike as S3ClientLike, type index_SSEEvent as SSEEvent, type index_SignalMessage as SignalMessage, type index_SinkFailure as SinkFailure, type index_SinkHandle as SinkHandle, type index_SinkTransportError as SinkTransportError, type index_SqliteDbLike as SqliteDbLike, type index_SqliteIterableDbLike as SqliteIterableDbLike, type index_StatsDMetric as StatsDMetric, type index_StatsDRegister as StatsDRegister, type index_StatusValue as StatusValue, index_StorageHandle as StorageHandle, index_StorageTier as StorageTier, type index_SyslogMessage as SyslogMessage, type index_SyslogRegister as SyslogRegister, type index_TapObserver as TapObserver, type index_TempoClientLike as TempoClientLike, type index_ThrottleOptions as ThrottleOptions, index_TimeoutError as TimeoutError, type index_ToCSVOptions as ToCSVOptions, type index_ToClickHouseOptions as ToClickHouseOptions, type index_ToFileOptions as ToFileOptions, type index_ToHTTPOptions as ToHTTPOptions, type index_ToKafkaOptions as ToKafkaOptions, type index_ToLokiOptions as ToLokiOptions, type index_ToMongoOptions as ToMongoOptions, type index_ToNATSOptions as ToNATSOptions, index_ToObservableOptions as ToObservableOptions, type index_ToPostgresOptions as ToPostgresOptions, type index_ToPulsarOptions as ToPulsarOptions, type index_ToRabbitMQOptions as ToRabbitMQOptions, type index_ToRedisStreamOptions as ToRedisStreamOptions, type index_ToS3Options as ToS3Options, type index_ToSSEOptions as ToSSEOptions, type index_ToSqliteOptions as ToSqliteOptions, type index_ToTempoOptions as ToTempoOptions, type index_ToWebSocketOptions as ToWebSocketOptions, type index_TokenBucket as TokenBucket, type index_UpsertOptions as UpsertOptions, 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_cascadingCache as cascadingCache, index_catchError as catchError, index_checkpointToRedis as checkpointToRedis, index_checkpointToS3 as checkpointToS3, 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_csvRows as csvRows, index_debounce as debounce, index_debounceTime as debounceTime, index_decorrelatedJitter as decorrelatedJitter, index_delay as delay, index_deserializeError as deserializeError, index_dictStorage as dictStorage, 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_externalBundle as externalBundle, index_externalProducer as externalProducer, index_fallback as fallback, index_fibonacci as fibonacci, index_fileStorage as fileStorage, index_filter as filter, index_find as find, index_first as first, index_firstValueFrom as firstValueFrom, index_firstWhere as firstWhere, 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_fromDrizzle as fromDrizzle, index_fromEvent as fromEvent, index_fromFSWatch as fromFSWatch, index_fromGitHook as fromGitHook, index_fromHTTP as fromHTTP, index_fromHTTPPoll as fromHTTPPoll, index_fromHTTPStream as fromHTTPStream, index_fromIDBRequest as fromIDBRequest, index_fromIDBTransaction as fromIDBTransaction, index_fromIter as fromIter, index_fromKafka as fromKafka, index_fromKysely as fromKysely, index_fromMCP as fromMCP, index_fromNATS as fromNATS, index_fromNDJSON as fromNDJSON, index_fromOTel as fromOTel, index_fromPrisma as fromPrisma, index_fromPrometheus as fromPrometheus, index_fromPromise as fromPromise, index_fromPulsar as fromPulsar, index_fromRabbitMQ as fromRabbitMQ, index_fromRaf as fromRaf, index_fromRedisStream as fromRedisStream, index_fromSSE as fromSSE, index_fromSqlite as fromSqlite, index_fromSqliteCursor as fromSqliteCursor, index_fromStatsD as fromStatsD, index_fromSyslog as fromSyslog, index_fromTimer as fromTimer, index_fromWebSocket as fromWebSocket, index_fromWebSocketReconnect as fromWebSocketReconnect, index_fromWebhook as fromWebhook, index_globToRegExp as globToRegExp, index_indexedDbStorage as indexedDbStorage, index_interval as interval, index_keepalive as keepalive, index_last as last, index_linear as linear, index_lru as lru, index_map as map, index_matchesAnyPattern as matchesAnyPattern, index_matchesCron as matchesCron, index_memoryStorage as memoryStorage, index_merge as merge, index_mergeMap as mergeMap, index_nameToSignal as nameToSignal, index_ndjsonRows as ndjsonRows, index_never as never, 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_reactiveCounter as reactiveCounter, index_reactiveIndex as reactiveIndex, index_reactiveList as reactiveList, index_reactiveLog as reactiveLog, index_reactiveMap as reactiveMap, index_reactiveSink as reactiveSink, index_reduce as reduce, index_repeat as repeat, index_replay as replay, index_rescue as rescue, index_resolveBackoffPreset as resolveBackoffPreset, index_retry as retry, index_retrySource as retrySource, index_sample as sample, 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_sqliteStorage as sqliteStorage, 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_toCSV as toCSV, index_toClickHouse as toClickHouse, index_toFile as toFile, index_toHTTP as toHTTP, index_toKafka as toKafka, index_toLoki as toLoki, index_toMongo as toMongo, index_toNATS as toNATS, index_toObservable as toObservable, index_toPostgres as toPostgres, index_toPulsar as toPulsar, index_toRabbitMQ as toRabbitMQ, index_toReadableStream as toReadableStream, index_toRedisStream as toRedisStream, index_toS3 as toS3, index_toSSE as toSSE, index_toSSEBytes as toSSEBytes, index_toSqlite as toSqlite, index_toTempo as toTempo, index_toWebSocket as toWebSocket, index_tokenBucket as tokenBucket, index_valve as valve, 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 { type index_AckableMessage as AckableMessage, type index_AdapterHandlers as AdapterHandlers, index_AsyncSourceOpts as AsyncSourceOpts, index_BackoffPreset as BackoffPreset, index_BackoffStrategy as BackoffStrategy, type index_BatchMessage as BatchMessage, type index_BridgeMessage as BridgeMessage, type index_BufferedSinkHandle as BufferedSinkHandle, type index_BundleTriad as BundleTriad, type index_CSVRow as CSVRow, type index_CacheEvictionPolicy as CacheEvictionPolicy, type index_CascadingCache as CascadingCache, type index_CascadingCacheOptions as CascadingCacheOptions, type index_CheckpointToRedisOptions as CheckpointToRedisOptions, type index_CheckpointToS3Options as CheckpointToS3Options, index_CircuitBreaker as CircuitBreaker, index_CircuitBreakerOptions as CircuitBreakerOptions, index_CircuitOpenError as CircuitOpenError, index_CircuitState as CircuitState, type index_ClickHouseClientLike as ClickHouseClientLike, type index_ClickHouseInsertClientLike as ClickHouseInsertClientLike, type index_ClickHouseRow as ClickHouseRow, type index_CronSchedule as CronSchedule, index_DistillBundle as DistillBundle, index_DistillOptions as DistillOptions, type index_DrizzleQueryLike as DrizzleQueryLike, type index_EmitTriad as EmitTriad, type index_ErrorMessage as ErrorMessage, index_EventTargetLike as EventTargetLike, index_ExponentialBackoffOptions as ExponentialBackoffOptions, type index_ExternalBundleOptions as ExternalBundleOptions, type index_ExternalRegister as ExternalRegister, index_Extraction as Extraction, index_FallbackInput as FallbackInput, type index_FileWriterLike as FileWriterLike, type index_FromCSVOptions as FromCSVOptions, type index_FromClickHouseWatchOptions as FromClickHouseWatchOptions, index_FromCronOptions as FromCronOptions, type index_FromDrizzleOptions as FromDrizzleOptions, type index_FromHTTPOptions as FromHTTPOptions, type index_FromHTTPPollOptions as FromHTTPPollOptions, type index_FromHTTPStreamOptions as FromHTTPStreamOptions, type index_FromKafkaOptions as FromKafkaOptions, type index_FromKyselyOptions as FromKyselyOptions, type index_FromMCPOptions as FromMCPOptions, type index_FromNATSOptions as FromNATSOptions, type index_FromNDJSONOptions as FromNDJSONOptions, type index_FromOTelOptions as FromOTelOptions, type index_FromPrismaOptions as FromPrismaOptions, type index_FromPrometheusOptions as FromPrometheusOptions, type index_FromPulsarOptions as FromPulsarOptions, type index_FromRabbitMQOptions as FromRabbitMQOptions, type index_FromRedisStreamOptions as FromRedisStreamOptions, type index_FromSSEOptions as FromSSEOptions, type index_FromSqliteOptions as FromSqliteOptions, type index_FromStatsDOptions as FromStatsDOptions, type index_FromSyslogOptions as FromSyslogOptions, type index_FromWebSocketReconnectOptions as FromWebSocketReconnectOptions, type index_HTTPBundle as HTTPBundle, index_IndexBackend as IndexBackend, index_IndexRow as IndexRow, type index_InitMessage as InitMessage, index_JitterMode as JitterMode, type index_KafkaConsumerLike as KafkaConsumerLike, type index_KafkaMessage as KafkaMessage, type index_KafkaProducerLike as KafkaProducerLike, type index_KyselyQueryLike as KyselyQueryLike, index_ListBackend as ListBackend, index_LogBackend as LogBackend, type index_LokiClientLike as LokiClientLike, type index_LokiStream as LokiStream, type index_MCPClientLike as MCPClientLike, index_MapBackend as MapBackend, index_MergeMapOptions as MergeMapOptions, type index_MongoCollectionLike as MongoCollectionLike, type index_NATSClientLike as NATSClientLike, type index_NATSMessage as NATSMessage, type index_NATSSubscriptionLike as NATSSubscriptionLike, index_NS_PER_MS as NS_PER_MS, index_NS_PER_SEC as NS_PER_SEC, index_NativeIndexBackend as NativeIndexBackend, index_NativeListBackend as NativeListBackend, index_NativeLogBackend as NativeLogBackend, index_NativeMapBackend as NativeMapBackend, index_NativeMapBackendOptions as NativeMapBackendOptions, index_NativePubSubBackend as NativePubSubBackend, 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_PostgresClientLike as PostgresClientLike, type index_PrismaModelLike as PrismaModelLike, type index_PrometheusMetric as PrometheusMetric, type index_PubSubBackend as PubSubBackend, type index_PubSubHub as PubSubHub, type index_PubSubHubOptions as PubSubHubOptions, type index_PulsarConsumerLike as PulsarConsumerLike, type index_PulsarMessage as PulsarMessage, type index_PulsarProducerLike as PulsarProducerLike, type index_RabbitMQChannelLike as RabbitMQChannelLike, type index_RabbitMQMessage as RabbitMQMessage, index_RateLimiterOptions as RateLimiterOptions, index_RateLimiterOverflowError as RateLimiterOverflowError, index_RateLimiterOverflowPolicy as RateLimiterOverflowPolicy, index_ReactiveCounterBundle as ReactiveCounterBundle, index_ReactiveIndexBundle as ReactiveIndexBundle, index_ReactiveIndexOptions as ReactiveIndexOptions, index_ReactiveListBundle as ReactiveListBundle, index_ReactiveListOptions as ReactiveListOptions, index_ReactiveLogBundle as ReactiveLogBundle, index_ReactiveLogOptions as ReactiveLogOptions, index_ReactiveMapBundle as ReactiveMapBundle, index_ReactiveMapOptions as ReactiveMapOptions, type index_ReactiveSinkBackpressureOptions as ReactiveSinkBackpressureOptions, type index_ReactiveSinkConfig as ReactiveSinkConfig, type index_ReactiveSinkHandle as ReactiveSinkHandle, type index_ReactiveSinkOptions as ReactiveSinkOptions, type index_ReactiveSinkRetryOptions as ReactiveSinkRetryOptions, type index_ReadyMessage as ReadyMessage, type index_RedisCheckpointClientLike as RedisCheckpointClientLike, type index_RedisClientLike as RedisClientLike, type index_RedisStreamEntry as RedisStreamEntry, index_ResettableTimer as ResettableTimer, index_RetryOptions as RetryOptions, index_RetrySourceOptions as RetrySourceOptions, type index_S3ClientLike as S3ClientLike, type index_SSEEvent as SSEEvent, type index_SignalMessage as SignalMessage, type index_SingleFromAnyOptions as SingleFromAnyOptions, type index_SinkFailure as SinkFailure, type index_SinkHandle as SinkHandle, type index_SinkTransportError as SinkTransportError, type index_SqliteDbLike as SqliteDbLike, type index_SqliteIterableDbLike as SqliteIterableDbLike, type index_StatsDMetric as StatsDMetric, type index_StatsDRegister as StatsDRegister, index_StatusValue as StatusValue, index_StorageHandle as StorageHandle, index_StorageTier as StorageTier, type index_StratifyOptions as StratifyOptions, type index_StratifyRule as StratifyRule, type index_SyslogMessage as SyslogMessage, type index_SyslogRegister as SyslogRegister, index_TapObserver as TapObserver, type index_TempoClientLike as TempoClientLike, index_ThrottleOptions as ThrottleOptions, index_TimeoutError as TimeoutError, type index_ToCSVOptions as ToCSVOptions, type index_ToClickHouseOptions as ToClickHouseOptions, type index_ToFileOptions as ToFileOptions, type index_ToHTTPOptions as ToHTTPOptions, type index_ToKafkaOptions as ToKafkaOptions, type index_ToLokiOptions as ToLokiOptions, type index_ToMongoOptions as ToMongoOptions, type index_ToNATSOptions as ToNATSOptions, index_ToObservableOptions as ToObservableOptions, type index_ToPostgresOptions as ToPostgresOptions, type index_ToPulsarOptions as ToPulsarOptions, type index_ToRabbitMQOptions as ToRabbitMQOptions, type index_ToRedisStreamOptions as ToRedisStreamOptions, type index_ToS3Options as ToS3Options, type index_ToSSEOptions as ToSSEOptions, type index_ToSqliteOptions as ToSqliteOptions, type index_ToTempoOptions as ToTempoOptions, type index_ToWebSocketOptions as ToWebSocketOptions, index_TokenBucket as TokenBucket, index_UpsertOptions as UpsertOptions, type index_ValueMessage as ValueMessage, index_VerifiableBundle as VerifiableBundle, index_VerifiableOptions as VerifiableOptions, 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, index_WithBreakerBundle as WithBreakerBundle, 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_awaitSettled as awaitSettled, index_buffer as buffer, index_bufferCount as bufferCount, index_bufferTime as bufferTime, index_cached as cached, index_cascadingCache as cascadingCache, index_catchError as catchError, index_checkpointToRedis as checkpointToRedis, index_checkpointToS3 as checkpointToS3, 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_csvRows as csvRows, index_debounce as debounce, index_debounceTime as debounceTime, index_decorrelatedJitter as decorrelatedJitter, index_delay as delay, index_deserializeError as deserializeError, index_dictStorage as dictStorage, 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_externalBundle as externalBundle, index_externalProducer as externalProducer, index_fallback as fallback, index_fibonacci as fibonacci, index_filter as filter, index_find as find, index_first as first, index_firstValueFrom as firstValueFrom, index_firstWhere as firstWhere, 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_fromDrizzle as fromDrizzle, index_fromEvent as fromEvent, index_fromHTTP as fromHTTP, index_fromHTTPPoll as fromHTTPPoll, index_fromHTTPStream as fromHTTPStream, index_fromIter as fromIter, index_fromKafka as fromKafka, index_fromKysely as fromKysely, index_fromMCP as fromMCP, index_fromNATS as fromNATS, index_fromNDJSON as fromNDJSON, index_fromOTel as fromOTel, index_fromPrisma as fromPrisma, index_fromPrometheus as fromPrometheus, index_fromPromise as fromPromise, index_fromPulsar as fromPulsar, index_fromRabbitMQ as fromRabbitMQ, index_fromRaf as fromRaf, index_fromRedisStream as fromRedisStream, index_fromSSE as fromSSE, index_fromSqlite as fromSqlite, index_fromSqliteCursor as fromSqliteCursor, index_fromStatsD as fromStatsD, index_fromSyslog as fromSyslog, index_fromTimer as fromTimer, index_fromWebSocket as fromWebSocket, index_fromWebSocketReconnect as fromWebSocketReconnect, index_fromWebhook as fromWebhook, index_globToRegExp as globToRegExp, index_interval as interval, index_keepalive as keepalive, index_last as last, index_linear as linear, index_lru as lru, index_map as map, index_matchesAnyPattern as matchesAnyPattern, index_matchesCron as matchesCron, index_memoryStorage as memoryStorage, index_merge as merge, index_mergeMap as mergeMap, index_nameToSignal as nameToSignal, index_ndjsonRows as ndjsonRows, index_never as never, 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_reactiveCounter as reactiveCounter, index_reactiveIndex as reactiveIndex, index_reactiveList as reactiveList, index_reactiveLog as reactiveLog, index_reactiveMap as reactiveMap, index_reactiveSink as reactiveSink, index_reduce as reduce, index_repeat as repeat, index_replay as replay, index_rescue as rescue, index_resolveBackoffPreset as resolveBackoffPreset, index_retry as retry, index_retrySource as retrySource, index_sample as sample, index_scan as scan, index_serializeError as serializeError, index_share as share, index_shareReplay as shareReplay, index_signalToName as signalToName, index_singleFromAny as singleFromAny, index_singleNodeFromAny as singleNodeFromAny, index_skip as skip, index_sortJsonValue as sortJsonValue, index_stableJsonString as stableJsonString, index_stratify as stratify, 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_toCSV as toCSV, index_toClickHouse as toClickHouse, index_toFile as toFile, index_toHTTP as toHTTP, index_toKafka as toKafka, index_toLoki as toLoki, index_toMongo as toMongo, index_toNATS as toNATS, index_toObservable as toObservable, index_toPostgres as toPostgres, index_toPulsar as toPulsar, index_toRabbitMQ as toRabbitMQ, index_toReadableStream as toReadableStream, index_toRedisStream as toRedisStream, index_toS3 as toS3, index_toSSE as toSSE, index_toSSEBytes as toSSEBytes, index_toSqlite as toSqlite, index_toTempo as toTempo, index_toWebSocket as toWebSocket, index_tokenBucket as tokenBucket, index_valve as valve, 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 { type FromNDJSONOptions as $, type AckableMessage as A, type BackoffPreset as B, type CircuitState as C, type DistillBundle as D, type Extraction as E, type FallbackInput as F, type ExponentialBackoffOptions as G, type ExternalBundleOptions as H, type ExternalRegister as I, type FSEvent as J, type FSEventType as K, type FileWriterLike as L, type FromCSVOptions as M, NS_PER_MS as N, type FromClickHouseWatchOptions as O, type FromDrizzleOptions as P, type FromFSWatchOptions as Q, type ReactiveMapBundle as R, type StatusValue as S, type FromGitHookOptions as T, type FromHTTPOptions as U, type FromHTTPPollOptions as V, type FromHTTPStreamOptions as W, type FromKafkaOptions as X, type FromKyselyOptions as Y, type FromMCPOptions as Z, type FromNATSOptions as _, type RateLimiterOptions as a, type ReactiveMapOptions as a$, type FromOTelOptions as a0, type FromPrismaOptions as a1, type FromPrometheusOptions as a2, type FromPulsarOptions as a3, type FromRabbitMQOptions as a4, type FromRedisStreamOptions as a5, type FromSSEOptions as a6, type FromSqliteOptions as a7, type FromStatsDOptions as a8, type FromSyslogOptions as a9, NativeMapBackend as aA, type NativeMapBackendOptions as aB, NativePubSubBackend as aC, type OTelBundle as aD, type OTelLog as aE, type OTelMetric as aF, type OTelRegister as aG, type OTelSpan as aH, type PostgresClientLike as aI, type PrismaModelLike as aJ, type PrometheusMetric as aK, type PubSubBackend as aL, type PubSubHub as aM, type PubSubHubOptions as aN, type PulsarConsumerLike as aO, type PulsarMessage as aP, type PulsarProducerLike as aQ, type RabbitMQChannelLike as aR, type RabbitMQMessage as aS, RateLimiterOverflowError as aT, type RateLimiterOverflowPolicy as aU, type ReactiveIndexBundle as aV, type ReactiveIndexOptions as aW, type ReactiveListBundle as aX, type ReactiveListOptions as aY, type ReactiveLogBundle as aZ, type ReactiveLogOptions as a_, type FromWebSocketReconnectOptions as aa, type GitEvent as ab, type GitHookType as ac, type HTTPBundle as ad, type IndexBackend as ae, type IndexRow as af, type InitMessage as ag, type JitterMode as ah, type KafkaConsumerLike as ai, type KafkaMessage as aj, type KafkaProducerLike as ak, type KyselyQueryLike as al, type ListBackend as am, type LogBackend as an, type LokiClientLike as ao, type LokiStream as ap, type MCPClientLike as aq, type MapBackend as ar, type MergeMapOptions as as, type MongoCollectionLike as at, type NATSClientLike as au, type NATSMessage as av, type NATSSubscriptionLike as aw, NativeIndexBackend as ax, NativeListBackend as ay, NativeLogBackend as az, type CircuitBreakerOptions as b, audit as b$, type ReactiveSinkBackpressureOptions as b0, type ReactiveSinkConfig as b1, type ReactiveSinkHandle as b2, type ReactiveSinkOptions as b3, type ReactiveSinkRetryOptions as b4, type ReadyMessage as b5, type RedisCheckpointClientLike as b6, type RedisClientLike as b7, type RedisStreamEntry as b8, ResettableTimer as b9, type ToPulsarOptions as bA, type ToRabbitMQOptions as bB, type ToRedisStreamOptions as bC, type ToS3Options as bD, type ToSSEOptions as bE, type ToSqliteOptions as bF, type ToTempoOptions as bG, type ToWebSocketOptions as bH, type TokenBucket as bI, type UpsertOptions as bJ, type ValueMessage as bK, type VerifiableBundle as bL, type VerifiableOptions as bM, type VerifyValue as bN, type WatermarkController as bO, type WatermarkOptions as bP, type WebSocketLike as bQ, type WebSocketMessageEventLike as bR, type WebSocketRegister as bS, type WebhookRegister as bT, type WithBreakerBundle as bU, type WithStatusBundle as bV, type WorkerBridge as bW, type WorkerBridgeOptions as bX, type WorkerSelfHandle as bY, type WorkerSelfOptions as bZ, type WorkerTransport as b_, type RetrySourceOptions as ba, type S3ClientLike as bb, type SSEEvent as bc, type SignalMessage as bd, type SinkFailure as be, type SinkHandle as bf, type SinkTransportError as bg, type SqliteDbLike as bh, type SqliteIterableDbLike as bi, type StatsDMetric as bj, type StatsDRegister as bk, type SyslogMessage as bl, type SyslogRegister as bm, type TapObserver as bn, type TempoClientLike as bo, type ThrottleOptions as bp, TimeoutError as bq, type ToCSVOptions as br, type ToClickHouseOptions as bs, type ToFileOptions as bt, type ToHTTPOptions as bu, type ToKafkaOptions as bv, type ToLokiOptions as bw, type ToMongoOptions as bx, type ToNATSOptions as by, type ToPostgresOptions as bz, type RetryOptions as c, last as c$, buffer as c0, bufferCount as c1, bufferTime as c2, cascadingCache as c3, catchError as c4, checkpointToRedis as c5, checkpointToS3 as c6, circuitBreaker as c7, combine as c8, combineLatest as c9, fromClickHouseWatch as cA, fromDrizzle as cB, fromFSWatch as cC, fromGitHook as cD, fromHTTP as cE, fromHTTPPoll as cF, fromHTTPStream as cG, fromKafka as cH, fromKysely as cI, fromMCP as cJ, fromNATS as cK, fromNDJSON as cL, fromOTel as cM, fromPrisma as cN, fromPrometheus as cO, fromPulsar as cP, fromRabbitMQ as cQ, fromRedisStream as cR, fromSSE as cS, fromSqlite as cT, fromSqliteCursor as cU, fromStatsD as cV, fromSyslog as cW, fromWebSocket as cX, fromWebSocketReconnect as cY, fromWebhook as cZ, interval as c_, concat as ca, concatMap as cb, constant as cc, createTransport as cd, createWatermarkController as ce, csvRows as cf, debounce as cg, debounceTime as ch, decorrelatedJitter as ci, delay as cj, deserializeError as ck, distill as cl, distinctUntilChanged as cm, elementAt as cn, exhaustMap as co, exponential as cp, externalBundle as cq, externalProducer as cr, index as cs, fallback as ct, fibonacci as cu, filter as cv, find as cw, first as cx, flatMap as cy, fromCSV as cz, NS_PER_SEC as d, verifiable as d$, linear as d0, lru as d1, map as d2, matchesCron as d3, merge as d4, mergeMap as d5, nameToSignal as d6, ndjsonRows as d7, pairwise as d8, parseCron as d9, takeUntil as dA, takeWhile as dB, tap as dC, throttle as dD, throttleTime as dE, timeout as dF, toCSV as dG, toClickHouse as dH, toFile as dI, toHTTP as dJ, toKafka as dK, toLoki as dL, toMongo as dM, toNATS as dN, toPostgres as dO, toPulsar as dP, toRabbitMQ as dQ, toReadableStream as dR, toRedisStream as dS, toS3 as dT, toSSE as dU, toSSEBytes as dV, toSqlite as dW, toTempo as dX, toWebSocket as dY, tokenBucket as dZ, valve as d_, parsePrometheusText as da, parseStatsD as db, parseSyslog as dc, pausable as dd, pubsub as de, race as df, rateLimiter as dg, reactiveIndex as dh, reactiveList as di, reactiveLog as dj, reactiveMap as dk, reactiveSink as dl, reduce as dm, repeat as dn, rescue as dp, resolveBackoffPreset as dq, retry as dr, retrySource as ds, sample as dt, scan as du, serializeError as dv, signalToName as dw, skip as dx, switchMap as dy, take as dz, type AdapterHandlers as e, window as e0, windowCount as e1, windowTime as e2, withBreaker as e3, withLatestFrom as e4, withMaxAttempts as e5, withStatus as e6, workerBridge as e7, workerSelf as e8, zip as e9, type BackoffStrategy as f, type BatchMessage as g, type BridgeMessage as h, type BufferedSinkHandle as i, type BundleTriad as j, type CSVRow as k, type CacheEvictionPolicy as l, type CascadingCache as m, type CascadingCacheOptions as n, type CheckpointToRedisOptions as o, type CheckpointToS3Options as p, type CircuitBreaker as q, CircuitOpenError as r, type ClickHouseClientLike as s, type ClickHouseInsertClientLike as t, type ClickHouseRow as u, type CronSchedule as v, type DistillOptions as w, type DrizzleQueryLike as x, type EmitTriad as y, type ErrorMessage as z };
+export { type MongoCollectionLike as $, type AckableMessage as A, type BatchMessage as B, type CSVRow as C, type DrizzleQueryLike as D, type EmitTriad as E, type FileWriterLike as F, type FromNDJSONOptions as G, type FromOTelOptions as H, type FromPrismaOptions as I, type FromPrometheusOptions as J, type FromPulsarOptions as K, type FromRabbitMQOptions as L, type FromRedisStreamOptions as M, type FromSSEOptions as N, type FromSqliteOptions as O, type FromStatsDOptions as P, type FromSyslogOptions as Q, type FromWebSocketReconnectOptions as R, type HTTPBundle as S, type InitMessage as T, type KafkaConsumerLike as U, type KafkaMessage as V, type KafkaProducerLike as W, type KyselyQueryLike as X, type LokiClientLike as Y, type LokiStream as Z, type MCPClientLike as _, type AdapterHandlers as a, type ValueMessage as a$, type NATSClientLike as a0, type NATSMessage as a1, type NATSSubscriptionLike as a2, NativePubSubBackend as a3, type OTelBundle as a4, type OTelLog as a5, type OTelMetric as a6, type OTelRegister as a7, type OTelSpan as a8, type PostgresClientLike as a9, type SinkTransportError as aA, type SqliteDbLike as aB, type SqliteIterableDbLike as aC, type StatsDMetric as aD, type StatsDRegister as aE, type StratifyOptions as aF, type StratifyRule as aG, type SyslogMessage as aH, type SyslogRegister as aI, type TempoClientLike as aJ, type ToCSVOptions as aK, type ToClickHouseOptions as aL, type ToFileOptions as aM, type ToHTTPOptions as aN, type ToKafkaOptions as aO, type ToLokiOptions as aP, type ToMongoOptions as aQ, type ToNATSOptions as aR, type ToPostgresOptions as aS, type ToPulsarOptions as aT, type ToRabbitMQOptions as aU, type ToRedisStreamOptions as aV, type ToS3Options as aW, type ToSSEOptions as aX, type ToSqliteOptions as aY, type ToTempoOptions as aZ, type ToWebSocketOptions as a_, type PrismaModelLike as aa, type PrometheusMetric as ab, type PubSubBackend as ac, type PubSubHub as ad, type PubSubHubOptions as ae, type PulsarConsumerLike as af, type PulsarMessage as ag, type PulsarProducerLike as ah, type RabbitMQChannelLike as ai, type RabbitMQMessage as aj, type ReactiveSinkBackpressureOptions as ak, type ReactiveSinkConfig as al, type ReactiveSinkHandle as am, type ReactiveSinkOptions as an, type ReactiveSinkRetryOptions as ao, type ReadyMessage as ap, type RedisCheckpointClientLike as aq, type RedisClientLike as ar, type RedisStreamEntry as as, ResettableTimer as at, type S3ClientLike as au, type SSEEvent as av, type SignalMessage as aw, type SingleFromAnyOptions as ax, type SinkFailure as ay, type SinkHandle as az, type BridgeMessage as b, toFile as b$, type WatermarkController as b0, type WatermarkOptions as b1, type WebSocketLike as b2, type WebSocketMessageEventLike as b3, type WebSocketRegister as b4, type WebhookRegister as b5, type WorkerBridge as b6, type WorkerBridgeOptions as b7, type WorkerSelfHandle as b8, type WorkerSelfOptions as b9, fromRabbitMQ as bA, fromRedisStream as bB, fromSSE as bC, fromSqlite as bD, fromSqliteCursor as bE, fromStatsD as bF, fromSyslog as bG, fromWebSocket as bH, fromWebSocketReconnect as bI, fromWebhook as bJ, lru as bK, matchesCron as bL, nameToSignal as bM, ndjsonRows as bN, parseCron as bO, parsePrometheusText as bP, parseStatsD as bQ, parseSyslog as bR, pubsub as bS, reactiveSink as bT, serializeError as bU, signalToName as bV, singleFromAny as bW, singleNodeFromAny as bX, stratify as bY, toCSV as bZ, toClickHouse as b_, type WorkerTransport as ba, cascadingCache as bb, checkpointToRedis as bc, checkpointToS3 as bd, createTransport as be, createWatermarkController as bf, csvRows as bg, deserializeError as bh, externalBundle as bi, externalProducer as bj, index as bk, fromCSV as bl, fromClickHouseWatch as bm, fromDrizzle as bn, fromHTTP as bo, fromHTTPPoll as bp, fromHTTPStream as bq, fromKafka as br, fromKysely as bs, fromMCP as bt, fromNATS as bu, fromNDJSON as bv, fromOTel as bw, fromPrisma as bx, fromPrometheus as by, fromPulsar as bz, type BufferedSinkHandle as c, toHTTP as c0, toKafka as c1, toLoki as c2, toMongo as c3, toNATS as c4, toPostgres as c5, toPulsar as c6, toRabbitMQ as c7, toReadableStream as c8, toRedisStream as c9, toS3 as ca, toSSE as cb, toSSEBytes as cc, toSqlite as cd, toTempo as ce, toWebSocket as cf, workerBridge as cg, workerSelf as ch, type BundleTriad as d, type CacheEvictionPolicy as e, type CascadingCache as f, type CascadingCacheOptions as g, type CheckpointToRedisOptions as h, type CheckpointToS3Options as i, type ClickHouseClientLike as j, type ClickHouseInsertClientLike as k, type ClickHouseRow as l, type CronSchedule as m, type ErrorMessage as n, type ExternalBundleOptions as o, type ExternalRegister as p, type FromCSVOptions as q, type FromClickHouseWatchOptions as r, type FromDrizzleOptions as s, type FromHTTPOptions as t, type FromHTTPPollOptions as u, type FromHTTPStreamOptions as v, type FromKafkaOptions as w, type FromKyselyOptions as x, type FromMCPOptions as y, type FromNATSOptions as z };