@graphrefly/graphrefly 0.21.0 → 0.22.0

package/dist/{index-DuN3bhtm.d.ts → index-BbYZma8G.d.ts}

@@ -1,6 +1,141 @@
-import { N as Node, a as NodeOptions, M as Message, l as Messages } from './meta-BnG7XAaE.js';
-import { G as Graph } from './graph-mILUUqW8.js';
-import { T as ToObservableOptions, t as toObservable } from './observable-DcBwQY7t.js';
+import { a as NodeOptions, N as Node, M as Message, t as Messages, a6 as VersioningLevel } from './node-C5UD5MGq.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-C9fZfMfM.js';
+import { T as ToObservableOptions, t as toObservable } from './observable-CQRBtEbq.js';
+
+/**
+ * External-register helpers — the common `register({emit, error, complete})`
+ * contract shared by webhook, MCP, syslog, StatsD, OTel and other callback-
+ * based integrations. Absorbs the `active` flag that every such adapter needs
+ * to guard against emits after teardown (§5.10 boundary pattern).
+ *
+ * Two shapes:
+ *
+ * - {@link externalProducer} — single channel. Lazy activation: the register
+ *   fn runs when the node gains its first subscriber; its returned cleanup
+ *   runs on deactivation.
+ *
+ * - {@link externalBundle} — multiple named channels. Eager activation: the
+ *   register fn runs at bundle construction time so externally-owned servers
+ *   (HTTP endpoints, UDP sockets) start accepting traffic immediately. A
+ *   shared refcount fires the returned cleanup once every channel has fully
+ *   torn down.
+ */
+
+type ExtraOpts$3 = Omit<NodeOptions<unknown>, "describeKind">;
+/**
+ * Standard emit-triad passed to a single-channel external registrar.
+ *
+ * Post-teardown calls on any of these are automatically no-ops — the
+ * registrar does not need its own guard flag.
+ *
+ * @category extra
+ */
+type EmitTriad<T> = {
+    /** Emit a value as `DATA`. */
+    emit: (value: T) => void;
+    /** Terminate with `ERROR`. Subsequent `emit` / `error` / `complete` are ignored. */
+    error: (err: unknown) => void;
+    /** Terminate with `COMPLETE`. Subsequent `emit` / `error` / `complete` are ignored. */
+    complete: () => void;
+};
+/**
+ * Multi-channel emit bundle. Each declared channel name maps to an emit fn;
+ * `error` and `complete` terminate every channel atomically.
+ *
+ * @category extra
+ */
+type BundleTriad<TChannels extends Record<string, unknown>> = {
+    [K in keyof TChannels]: (value: TChannels[K]) => void;
+} & {
+    /** Terminate every channel with `ERROR`. */
+    error: (err: unknown) => void;
+    /** Terminate every channel with `COMPLETE`. */
+    complete: () => void;
+};
+/**
+ * Generic external registrator contract. The caller installs handlers into a
+ * third-party library / framework / server and optionally returns a cleanup
+ * callback. Returning `undefined` / `void` is equivalent to a no-op cleanup.
+ *
+ * @category extra
+ */
+type ExternalRegister<H> = (handlers: H) => (() => void) | undefined;
+/**
+ * Wraps a callback-style external integration as a reactive source.
+ *
+ * The registrar installs the supplied `emit` / `error` / `complete` handlers
+ * into the external SDK; post-teardown calls are silently dropped. Synchronous
+ * exceptions thrown by the registrar surface as terminal `ERROR`.
+ *
+ * @param register - Installs handlers. Optionally returns a cleanup fn.
+ * @param opts - Node options (name, equals, resubscribable, ...).
+ *
+ * @example
+ * ```ts
+ * import { externalProducer } from "@graphrefly/graphrefly-ts";
+ *
+ * const hook$ = externalProducer<Payload>(({ emit, error }) => {
+ *   const id = transport.onMessage((raw) => {
+ *     try { emit(parse(raw)); } catch (e) { error(e); }
+ *   });
+ *   return () => transport.off(id);
+ * });
+ * ```
+ *
+ * @category extra
+ */
+declare function externalProducer<T = unknown>(register: ExternalRegister<EmitTriad<T>>, opts?: ExtraOpts$3): Node<T>;
+/**
+ * Options for {@link externalBundle}.
+ *
+ * @category extra
+ */
+type ExternalBundleOptions<TChannels extends Record<string, unknown>> = {
+    /** Base name prefix for channel nodes; each node is named `${name}::${channel}`. */
+    name?: string;
+    /** Per-channel node options (equals, resubscribable, ...). */
+    channelOpts?: {
+        [K in keyof TChannels]?: ExtraOpts$3;
+    };
+};
+/**
+ * Multi-channel variant — one `Node<T>` per named channel, sharing a single
+ * registrar. Activation is eager: the registrar runs at construction time so
+ * externally-owned servers (HTTP, UDP, queue consumers) can start accepting
+ * traffic immediately. The returned cleanup fires once every channel has been
+ * subscribed and then fully deactivated (refcount-on-teardown).
+ *
+ * Any call to `error` or `complete` propagates to every channel atomically.
+ *
+ * @param register - Installs handlers for each channel plus shared error/complete.
+ * @param channels - Ordered channel names; determines the returned object shape.
+ * @param opts - Optional name prefix and per-channel node options.
+ *
+ * @example
+ * ```ts
+ * import { externalBundle } from "@graphrefly/graphrefly-ts";
+ *
+ * type OTelChannels = { traces: Span; metrics: Metric; logs: LogRec };
+ * const otel = externalBundle<OTelChannels>(
+ *   ({ traces, metrics, logs, error }) => {
+ *     app.post("/v1/traces",  (req, res) => { traces(req.body);  res.sendStatus(200); });
+ *     app.post("/v1/metrics", (req, res) => { metrics(req.body); res.sendStatus(200); });
+ *     app.post("/v1/logs",    (req, res) => { logs(req.body);    res.sendStatus(200); });
+ *     server.on("error", error);
+ *     return () => server.close();
+ *   },
+ *   ["traces", "metrics", "logs"],
+ * );
+ * otel.traces.subscribe(...);
+ * ```
+ *
+ * @category extra
+ */
+declare function externalBundle<TChannels extends Record<string, unknown>>(register: ExternalRegister<BundleTriad<TChannels>>, channels: readonly (keyof TChannels & string)[], opts?: ExternalBundleOptions<TChannels>): {
+    [K in keyof TChannels]: Node<TChannels[K]>;
+} & {
+    dispose(): void;
+};
 
 /**
  * Backoff strategies for {@link retry} (roadmap §3.1). Delays are in **nanoseconds**.
@@ -155,6 +290,187 @@ declare function withMaxAttempts(strategy: BackoffStrategy, maxAttempts: number)
  */
 declare function resolveBackoffPreset(name: BackoffPreset): BackoffStrategy;
 
+/**
+ * {@link reactiveSink} — canonical sink factory for Wave 5 adapters.
+ *
+ * Every `to*` adapter in {@link ./adapters.ts} can be expressed as a thin
+ * config wrapper around this one factory. It centralizes:
+ *
+ * - **Transport boundary** — the sole place in the sink layer where a raw
+ *   Promise / `.then` / `.catch` sits (§5.10 boundary documented here).
+ * - **Retry** — delegates to {@link BackoffStrategy} from `backoff.ts`.
+ * - **Buffering** — `batchSize` / `flushIntervalMs` with tier-3 flush-on-
+ *   terminal per spec §5.11. Buffered mode activates when `sendBatch` is
+ *   supplied or a batching knob is set.
+ * - **Backpressure** — bounded internal queue with `drop-oldest` /
+ *   `drop-newest` / `error` strategies. The `"wait"` strategy is deferred
+ *   to external composition (`source | valve(...) | reactiveSink(...)`).
+ * - **Companions** — `sent` / `failed` / `inFlight` / `errors` (+ `buffered`
+ *   / `paused` when buffering or backpressure is active). These surface
+ *   every transport outcome as reactive nodes so downstream operators can
+ *   build retry fallbacks, dead-letter queues, or SLO gauges without
+ *   touching callback soup.
+ */
+
+/**
+ * Structured transport-failure record. Every sink routes both recoverable
+ * (pre-retry) and terminal (post-exhaustion) failures through this shape.
+ *
+ * @category extra
+ */
+type SinkTransportError = {
+    /**
+     * Failure stage. Known values: `"serialize"`, `"send"`, `"close"`,
+     * `"routing_key"`, `"ack"`, `"retry_exhausted"`. Open to extension for
+     * protocol-specific stages.
+     */
+    stage: string;
+    /** The error. */
+    error: Error;
+    /** Unwrapped DATA value (present for per-record failures). */
+    value: unknown;
+    /** Full message tuple (present for non-DATA stages like `"close"`). */
+    message?: Message;
+    /** Attempt number when `retry` is active — `1` = initial send. */
+    attempt?: number;
+};
+/**
+ * Terminal failure record delivered on the `failed` companion after retries
+ * are exhausted (or `shouldRetry` returned `false`).
+ *
+ * @category extra
+ */
+type SinkFailure<T> = {
+    value: T;
+    error: Error;
+    /** Total attempts made, including the initial send. */
+    attempts: number;
+};
+/**
+ * Handle returned by every Wave 5 sink.
+ *
+ * @category extra
+ */
+type ReactiveSinkHandle<T> = {
+    /** Unsubscribe from source, cancel timers, fire `TEARDOWN` on companions. */
+    dispose(): void;
+    /** Drain buffer + await in-flight sends (buffered mode only). */
+    flush?(): Promise<void>;
+    /** DATA values that successfully reached the transport. */
+    sent: Node<T>;
+    /** Values that permanently failed (after any retries). */
+    failed: Node<SinkFailure<T> | null>;
+    /** Number of pending transport operations. */
+    inFlight: Node<number>;
+    /** Every transient transport error (pre-retry). Latest-only. */
+    errors: Node<SinkTransportError | null>;
+    /** Items currently buffered (buffered mode / backpressure only). */
+    buffered?: Node<number>;
+    /** `true` when a backpressure strategy has dropped / rejected items. */
+    paused?: Node<boolean>;
+};
+/**
+ * Retry configuration for {@link reactiveSink}.
+ *
+ * @category extra
+ */
+type ReactiveSinkRetryOptions = {
+    /** Total attempts including the initial send. Default: `1` (no retry). */
+    maxAttempts?: number;
+    /** Backoff strategy (ns) or preset name. Default: `"exponential"` when `maxAttempts > 1`. */
+    backoff?: BackoffStrategy | BackoffPreset;
+    /** Predicate — return `false` to short-circuit retry for a given error. */
+    shouldRetry?: (err: Error, attempt: number) => boolean;
+};
+/**
+ * Backpressure configuration for {@link reactiveSink}. When omitted, the
+ * sink has no internal buffer cap beyond the natural `batchSize` /
+ * `flushIntervalMs` limits.
+ *
+ * @category extra
+ */
+type ReactiveSinkBackpressureOptions = {
+    /** Hard cap on buffered items; further items trigger `strategy`. Default: `Infinity`. */
+    maxBuffer?: number;
+    /** Policy when the buffer is full. Default: `"drop-oldest"`. */
+    strategy?: "drop-oldest" | "drop-newest" | "error";
+};
+/**
+ * Base options shared by every sink built on {@link reactiveSink}.
+ *
+ * @category extra
+ */
+type ReactiveSinkOptions<T> = {
+    /** Optional name used for companion node naming. */
+    name?: string;
+    /** Invoked synchronously for every transient transport error. */
+    onTransportError?: (err: SinkTransportError) => void;
+    /** Retry configuration. */
+    retry?: ReactiveSinkRetryOptions;
+    /** Backpressure configuration. */
+    backpressure?: ReactiveSinkBackpressureOptions;
+    /** Batch size before auto-flush (buffered mode). */
+    batchSize?: number;
+    /** Flush interval in ms; `0` = write-through (buffered mode). */
+    flushIntervalMs?: number;
+    /** Optional transform applied before `send` / `sendBatch`. */
+    serialize?: (value: T) => unknown;
+    /**
+     * Reactive stop signal — when this node emits any DATA or terminal, the
+     * sink tears down. Gives callers a reactive alternative to the imperative
+     * `handle.dispose()` call so teardown can be wired through the graph.
+     */
+    stopOn?: Node<unknown>;
+    /**
+     * Optional hook invoked for each upstream non-DATA message (COMPLETE /
+     * ERROR / etc.) observed by the sink. Used by adapters like
+     * {@link toWebSocket} to close the underlying resource when the source
+     * terminates, without the caller having to subscribe twice.
+     */
+    onUpstreamMessage?: (msg: Message) => void;
+    /**
+     * Invoked once during `dispose()` after the sink's own cleanup (unsub,
+     * final drain, TEARDOWN on companions). Adapters wrap external resources
+     * (socket listeners, file handles) by passing their cleanup here —
+     * avoids hand-rolling a wrapper around `handle.dispose`.
+     */
+    onDispose?: () => void;
+    /**
+     * Ignored — reserved for future parity with `source.pipe(...)` style.
+     *
+     * @internal
+     */
+    _reserved?: never;
+};
+/**
+ * Full config accepted by {@link reactiveSink}. One of `send` / `sendBatch`
+ * is required.
+ *
+ * @category extra
+ */
+type ReactiveSinkConfig<T, Ctx = unknown> = ReactiveSinkOptions<T> & {
+    /** Per-record transport call. */
+    send?: (value: T, ctx: Ctx) => Promise<void> | void;
+    /** Batched transport call. When supplied, buffering activates automatically. */
+    sendBatch?: (batch: T[], ctx: Ctx) => Promise<void> | void;
+    /** Context object threaded into every `send` / `sendBatch` call. */
+    ctx?: Ctx;
+};
+/**
+ * Build a reactive sink with retry / buffering / backpressure / observability
+ * companions. Every Wave 5 `to*` adapter is a thin config wrapper around
+ * this factory.
+ *
+ * **Modes:**
+ * - `send` only, no batching knobs → **per-record write-through**
+ * - `send` + `batchSize` or `flushIntervalMs` → **per-record buffered**
+ *   (buffer drains via repeated `send` calls — one-by-one in order)
+ * - `sendBatch` → **batched** (whole chunks handed to the transport)
+ *
+ * @category extra
+ */
+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;
@@ -177,7 +493,7 @@ type RetryOptions = {
  * import { ERROR, NS_PER_SEC, pipe, producer, retry, constant } from "@graphrefly/graphrefly-ts";
  *
  * const src = producer(
- *   (_d, a) => {
+ *   (a) => {
  *     a.down([[ERROR, new Error("x")]]);
  *   },
  *   { resubscribable: true },
@@ -188,6 +504,45 @@ type RetryOptions = {
  * @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.
@@ -302,48 +657,52 @@ interface TokenBucket {
  * @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;
+};
 /**
- * Same behavior as {@link tokenBucket}. Exposed for naming parity with graphrefly-py (`token_tracker`).
- *
- * @param capacity - Maximum tokens (must be positive).
- * @param refillPerSecond - Tokens added per elapsed second (non-negative).
- * @returns A {@link TokenBucket} instance.
- *
- * @example
- * ```ts
- * import { tokenTracker } from "@graphrefly/graphrefly-ts";
- *
- * const tracker = tokenTracker(100, 10); // 100-token capacity, 10/sec refill
- * tracker.tryConsume(5); // true
- * ```
+ * Thrown by {@link rateLimiter} when `onOverflow: "error"` and the pending buffer is full.
  *
  * @category extra
  */
-declare function tokenTracker(capacity: number, refillPerSecond: number): TokenBucket;
+declare class RateLimiterOverflowError extends Error {
+    name: string;
+    constructor(maxBuffer: number);
+}
 /**
- * Enforces a sliding window: at most `maxEvents` `DATA` values per `windowNs`.
+ * 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 maxEvents - Maximum `DATA` emissions per window (must be positive).
- * @param windowNs - Window length in nanoseconds (must be positive).
- * @returns Node that queues excess values FIFO until a slot frees.
+ * @param opts - Rate + optional bounded-buffer configuration.
+ * @returns Node that emits DATA at most `maxEvents` per `windowNs`.
  *
  * @remarks
- * **Terminal:** `COMPLETE` / `ERROR` cancel timers, drop pending queue, and clear window state.
+ * **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
- * const limited = rateLimiter(src, 5, NS_PER_SEC);
- * limited.subscribe((msgs) => console.log(msgs));
+ * // 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>, maxEvents: number, windowNs: number): Node<T>;
+declare function rateLimiter<T>(source: Node<T>, opts: RateLimiterOptions): Node<T>;
 type StatusValue = "pending" | "active" | "completed" | "errored";
 type WithStatusBundle<T> = {
     node: Node<T>;
@@ -385,17 +744,27 @@ 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`, emit a fallback value instead of propagating the error.
+ * 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})
  *
- * If `fb` is a plain value, emits `[[DATA, fb], [COMPLETE]]` on error.
- * If `fb` is a `Node`, switches to that node's stream on error (all further messages
- * from the fallback node are forwarded).
+ * 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"))`.
+ * Composes naturally with {@link retry}:
+ * `pipe(source, retry({count:3}), fallback("default"))`.
  *
  * @param source - Upstream node.
- * @param fb - Fallback value or fallback node to switch to on error.
+ * @param fb - Fallback value, node, promise, or async iterable.
  * @returns Node that replaces errors with the fallback.
  *
  * @example
@@ -403,12 +772,12 @@ declare class TimeoutError extends Error {
  * import { fallback, throwError } from "@graphrefly/graphrefly-ts";
  *
  * const safe = fallback(throwError(new Error("boom")), "default");
- * safe.get(); // "default" after subscribe
+ * safe.cache; // "default" after subscribe
  * ```
  *
  * @category extra
  */
-declare function fallback<T>(source: Node<T>, fb: T | Node<T>): Node<T>;
+declare function fallback<T>(source: Node<T>, fb: FallbackInput<T>): Node<T>;
 /**
  * Emits `ERROR` with {@link TimeoutError} if no `DATA` arrives within the deadline.
  *
@@ -430,29 +799,6 @@ declare function fallback<T>(source: Node<T>, fb: T | Node<T>): Node<T>;
  * @category extra
  */
 declare function timeout<T>(source: Node<T>, timeoutNs: number): Node<T>;
-/**
- * Memoize the last `DATA` value with a TTL. On resubscription (or new subscriber),
- * if a cached value exists within `ttlNs`, emit it immediately then forward live
- * upstream messages.
- *
- * Stale-while-revalidate pattern: subscribers always get the cached value first
- * (if within TTL), then see live updates as they arrive.
- *
- * @param source - Upstream node.
- * @param ttlNs - Time-to-live in nanoseconds.
- * @returns Node with TTL-based caching.
- *
- * @example
- * ```ts
- * import { cache, state, NS_PER_SEC } from "@graphrefly/graphrefly-ts";
- *
- * const src = state(42);
- * const c = cache(src, 10 * NS_PER_SEC);
- * ```
- *
- * @category extra
- */
-declare function cache<T>(source: Node<T>, ttlNs: number): Node<T>;
 
 /**
  * Core reactive sources, sinks, and utilities (roadmap §2.3).
@@ -464,7 +810,7 @@ declare function cache<T>(source: Node<T>, ttlNs: number): Node<T>;
  * live in {@link ./adapters.ts}.
  */
 
-type ExtraOpts$2 = Omit<NodeOptions, "describeKind">;
+type ExtraOpts$2 = Omit<NodeOptions<unknown>, "describeKind">;
 /** Options for {@link fromTimer} / {@link fromPromise} / {@link fromAsyncIter}. */
 type AsyncSourceOpts = ExtraOpts$2 & {
     signal?: AbortSignal;
@@ -747,7 +1093,7 @@ declare function forEach<T>(source: Node<T>, fn: (value: T) => void, opts?: Extr
  * Buffers every `DATA`; on upstream `COMPLETE` emits one `DATA` with the full array then `COMPLETE`.
  *
  * @param source - Upstream node.
- * @param opts - Optional node options (operator describe kind).
+ * @param opts - Optional node options (derived describe kind).
  * @returns `Node<T[]>` — single array emission before completion.
  *
  * @example
@@ -764,7 +1110,7 @@ declare function toArray<T>(source: Node<T>, opts?: ExtraOpts$2): Node<T[]>;
  * Multicasts upstream: one subscription to `source` while this wrapper has subscribers (via {@link producer}).
  *
  * @param source - Upstream node to share.
- * @param opts - Producer options; `initial` seeds from `source.get()` when set by factory.
+ * @param opts - Producer options; `initial` seeds from `source.cache` when set by factory.
  * @returns `Node<T>` — hot ref-counted bridge.
  *
  * @example
@@ -818,7 +1164,7 @@ declare function cached<T>(source: Node<T>, opts?: ExtraOpts$2): Node<T>;
  *
  * **Important:** This subscribes and waits for a **future** emission. Data that
  * has already flowed is gone and will not be seen. Call this *before* the upstream
- * emits, or use `source.get()` / `source.status` for already-cached state.
+ * emits, or use `source.cache` / `source.status` for already-cached state.
  * See COMPOSITION-GUIDE §2 (subscription ordering).
  *
  * @param source - Node to read once.
@@ -843,7 +1189,7 @@ declare function firstValueFrom<T>(source: Node<T>): Promise<T>;
  *
  * **Important:** This only captures **future** emissions — data that has
  * already flowed through the node is gone. Call this *before* the upstream
- * emits. For already-cached values, use `source.get()` / `source.status`.
+ * emits. For already-cached values, use `source.cache` / `source.status`.
  * See COMPOSITION-GUIDE §2 (subscription ordering).
  *
  * ```ts
@@ -876,7 +1222,7 @@ declare const shareReplay: typeof replay;
  *
  * Derived/effect nodes are lazy — they don't compute until at least one
  * subscriber exists (COMPOSITION-GUIDE §5). `keepalive` subscribes with an
- * empty sink so the node stays wired for `.get()` and upstream propagation.
+ * empty sink so the node stays wired for `.cache` and upstream propagation.
  *
  * Returns the unsubscribe handle. Common usage:
  * `graph.addDisposer(keepalive(node))`.
@@ -929,12 +1275,6 @@ declare function reactiveCounter(cap: number): ReactiveCounterBundle;
  * fromRabbitMQ/toRabbitMQ.
  */
 
-/** Structured callback for sink transport failures (Kafka, Redis, etc.). */
-type SinkTransportError = {
-    stage: "serialize" | "send" | "routing_key";
-    error: Error;
-    value: unknown;
-};
 /** Handle returned by per-record and buffered sinks. */
 type SinkHandle = {
     /** Stop the sink (unsubscribe from source). */
@@ -972,15 +1312,8 @@ declare function fromWebSocket<T = unknown>(register: WebSocketRegister<T>, opts
     parse?: (payload: unknown, event: unknown) => T;
     closeOnTeardown?: boolean;
 }): Node<T>;
-/** Registration callback for {@link fromWebhook}. */
-type WebhookRegister<T> = (handlers: {
-    /** Push one webhook payload downstream as `[[DATA, payload]]`. */
-    emit: (payload: T) => void;
-    /** Push terminal error as `[[ERROR, err]]`. */
-    error: (err: unknown) => void;
-    /** Push terminal completion as `[[COMPLETE]]`. */
-    complete: () => void;
-}) => (() => void) | undefined;
+/** Registration callback for {@link fromWebhook}. Alias of {@link ExternalRegister} over {@link EmitTriad}. */
+type WebhookRegister<T> = ExternalRegister<EmitTriad<T>>;
 /**
  * Bridges HTTP webhook callbacks into a GraphReFly source.
  *
@@ -1058,6 +1391,19 @@ interface FromHTTPOptions extends AsyncSourceOpts {
     transform?: (response: Response) => any | Promise<any>;
     /** Request timeout in **nanoseconds**. Default: `30s` (30 * NS_PER_SEC). */
     timeoutNs?: number;
+    /**
+     * When `true`, emit `COMPLETE` after the first successful fetch. Useful for
+     * one-shot semantics where downstream wants to know "no more values ever."
+     * Default: `false` — the node stays live and replays cached DATA to late
+     * subscribers via push-on-subscribe (spec §2.2).
+     */
+    completeAfterFetch?: boolean;
+    /**
+     * When `true`, trigger a fresh fetch on each new subscriber instead of
+     * sharing one cached result. Default: `false` — one shared fetch whose
+     * result is cached and replayed to every subscriber.
+     */
+    refetchOnSubscribe?: boolean;
 }
 /**
  * Result of {@link fromHTTP}: main source plus status, error, and fetch count companions.
@@ -1069,6 +1415,14 @@ type HTTPBundle<T> = WithStatusBundle<T> & {
     fetchCount: Node<number>;
     /** Nanosecond wall-clock timestamp of the last successful fetch. */
     lastUpdated: Node<number>;
+    /**
+     * `true` after at least one successful fetch; stays `true` across
+     * resubscribes. Orthogonal to {@link withStatus}'s `active`/`completed`
+     * lifecycle — use this as the "fetch done" signal under the default
+     * (cached, stays-live) behavior where `withStatus` never transitions to
+     * `"completed"` unless `completeAfterFetch: true` is set.
+     */
+    fetched: Node<boolean>;
 };
 /**
  * Creates a one-shot fetch-based HTTP source with lifecycle tracking.
@@ -1076,6 +1430,46 @@ type HTTPBundle<T> = WithStatusBundle<T> & {
  * @category extra
  */
 declare function fromHTTP<T = any>(url: string, opts?: FromHTTPOptions): HTTPBundle<T>;
+/** Options for {@link toHTTP}. */
+type ToHTTPOptions<T> = ExtraOpts$1 & {
+    /** HTTP method. Default: `"POST"`. */
+    method?: string;
+    /** Request headers applied to every call. Caller sets Content-Type. */
+    headers?: Record<string, string>;
+    /** Serialize a value to a request body. Default: `JSON.stringify`. */
+    serialize?: (value: T) => string | Uint8Array;
+    /** Optional request timeout in nanoseconds. */
+    timeoutNs?: number;
+    /**
+     * Format used when `batchSize` / `flushIntervalMs` is set:
+     * - `"json-array"` — body is `JSON.stringify(batch)`
+     * - `"ndjson"` — body is newline-delimited JSON.
+     * Default: `"json-array"`.
+     */
+    batchFormat?: "json-array" | "ndjson";
+    /** Batch size before auto-flush (buffered mode). */
+    batchSize?: number;
+    /** Flush interval in ms (buffered mode). */
+    flushIntervalMs?: number;
+    /** Retry configuration — same shape as {@link ReactiveSinkRetryOptions}. */
+    retry?: Parameters<typeof reactiveSink<T>>[1]["retry"];
+    onTransportError?: (err: SinkTransportError) => void;
+};
+/**
+ * HTTP sink — forwards upstream `DATA` values as HTTP requests.
+ *
+ * Per-record mode (default, no batching knobs): one request per DATA.
+ * Buffered mode (`batchSize` / `flushIntervalMs`): one request per chunk,
+ * body is JSON-array or NDJSON depending on `batchFormat`.
+ *
+ * @param source - Upstream node.
+ * @param url - Request URL.
+ * @param opts - Serialization, batching, retry options.
+ * @returns {@link ReactiveSinkHandle}.
+ *
+ * @category extra
+ */
+declare function toHTTP<T>(source: Node<T>, url: string, opts?: ToHTTPOptions<T>): ReactiveSinkHandle<T>;
 /** Options for {@link toSSE}. */
 type ToSSEOptions = {
     /** Custom payload serializer for non-string payloads. Default: `JSON.stringify` fallback to `String(value)`. */
@@ -1103,6 +1497,83 @@ type ToSSEOptions = {
  * @category extra
  */
 declare function toSSE<T>(source: Node<T>, opts?: ToSSEOptions): ReadableStream<Uint8Array>;
+/**
+ * Composable variant of {@link toSSE} — emits encoded SSE frames as
+ * `Uint8Array` through a reactive `Node`. Use this when you want to pipe SSE
+ * bytes through the reactive graph (persist to file, tee to multiple streams,
+ * etc.). Wrap with {@link toReadableStream} to expose a `ReadableStream` for
+ * `new Response(...)` use cases.
+ *
+ * @category extra
+ */
+declare function toSSEBytes<T>(source: Node<T>, opts?: ToSSEOptions): Node<Uint8Array>;
+/**
+ * Converts a `Node<Uint8Array>` into a WHATWG `ReadableStream<Uint8Array>`.
+ * Useful for composing with `new Response(...)` / `fetch` bodies.
+ *
+ * @category extra
+ */
+declare function toReadableStream(bytes: Node<Uint8Array>): ReadableStream<Uint8Array>;
+/** Parsed Server-Sent Event. */
+type SSEEvent<T = string> = {
+    event: string;
+    data: T;
+    id?: string;
+    retry?: number;
+};
+/** Options for {@link fromSSE}. */
+type FromSSEOptions<T = string> = ExtraOpts$1 & {
+    /** Parse the raw `data:` payload. Default: identity (string). */
+    parse?: (raw: string) => T;
+};
+/**
+ * Parses a Server-Sent Events stream into structured `{event, data, id}` records.
+ *
+ * @param source - SSE byte source (`ReadableStream`, `Response`, or `AsyncIterable<Uint8Array>`).
+ * @param opts - Parse function and node options.
+ * @returns `Node<SSEEvent<T>>` — one `DATA` per SSE event; `COMPLETE` on stream end.
+ *
+ * @category extra
+ */
+declare function fromSSE<T = string>(source: ReadableStream<Uint8Array> | Response | AsyncIterable<Uint8Array>, opts?: FromSSEOptions<T>): Node<SSEEvent<T>>;
+/** Options for {@link fromHTTPStream}. */
+type FromHTTPStreamOptions = ExtraOpts$1 & {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    signal?: AbortSignal;
+};
+/**
+ * Streaming HTTP source — emits each chunk from the response body as a
+ * `Uint8Array` `DATA`. `COMPLETE` when the stream ends; `ERROR` on non-ok
+ * response or fetch failure.
+ *
+ * Useful for ingesting server-push APIs (LLM streaming, SSE endpoints — pair
+ * with {@link fromSSE}, NDJSON endpoints — pair with {@link fromNDJSON}).
+ *
+ * @category extra
+ */
+declare function fromHTTPStream(url: string, opts?: FromHTTPStreamOptions): Node<Uint8Array>;
+/** Options for {@link fromHTTPPoll}. */
+type FromHTTPPollOptions = FromHTTPOptions & {
+    /** Poll interval in milliseconds. Default: `5000`. */
+    intervalMs?: number;
+};
+/**
+ * Repeatedly-fetching HTTP source — a reactive composition of
+ * {@link fromTimer} + {@link switchMap} + {@link fromHTTP} that fetches on an
+ * interval and emits the latest response. Previous in-flight fetches are
+ * cancelled when a new tick arrives (switch semantics).
+ *
+ * @example
+ * ```ts
+ * import { fromHTTPPoll } from "@graphrefly/graphrefly-ts";
+ * const health$ = fromHTTPPoll<{ ok: boolean }>("https://example.com/health", { intervalMs: 10_000 });
+ * ```
+ *
+ * @category extra
+ */
+declare function fromHTTPPoll<T = unknown>(url: string, opts?: FromHTTPPollOptions): Node<T>;
 /** Options for {@link toWebSocket}. */
 type ToWebSocketOptions<T> = {
     /** Serialize DATA payloads before `socket.send(...)`. */
@@ -1115,20 +1586,61 @@ type ToWebSocketOptions<T> = {
     closeCode?: number;
     /** Optional close reason used when close is triggered by terminal tuples. */
     closeReason?: string;
-    /** Structured callback for serialize/send/close transport failures. */
-    onTransportError?: (event: ToWebSocketTransportError) => void;
-};
-type ToWebSocketTransportError = {
-    stage: "serialize" | "send" | "close";
-    error: Error;
-    message: Message | undefined;
+    /** Structured callback — uses the unified {@link SinkTransportError} shape. */
+    onTransportError?: (event: SinkTransportError) => void;
+    /** Retry configuration — passed through to {@link reactiveSink}. */
+    retry?: ReactiveSinkHandle<T> extends infer _ ? Parameters<typeof reactiveSink<T>>[1]["retry"] : never;
+    /** Backpressure configuration — passed through to {@link reactiveSink}. */
+    backpressure?: Parameters<typeof reactiveSink<T>>[1]["backpressure"];
+    /** Reactive stop signal — when it emits any DATA / terminal, the sink tears down. */
+    stopOn?: Node<unknown>;
 };
 /**
  * Forwards upstream `DATA` payloads to a WebSocket via `send`.
  *
+ * Returns a {@link ReactiveSinkHandle} — every transport outcome (including
+ * socket `close` events) surfaces on the `errors` / `failed` / `sent` /
+ * `inFlight` companions.
+ *
  * @category extra
  */
-declare function toWebSocket<T>(source: Node<T>, socket: WebSocketLike, opts?: ToWebSocketOptions<T>): () => void;
+declare function toWebSocket<T>(source: Node<T>, socket: WebSocketLike, opts?: ToWebSocketOptions<T>): ReactiveSinkHandle<T>;
+/** Options for {@link fromWebSocketReconnect}. */
+type FromWebSocketReconnectOptions<T> = ExtraOpts$1 & {
+    /** Optional parser applied to incoming messages. */
+    parse?: (payload: unknown, event: unknown) => T;
+    /** Max reconnect attempts. Default: `Infinity` (implied when `backoff` is set). */
+    maxRetries?: number;
+    /** Backoff strategy (ns) or preset name. Default: `"exponential"`. */
+    backoff?: Parameters<typeof retrySource>[1] extends infer O ? O extends {
+        backoff?: infer B;
+    } ? B : never : never;
+    /** Close the socket on teardown. Default: `true`. */
+    closeOnTeardown?: boolean;
+};
+/**
+ * Reconnecting WebSocket source — each connection attempt calls `factory` to
+ * obtain a fresh {@link WebSocketLike}; on `close` (treated as terminal
+ * `COMPLETE`), {@link retrySource} rebuilds the inner source and reconnects.
+ *
+ * For transient errors, {@link retrySource} retries with the configured
+ * backoff. On `maxRetries` exhaustion, terminal `ERROR` propagates.
+ *
+ * @param factory - Invoked per reconnect to create a fresh WebSocket.
+ * @param opts - Parse, retry, and close options.
+ *
+ * @example
+ * ```ts
+ * import { fromWebSocketReconnect } from "@graphrefly/graphrefly-ts";
+ * const ws$ = fromWebSocketReconnect(
+ *   () => new WebSocket("wss://example/stream"),
+ *   { backoff: "exponential", maxRetries: 10 },
+ * );
+ * ```
+ *
+ * @category extra
+ */
+declare function fromWebSocketReconnect<T = unknown>(factory: () => WebSocketLike, opts?: FromWebSocketReconnectOptions<T>): Node<T>;
 /**
  * Duck-typed MCP (Model Context Protocol) client — only the notification
  * registration surface is required so callers are not coupled to a specific SDK.
@@ -1164,6 +1676,13 @@ type FromGitHookOptions = ExtraOpts$1 & {
     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.
@@ -1171,11 +1690,58 @@ type FromGitHookOptions = ExtraOpts$1 & {
  * @category extra
  */
 declare function fromGitHook(repoPath: string, opts?: FromGitHookOptions): Node<GitEvent>;
-/** Standard handler triple for adapters that accept injected registrations. */
-type AdapterHandlers<T> = {
-    emit: (payload: T) => void;
-    error: (err: unknown) => void;
-    complete: () => void;
+/** Standard handler triple for adapters that accept injected registrations. Alias of {@link EmitTriad}. */
+type AdapterHandlers<T> = EmitTriad<T>;
+/**
+ * Message envelope emitted by queue consumers when `autoAck: false`. The
+ * caller is responsible for calling `ack()` after successful processing or
+ * `nack()` to re-queue / dead-letter. Pairs cleanly with reactive pipelines:
+ *
+ * ```ts
+ * const messages$ = fromPulsar(consumer, { autoAck: false });
+ * effect([messages$], ([m]) => {
+ *   try {
+ *     process(m.value);
+ *     m.ack();
+ *   } catch (err) {
+ *     m.nack({ requeue: true });
+ *   }
+ * });
+ * ```
+ *
+ * Ack/nack are imperative callbacks (§5.10 boundary) because the underlying
+ * SDKs expose them as such. Reactive-all-the-way ack flows can be built by
+ * piping `msg.ack` calls into a `reactiveSink` if desired.
+ *
+ * **Caller contract — must settle every emitted message.** The envelope holds
+ * a closure reference to the raw SDK message; unsettled envelopes keep the
+ * broker's in-flight window full and leak memory proportional to consumer
+ * throughput. Patterns that drop messages (filter, take-first, switchMap
+ * discard) must explicitly `nack({ requeue: true })` the discarded ones, or
+ * wrap the source to force-settle on teardown.
+ *
+ * **Ack/nack transport failures.** Both methods route exceptions through
+ * the source's `onAckError` option (when provided) — SDK rejections from
+ * `acknowledge()`/`negativeAcknowledge()` don't escape as unhandled
+ * rejections. Default (no `onAckError`): swallow. The broker handles
+ * redelivery on its own timeline.
+ *
+ * @category extra
+ */
+type AckableMessage<T> = {
+    /** The wrapped message body. */
+    value: T;
+    /** Acknowledge successful processing. Safe to call more than once — idempotent. */
+    ack(): void;
+    /**
+     * Negative-acknowledge — signals the broker the message was not processed
+     * successfully. `requeue: true` asks the broker to redeliver; `requeue: false`
+     * may route to a dead-letter queue (SDK-specific). Omit `requeue` to
+     * defer to the SDK's own default.
+     */
+    nack(opts?: {
+        requeue?: boolean;
+    }): void;
 };
 /** Structured OTel span. */
 type OTelSpan = {
@@ -1227,6 +1793,8 @@ type OTelBundle = {
     traces: Node<OTelSpan>;
     metrics: Node<OTelMetric>;
     logs: Node<OTelLog>;
+    /** Unconditional teardown — calls the registrar's cleanup and fires COMPLETE on every channel. */
+    dispose(): void;
 };
 /**
  * OTLP/HTTP receiver — accepts traces, metrics, and logs as separate reactive nodes.
@@ -1270,8 +1838,8 @@ type SyslogMessage = {
     message: string;
     timestampNs: number;
 };
-/** Registration callback for syslog receiver. */
-type SyslogRegister = (handlers: AdapterHandlers<SyslogMessage>) => (() => void) | undefined;
+/** Registration callback for syslog receiver. Alias of {@link ExternalRegister} over {@link EmitTriad}. */
+type SyslogRegister = ExternalRegister<EmitTriad<SyslogMessage>>;
 /** Options for {@link fromSyslog}. */
 type FromSyslogOptions = ExtraOpts$1 & {};
 /**
@@ -1320,8 +1888,8 @@ type StatsDMetric = {
     tags: Record<string, string>;
     timestampNs: number;
 };
-/** Registration callback for StatsD receiver. */
-type StatsDRegister = (handlers: AdapterHandlers<StatsDMetric>) => (() => void) | undefined;
+/** Registration callback for StatsD receiver. Alias of {@link ExternalRegister} over {@link EmitTriad}. */
+type StatsDRegister = ExternalRegister<EmitTriad<StatsDMetric>>;
 /** Options for {@link fromStatsD}. */
 type FromStatsDOptions = ExtraOpts$1 & {};
 /**
@@ -1383,6 +1951,12 @@ type FromPrometheusOptions = AsyncSourceOpts & {
     headers?: Record<string, string>;
     /** Request timeout in nanoseconds. Default `10 * NS_PER_SEC` (10s). */
     timeoutNs?: number;
+    /**
+     * Maximum consecutive scrape errors before terminating the source. Prevents
+     * error storms when the endpoint is down. Default: `1` (terminate on first error — preserves pre-switchMap back-compat). Raise it (or set `Infinity`)
+     * to keep retrying indefinitely.
+     */
+    maxConsecutiveErrors?: number;
 };
 /**
  * Scrapes a Prometheus `/metrics` endpoint on a reactive timer interval.
@@ -1507,7 +2081,7 @@ type ToKafkaOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toKafka<T>(source: Node<T>, kafkaProducer: KafkaProducerLike, topic: string, opts?: ToKafkaOptions<T>): SinkHandle;
+declare function toKafka<T>(source: Node<T>, kafkaProducer: KafkaProducerLike, topic: string, opts?: ToKafkaOptions<T>): ReactiveSinkHandle<T>;
 /** Duck-typed Redis client (compatible with ioredis, redis). */
 type RedisClientLike = {
     xadd(key: string, id: string, ...fieldsAndValues: string[]): Promise<string>;
@@ -1573,7 +2147,7 @@ type ToRedisStreamOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toRedisStream<T>(source: Node<T>, client: RedisClientLike, key: string, opts?: ToRedisStreamOptions<T>): SinkHandle;
+declare function toRedisStream<T>(source: Node<T>, client: RedisClientLike, key: string, opts?: ToRedisStreamOptions<T>): ReactiveSinkHandle<T>;
 /** Parsed CSV row. */
 type CSVRow = Record<string, string>;
 /** Options for {@link fromCSV}. */
@@ -1608,6 +2182,33 @@ type FromCSVOptions = ExtraOpts$1 & {
  * @category extra
  */
 declare function fromCSV(source: AsyncIterable<string>, opts?: FromCSVOptions): Node<CSVRow>;
+/**
+ * Stateful CSV parser operator — takes a `Node<string>` emitting raw text
+ * chunks (from any source: {@link fromAsyncIter}, {@link fromHTTPStream},
+ * WebSocket, file watcher, etc.) and emits one `DATA` per parsed row.
+ *
+ * Buffers incomplete lines across chunks. Mirrors {@link fromCSV}'s parsing
+ * logic without committing to an async-iterable-only input.
+ *
+ * @example
+ * ```ts
+ * import { fromHTTPStream, csvRows } from "@graphrefly/graphrefly-ts";
+ * const bytes$ = fromHTTPStream("https://example.com/data.csv");
+ * const text$ = decodeText(bytes$);   // caller-provided byte→string decoder
+ * const rows$ = csvRows(text$, { columns: ["name", "age"] });
+ * ```
+ *
+ * @category extra
+ */
+declare function csvRows(source: Node<string>, opts?: FromCSVOptions): Node<CSVRow>;
+/**
+ * Stateful NDJSON parser operator — takes a `Node<string>` of raw text chunks
+ * and emits one `DATA` per parsed JSON object. Buffers partial lines across
+ * chunks.
+ *
+ * @category extra
+ */
+declare function ndjsonRows<T = unknown>(source: Node<string>, opts?: ExtraOpts$1): Node<T>;
 /** Options for {@link fromNDJSON}. */
 type FromNDJSONOptions = ExtraOpts$1 & {};
 /**
@@ -1648,6 +2249,12 @@ type FromClickHouseWatchOptions = AsyncSourceOpts & {
     intervalNs?: number;
     /** JSON format to request. Default: `"JSONEachRow"`. */
     format?: string;
+    /**
+     * Maximum consecutive query errors before terminating the source. Prevents
+     * error storms when the database is unavailable. Default: `5`. Set to
+     * `Infinity` to keep retrying indefinitely.
+     */
+    maxConsecutiveErrors?: number;
 };
 /**
  * ClickHouse live materialized view as a reactive source.
@@ -1714,6 +2321,13 @@ type FromPulsarOptions = ExtraOpts$1 & {
     deserialize?: (data: Buffer) => unknown;
     /** Acknowledge messages automatically. Default: `true`. */
     autoAck?: boolean;
+    /**
+     * Routes ack/nack transport failures to the caller. Covers:
+     * - `autoAck: true` — post-emit `acknowledge()` promise rejections.
+     * - `autoAck: false` — envelope `ack()` / `nack()` promise rejections.
+     * Default: swallow (SDK handles redelivery on its own).
+     */
+    onAckError?: (err: Error) => void;
 };
 /**
  * Apache Pulsar consumer as a reactive source (native client).
@@ -1742,7 +2356,12 @@ type FromPulsarOptions = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function fromPulsar<T = unknown>(consumer: PulsarConsumerLike, opts?: FromPulsarOptions): Node<PulsarMessage<T>>;
+declare function fromPulsar<T = unknown>(consumer: PulsarConsumerLike, opts?: FromPulsarOptions & {
+    autoAck?: true;
+}): Node<PulsarMessage<T>>;
+declare function fromPulsar<T = unknown>(consumer: PulsarConsumerLike, opts: FromPulsarOptions & {
+    autoAck: false;
+}): Node<AckableMessage<PulsarMessage<T>>>;
 /** Options for {@link toPulsar}. */
 type ToPulsarOptions<T> = ExtraOpts$1 & {
     /** Serialize value for Pulsar. Default: `JSON.stringify` → Buffer. */
@@ -1764,7 +2383,7 @@ type ToPulsarOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toPulsar<T>(source: Node<T>, pulsarProducer: PulsarProducerLike, opts?: ToPulsarOptions<T>): SinkHandle;
+declare function toPulsar<T>(source: Node<T>, pulsarProducer: PulsarProducerLike, opts?: ToPulsarOptions<T>): ReactiveSinkHandle<T>;
 /** Duck-typed NATS subscription (compatible with nats.js). */
 type NATSSubscriptionLike = AsyncIterable<{
     subject: string;
@@ -1848,7 +2467,7 @@ type ToNATSOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toNATS<T>(source: Node<T>, client: NATSClientLike, subject: string, opts?: ToNATSOptions<T>): SinkHandle;
+declare function toNATS<T>(source: Node<T>, client: NATSClientLike, subject: string, opts?: ToNATSOptions<T>): ReactiveSinkHandle<T>;
 /** Duck-typed RabbitMQ channel (compatible with amqplib). */
 type RabbitMQChannelLike = {
     consume(queue: string, onMessage: (msg: {
@@ -1887,6 +2506,11 @@ type FromRabbitMQOptions = ExtraOpts$1 & {
     deserialize?: (content: Buffer) => unknown;
     /** Auto-acknowledge messages. Default: `true`. */
     autoAck?: boolean;
+    /**
+     * Routes envelope ack/nack transport failures (including "SDK exposes no
+     * `nack` method") to the caller. Default: swallow.
+     */
+    onAckError?: (err: Error) => void;
 };
 /**
  * RabbitMQ consumer as a reactive source.
@@ -1919,7 +2543,12 @@ type FromRabbitMQOptions = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function fromRabbitMQ<T = unknown>(channel: RabbitMQChannelLike, queue: string, opts?: FromRabbitMQOptions): Node<RabbitMQMessage<T>>;
+declare function fromRabbitMQ<T = unknown>(channel: RabbitMQChannelLike, queue: string, opts?: FromRabbitMQOptions & {
+    autoAck?: true;
+}): Node<RabbitMQMessage<T>>;
+declare function fromRabbitMQ<T = unknown>(channel: RabbitMQChannelLike, queue: string, opts: FromRabbitMQOptions & {
+    autoAck: false;
+}): Node<AckableMessage<RabbitMQMessage<T>>>;
 /** Options for {@link toRabbitMQ}. */
 type ToRabbitMQOptions<T> = ExtraOpts$1 & {
     /** Serialize value for RabbitMQ. Default: `Buffer.from(JSON.stringify(value))`. */
@@ -1940,7 +2569,7 @@ type ToRabbitMQOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toRabbitMQ<T>(source: Node<T>, channel: RabbitMQChannelLike, exchange: string, opts?: ToRabbitMQOptions<T>): SinkHandle;
+declare function toRabbitMQ<T>(source: Node<T>, channel: RabbitMQChannelLike, exchange: string, opts?: ToRabbitMQOptions<T>): ReactiveSinkHandle<T>;
 /** Handle returned by buffered sinks. `flush()` drains remaining buffer. */
 type BufferedSinkHandle = SinkHandle & {
     /** Manually drain the internal buffer. */
@@ -1976,7 +2605,7 @@ type ToFileOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toFile<T>(source: Node<T>, writer: FileWriterLike, opts?: ToFileOptions<T>): BufferedSinkHandle;
+declare function toFile<T>(source: Node<T>, writer: FileWriterLike, opts?: ToFileOptions<T>): ReactiveSinkHandle<T>;
 /** Options for {@link toCSV}. */
 type ToCSVOptions<T> = ExtraOpts$1 & {
     /** Column names. Required — determines header row and field order. */
@@ -2003,7 +2632,7 @@ type ToCSVOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toCSV<T>(source: Node<T>, writer: FileWriterLike, opts: ToCSVOptions<T>): BufferedSinkHandle;
+declare function toCSV<T>(source: Node<T>, writer: FileWriterLike, opts: ToCSVOptions<T>): ReactiveSinkHandle<T>;
 /** Duck-typed ClickHouse client for batch inserts. */
 type ClickHouseInsertClientLike = {
     insert(params: {
@@ -2037,7 +2666,7 @@ type ToClickHouseOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toClickHouse<T>(source: Node<T>, client: ClickHouseInsertClientLike, table: string, opts?: ToClickHouseOptions<T>): BufferedSinkHandle;
+declare function toClickHouse<T>(source: Node<T>, client: ClickHouseInsertClientLike, table: string, opts?: ToClickHouseOptions<T>): ReactiveSinkHandle<T>;
 /** Duck-typed S3 client (compatible with AWS SDK v3 `S3Client.send(PutObjectCommand(...))`). */
 type S3ClientLike = {
     putObject(params: {
@@ -2072,7 +2701,7 @@ type ToS3Options<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toS3<T>(source: Node<T>, client: S3ClientLike, bucket: string, opts?: ToS3Options<T>): BufferedSinkHandle;
+declare function toS3<T>(source: Node<T>, client: S3ClientLike, bucket: string, opts?: ToS3Options<T>): ReactiveSinkHandle<T>;
 /** Duck-typed Postgres client (compatible with `pg.Client` / `pg.Pool`). */
 type PostgresClientLike = {
     query(sql: string, params?: unknown[]): Promise<unknown>;
@@ -2097,7 +2726,7 @@ type ToPostgresOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toPostgres<T>(source: Node<T>, client: PostgresClientLike, table: string, opts?: ToPostgresOptions<T>): SinkHandle;
+declare function toPostgres<T>(source: Node<T>, client: PostgresClientLike, table: string, opts?: ToPostgresOptions<T>): ReactiveSinkHandle<T>;
 /** Duck-typed MongoDB collection (compatible with `mongodb` driver). */
 type MongoCollectionLike = {
     insertOne(doc: unknown): Promise<unknown>;
@@ -2118,7 +2747,7 @@ type ToMongoOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toMongo<T>(source: Node<T>, collection: MongoCollectionLike, opts?: ToMongoOptions<T>): SinkHandle;
+declare function toMongo<T>(source: Node<T>, collection: MongoCollectionLike, opts?: ToMongoOptions<T>): ReactiveSinkHandle<T>;
 /** Loki log stream entry. */
 type LokiStream = {
     stream: Record<string, string>;
@@ -2150,7 +2779,7 @@ type ToLokiOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toLoki<T>(source: Node<T>, client: LokiClientLike, opts?: ToLokiOptions<T>): SinkHandle;
+declare function toLoki<T>(source: Node<T>, client: LokiClientLike, opts?: ToLokiOptions<T>): ReactiveSinkHandle<T>;
 /** Duck-typed Tempo span push client (OTLP/HTTP shape). */
 type TempoClientLike = {
     push(payload: {
@@ -2173,19 +2802,32 @@ type ToTempoOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toTempo<T>(source: Node<T>, client: TempoClientLike, opts?: ToTempoOptions<T>): SinkHandle;
+declare function toTempo<T>(source: Node<T>, client: TempoClientLike, opts?: ToTempoOptions<T>): ReactiveSinkHandle<T>;
 /** Options for {@link checkpointToS3}. */
 type CheckpointToS3Options = {
     /** S3 key prefix. Default: `"checkpoints/"`. */
     prefix?: string;
-    /** Debounce ms for autoCheckpoint. Default: `500`. */
+    /** Debounce ms on the S3 tier. Default: `500`. */
     debounceMs?: number;
     /** Full snapshot compaction interval. Default: `10`. */
     compactEvery?: number;
     onError?: (error: unknown) => void;
 };
+type StorageTierLike = {
+    load(key: string): unknown | Promise<unknown>;
+    save(key: string, data: unknown): void | Promise<void>;
+    clear?(key: string): void | Promise<void>;
+    debounceMs?: number;
+    compactEvery?: number;
+};
+type AttachStorageGraphLike = {
+    attachStorage: (tiers: readonly StorageTierLike[], opts?: unknown) => {
+        dispose(): void;
+    };
+    name: string;
+};
 /**
- * Wires `graph.autoCheckpoint()` to persist snapshots to S3.
+ * Wires `graph.attachStorage()` with an S3-backed tier.
  *
  * @param graph - Graph instance to checkpoint.
  * @param client - S3-compatible client with `putObject()`.
@@ -2195,14 +2837,7 @@ type CheckpointToS3Options = {
  *
  * @category extra
  */
-declare function checkpointToS3(graph: {
-    autoCheckpoint: (adapter: {
-        save(key: string, data: unknown): void;
-    }, opts?: unknown) => {
-        dispose(): void;
-    };
-    name: string;
-}, client: S3ClientLike, bucket: string, opts?: CheckpointToS3Options): {
+declare function checkpointToS3(graph: AttachStorageGraphLike, client: S3ClientLike, bucket: string, opts?: CheckpointToS3Options): {
     dispose(): void;
 };
 /** Duck-typed Redis client for checkpoint storage. */
@@ -2214,14 +2849,14 @@ type RedisCheckpointClientLike = {
 type CheckpointToRedisOptions = {
     /** Key prefix. Default: `"graphrefly:checkpoint:"`. */
     prefix?: string;
-    /** Debounce ms for autoCheckpoint. Default: `500`. */
+    /** Debounce ms on the Redis tier. Default: `500`. */
     debounceMs?: number;
     /** Full snapshot compaction interval. Default: `10`. */
     compactEvery?: number;
     onError?: (error: unknown) => void;
 };
 /**
- * Wires `graph.autoCheckpoint()` to persist snapshots to Redis.
+ * Wires `graph.attachStorage()` with a Redis-backed tier.
  *
  * @param graph - Graph instance to checkpoint.
  * @param client - Redis client with `set()`/`get()`.
@@ -2230,14 +2865,7 @@ type CheckpointToRedisOptions = {
  *
  * @category extra
  */
-declare function checkpointToRedis(graph: {
-    autoCheckpoint: (adapter: {
-        save(key: string, data: unknown): void;
-    }, opts?: unknown) => {
-        dispose(): void;
-    };
-    name: string;
-}, client: RedisCheckpointClientLike, opts?: CheckpointToRedisOptions): {
+declare function checkpointToRedis(graph: AttachStorageGraphLike, client: RedisCheckpointClientLike, opts?: CheckpointToRedisOptions): {
     dispose(): void;
 };
 /**
@@ -2261,14 +2889,16 @@ type FromSqliteOptions<T> = ExtraOpts$1 & {
 /**
  * One-shot SQLite query as a reactive source.
  *
- * Executes `query` synchronously via `db.query()`, emits one `DATA` per result
- * row, then `COMPLETE`. Compose with `switchMap` + `fromTimer` / `fromFSWatch`
- * for periodic or change-driven re-query.
+ * Executes `query` synchronously via `db.query()`, emits **one `DATA` containing
+ * the full result array**, then `COMPLETE`. Downstream flattens with
+ * `mergeAll` / a custom operator if per-row semantics are required — the
+ * array shape is the simpler default and matches how every SQL driver returns
+ * results natively. Use {@link fromSqliteCursor} for streaming row-by-row.
  *
  * @param db - SQLite database (caller owns connection).
  * @param query - SQL string to execute.
  * @param opts - Row mapper, params, and node options.
- * @returns `Node<T>` — one `DATA` per row, then `COMPLETE`.
+ * @returns `Node<T[]>` — one `DATA` with the full row array, then `COMPLETE`.
  *
  * @example
  * ```ts
@@ -2282,7 +2912,25 @@ type FromSqliteOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function fromSqlite<T = unknown>(db: SqliteDbLike, query: string, opts?: FromSqliteOptions<T>): Node<T>;
+declare function fromSqlite<T = unknown>(db: SqliteDbLike, query: string, opts?: FromSqliteOptions<T>): Node<T[]>;
+/**
+ * Duck-typed iterable-capable SQLite database — `iterate(sql, params)` returns
+ * a synchronous iterator over rows, avoiding the "all-rows-in-memory" cost of
+ * `db.query`. Compatible with `better-sqlite3`'s `.prepare().iterate()`.
+ *
+ * @category extra
+ */
+type SqliteIterableDbLike = {
+    iterate(sql: string, params?: unknown[]): Iterable<unknown>;
+};
+/**
+ * Cursor-streaming SQLite query — emits one `DATA` per row from a synchronous
+ * row iterator, then `COMPLETE`. Use when result sets are too large to
+ * materialize fully into an array.
+ *
+ * @category extra
+ */
+declare function fromSqliteCursor<T = unknown>(db: SqliteIterableDbLike, query: string, opts?: FromSqliteOptions<T>): Node<T>;
 /** Options for {@link toSqlite}. */
 type ToSqliteOptions<T> = ExtraOpts$1 & {
     /** Build SQL + params for an insert. Default: JSON insert into `(data)` column. */
@@ -2329,7 +2977,7 @@ type ToSqliteOptions<T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function toSqlite<T>(source: Node<T>, db: SqliteDbLike, table: string, opts?: ToSqliteOptions<T>): SinkHandle;
+declare function toSqlite<T>(source: Node<T>, db: SqliteDbLike, table: string, opts?: ToSqliteOptions<T>): ReactiveSinkHandle<T>;
 /**
  * Duck-typed Prisma model delegate.
  *
@@ -2369,7 +3017,7 @@ type FromPrismaOptions<T, U = T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function fromPrisma<T = unknown, U = T>(model: PrismaModelLike<T>, opts?: FromPrismaOptions<T, U>): Node<U>;
+declare function fromPrisma<T = unknown, U = T>(model: PrismaModelLike<T>, opts?: FromPrismaOptions<T, U>): Node<U[]>;
 /**
  * Duck-typed Drizzle query builder result.
  *
@@ -2406,7 +3054,7 @@ type FromDrizzleOptions<T, U = T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function fromDrizzle<T = unknown, U = T>(query: DrizzleQueryLike<T>, opts?: FromDrizzleOptions<T, U>): Node<U>;
+declare function fromDrizzle<T = unknown, U = T>(query: DrizzleQueryLike<T>, opts?: FromDrizzleOptions<T, U>): Node<U[]>;
 /**
  * Duck-typed Kysely query builder result.
  *
@@ -2442,7 +3090,7 @@ type FromKyselyOptions<T, U = T> = ExtraOpts$1 & {
  *
  * @category extra
  */
-declare function fromKysely<T = unknown, U = T>(query: KyselyQueryLike<T>, opts?: FromKyselyOptions<T, U>): Node<U>;
+declare function fromKysely<T = unknown, U = T>(query: KyselyQueryLike<T>, opts?: FromKyselyOptions<T, U>): Node<U[]>;
 
 /**
  * Watermark-based backpressure controller — reactive PAUSE/RESUME flow control.
@@ -2451,292 +3099,60 @@ declare function fromKysely<T = unknown, U = T>(query: KyselyQueryLike<T>, opts?
  * Each controller instance uses a unique lockId so multiple controllers
  * on the same upstream node do not collide.
  *
- * @module
- */
-
-type WatermarkOptions = {
-    /** Pending count at which PAUSE is sent upstream. */
-    highWaterMark: number;
-    /** Pending count at which RESUME is sent upstream (after being paused). */
-    lowWaterMark: number;
-};
-type WatermarkController = {
-    /** Call when a DATA message is buffered/enqueued. Returns `true` if PAUSE was just sent. */
-    onEnqueue(): boolean;
-    /** Call when a buffered item is consumed. Returns `true` if RESUME was just sent. */
-    onDequeue(): boolean;
-    /** Current un-consumed item count. */
-    readonly pending: number;
-    /** Whether upstream is currently paused by this controller. */
-    readonly paused: boolean;
-    /** Dispose: if paused, sends RESUME to unblock upstream. */
-    dispose(): void;
-};
-/**
- * Creates a watermark-based backpressure controller.
- *
- * @param sendUp - Callback that delivers messages upstream (typically `handle.up`).
- * @param opts - High/low watermark thresholds (item counts).
- * @returns A {@link WatermarkController}.
- *
- * @example
- * ```ts
- * const handle = graph.observe("fast-source");
- * const wm = createWatermarkController(
- *   (msgs) => handle.up(msgs),
- *   { highWaterMark: 64, lowWaterMark: 16 },
- * );
- *
- * // In sink callback:
- * handle.subscribe((msgs) => {
- *   for (const msg of msgs) {
- *     if (msg[0] === DATA) {
- *       buffer.push(msg[1]);
- *       wm.onEnqueue();
- *     }
- *   }
- * });
- *
- * // When consumer drains:
- * const item = buffer.shift();
- * wm.onDequeue();
- * ```
- *
- * @category extra
- */
-declare function createWatermarkController(sendUp: (messages: Messages) => void, opts: WatermarkOptions): WatermarkController;
-
-/**
- * Checkpoint adapters and {@link Graph} save/restore helpers (roadmap §3.1).
- */
-
-/**
- * Key-value persistence contract (roadmap §3.1 + §3.1c).
- *
- * Each adapter stores opaque JSON-serializable blobs under caller-provided string keys.
- * Used by {@link saveGraphCheckpoint}/{@link restoreGraphCheckpoint} (key = graph name),
- * {@link Graph.autoCheckpoint} (key = graph name), and {@link cascadingCache}/{@link tieredStorage}
- * (key = cache entry key).
- */
-interface CheckpointAdapter {
-    save(key: string, data: unknown): void;
-    load(key: string): unknown | null;
-    clear(key: string): void;
-}
-/**
- * In-memory adapter (process-local; useful for tests).
- *
- * @category extra
- */
-declare class MemoryCheckpointAdapter implements CheckpointAdapter {
-    #private;
-    save(key: string, data: unknown): void;
-    load(key: string): unknown | null;
-    clear(key: string): void;
-}
-/**
- * Stores JSON-cloned values under caller keys inside a caller-owned record (tests / embedding).
- *
- * @category extra
- */
-declare class DictCheckpointAdapter implements CheckpointAdapter {
-    #private;
-    constructor(storage: Record<string, unknown>);
-    save(key: string, data: unknown): void;
-    load(key: string): unknown | null;
-    clear(key: string): void;
-}
-/**
- * Atomic JSON file persistence (one file per key in a directory, temp + rename).
- *
- * @remarks
- * **Key mapping:** keys are sanitized to filesystem-safe names (`[^a-zA-Z0-9_-]` → `_`).
- * **Errors:** `load()` returns `null` for missing files, empty files, or invalid JSON (no throw).
- *
- * @category extra
- */
-declare class FileCheckpointAdapter implements CheckpointAdapter {
-    #private;
-    constructor(dir: string);
-    save(key: string, data: unknown): void;
-    load(key: string): unknown | null;
-    clear(key: string): void;
-}
-/**
- * Key-value persistence using Node.js `node:sqlite` ({@link DatabaseSync}).
- *
- * @remarks
- * **Runtime:** Requires Node 22.5+ with `node:sqlite` enabled (experimental in some releases). Call `close()` when discarding the adapter.
- *
- * @category extra
- */
-declare class SqliteCheckpointAdapter implements CheckpointAdapter {
-    #private;
-    constructor(path: string);
-    save(key: string, data: unknown): void;
-    load(key: string): unknown | null;
-    clear(key: string): void;
-    /** Close the underlying SQLite connection (safe to call more than once). */
-    close(): void;
-}
-/**
- * Writes {@link Graph.snapshot} through `adapter.save` using `graph.name` as key.
- *
- * @param graph - Target graph instance.
- * @param adapter - Sync key-value persistence backend.
- * @returns `void` — side-effect only; the snapshot is written to `adapter`.
- *
- * @example
- * ```ts
- * import { saveGraphCheckpoint, MemoryCheckpointAdapter, Graph } from "@graphrefly/graphrefly-ts";
- *
- * const g = new Graph("app");
- * const adapter = new MemoryCheckpointAdapter();
- * saveGraphCheckpoint(g, adapter);
- * ```
- *
- * @category extra
- */
-declare function saveGraphCheckpoint(graph: Graph, adapter: CheckpointAdapter): void;
-/**
- * Loads a snapshot via `adapter.load(graph.name)` and applies {@link Graph.restore} when data exists.
- *
- * @param graph - Graph whose topology matches the snapshot.
- * @param adapter - Sync key-value persistence backend.
- * @returns `true` if data was present and `restore` ran; `false` if `load()` returned `null`.
- *
- * @example
- * ```ts
- * import {
- *   saveGraphCheckpoint,
- *   restoreGraphCheckpoint,
- *   MemoryCheckpointAdapter,
- *   Graph,
- * } from "@graphrefly/graphrefly-ts";
- *
- * const g = new Graph("app");
- * const adapter = new MemoryCheckpointAdapter();
- * saveGraphCheckpoint(g, adapter);
- *
- * const g2 = new Graph("app");
- * restoreGraphCheckpoint(g2, adapter); // true
- * ```
- *
- * @category extra
- */
-declare function restoreGraphCheckpoint(graph: Graph, adapter: CheckpointAdapter): boolean;
-/**
- * Minimal JSON-shaped payload for a single node's cached value (custom adapters).
- *
- * @param n - Any {@link Node}.
- * @returns `{ version: 1, value }` from {@link Node.get}.
- *
- * @example
- * ```ts
- * import { checkpointNodeValue, state } from "@graphrefly/graphrefly-ts";
- *
- * const s = state(42);
- * checkpointNodeValue(s); // { version: 1, value: 42 }
- * ```
- *
- * @category extra
- */
-declare function checkpointNodeValue<T>(n: Node<T>): {
-    version: number;
-    value: T | undefined;
-};
-type IndexedDbCheckpointSpec = {
-    dbName: string;
-    storeName: string;
-    /** @default "graphrefly_checkpoint" */
-    key?: string;
-    version?: number;
-};
-/**
- * Wraps an `IDBRequest` as a one-shot reactive source.
- *
- * @param req - Request whose callbacks are converted to protocol messages.
- * @returns `Node<T>` that emits `DATA` once on success, then `COMPLETE`; emits `ERROR` on failure.
- *
- * @example
- * ```ts
- * import { fromIDBRequest } from "@graphrefly/graphrefly-ts";
- *
- * const req = indexedDB.open("myDb", 1);
- * fromIDBRequest(req).subscribe((msgs) => console.log(msgs));
- * // Emits [[DATA, IDBDatabase], [COMPLETE]] on success
- * ```
- *
- * @category extra
- */
-declare function fromIDBRequest<T>(req: IDBRequest<T>): Node<T>;
-/**
- * Wraps an `IDBTransaction` terminal lifecycle as a one-shot reactive source.
- *
- * @param tx - Transaction to observe.
- * @returns `Node<void>` that emits `DATA` (`undefined`) then `COMPLETE` on success; emits `ERROR` on `error`/`abort`.
- *
- * @example
- * ```ts
- * import { fromIDBTransaction } from "@graphrefly/graphrefly-ts";
- *
- * const db: IDBDatabase = ...; // obtained from indexedDB.open
- * const tx = db.transaction("store", "readwrite");
- * fromIDBTransaction(tx).subscribe((msgs) => console.log(msgs));
- * // Emits [[DATA, undefined], [COMPLETE]] when the transaction commits
- * ```
- *
- * @category extra
- */
-declare function fromIDBTransaction(tx: IDBTransaction): Node<void>;
-/**
- * Persists {@link Graph.snapshot} under `spec.key` (browser IndexedDB).
- *
- * @param graph - Graph to snapshot.
- * @param spec - Database name, object store name, optional `key` and schema `version`.
- * @returns A reactive `Node<void>` that emits `DATA` (`undefined`) then `COMPLETE` on success, or `ERROR` on failure.
- *
- * @remarks
- * **Environment:** Emits `ERROR` if `indexedDB` is undefined (e.g. Node without a polyfill).
- *
- * @example
- * ```ts
- * import { saveGraphCheckpointIndexedDb, Graph } from "@graphrefly/graphrefly-ts";
- *
- * const g = new Graph("app");
- * const save$ = saveGraphCheckpointIndexedDb(g, {
- *   dbName: "myApp",
- *   storeName: "checkpoints",
- * });
- * save$.subscribe((msgs) => console.log("saved:", msgs));
- * ```
- *
- * @category extra
+ * @module
  */
-declare function saveGraphCheckpointIndexedDb(graph: Graph, spec: IndexedDbCheckpointSpec): Node<void>;
+
+type WatermarkOptions = {
+    /** Pending count at which PAUSE is sent upstream. */
+    highWaterMark: number;
+    /** Pending count at which RESUME is sent upstream (after being paused). */
+    lowWaterMark: number;
+};
+type WatermarkController = {
+    /** Call when a DATA message is buffered/enqueued. Returns `true` if PAUSE was just sent. */
+    onEnqueue(): boolean;
+    /** Call when a buffered item is consumed. Returns `true` if RESUME was just sent. */
+    onDequeue(): boolean;
+    /** Current un-consumed item count. */
+    readonly pending: number;
+    /** Whether upstream is currently paused by this controller. */
+    readonly paused: boolean;
+    /** Dispose: if paused, sends RESUME to unblock upstream. */
+    dispose(): void;
+};
 /**
- * Loads a snapshot from IndexedDB and applies {@link Graph.restore} when present.
+ * Creates a watermark-based backpressure controller.
  *
- * @param graph - Graph whose topology matches the stored snapshot.
- * @param spec - Same `dbName` / `storeName` / `key` / `version` as save.
- * @returns A reactive `Node<boolean>`: emits `true` if a snapshot was restored, `false` if missing or not a plain object, then `COMPLETE`; or `ERROR` on I/O failure.
+ * @param sendUp - Callback that delivers messages upstream (typically `handle.up`).
+ * @param opts - High/low watermark thresholds (item counts).
+ * @returns A {@link WatermarkController}.
  *
  * @example
  * ```ts
- * import { restoreGraphCheckpointIndexedDb, Graph } from "@graphrefly/graphrefly-ts";
+ * const handle = graph.observe("fast-source");
+ * const wm = createWatermarkController(
+ *   (msgs) => handle.up(msgs),
+ *   { highWaterMark: 64, lowWaterMark: 16 },
+ * );
  *
- * const g = new Graph("app");
- * const restore$ = restoreGraphCheckpointIndexedDb(g, {
- *   dbName: "myApp",
- *   storeName: "checkpoints",
+ * // In sink callback:
+ * handle.subscribe((msgs) => {
+ *   for (const msg of msgs) {
+ *     if (msg[0] === DATA) {
+ *       buffer.push(msg[1]);
+ *       wm.onEnqueue();
+ *     }
+ *   }
  * });
- * restore$.subscribe((msgs) => console.log("restored:", msgs));
- * // Emits [[DATA, true], [COMPLETE]] if a snapshot was found and applied
+ *
+ * // When consumer drains:
+ * const item = buffer.shift();
+ * wm.onDequeue();
  * ```
  *
  * @category extra
  */
-declare function restoreGraphCheckpointIndexedDb(graph: Graph, spec: IndexedDbCheckpointSpec): Node<boolean>;
+declare function createWatermarkController(sendUp: (messages: Messages) => void, opts: WatermarkOptions): WatermarkController;
 
 /** Pluggable eviction policy for {@link cascadingCache}. */
 interface CacheEvictionPolicy<K> {
@@ -2754,15 +3170,6 @@ interface CacheEvictionPolicy<K> {
  * @category extra
  */
 declare function lru<K>(): CacheEvictionPolicy<K>;
-/** A single lookup/storage tier for {@link cascadingCache}. */
-interface CacheTier<V> {
-    /** Read a value. `undefined` / `null` = miss. */
-    load(key: string): V | undefined | null;
-    /** Write a value. Optional — tiers without save are read-only. */
-    save?(key: string, value: V): void;
-    /** Delete a value. Optional. */
-    clear?(key: string): void;
-}
 interface CascadingCacheOptions {
     /** Max entries before eviction. 0 = unlimited (default). */
     maxSize?: number;
@@ -2790,11 +3197,15 @@ interface CascadingCache<V> {
  *
  * Each cached entry is a `state()` node. On cache miss, tiers are tried in order
  * (index 0 = hottest/fastest). When a lower tier hits, the value is auto-promoted
- * to all faster tiers. Concurrent lookups for the same key share the same state
+ * to all faster tiers. Concurrent loads for the same key share the same state
  * instance — natural dedup.
  *
- * **Note:** `undefined` is the "not yet loaded" sentinel. Tiers that return
- * `undefined` or `null` are treated as misses.
+ * **Sync vs async tiers:** if `tier.load` returns a plain value, the cache node
+ * cache is populated synchronously (`c.load("k").cache` is readable immediately).
+ * If it returns a `Promise`, the node emits `DATA` when the promise resolves.
+ *
+ * **Miss sentinel:** `undefined` and `null` are both treated as misses — the
+ * cascade continues to the next tier.
  *
  * @param tiers - Ordered lookup tiers, hottest first.
  * @param opts - Optional configuration (maxSize, eviction policy, writeThrough).
@@ -2802,101 +3213,237 @@ interface CascadingCache<V> {
  *
  * @example
  * ```ts
- * import { cascadingCache } from "@graphrefly/graphrefly-ts";
+ * import { cascadingCache, memoryStorage, fileStorage } from "@graphrefly/graphrefly-ts";
  *
- * const cache = cascadingCache([
- *   { load: k => memMap.get(k), save: (k, v) => memMap.set(k, v) },
- *   { load: k => JSON.parse(fs.readFileSync(`cache/${k}`, "utf8")) },
- * ]);
+ * const cache = cascadingCache<User>([memoryStorage(), fileStorage("./cache")]);
  * const user = cache.load("user:42"); // Node<User | undefined>
  * user.subscribe(msgs => console.log(msgs));
  * ```
  *
  * @category extra
  */
-declare function cascadingCache<V>(tiers: CacheTier<V>[], opts?: CascadingCacheOptions): CascadingCache<V>;
-interface TieredStorageOptions {
-    /** Max entries before eviction. 0 = no limit (default). */
-    maxSize?: number;
-    /** Eviction policy. Default: LRU. Only used when maxSize > 0. */
-    eviction?: CacheEvictionPolicy<string>;
-}
-interface TieredStorage {
-    /** Get or create a singleton state node for this key. Cascades tiers on miss. */
-    load(key: string): Node<unknown | undefined>;
-    /** Write value to tier 0 (hottest) and update cache node in-place. */
-    save(key: string, value: unknown): void;
-    /** Re-cascade tiers into the existing cache node. */
-    invalidate(key: string): void;
-    /** Remove from all tiers and delete cache entry. */
-    delete(key: string): void;
-    /** Check if key exists in cache. */
-    has(key: string): boolean;
-    /** Number of cached entries. */
-    readonly size: number;
-    /** The underlying cascading cache (for advanced use). */
-    readonly cache: CascadingCache<unknown>;
-}
-/**
- * Creates a reactive tiered storage cache backed by {@link CheckpointAdapter}s.
- *
- * Each cached key is a `state()` node. On cache miss, adapters are tried in order
- * (index 0 = hottest). Hits auto-promote to faster adapters.
- *
- * @param adapters - Ordered `CheckpointAdapter`s, hottest first.
- * @param opts - Optional configuration (maxSize, eviction policy).
- * @returns A reactive tiered storage where each entry is a `Node<unknown | undefined>`.
- *
- * @example
- * ```ts
- * import { tieredStorage, MemoryCheckpointAdapter } from "@graphrefly/graphrefly-ts";
- *
- * const storage = tieredStorage([new MemoryCheckpointAdapter()], { maxSize: 100 });
- * const val = storage.load("key"); // Node<unknown | undefined>
- * ```
- *
- * @category extra
- */
-declare function tieredStorage(adapters: CheckpointAdapter[], opts?: TieredStorageOptions): TieredStorage;
+declare function cascadingCache<V = unknown>(tiers: readonly StorageTier[], opts?: CascadingCacheOptions): CascadingCache<V>;
 
-type ReactiveMapOptions = {
+type ReactiveMapOptions<K, V> = {
     /** Optional registry name for `describe()` / debugging. */
     name?: string;
-    /** When set, evicts least-recently-used keys after inserts that exceed this size. */
+    /**
+     * 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` omits per-call `ttl`. */
+    /**
+     * 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;
-} & Omit<NodeOptions, "initial" | "describeKind" | "equals">;
+    /**
+     * 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;
-    has: (key: K) => boolean;
+    /**
+     * 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;
-    /** Removes expired entries (monotonic clock), emitting if the visible map changes. */
+    /** 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 - Node options plus `maxSize` / `defaultTtl` (seconds).
- * @returns `ReactiveMapBundle` — imperative `get` / `set` / `delete` / `clear` / `pruneExpired` and an `entries` node emitting `ReadonlyMap` snapshots.
+ * @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). There is no
- * background timer; monotonic-clock–expired keys may still appear in the last-emitted
- * snapshot on `node` until a read or `pruneExpired` removes them.
- * Uses `monotonicNs()` — immune to wall-clock adjustments.
+ * 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).
  *
- * **LRU:** Uses native `Map` insertion order — `get` / `has` refreshes position; under
- * `maxSize` pressure the first key in iteration order is evicted. When `maxSize` is
- * omitted or is less than 1, no size-based eviction runs.
+ * **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
@@ -2904,14 +3451,13 @@ type ReactiveMapBundle<K, V> = {
  *
  * const m = reactiveMap<string, number>({ name: "cache", maxSize: 100, defaultTtl: 60 });
  * m.set("x", 1);
- * m.entries.subscribe((msgs) => {
- *   console.log(msgs);
- * });
+ * m.setMany([["y", 2], ["z", 3]]);
+ * m.entries.subscribe((msgs) => { console.log(msgs); });
  * ```
  *
  * @category extra
  */
-declare function reactiveMap<K, V>(options?: ReactiveMapOptions): ReactiveMapBundle<K, V>;
+declare function reactiveMap<K, V>(options?: ReactiveMapOptions<K, V>): ReactiveMapBundle<K, V>;
 
 /**
  * Composite data patterns (roadmap §3.2b).
@@ -2961,7 +3507,7 @@ type DistillOptions<TMem> = {
     consolidate?: (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
     consolidateTrigger?: NodeInput<unknown>;
     context?: NodeInput<unknown>;
-    mapOptions?: ReactiveMapOptions;
+    mapOptions?: ReactiveMapOptions<string, TMem>;
 };
 type DistillBundle<TMem> = {
     store: ReactiveMapBundle<string, TMem>;
@@ -3031,9 +3577,14 @@ 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 = Omit<NodeOptions, "describeKind">;
+type ExtraOpts = Omit<NodeOptions<unknown>, "describeKind">;
 /**
  * Maps each settled value from `source` through `project`.
  *
@@ -3607,9 +4158,8 @@ declare function throttle<T>(source: Node<T>, ms: number, opts?: ExtraOpts & Thr
  * 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. Unknown message types from
- * either dep are forwarded per spec §1.3.6. At most one terminal message is emitted
- * downstream (latch). Supports `resubscribable` — closure state resets on resubscribe.
+ * 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.
@@ -3781,19 +4331,21 @@ declare function interval(periodMs: number, opts?: ExtraOpts): Node<number>;
  */
 declare function repeat<T>(source: Node<T>, count: number, opts?: ExtraOpts): Node<T>;
 /**
- * While `PAUSE` is in effect, buffers `DIRTY` / `DATA` / `RESOLVED`; flushes on `RESUME`.
+ * 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 with pause buffering.
+ * @returns `Node<T>` - Pass-through (identity).
  * @example
  * ```ts
- * import { pausable, state, PAUSE, RESUME } from "@graphrefly/graphrefly-ts";
+ * import { pausable, state } from "@graphrefly/graphrefly-ts";
  *
+ * // No longer needed — default nodes handle PAUSE/RESUME.
  * const s = state(0);
- * pausable(s);
- * s.down([[PAUSE]]);
- * s.down([[RESUME]]);
+ * pausable(s); // identity passthrough
  * ```
  *
  * @category extra
@@ -3818,16 +4370,17 @@ declare function pausable<T>(source: Node<T>, opts?: ExtraOpts): Node<T>;
 declare function rescue<T>(source: Node<T>, recover: (err: unknown) => T, opts?: ExtraOpts): Node<T>;
 /**
  * Forwards upstream `DATA` only while `control.get()` is truthy; when closed, emits `RESOLVED`
- * instead of repeating the last value (value-level valve). For protocol pause/resume, use {@link pausable}.
+ * 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 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”;
+ * import { valve, state } from "@graphrefly/graphrefly-ts";
  *
  * const data = state(1);
  * const open = state(true);
@@ -3909,11 +4462,71 @@ declare const throttleTime: typeof throttle;
 declare const catchError: typeof rescue;
 
 /**
- * Lazy per-topic manual nodes (roadmap §3.2) — create topics on first access, publish with two-phase push.
+ * Lazy per-topic state hub (roadmap §3.2) — lightweight last-value broadcasts.
+ *
+ * Each topic is a sentinel `node<unknown>()` with push-on-subscribe replay of
+ * the most recent published value (no push until the first `publish`). For
+ * Pulsar-inspired retained message logs,
+ * cursor-based subscriptions, and job-queue semantics, use `messagingHub()` in
+ * `patterns/messaging.ts` — built on `TopicGraph` / `SubscriptionGraph` with
+ * retention policies, absolute cursor tracking, and per-subscriber state.
+ *
+ * **Wave 4 refactor (2026-04-15):** Introduces `PubSubBackend` (thin registry
+ * with version counter). Converts class-based hub to closure factory for
+ * consistency with other `extra/` factories. New bundle APIs: `has(name)`,
+ * `size`, `topicNames()`, `publishMany(entries)`. `removeTopic` → `TEARDOWN`
+ * semantics preserved.
  */
 
 /**
- * In-memory lazy topic registry: each topic is an independent {@link state} node.
+ * Storage contract for {@link pubsub} — registry only.
+ *
+ * Tracks the set of topic names plus a monotonic `version` counter that
+ * advances on topic create/remove. Does NOT own per-topic message storage —
+ * per-topic cached last values live in the topic nodes themselves (sentinel
+ * until the first publish).
+ *
+ * For distributed / persistent per-topic storage, use `messagingHub()` in
+ * `patterns/messaging.ts`, which composes `TopicGraph` under a lazy registry.
+ *
+ * @category extra
+ */
+interface PubSubBackend {
+    /** Monotonic counter; advances on topic create/remove. */
+    readonly version: number;
+    readonly topicCount: number;
+    hasTopic(name: string): boolean;
+    topicNames(): IterableIterator<string>;
+    /** Records topic creation. Returns `true` if newly added (advances `version`). */
+    createTopic(name: string): boolean;
+    /** Records topic removal. Returns `true` if it existed (advances `version`). */
+    removeTopic(name: string): boolean;
+}
+/**
+ * Default in-memory registry backend.
+ *
+ * @category extra
+ */
+declare class NativePubSubBackend implements PubSubBackend {
+    private _version;
+    private readonly _topics;
+    get version(): number;
+    get topicCount(): number;
+    hasTopic(name: string): boolean;
+    topicNames(): IterableIterator<string>;
+    createTopic(name: string): boolean;
+    removeTopic(name: string): boolean;
+}
+type PubSubHubOptions = {
+    /**
+     * Storage backend. Defaults to `NativePubSubBackend`. Pluggable for audit /
+     * monitoring / mirror-to-external-broker use cases.
+     */
+    backend?: PubSubBackend;
+};
+/**
+ * Lazy per-topic state hub. Topics are single-value sentinel nodes
+ * with push-on-subscribe replay of the most recent publish.
  *
  * @category extra
  */
@@ -3922,27 +4535,47 @@ interface PubSubHub {
      * Returns the topic node, creating it on first use.
      *
      * @param name - Topic key.
-     * @returns `Node` whose value is the last published payload (initially `undefined`).
+     * @returns `Node` whose value is the last published payload. Starts in
+     *   sentinel state — no push-on-subscribe until the first publish.
      */
     topic(name: string): Node<unknown>;
-    /**
-     * Pushes a value to the topic (two-phase `DIRTY` then `DATA`, matching other manual sources here).
-     *
-     * @param name - Topic key.
-     * @param value - Payload.
-     */
+    /** Publishes a value to the topic (lazily creating the topic if missing). */
     publish(name: string, value: unknown): void;
     /**
-     * Removes a topic and tears down its node. Returns `true` if the topic existed.
+     * Bulk publish — single outer batch for all entries. No-op if empty.
      *
-     * @param name - Topic key.
+     * **Iterable consumption (F6):** `entries` is consumed once (single-pass).
+     * Pass an array or `Set` for multi-shot callers. Iteration happens INSIDE
+     * the batch frame — if the iterator throws mid-way, the batch is discarded
+     * and NO publishes are visible to subscribers (all-or-nothing within one
+     * call).
      */
+    publishMany(entries: Iterable<[string, unknown]>): void;
+    /** Removes a topic; sends `TEARDOWN` to its node. Returns `true` if it existed. */
     removeTopic(name: string): boolean;
+    /** Checks topic existence without creating. O(1). */
+    has(name: string): boolean;
+    /** Number of topics currently registered. O(1). */
+    readonly size: number;
+    /** Iterator over topic names. */
+    topicNames(): IterableIterator<string>;
 }
 /**
- * Creates an empty {@link PubSubHub} for lazy topic nodes.
+ * Creates a lazy per-topic state hub.
  *
- * @returns A new hub with no topics until {@link PubSubHub.topic} or {@link PubSubHub.publish} runs.
+ * @param options - Optional pluggable `backend` (defaults to `NativePubSubBackend`).
+ * @returns Hub with lazy `topic()` / `publish()` / `publishMany()` / `removeTopic()` /
+ *   `has()` / `size` / `topicNames()`.
+ *
+ * @remarks
+ * **Scope:** Each topic is a sentinel node — retains only the last published
+ * value (no push-on-subscribe before the first publish). For Pulsar-inspired
+ * retention + cursor reading, use
+ * `messagingHub()` in `patterns/messaging.ts`.
+ *
+ * **`removeTopic`:** Sends `TEARDOWN` to the topic node; all subscribers receive
+ * the TEARDOWN message. Subsequent `publish(name, value)` silently recreates the
+ * topic with a fresh node — existing subscribers to the old node do NOT reconnect.
  *
  * @example
  * ```ts
@@ -3952,41 +4585,213 @@ interface PubSubHub {
  * const t = hub.topic("events");
  * t.subscribe((msgs) => console.log(msgs));
  * hub.publish("events", { ok: true });
- * hub.removeTopic("events"); // tears down the node
+ * hub.publishMany([["events", 1], ["status", "ready"]]);
  * ```
  *
  * @category extra
  */
-declare function pubsub(): PubSubHub;
+declare function pubsub(options?: PubSubHubOptions): PubSubHub;
 
 type IndexRow<K, V = unknown> = {
     readonly primary: K;
     readonly secondary: unknown;
     readonly value: V;
 };
-type ReactiveIndexOptions = {
+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>>;
-    upsert: (primary: K, secondary: unknown, value: V) => void;
+    /** 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.
  *
- * @param options - Optional `name` for `describe()` / debugging.
- * @returns Bundle with `ordered` (sorted rows), `byPrimary` (map), and imperative `upsert` / `delete` / `clear`.
+ * @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`.
  *
  * @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).
  *
+ * **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.
+ *
  * @example
  * ```ts
  * import { reactiveIndex } from "@graphrefly/graphrefly-ts";
@@ -3998,25 +4803,128 @@ type ReactiveIndexBundle<K, V = unknown> = {
  *
  * @category extra
  */
-declare function reactiveIndex<K, V = unknown>(options?: ReactiveIndexOptions): ReactiveIndexBundle<K, V>;
+declare function reactiveIndex<K, V = unknown>(options?: ReactiveIndexOptions<K, V>): ReactiveIndexBundle<K, V>;
 
-type ReactiveListOptions = {
+type ReactiveListOptions<T> = {
     name?: string;
+    /**
+     * Storage backend. Defaults to `NativeListBackend` (flat mutable array).
+     * Users can plug in persistent / RRB-tree backends via the {@link ListBackend} interface.
+     */
+    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[];
+}
+/**
+ * Default mutable-array backend.
+ *
+ * **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
+ */
+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[];
+}
 /**
  * Creates a reactive list with immutable array snapshots.
  *
  * @param initial - Optional initial items (copied).
- * @param options - Optional `name` for `describe()` / debugging.
- * @returns Bundle with `items` (state node) and `append` / `insert` / `pop` / `clear`.
+ * @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).
+ *
+ * **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
@@ -4024,74 +4932,234 @@ type ReactiveListBundle<T> = {
  *
  * const list = reactiveList<string>(["a"], { name: "queue" });
  * list.append("b");
+ * list.insertMany(1, ["x", "y"]);
  * ```
  *
  * @category extra
  */
-declare function reactiveList<T>(initial?: readonly T[], options?: ReactiveListOptions): ReactiveListBundle<T>;
+declare function reactiveList<T>(initial?: readonly T[], options?: ReactiveListOptions<T>): ReactiveListBundle<T>;
 
-type ReactiveLogOptions = {
+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 (two-phase). */
+    /** 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, trim once, emit one snapshot. */
+    /**
+     * 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; emits snapshot. */
+    /** Remove the first `n` entries (clamped to `size`). Throws on non-integer or negative `n`. */
     trimHead: (n: number) => void;
-    /** Last `n` entries (or fewer); updates when the log changes. */
+    /**
+     * 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.
  *
- * @param initial - Optional seed entries (copied).
- * @param options - Optional `name` for `describe()` / debugging.
- * @returns Bundle with `entries` (state node), `append`, `clear`, and {@link ReactiveLogBundle.tail}.
+ * @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?)`.
  *
  * @remarks
- * **Derived views:** {@link tail} and {@link logSlice} install an internal noop subscription so
- * `get()` stays wired without an external sink; creating very many disposable derived nodes can
- * retain subscriptions until the log bundle is unreachable.
+ * **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" });
+ * 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): ReactiveLogBundle<T>;
+declare function reactiveLog<T>(initial?: readonly T[], options?: ReactiveLogOptions<T>): ReactiveLogBundle<T>;
+
 /**
- * Builds a derived node for `entries.slice(start, stop)` (same semantics as `Array.prototype.slice`; `stop` exclusive).
+ * Creates a resettable deadline timer for internal timeout, retry, and rate-limiting use.
+ *
+ * @remarks **Centralised primitive:** wraps `setTimeout`/`clearTimeout` with a generation guard
+ * so that stale callbacks never fire after `cancel()` or a new `start()`.
  *
- * @param log - Log from {@link reactiveLog}.
- * @param start - Start index (must be `>= 0`).
- * @param stop - End index (exclusive); omit to slice to the end.
- * @returns Derived node emitting the sliced readonly array.
+ * @remarks **Spec §5.10 exception:** resilience operators (`timeout`, `retry`, `rateLimiter`)
+ * need raw timers — `fromTimer` creates a new Node per reset, which is too heavy here.
+ * Lives in `src/extra/` (not `src/core/`) because it is a documented escape hatch from
+ * the protocol-pure core layer.
  *
  * @example
  * ```ts
- * import { reactiveLog, logSlice } from "@graphrefly/graphrefly-ts";
+ * import { ResettableTimer } from "@graphrefly/graphrefly-ts";
  *
- * const lg = reactiveLog<number>([10, 20, 30, 40, 50]);
- * const slice$ = logSlice(lg, 1, 4); // reactive view of [20, 30, 40]
- * slice$.subscribe((msgs) => console.log(msgs));
- *
- * lg.append(60); // slice$ now reflects [20, 30, 40] (indices 1–3 of updated log)
+ * const timer = new ResettableTimer();
+ * timer.start(1000, () => console.log("fired"));
+ * timer.cancel();          // cancels before firing
+ * timer.start(500, () => console.log("new deadline"));
+ * console.log(timer.pending); // true
  * ```
  *
  * @category extra
  */
-declare function logSlice<T>(log: ReactiveLogBundle<T>, start: number, stop?: number): Node<readonly T[]>;
+declare class ResettableTimer {
+    private _timer;
+    private _gen;
+    /** Schedule callback after delayMs. Cancels any pending timer. */
+    start(delayMs: number, callback: () => void): void;
+    /** Cancel the pending timer (if any). */
+    cancel(): void;
+    /** Whether a timer is currently pending. */
+    get pending(): boolean;
+}
 
 /**
  * WorkerTransport — normalized message channel for all worker types.
@@ -4301,6 +5369,7 @@ declare function workerSelf<TImport extends readonly string[]>(target: unknown |
  * Extra layer: operators, sources, sinks (Phase 2+).
  */
 
+type index_AckableMessage<T> = AckableMessage<T>;
 type index_AdapterHandlers<T> = AdapterHandlers<T>;
 type index_AsyncSourceOpts = AsyncSourceOpts;
 type index_BackoffPreset = BackoffPreset;
@@ -4308,12 +5377,11 @@ type index_BackoffStrategy = BackoffStrategy;
 type index_BatchMessage = BatchMessage;
 type index_BridgeMessage = BridgeMessage;
 type index_BufferedSinkHandle = BufferedSinkHandle;
+type index_BundleTriad<TChannels extends Record<string, unknown>> = BundleTriad<TChannels>;
 type index_CSVRow = CSVRow;
 type index_CacheEvictionPolicy<K> = CacheEvictionPolicy<K>;
-type index_CacheTier<V> = CacheTier<V>;
 type index_CascadingCache<V> = CascadingCache<V>;
 type index_CascadingCacheOptions = CascadingCacheOptions;
-type index_CheckpointAdapter = CheckpointAdapter;
 type index_CheckpointToRedisOptions = CheckpointToRedisOptions;
 type index_CheckpointToS3Options = CheckpointToS3Options;
 type index_CircuitBreaker = CircuitBreaker;
@@ -4325,19 +5393,19 @@ type index_ClickHouseClientLike = ClickHouseClientLike;
 type index_ClickHouseInsertClientLike = ClickHouseInsertClientLike;
 type index_ClickHouseRow = ClickHouseRow;
 type index_CronSchedule = CronSchedule;
-type index_DictCheckpointAdapter = DictCheckpointAdapter;
-declare const index_DictCheckpointAdapter: typeof DictCheckpointAdapter;
 type index_DistillBundle<TMem> = DistillBundle<TMem>;
 type index_DistillOptions<TMem> = DistillOptions<TMem>;
 type index_DrizzleQueryLike<T = unknown> = DrizzleQueryLike<T>;
+type index_EmitTriad<T> = EmitTriad<T>;
 type index_ErrorMessage = ErrorMessage;
 type index_EventTargetLike = EventTargetLike;
 type index_ExponentialBackoffOptions = 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_FileCheckpointAdapter = FileCheckpointAdapter;
-declare const index_FileCheckpointAdapter: typeof FileCheckpointAdapter;
+type index_FallbackInput<T> = FallbackInput<T>;
 type index_FileWriterLike = FileWriterLike;
 type index_FromCSVOptions = FromCSVOptions;
 type index_FromClickHouseWatchOptions = FromClickHouseWatchOptions;
@@ -4346,6 +5414,8 @@ 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;
 type index_FromKafkaOptions = FromKafkaOptions;
 type index_FromKyselyOptions<T, U = T> = FromKyselyOptions<T, U>;
 type index_FromMCPOptions = FromMCPOptions;
@@ -4357,25 +5427,29 @@ type index_FromPrometheusOptions = FromPrometheusOptions;
 type index_FromPulsarOptions = FromPulsarOptions;
 type index_FromRabbitMQOptions = FromRabbitMQOptions;
 type index_FromRedisStreamOptions = FromRedisStreamOptions;
+type index_FromSSEOptions<T = string> = FromSSEOptions<T>;
 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>;
-type index_IndexedDbCheckpointSpec = IndexedDbCheckpointSpec;
+declare const index_IndexedDbStorageSpec: typeof IndexedDbStorageSpec;
 type index_InitMessage = InitMessage;
 type index_JitterMode = JitterMode;
 type index_KafkaConsumerLike = KafkaConsumerLike;
 type index_KafkaMessage<T = unknown> = KafkaMessage<T>;
 type index_KafkaProducerLike = KafkaProducerLike;
 type index_KyselyQueryLike<T = unknown> = KyselyQueryLike<T>;
+type index_ListBackend<T> = ListBackend<T>;
+type index_LogBackend<T> = LogBackend<T>;
 type index_LokiClientLike = LokiClientLike;
 type index_LokiStream = LokiStream;
 type index_MCPClientLike = MCPClientLike;
-type index_MemoryCheckpointAdapter = MemoryCheckpointAdapter;
-declare const index_MemoryCheckpointAdapter: typeof MemoryCheckpointAdapter;
+type index_MapBackend<K, V> = MapBackend<K, V>;
 type index_MergeMapOptions = MergeMapOptions;
 type index_MongoCollectionLike = MongoCollectionLike;
 type index_NATSClientLike = NATSClientLike;
@@ -4383,6 +5457,17 @@ 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;
+type index_NativePubSubBackend = NativePubSubBackend;
+declare const index_NativePubSubBackend: typeof NativePubSubBackend;
 type index_NodeInput<T> = NodeInput<T>;
 type index_OTelBundle = OTelBundle;
 type index_OTelLog = OTelLog;
@@ -4392,48 +5477,64 @@ type index_OTelSpan = OTelSpan;
 type index_PostgresClientLike = PostgresClientLike;
 type index_PrismaModelLike<T = unknown> = PrismaModelLike<T>;
 type index_PrometheusMetric = PrometheusMetric;
+type index_PubSubBackend = PubSubBackend;
 type index_PubSubHub = PubSubHub;
+type index_PubSubHubOptions = PubSubHubOptions;
 type index_PulsarConsumerLike = PulsarConsumerLike;
 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_RateLimiterOverflowError: typeof RateLimiterOverflowError;
+type index_RateLimiterOverflowPolicy = RateLimiterOverflowPolicy;
 type index_ReactiveCounterBundle = ReactiveCounterBundle;
 type index_ReactiveIndexBundle<K, V = unknown> = ReactiveIndexBundle<K, V>;
-type index_ReactiveIndexOptions = ReactiveIndexOptions;
+type index_ReactiveIndexOptions<K, V = unknown> = ReactiveIndexOptions<K, V>;
 type index_ReactiveListBundle<T> = ReactiveListBundle<T>;
-type index_ReactiveListOptions = ReactiveListOptions;
+type index_ReactiveListOptions<T> = ReactiveListOptions<T>;
 type index_ReactiveLogBundle<T> = ReactiveLogBundle<T>;
-type index_ReactiveLogOptions = ReactiveLogOptions;
+type index_ReactiveLogOptions<T> = ReactiveLogOptions<T>;
 type index_ReactiveMapBundle<K, V> = ReactiveMapBundle<K, V>;
-type index_ReactiveMapOptions = ReactiveMapOptions;
+type index_ReactiveMapOptions<K, V> = ReactiveMapOptions<K, V>;
+type index_ReactiveSinkBackpressureOptions = ReactiveSinkBackpressureOptions;
+type index_ReactiveSinkConfig<T, Ctx = unknown> = ReactiveSinkConfig<T, Ctx>;
+type index_ReactiveSinkHandle<T> = ReactiveSinkHandle<T>;
+type index_ReactiveSinkOptions<T> = ReactiveSinkOptions<T>;
+type index_ReactiveSinkRetryOptions = ReactiveSinkRetryOptions;
 type index_ReadyMessage = ReadyMessage;
 type index_RedisCheckpointClientLike = RedisCheckpointClientLike;
 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>;
 type index_S3ClientLike = S3ClientLike;
+type index_SSEEvent<T = string> = SSEEvent<T>;
 type index_SignalMessage = SignalMessage;
+type index_SinkFailure<T> = SinkFailure<T>;
 type index_SinkHandle = SinkHandle;
 type index_SinkTransportError = SinkTransportError;
-type index_SqliteCheckpointAdapter = SqliteCheckpointAdapter;
-declare const index_SqliteCheckpointAdapter: typeof SqliteCheckpointAdapter;
 type index_SqliteDbLike = SqliteDbLike;
+type index_SqliteIterableDbLike = SqliteIterableDbLike;
 type index_StatsDMetric = StatsDMetric;
 type index_StatsDRegister = StatsDRegister;
 type index_StatusValue = StatusValue;
+declare const index_StorageHandle: typeof StorageHandle;
+declare const index_StorageTier: typeof StorageTier;
 type index_SyslogMessage = SyslogMessage;
 type index_SyslogRegister = SyslogRegister;
 type index_TapObserver<T> = TapObserver<T>;
 type index_TempoClientLike = TempoClientLike;
 type index_ThrottleOptions = ThrottleOptions;
-type index_TieredStorage = TieredStorage;
-type index_TieredStorageOptions = TieredStorageOptions;
 type index_TimeoutError = TimeoutError;
 declare const index_TimeoutError: typeof TimeoutError;
 type index_ToCSVOptions<T> = ToCSVOptions<T>;
 type index_ToClickHouseOptions<T> = ToClickHouseOptions<T>;
 type index_ToFileOptions<T> = ToFileOptions<T>;
+type index_ToHTTPOptions<T> = ToHTTPOptions<T>;
 type index_ToKafkaOptions<T> = ToKafkaOptions<T>;
 type index_ToLokiOptions<T> = ToLokiOptions<T>;
 type index_ToMongoOptions<T> = ToMongoOptions<T>;
@@ -4448,8 +5549,8 @@ type index_ToSSEOptions = ToSSEOptions;
 type index_ToSqliteOptions<T> = ToSqliteOptions<T>;
 type index_ToTempoOptions<T> = ToTempoOptions<T>;
 type index_ToWebSocketOptions<T> = ToWebSocketOptions<T>;
-type index_ToWebSocketTransportError = ToWebSocketTransportError;
 type index_TokenBucket = TokenBucket;
+type index_UpsertOptions<K, V> = UpsertOptions<K, V>;
 type index_ValueMessage = ValueMessage;
 type index_VerifiableBundle<T, TVerify = VerifyValue> = VerifiableBundle<T, TVerify>;
 type index_VerifiableOptions<TVerify = VerifyValue> = VerifiableOptions<TVerify>;
@@ -4471,11 +5572,9 @@ declare const index_audit: typeof audit;
 declare const index_buffer: typeof buffer;
 declare const index_bufferCount: typeof bufferCount;
 declare const index_bufferTime: typeof bufferTime;
-declare const index_cache: typeof cache;
 declare const index_cached: typeof cached;
 declare const index_cascadingCache: typeof cascadingCache;
 declare const index_catchError: typeof catchError;
-declare const index_checkpointNodeValue: typeof checkpointNodeValue;
 declare const index_checkpointToRedis: typeof checkpointToRedis;
 declare const index_checkpointToS3: typeof checkpointToS3;
 declare const index_circuitBreaker: typeof circuitBreaker;
@@ -4486,11 +5585,13 @@ declare const index_concatMap: typeof concatMap;
 declare const index_constant: typeof constant;
 declare const index_createTransport: typeof createTransport;
 declare const index_createWatermarkController: typeof createWatermarkController;
+declare const index_csvRows: typeof csvRows;
 declare const index_debounce: typeof debounce;
 declare const index_debounceTime: typeof debounceTime;
 declare const index_decorrelatedJitter: typeof decorrelatedJitter;
 declare const index_delay: typeof delay;
 declare const index_deserializeError: typeof deserializeError;
+declare const index_dictStorage: typeof dictStorage;
 declare const index_distill: typeof distill;
 declare const index_distinctUntilChanged: typeof distinctUntilChanged;
 declare const index_elementAt: typeof elementAt;
@@ -4498,8 +5599,11 @@ declare const index_empty: typeof empty;
 declare const index_escapeRegexChar: typeof escapeRegexChar;
 declare const index_exhaustMap: typeof exhaustMap;
 declare const index_exponential: typeof exponential;
+declare const index_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;
@@ -4517,6 +5621,8 @@ 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;
@@ -4532,25 +5638,30 @@ declare const index_fromPromise: typeof fromPromise;
 declare const index_fromPulsar: typeof fromPulsar;
 declare const index_fromRabbitMQ: typeof fromRabbitMQ;
 declare const index_fromRedisStream: typeof fromRedisStream;
+declare const index_fromSSE: typeof fromSSE;
 declare const index_fromSqlite: typeof fromSqlite;
+declare const index_fromSqliteCursor: typeof fromSqliteCursor;
 declare const index_fromStatsD: typeof fromStatsD;
 declare const index_fromSyslog: typeof fromSyslog;
 declare const index_fromTimer: typeof fromTimer;
 declare const index_fromWebSocket: typeof fromWebSocket;
+declare const index_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;
 declare const index_linear: typeof linear;
-declare const index_logSlice: typeof logSlice;
 declare const index_lru: typeof lru;
 declare const index_map: typeof map;
 declare const index_matchesAnyPattern: typeof matchesAnyPattern;
 declare const index_matchesCron: typeof matchesCron;
+declare const index_memoryStorage: typeof memoryStorage;
 declare const index_merge: typeof merge;
 declare const index_mergeMap: typeof mergeMap;
 declare const index_nameToSignal: typeof nameToSignal;
+declare const index_ndjsonRows: typeof ndjsonRows;
 declare const index_never: typeof never;
 declare const index_of: typeof of;
 declare const index_pairwise: typeof pairwise;
@@ -4567,23 +5678,22 @@ declare const index_reactiveIndex: typeof reactiveIndex;
 declare const index_reactiveList: typeof reactiveList;
 declare const index_reactiveLog: typeof reactiveLog;
 declare const index_reactiveMap: typeof reactiveMap;
+declare const index_reactiveSink: typeof reactiveSink;
 declare const index_reduce: typeof reduce;
 declare const index_repeat: typeof repeat;
 declare const index_replay: typeof replay;
 declare const index_rescue: typeof rescue;
 declare const index_resolveBackoffPreset: typeof resolveBackoffPreset;
-declare const index_restoreGraphCheckpoint: typeof restoreGraphCheckpoint;
-declare const index_restoreGraphCheckpointIndexedDb: typeof restoreGraphCheckpointIndexedDb;
 declare const index_retry: typeof retry;
+declare const index_retrySource: typeof retrySource;
 declare const index_sample: typeof sample;
-declare const index_saveGraphCheckpoint: typeof saveGraphCheckpoint;
-declare const index_saveGraphCheckpointIndexedDb: typeof saveGraphCheckpointIndexedDb;
 declare const index_scan: typeof scan;
 declare const index_serializeError: typeof serializeError;
 declare const index_share: typeof share;
 declare const index_shareReplay: typeof shareReplay;
 declare const index_signalToName: typeof signalToName;
 declare const index_skip: typeof skip;
+declare const index_sqliteStorage: typeof sqliteStorage;
 declare const index_switchMap: typeof switchMap;
 declare const index_take: typeof take;
 declare const index_takeUntil: typeof takeUntil;
@@ -4592,12 +5702,12 @@ declare const index_tap: typeof tap;
 declare const index_throttle: typeof throttle;
 declare const index_throttleTime: typeof throttleTime;
 declare const index_throwError: typeof throwError;
-declare const index_tieredStorage: typeof tieredStorage;
 declare const index_timeout: typeof timeout;
 declare const index_toArray: typeof toArray;
 declare const index_toCSV: typeof toCSV;
 declare const index_toClickHouse: typeof toClickHouse;
 declare const index_toFile: typeof toFile;
+declare const index_toHTTP: typeof toHTTP;
 declare const index_toKafka: typeof toKafka;
 declare const index_toLoki: typeof toLoki;
 declare const index_toMongo: typeof toMongo;
@@ -4606,14 +5716,15 @@ declare const index_toObservable: typeof toObservable;
 declare const index_toPostgres: typeof toPostgres;
 declare const index_toPulsar: typeof toPulsar;
 declare const index_toRabbitMQ: typeof toRabbitMQ;
+declare const index_toReadableStream: typeof toReadableStream;
 declare const index_toRedisStream: typeof toRedisStream;
 declare const index_toS3: typeof toS3;
 declare const index_toSSE: typeof toSSE;
+declare const index_toSSEBytes: typeof toSSEBytes;
 declare const index_toSqlite: typeof toSqlite;
 declare const index_toTempo: typeof toTempo;
 declare const index_toWebSocket: typeof toWebSocket;
 declare const index_tokenBucket: typeof tokenBucket;
-declare const index_tokenTracker: typeof tokenTracker;
 declare const index_valve: typeof valve;
 declare const index_verifiable: typeof verifiable;
 declare const index_window: typeof window;
@@ -4627,7 +5738,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_AdapterHandlers as AdapterHandlers, type index_AsyncSourceOpts as AsyncSourceOpts, type index_BackoffPreset as BackoffPreset, type index_BackoffStrategy as BackoffStrategy, type index_BatchMessage as BatchMessage, type index_BridgeMessage as BridgeMessage, type index_BufferedSinkHandle as BufferedSinkHandle, type index_CSVRow as CSVRow, type index_CacheEvictionPolicy as CacheEvictionPolicy, type index_CacheTier as CacheTier, type index_CascadingCache as CascadingCache, type index_CascadingCacheOptions as CascadingCacheOptions, type index_CheckpointAdapter as CheckpointAdapter, 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, index_DictCheckpointAdapter as DictCheckpointAdapter, type index_DistillBundle as DistillBundle, type index_DistillOptions as DistillOptions, type index_DrizzleQueryLike as DrizzleQueryLike, type index_ErrorMessage as ErrorMessage, type index_EventTargetLike as EventTargetLike, type index_ExponentialBackoffOptions as ExponentialBackoffOptions, type index_Extraction as Extraction, type index_FSEvent as FSEvent, type index_FSEventType as FSEventType, index_FileCheckpointAdapter as FileCheckpointAdapter, type index_FileWriterLike as FileWriterLike, type index_FromCSVOptions as FromCSVOptions, type index_FromClickHouseWatchOptions as FromClickHouseWatchOptions, type 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_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_FromSqliteOptions as FromSqliteOptions, type index_FromStatsDOptions as FromStatsDOptions, type index_FromSyslogOptions as FromSyslogOptions, type index_GitEvent as GitEvent, type index_GitHookType as GitHookType, type index_HTTPBundle as HTTPBundle, type index_IndexRow as IndexRow, type index_IndexedDbCheckpointSpec as IndexedDbCheckpointSpec, type index_InitMessage as InitMessage, type index_JitterMode as JitterMode, type index_KafkaConsumerLike as KafkaConsumerLike, type index_KafkaMessage as KafkaMessage, type index_KafkaProducerLike as KafkaProducerLike, type index_KyselyQueryLike as KyselyQueryLike, type index_LokiClientLike as LokiClientLike, type index_LokiStream as LokiStream, type index_MCPClientLike as MCPClientLike, index_MemoryCheckpointAdapter as MemoryCheckpointAdapter, 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, type index_NodeInput as NodeInput, type index_OTelBundle as OTelBundle, type index_OTelLog as OTelLog, type index_OTelMetric as OTelMetric, type index_OTelRegister as OTelRegister, type index_OTelSpan as OTelSpan, type index_PostgresClientLike as PostgresClientLike, type index_PrismaModelLike as PrismaModelLike, type index_PrometheusMetric as PrometheusMetric, type index_PubSubHub as PubSubHub, 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_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_ReadyMessage as ReadyMessage, type index_RedisCheckpointClientLike as RedisCheckpointClientLike, type index_RedisClientLike as RedisClientLike, type index_RedisStreamEntry as RedisStreamEntry, type index_RetryOptions as RetryOptions, type index_S3ClientLike as S3ClientLike, type index_SignalMessage as SignalMessage, type index_SinkHandle as SinkHandle, type index_SinkTransportError as SinkTransportError, index_SqliteCheckpointAdapter as SqliteCheckpointAdapter, type index_SqliteDbLike as SqliteDbLike, type index_StatsDMetric as StatsDMetric, type index_StatsDRegister as StatsDRegister, type index_StatusValue as StatusValue, type index_SyslogMessage as SyslogMessage, type index_SyslogRegister as SyslogRegister, type index_TapObserver as TapObserver, type index_TempoClientLike as TempoClientLike, type index_ThrottleOptions as ThrottleOptions, type index_TieredStorage as TieredStorage, type index_TieredStorageOptions as TieredStorageOptions, index_TimeoutError as TimeoutError, type index_ToCSVOptions as ToCSVOptions, type index_ToClickHouseOptions as ToClickHouseOptions, type index_ToFileOptions as ToFileOptions, 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_ToWebSocketTransportError as ToWebSocketTransportError, type index_TokenBucket as TokenBucket, type index_ValueMessage as ValueMessage, type index_VerifiableBundle as VerifiableBundle, type index_VerifiableOptions as VerifiableOptions, type index_VerifyValue as VerifyValue, type index_WatermarkController as WatermarkController, type index_WatermarkOptions as WatermarkOptions, type index_WebSocketLike as WebSocketLike, type index_WebSocketMessageEventLike as WebSocketMessageEventLike, type index_WebSocketRegister as WebSocketRegister, type index_WebhookRegister as WebhookRegister, type index_WithBreakerBundle as WithBreakerBundle, type index_WithStatusBundle as WithStatusBundle, type index_WorkerBridge as WorkerBridge, type index_WorkerBridgeOptions as WorkerBridgeOptions, type index_WorkerSelfHandle as WorkerSelfHandle, type index_WorkerSelfOptions as WorkerSelfOptions, type index_WorkerTransport as WorkerTransport, index_audit as audit, index_buffer as buffer, index_bufferCount as bufferCount, index_bufferTime as bufferTime, index_cache as cache, index_cached as cached, index_cascadingCache as cascadingCache, index_catchError as catchError, index_checkpointNodeValue as checkpointNodeValue, 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_debounce as debounce, index_debounceTime as debounceTime, index_decorrelatedJitter as decorrelatedJitter, index_delay as delay, index_deserializeError as deserializeError, index_distill as distill, index_distinctUntilChanged as distinctUntilChanged, index_elementAt as elementAt, index_empty as empty, index_escapeRegexChar as escapeRegexChar, index_exhaustMap as exhaustMap, index_exponential as exponential, index_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_fromFSWatch as fromFSWatch, index_fromGitHook as fromGitHook, index_fromHTTP as fromHTTP, index_fromIDBRequest as fromIDBRequest, index_fromIDBTransaction as fromIDBTransaction, index_fromIter as fromIter, index_fromKafka as fromKafka, index_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_fromRedisStream as fromRedisStream, index_fromSqlite as fromSqlite, index_fromStatsD as fromStatsD, index_fromSyslog as fromSyslog, index_fromTimer as fromTimer, index_fromWebSocket as fromWebSocket, 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_logSlice as logSlice, index_lru as lru, index_map as map, index_matchesAnyPattern as matchesAnyPattern, index_matchesCron as matchesCron, index_merge as merge, index_mergeMap as mergeMap, index_nameToSignal as nameToSignal, index_never as never, index_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_reduce as reduce, index_repeat as repeat, index_replay as replay, index_rescue as rescue, index_resolveBackoffPreset as resolveBackoffPreset, index_restoreGraphCheckpoint as restoreGraphCheckpoint, index_restoreGraphCheckpointIndexedDb as restoreGraphCheckpointIndexedDb, index_retry as retry, index_sample as sample, index_saveGraphCheckpoint as saveGraphCheckpoint, index_saveGraphCheckpointIndexedDb as saveGraphCheckpointIndexedDb, index_scan as scan, index_serializeError as serializeError, index_share as share, index_shareReplay as shareReplay, index_signalToName as signalToName, index_skip as skip, index_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_tieredStorage as tieredStorage, index_timeout as timeout, index_toArray as toArray, index_toCSV as toCSV, index_toClickHouse as toClickHouse, index_toFile as toFile, 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_toRedisStream as toRedisStream, index_toS3 as toS3, index_toSSE as toSSE, index_toSqlite as toSqlite, index_toTempo as toTempo, index_toWebSocket as toWebSocket, index_tokenBucket as tokenBucket, index_tokenTracker as tokenTracker, 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, type index_AsyncSourceOpts as AsyncSourceOpts, type index_BackoffPreset as BackoffPreset, type index_BackoffStrategy as BackoffStrategy, type index_BatchMessage as BatchMessage, type index_BridgeMessage as BridgeMessage, type index_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, type 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, type 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, type index_NodeInput as NodeInput, type index_OTelBundle as OTelBundle, type index_OTelLog as OTelLog, type index_OTelMetric as OTelMetric, type index_OTelRegister as OTelRegister, type index_OTelSpan as OTelSpan, type index_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, type 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_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 FromRedisStreamOptions as $, type AdapterHandlers as A, type BackoffPreset as B, type CSVRow as C, type DistillBundle as D, type Extraction as E, type FSEvent as F, type FSEventType as G, FileCheckpointAdapter as H, type FileWriterLike as I, type FromCSVOptions as J, type FromClickHouseWatchOptions as K, type FromCronOptions as L, type FromDrizzleOptions as M, type NodeInput as N, type FromFSWatchOptions as O, type FromGitHookOptions as P, type FromHTTPOptions as Q, type FromKafkaOptions as R, type FromKyselyOptions as S, type FromMCPOptions as T, type FromNATSOptions as U, type FromNDJSONOptions as V, type FromOTelOptions as W, type FromPrismaOptions as X, type FromPrometheusOptions as Y, type FromPulsarOptions as Z, type FromRabbitMQOptions as _, type AsyncSourceOpts as a, type SyslogRegister as a$, type FromSqliteOptions as a0, type FromStatsDOptions as a1, type FromSyslogOptions as a2, type GitEvent as a3, type GitHookType as a4, type HTTPBundle as a5, type IndexRow as a6, type IndexedDbCheckpointSpec as a7, type InitMessage as a8, type JitterMode as a9, type PulsarProducerLike as aA, type RabbitMQChannelLike as aB, type RabbitMQMessage as aC, type ReactiveCounterBundle as aD, type ReactiveIndexBundle as aE, type ReactiveIndexOptions as aF, type ReactiveListBundle as aG, type ReactiveListOptions as aH, type ReactiveLogBundle as aI, type ReactiveLogOptions as aJ, type ReactiveMapBundle as aK, type ReactiveMapOptions as aL, type ReadyMessage as aM, type RedisCheckpointClientLike as aN, type RedisClientLike as aO, type RedisStreamEntry as aP, type RetryOptions as aQ, type S3ClientLike as aR, type SignalMessage as aS, type SinkHandle as aT, type SinkTransportError as aU, SqliteCheckpointAdapter as aV, type SqliteDbLike as aW, type StatsDMetric as aX, type StatsDRegister as aY, type StatusValue as aZ, type SyslogMessage as a_, type KafkaConsumerLike as aa, type KafkaMessage as ab, type KafkaProducerLike as ac, type KyselyQueryLike as ad, type LokiClientLike as ae, type LokiStream as af, type MCPClientLike as ag, MemoryCheckpointAdapter as ah, type MergeMapOptions as ai, type MongoCollectionLike as aj, type NATSClientLike as ak, type NATSMessage as al, type NATSSubscriptionLike as am, NS_PER_MS as an, NS_PER_SEC as ao, type OTelBundle as ap, type OTelLog as aq, type OTelMetric as ar, type OTelRegister as as, type OTelSpan as at, type PostgresClientLike as au, type PrismaModelLike as av, type PrometheusMetric as aw, type PubSubHub as ax, type PulsarConsumerLike as ay, type PulsarMessage as az, type BackoffStrategy as b, delay as b$, type TapObserver as b0, type TempoClientLike as b1, type ThrottleOptions as b2, type TieredStorage as b3, type TieredStorageOptions as b4, TimeoutError as b5, type ToCSVOptions as b6, type ToClickHouseOptions as b7, type ToFileOptions as b8, type ToKafkaOptions as b9, type WorkerBridge as bA, type WorkerBridgeOptions as bB, type WorkerSelfHandle as bC, type WorkerSelfOptions as bD, type WorkerTransport as bE, audit as bF, buffer as bG, bufferCount as bH, bufferTime as bI, cache as bJ, cached as bK, cascadingCache as bL, catchError as bM, checkpointNodeValue as bN, checkpointToRedis as bO, checkpointToS3 as bP, circuitBreaker as bQ, combine as bR, combineLatest as bS, concat as bT, concatMap as bU, constant as bV, createTransport as bW, createWatermarkController as bX, debounce as bY, debounceTime as bZ, decorrelatedJitter as b_, type ToLokiOptions as ba, type ToMongoOptions as bb, type ToNATSOptions as bc, type ToPostgresOptions as bd, type ToPulsarOptions as be, type ToRabbitMQOptions as bf, type ToRedisStreamOptions as bg, type ToS3Options as bh, type ToSSEOptions as bi, type ToSqliteOptions as bj, type ToTempoOptions as bk, type ToWebSocketOptions as bl, type ToWebSocketTransportError as bm, type TokenBucket as bn, type ValueMessage as bo, type VerifiableBundle as bp, type VerifiableOptions as bq, type VerifyValue as br, type WatermarkController as bs, type WatermarkOptions as bt, type WebSocketLike as bu, type WebSocketMessageEventLike as bv, type WebSocketRegister as bw, type WebhookRegister as bx, type WithBreakerBundle as by, type WithStatusBundle as bz, type BatchMessage as c, of as c$, deserializeError as c0, distill as c1, distinctUntilChanged as c2, elementAt as c3, empty as c4, escapeRegexChar as c5, exhaustMap as c6, exponential as c7, index as c8, fallback as c9, fromOTel as cA, fromPrisma as cB, fromPrometheus as cC, fromPromise as cD, fromPulsar as cE, fromRabbitMQ as cF, fromRedisStream as cG, fromSqlite as cH, fromStatsD as cI, fromSyslog as cJ, fromTimer as cK, fromWebSocket as cL, fromWebhook as cM, globToRegExp as cN, interval as cO, keepalive as cP, last as cQ, linear as cR, logSlice as cS, lru as cT, map as cU, matchesAnyPattern as cV, matchesCron as cW, merge as cX, mergeMap as cY, nameToSignal as cZ, never as c_, fibonacci as ca, filter as cb, find as cc, first as cd, firstValueFrom as ce, firstWhere as cf, flatMap as cg, forEach as ch, fromAny as ci, fromAsyncIter as cj, fromCSV as ck, fromClickHouseWatch as cl, fromCron as cm, fromDrizzle as cn, fromEvent as co, fromFSWatch as cp, fromGitHook as cq, fromHTTP as cr, fromIDBRequest as cs, fromIDBTransaction as ct, fromIter as cu, fromKafka as cv, fromKysely as cw, fromMCP as cx, fromNATS as cy, fromNDJSON as cz, type BridgeMessage as d, window as d$, pairwise as d0, parseCron as d1, parsePrometheusText as d2, parseStatsD as d3, parseSyslog as d4, pausable as d5, pubsub as d6, race as d7, rateLimiter as d8, reactiveCounter as d9, tap as dA, throttle as dB, throttleTime as dC, throwError as dD, tieredStorage as dE, timeout as dF, toArray as dG, toCSV as dH, toClickHouse as dI, toFile as dJ, toKafka as dK, toLoki as dL, toMongo as dM, toNATS as dN, toPostgres as dO, toPulsar as dP, toRabbitMQ as dQ, toRedisStream as dR, toS3 as dS, toSSE as dT, toSqlite as dU, toTempo as dV, toWebSocket as dW, tokenBucket as dX, tokenTracker as dY, valve as dZ, verifiable as d_, reactiveIndex as da, reactiveList as db, reactiveLog as dc, reactiveMap as dd, reduce as de, repeat as df, replay as dg, rescue as dh, resolveBackoffPreset as di, restoreGraphCheckpoint as dj, restoreGraphCheckpointIndexedDb as dk, retry as dl, sample as dm, saveGraphCheckpoint as dn, saveGraphCheckpointIndexedDb as dp, scan as dq, serializeError as dr, share as ds, shareReplay as dt, signalToName as du, skip as dv, switchMap as dw, take as dx, takeUntil as dy, takeWhile as dz, type BufferedSinkHandle as e, windowCount as e0, windowTime as e1, withBreaker as e2, withLatestFrom as e3, withMaxAttempts as e4, withStatus as e5, workerBridge as e6, workerSelf as e7, zip as e8, type CacheEvictionPolicy as f, type CacheTier as g, type CascadingCache as h, type CascadingCacheOptions as i, type CheckpointAdapter as j, type CheckpointToRedisOptions as k, type CheckpointToS3Options as l, type CircuitBreaker as m, type CircuitBreakerOptions as n, CircuitOpenError as o, type CircuitState as p, type ClickHouseClientLike as q, type ClickHouseInsertClientLike as r, type ClickHouseRow as s, type CronSchedule as t, DictCheckpointAdapter as u, type DistillOptions as v, type DrizzleQueryLike as w, type ErrorMessage as x, type EventTargetLike as y, type ExponentialBackoffOptions as z };
+export { type FromPrismaOptions as $, type AckableMessage as A, type BackoffPreset as B, type CSVRow as C, type DistillBundle as D, type Extraction as E, type ExternalBundleOptions as F, type ExternalRegister as G, type FSEvent as H, type FSEventType as I, type FallbackInput as J, type FileWriterLike as K, type FromCSVOptions as L, type FromClickHouseWatchOptions as M, type NodeInput as N, type FromCronOptions as O, type FromDrizzleOptions as P, type FromFSWatchOptions as Q, type FromGitHookOptions as R, type FromHTTPOptions as S, type FromHTTPPollOptions as T, type FromHTTPStreamOptions as U, type FromKafkaOptions as V, type FromKyselyOptions as W, type FromMCPOptions as X, type FromNATSOptions as Y, type FromNDJSONOptions as Z, type FromOTelOptions as _, type AdapterHandlers as a, type ReactiveLogBundle as a$, type FromPrometheusOptions as a0, type FromPulsarOptions as a1, type FromRabbitMQOptions as a2, type FromRedisStreamOptions as a3, type FromSSEOptions as a4, type FromSqliteOptions as a5, type FromStatsDOptions as a6, type FromSyslogOptions as a7, type FromWebSocketReconnectOptions as a8, type GitEvent 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, type RateLimiterOptions as aT, RateLimiterOverflowError as aU, type RateLimiterOverflowPolicy as aV, type ReactiveCounterBundle as aW, type ReactiveIndexBundle as aX, type ReactiveIndexOptions as aY, type ReactiveListBundle as aZ, type ReactiveListOptions as a_, type GitHookType as aa, type HTTPBundle as ab, type IndexBackend as ac, type IndexRow as ad, type InitMessage as ae, type JitterMode as af, type KafkaConsumerLike as ag, type KafkaMessage as ah, type KafkaProducerLike as ai, type KyselyQueryLike as aj, type ListBackend as ak, type LogBackend as al, type LokiClientLike as am, type LokiStream as an, type MCPClientLike as ao, type MapBackend as ap, type MergeMapOptions as aq, type MongoCollectionLike as ar, type NATSClientLike as as, type NATSMessage as at, type NATSSubscriptionLike as au, NS_PER_MS as av, NS_PER_SEC as aw, NativeIndexBackend as ax, NativeListBackend as ay, NativeLogBackend as az, type AsyncSourceOpts as b, type WorkerBridge as b$, type ReactiveLogOptions as b0, type ReactiveMapBundle as b1, type ReactiveMapOptions as b2, type ReactiveSinkBackpressureOptions as b3, type ReactiveSinkConfig as b4, type ReactiveSinkHandle as b5, type ReactiveSinkOptions as b6, type ReactiveSinkRetryOptions as b7, type ReadyMessage as b8, type RedisCheckpointClientLike as b9, type ToKafkaOptions as bA, type ToLokiOptions as bB, type ToMongoOptions as bC, type ToNATSOptions as bD, type ToPostgresOptions as bE, type ToPulsarOptions as bF, type ToRabbitMQOptions as bG, type ToRedisStreamOptions as bH, type ToS3Options as bI, type ToSSEOptions as bJ, type ToSqliteOptions as bK, type ToTempoOptions as bL, type ToWebSocketOptions as bM, type TokenBucket as bN, type UpsertOptions as bO, type ValueMessage as bP, type VerifiableBundle as bQ, type VerifiableOptions as bR, type VerifyValue as bS, type WatermarkController as bT, type WatermarkOptions as bU, type WebSocketLike as bV, type WebSocketMessageEventLike as bW, type WebSocketRegister as bX, type WebhookRegister as bY, type WithBreakerBundle as bZ, type WithStatusBundle as b_, type RedisClientLike as ba, type RedisStreamEntry as bb, ResettableTimer as bc, type RetryOptions as bd, type RetrySourceOptions as be, type S3ClientLike as bf, type SSEEvent as bg, type SignalMessage as bh, type SinkFailure as bi, type SinkHandle as bj, type SinkTransportError as bk, type SqliteDbLike as bl, type SqliteIterableDbLike as bm, type StatsDMetric as bn, type StatsDRegister as bo, type StatusValue as bp, type SyslogMessage as bq, type SyslogRegister as br, type TapObserver as bs, type TempoClientLike as bt, type ThrottleOptions as bu, TimeoutError as bv, type ToCSVOptions as bw, type ToClickHouseOptions as bx, type ToFileOptions as by, type ToHTTPOptions as bz, type BackoffStrategy as c, fromNDJSON as c$, type WorkerBridgeOptions as c0, type WorkerSelfHandle as c1, type WorkerSelfOptions as c2, type WorkerTransport as c3, audit as c4, buffer as c5, bufferCount as c6, bufferTime as c7, cached as c8, cascadingCache as c9, index as cA, fallback as cB, fibonacci as cC, filter as cD, find as cE, first as cF, firstValueFrom as cG, firstWhere as cH, flatMap as cI, forEach as cJ, fromAny as cK, fromAsyncIter as cL, fromCSV as cM, fromClickHouseWatch as cN, fromCron as cO, fromDrizzle as cP, fromEvent as cQ, fromFSWatch as cR, fromGitHook as cS, fromHTTP as cT, fromHTTPPoll as cU, fromHTTPStream as cV, fromIter as cW, fromKafka as cX, fromKysely as cY, fromMCP as cZ, fromNATS as c_, catchError as ca, checkpointToRedis as cb, checkpointToS3 as cc, circuitBreaker as cd, combine as ce, combineLatest as cf, concat as cg, concatMap as ch, constant as ci, createTransport as cj, createWatermarkController as ck, csvRows as cl, debounce as cm, debounceTime as cn, decorrelatedJitter as co, delay as cp, deserializeError as cq, distill as cr, distinctUntilChanged as cs, elementAt as ct, empty as cu, escapeRegexChar as cv, exhaustMap as cw, exponential as cx, externalBundle as cy, externalProducer as cz, type BatchMessage as d, takeUntil as d$, fromOTel as d0, fromPrisma as d1, fromPrometheus as d2, fromPromise as d3, fromPulsar as d4, fromRabbitMQ as d5, fromRedisStream as d6, fromSSE as d7, fromSqlite as d8, fromSqliteCursor as d9, parseSyslog as dA, pausable as dB, pubsub as dC, race as dD, rateLimiter as dE, reactiveCounter as dF, reactiveIndex as dG, reactiveList as dH, reactiveLog as dI, reactiveMap as dJ, reactiveSink as dK, reduce as dL, repeat as dM, replay as dN, rescue as dO, resolveBackoffPreset as dP, retry as dQ, retrySource as dR, sample as dS, scan as dT, serializeError as dU, share as dV, shareReplay as dW, signalToName as dX, skip as dY, switchMap as dZ, take as d_, fromStatsD as da, fromSyslog as db, fromTimer as dc, fromWebSocket as dd, fromWebSocketReconnect as de, fromWebhook as df, globToRegExp as dg, interval as dh, keepalive as di, last as dj, linear as dk, lru as dl, map as dm, matchesAnyPattern as dn, matchesCron as dp, merge as dq, mergeMap as dr, nameToSignal as ds, ndjsonRows as dt, never as du, of as dv, pairwise as dw, parseCron as dx, parsePrometheusText as dy, parseStatsD as dz, type BridgeMessage as e, takeWhile as e0, tap as e1, throttle as e2, throttleTime as e3, throwError as e4, timeout as e5, toArray as e6, toCSV as e7, toClickHouse as e8, toFile as e9, workerBridge as eA, workerSelf as eB, zip as eC, toHTTP as ea, toKafka as eb, toLoki as ec, toMongo as ed, toNATS as ee, toPostgres as ef, toPulsar as eg, toRabbitMQ as eh, toReadableStream as ei, toRedisStream as ej, toS3 as ek, toSSE as el, toSSEBytes as em, toSqlite as en, toTempo as eo, toWebSocket as ep, tokenBucket as eq, valve as er, verifiable as es, window as et, windowCount as eu, windowTime as ev, withBreaker as ew, withLatestFrom as ex, withMaxAttempts as ey, withStatus as ez, type BufferedSinkHandle as f, type BundleTriad as g, type CacheEvictionPolicy as h, type CascadingCache as i, type CascadingCacheOptions as j, type CheckpointToRedisOptions as k, type CheckpointToS3Options as l, type CircuitBreaker as m, type CircuitBreakerOptions as n, CircuitOpenError as o, type CircuitState as p, type ClickHouseClientLike as q, type ClickHouseInsertClientLike as r, type ClickHouseRow as s, type CronSchedule as t, type DistillOptions as u, type DrizzleQueryLike as v, type EmitTriad as w, type ErrorMessage as x, type EventTargetLike as y, type ExponentialBackoffOptions as z };