@graphrefly/graphrefly 0.44.0 → 0.45.0

package/dist/index-BHskSB8v.d.ts

@@ -1,3413 +0,0 @@
-import { a as NodeOptions, N as Node, r as Message, M as Messages } from './node-kK3CvTrR.js';
-import { i as GraphCheckpointRecord, a as GraphOptions, G as Graph, D as DescribeChangeset, d as DescribeEvent, M as Meta, Q as topologyDiff } from './graph-D9LFnda9.js';
-import { a as BackoffStrategy, B as BackoffPreset, t as retry, j as WithStatusBundle, C as CircuitBreaker, b as CircuitBreakerOptions, c as CircuitOpenError, d as CircuitState, E as ExponentialBackoffOptions, F as FallbackInput, J as JitterMode, N as NS_PER_MS, e as NS_PER_SEC, R as RateLimiterOptions, f as RateLimiterOverflowError, g as RateLimiterOverflowPolicy, h as RetryOptions, S as StatusValue, T as TimeoutError, i as TokenBucket, W as WithBreakerBundle, k as circuitBreaker, l as constant, m as decorrelatedJitter, n as exponential, o as fallback, p as fibonacci, q as linear, r as rateLimiter, s as resolveBackoffPreset, u as timeout, v as tokenBucket, w as withBreaker, x as withMaxAttempts, y as withStatus } from './index-B1F8Enjf.js';
-import { AsyncSourceOpts, NodeInput, EventTargetLike, FromCronOptions, ReactiveCounterBundle, awaitSettled, cached, defer, empty, escapeRegexChar, firstValueFrom, firstWhere, forEach, fromAny, fromAsyncIter, fromCron, fromEvent, fromIter, fromPromise, fromRaf, fromTimer, globToRegExp, keepalive, matchesAnyPattern, never, nodeSignal, of, reactiveCounter, replay, share, shareReplay, throwError, toArray } from './extra/sources.js';
-import { SnapshotStorageTier, KvStorageTier, AppendCursor, AppendLoadResult, AppendLogStorageOptions, AppendLogStorageTier, BaseStorageTier, Codec, KvStorageOptions, SnapshotStorageOptions, StorageBackend, appendLogStorage, dictKv, dictSnapshot, jsonCodec, jsonCodecFor, kvStorage, memoryAppendLog, memoryBackend, memoryKv, memorySnapshot, snapshotStorage } from './extra/storage-tiers.js';
-import { D as DistillBundle, a as DistillOptions, E as Extraction, V as VerifiableBundle, b as VerifiableOptions, c as VerifyValue, d as decay, e as distill, v as verifiable } from './decay-BvOWTZ00.js';
-import { C as ContentAddressedMissError, a as ContentAddressedMode, b as ContentAddressedStorage, c as ContentAddressedStorageOptions, d as canonicalJson, e as contentAddressedStorage } from './content-addressed-storage-DuYMjV7o.js';
-import { A as AuditLogOpts, B as BaseAuditRecord, D as DEFAULT_AUDIT_GUARD, F as FailureMeta, L as LightMutationOpts, M as MutationOpts, S as SuccessMeta, W as WrapMutationOpts, a as appendAudit, b as bumpCursor, c as createAuditLog, l as lightMutation, r as registerCursor, d as registerCursorMap, t as tryIncrementBounded, w as wrapMutation } from './index-Yq60JP3s.js';
-import { T as ToObservableOptions, t as toObservable } from './observable-DWjNfLvC.js';
-import { MergeMapOptions, TapObserver, ThrottleOptions, audit, buffer, bufferCount, bufferTime, catchError, combine, combineLatest, concat, concatMap, debounce, debounceTime, delay, distinctUntilChanged, elementAt, exhaustMap, filter, find, first, flatMap, interval, last, map, merge, mergeMap, onFirstData, pairwise, pausable, race, reduce, repeat, rescue, sample, scan, skip, switchMap, take, takeUntil, takeWhile, tap, tapFirst, throttle, throttleTime, valve, window, windowCount, windowTime, withLatestFrom, zip } from './extra/operators.js';
-import { IndexBackend, IndexRow, ListBackend, NativeIndexBackend, NativeListBackend, ReactiveIndexBundle, ReactiveIndexOptions, ReactiveListBundle, ReactiveListOptions, UpsertOptions, reactiveIndex, reactiveList } from './extra/reactive.js';
-import { L as LogBackend, M as MergedReactiveLog, N as NativeLogBackend, a as ReactiveLogBundle, R as ReactiveLogOptions, V as ViewSpec, m as mergeReactiveLogs, r as reactiveLog } from './reactive-log-BKALbfal.js';
-import { M as MapBackend, N as NativeMapBackend, a as NativeMapBackendOptions, R as ReactiveMapBundle, b as ReactiveMapOptions, c as ReactiveMapRetention, r as reactiveMap } from './reactive-map-DS_SIAxv.js';
-import { StorageHandle, sortJsonValue, stableJsonString } from './extra/storage-core.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$1 = 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$1): 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$1;
-    };
-};
-/**
- * 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;
-};
-
-/**
- * {@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>;
-
-/**
- * `budgetGate` — numeric-constraint flow gate (Tier 2.2 promotion from
- * `patterns/reduction/`).
- *
- * Lives alongside the other `extra/resilience/` flow controls (`retry`,
- * `circuitBreaker`, `rateLimiter`, `tokenBucket`, `fallback`, `withStatus`).
- *
- * @module
- */
-
-/** A reactive constraint for {@link budgetGate}. */
-type BudgetConstraint<T = unknown> = {
-    /** Constraint node whose value is checked. */
-    node: Node<T>;
-    /** Returns `true` when the constraint is satisfied (budget available). */
-    check: (value: T) => boolean;
-};
-/** Options for {@link budgetGate}. */
-type BudgetGateOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
-    meta?: Record<string, unknown>;
-};
-/**
- * Pass-through that respects reactive constraint nodes.
- *
- * DATA flows through when all constraints are satisfied. When any constraint
- * is exceeded, `PAUSE` is sent upstream and DATA is buffered in a FIFO queue.
- * When constraints relax, the queue drains in arrival order and `RESUME` is
- * sent upstream.
- *
- * ## Invariants (do not refactor without preserving)
- *
- * 1. **Terminal force-flush.** On `COMPLETE` / `ERROR` arriving from `source`,
- *    every buffered item is emitted downstream BEFORE the terminal message is
- *    forwarded. The constraint is intentionally bypassed for the flush — once
- *    upstream is done, the caller must see the buffered work, not lose it.
- *    See COMPOSITION-GUIDE §19 (terminal-emission operators).
- *
- * 2. **PAUSE-release ordering.** When a constraint flips from saturated →
- *    released, the queue drains in FIFO order downstream BEFORE `RESUME` is
- *    sent upstream. Reversing the order (RESUME-then-drain) would let new
- *    upstream DATA interleave with the queue tail, breaking arrival-order
- *    delivery. See COMPOSITION-GUIDE §9, §9a (diamond + batch coalescing).
- *
- * 3. **Deferred RESOLVED.** A `RESOLVED` from `source` while the queue is
- *    non-empty is held until the queue drains, then forwarded — so downstream
- *    sees `[buffered DATA…, RESOLVED]` in causal order rather than
- *    `[RESOLVED, buffered DATA…]`.
- *
- *    **Stall risk (qa D4):** if the constraint never relaxes AND no terminal
- *    arrives from `source`, the deferred RESOLVED is held forever. Downstream
- *    consumers that depend on `RESOLVED` for an `awaitSettled`-style
- *    coordination wait stall in this case. PAUSE is sent upstream so source
- *    backpressure stops further DATA, but the gate itself has no escape
- *    hatch — by design (the producer-pattern is fire-and-forget; recovery
- *    happens at the compositor level via timeout, retry, or cancellation).
- *
- * 4. **Constraint DIRTY suppression.** Constraint-node DIRTY does NOT
- *    propagate downstream — only `source`-DIRTY does. The gate's downstream
- *    semantics track `source`'s wave, not constraint waves.
- *
- * 5. **Lazy PAUSE (qa D3).** PAUSE is sent upstream ONLY when a `source` DATA
- *    arrives that fails the constraint check (the first blocked item). A
- *    constraint flipping closed BEFORE any source DATA arrives does NOT emit
- *    a preemptive PAUSE — upstream may push DATA freely until the first
- *    item is buffered. This matches the producer-pattern lazy-activation
- *    philosophy (don't impose backpressure for hypothetical future blocks).
- *    For eager-PAUSE semantics, wrap the gate in a compositor that watches
- *    constraints + source independently.
- *
- * ## Queue
- *
- * The internal buffer is an unbounded {@link HeadIndexQueue} (O(1) push,
- * O(1) shift, opportunistic compaction). It does NOT use {@link RingBuffer}
- * because RingBuffer's drop-oldest eviction would silently lose buffered
- * items between PAUSE and RESUME. Backpressure (PAUSE) is the upstream
- * contract for bounding the queue, not capacity-driven eviction here.
- *
- * ## Producer-pattern: source edge is invisible to `describe()`
- *
- * `budgetGate` is constructed via `node([], fn)` and subscribes to `source`
- * and the constraint nodes manually inside its activation fn. Because no
- * dep is declared at construction, **`describe()` shows no edge from
- * `source` (or any constraint) into the returned node** — the gate looks
- * like a standalone leaf source. This is intentional (see COMPOSITION-GUIDE
- * §24 "Edges are derived, not declared"): if you want the constraint /
- * source dependency to appear in describe output, surface it at the
- * compositor level (e.g. annotate via `meta.ai.upstream`, or wrap the gate
- * in a parent factory that exposes the deps as constructor args).
- *
- * ## Reference equality + Tier 6.5 3.2.5 locked semantics
- *
- * **Constraint VALUES are reactive.** Each `BudgetConstraint.node` is
- * subscribed at activation; per-value changes flip the gate (re-evaluate
- * in the same wave) and trigger PAUSE/RESUME upstream. Per the locked
- * semantic rule for the reactive-options-widening batch (Tier 6.5 3.2.5,
- * 2026-04-29): "constraints array re-evaluated immediately against
- * current source; adding/removing constraints triggers gate
- * re-evaluation in the same wave" — the per-value half is shipped via
- * the existing constraint-Node subscription model.
- *
- * **The constraints ARRAY shape is static.** The factory captures the
- * `constraints` array reference and each `check` function at
- * construction; it does NOT diff subsequent arrays. To add or remove
- * constraints reactively, build the swap at the compositor level (a
- * `switchMap` rebuild over a constraint-shape Node), or construct a new
- * gate. Dynamic constraint-array reactivity is intentionally deferred —
- * the subscription churn (resub on every constraint add/remove) and
- * `latestValues` shape mutation overshoot the budget-gate's
- * fire-and-forget ergonomics.
- *
- * @param source - Input node.
- * @param constraints - Reactive constraint checks. MUST be non-empty.
- * @param opts - Optional node options.
- * @returns Gated node.
- *
- * @throws {RangeError} when `constraints.length === 0`. The gate has no
- *   meaningful identity without at least one check — degenerate to plain
- *   pass-through (e.g. via `derived([source], ([v]) => v)`) instead.
- *
- * @category resilience
- */
-declare function budgetGate<T>(source: Node<T>, constraints: ReadonlyArray<BudgetConstraint>, opts?: BudgetGateOptions): Node<T>;
-
-/**
- * Protocol, system, and ingest adapters (roadmap §5.2, §5.2c).
- *
- * Each adapter wraps an external protocol or system as a reactive {@link Node}
- * built on {@link producer} / {@link node} — no second protocol.
- *
- * **Moved from sources.ts:** fromHTTP, fromWebSocket/toWebSocket, fromWebhook,
- * toSSE, fromMCP, fromGitHook.
- *
- * **New (5.2c):** fromOTel, fromSyslog, fromStatsD, fromPrometheus,
- * fromKafka/toKafka, fromRedisStream/toRedisStream, fromCSV, fromNDJSON,
- * fromClickHouseWatch, fromPulsar/toPulsar, fromNATS/toNATS,
- * fromRabbitMQ/toRabbitMQ.
- */
-
-/** Handle returned by per-record and buffered sinks. */
-type SinkHandle = {
-    /** Stop the sink (unsubscribe from source). */
-    dispose: () => void;
-    /** Reactive node that emits the latest transport error (or `null`). */
-    errors: Node<SinkTransportError | null>;
-    /** Manually drain the internal buffer (buffered sinks only). */
-    flush?: () => Promise<void>;
-};
-type ExtraOpts = Omit<NodeOptions, "describeKind">;
-/** WebSocket-like transport accepted by {@link fromWebSocket} / {@link toWebSocket}. */
-type WebSocketLike = {
-    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
-    close(code?: number, reason?: string): void;
-    addEventListener(type: "message" | "error" | "close", listener: (ev: unknown) => void): void;
-    removeEventListener(type: "message" | "error" | "close", listener: (ev: unknown) => void): void;
-};
-type WebSocketMessageEventLike = {
-    data: unknown;
-};
-type WebSocketRegister<T> = (emit: (payload: T) => void, error: (err: unknown) => void, complete: () => void) => () => void;
-/**
- * Wraps a WebSocket as a GraphReFly producer source.
- *
- * Incoming socket messages are emitted as `DATA`; socket `error` emits `ERROR`; socket `close`
- * emits `COMPLETE`. Teardown detaches listeners and optionally closes the socket.
- *
- * @category extra
- */
-declare function fromWebSocket<T = unknown>(socket: WebSocketLike, opts?: ExtraOpts & {
-    parse?: (payload: unknown, event: unknown) => T;
-    closeOnTeardown?: boolean;
-}): Node<T>;
-declare function fromWebSocket<T = unknown>(register: WebSocketRegister<T>, opts?: ExtraOpts & {
-    parse?: (payload: unknown, event: unknown) => T;
-    closeOnTeardown?: boolean;
-}): Node<T>;
-/** 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.
- *
- * The `register` callback wires your runtime/framework callback to GraphReFly and may return a
- * cleanup function. This keeps the adapter runtime-agnostic while following the same producer
- * pattern as {@link fromEvent}.
- *
- * @param register - Registers webhook handlers (`emit`, `error`, `complete`) and optionally returns cleanup.
- * @param opts - Optional producer options.
- * @returns `Node<T>` — webhook payloads as `DATA`; teardown runs returned cleanup.
- *
- * @example
- * ```ts
- * import express from "express";
- * import { fromWebhook } from "@graphrefly/graphrefly-ts";
- *
- * type HookPayload = { event: string; data: unknown };
- * const app = express();
- * app.use(express.json());
- *
- * const hook$ = fromWebhook<HookPayload>(({ emit, error }) => {
- *   const handler = (req: express.Request, res: express.Response) => {
- *     try {
- *       emit(req.body as HookPayload);
- *       res.status(200).send("ok");
- *     } catch (e) {
- *       error(e);
- *       res.status(500).send("error");
- *     }
- *   };
- *   app.post("/webhook", handler);
- *   return () => {
- *     // Express has no direct route-removal API in common use.
- *   };
- * });
- * ```
- *
- * @example Fastify
- * ```ts
- * import Fastify from "fastify";
- * import { fromWebhook } from "@graphrefly/graphrefly-ts";
- *
- * const fastify = Fastify();
- * const hook$ = fromWebhook<any>(({ emit, error }) => {
- *   const handler = async (req: any, reply: any) => {
- *     try {
- *       emit(req.body);
- *       reply.code(200).send({ ok: true });
- *     } catch (e) {
- *       error(e);
- *       reply.code(500).send({ ok: false });
- *     }
- *   };
- *   fastify.post("/webhook", handler);
- *   return () => {};
- * });
- * ```
- *
- * @category extra
- */
-declare function fromWebhook<T = unknown>(register: WebhookRegister<T>, opts?: ExtraOpts): Node<T>;
-/**
- * Options for {@link fromHTTP}.
- *
- * @category extra
- */
-interface FromHTTPOptions extends AsyncSourceOpts {
-    /** HTTP method. Default: `"GET"`. */
-    method?: string;
-    /** Request headers. */
-    headers?: Record<string, string>;
-    /** Request body (for POST/PUT/PATCH). */
-    body?: any;
-    /** Transform the Response before emitting. Default: `response.json()`. */
-    transform?: (response: Response) => any | Promise<any>;
-    /** Request timeout in **nanoseconds**. Default: `30s` (30 * NS_PER_SEC). */
-    timeoutNs?: number;
-    /**
-     * 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.
- *
- * @category extra
- */
-type HTTPBundle<T> = WithStatusBundle<T> & {
-    /** Number of successful fetches. */
-    fetchCount: Node<number>;
-    /** Nanosecond wall-clock timestamp of the last successful fetch. */
-    lastUpdated: Node<number>;
-    /**
-     * `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.
- *
- * @category extra
- */
-declare function fromHTTP<T = any>(url: string, opts?: FromHTTPOptions): HTTPBundle<T>;
-/** Options for {@link toHTTP}. */
-type ToHTTPOptions<T> = ExtraOpts & {
-    /** 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)`. */
-    serialize?: (value: unknown) => string;
-    /** Event name for DATA tuples. Default: `"data"`. */
-    dataEvent?: string;
-    /** Event name for ERROR tuples. Default: `"error"`. */
-    errorEvent?: string;
-    /** Event name for COMPLETE tuples. Default: `"complete"`. */
-    completeEvent?: string;
-    /** Emit `event: resolved` when RESOLVED arrives. Default: `false`. */
-    includeResolved?: boolean;
-    /** Emit `event: dirty` when DIRTY arrives. Default: `false`. */
-    includeDirty?: boolean;
-    /** Add SSE comment keepalive frames (`: keepalive`) on an interval. Disabled when unset. */
-    keepAliveMs?: number;
-    /** Optional abort signal to terminate the stream early. */
-    signal?: AbortSignal;
-    /** Maps custom message types to SSE event names. */
-    eventNameResolver?: (type: symbol) => string;
-};
-/**
- * Creates a standard Server-Sent Events stream from node messages.
- *
- * @category extra
- */
-declare function toSSE<T>(source: Node<T>, opts?: ToSSEOptions): ReadableStream<Uint8Array>;
-/**
- * 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 & {
-    /** Parse the raw `data:` payload. Default: identity (string). */
-    parse?: (raw: string) => T;
-};
-/** Options for {@link parseSSEStream}. */
-type ParseSSEStreamOptions<T = string> = {
-    /** Parse the raw `data:` payload. Default: identity (string). */
-    parse?: (raw: string) => T;
-    /**
-     * External abort signal. If aborted, the generator returns early after
-     * cancelling the underlying reader / iterator. Does not emit an error —
-     * the generator simply ends.
-     */
-    signal?: AbortSignal;
-};
-/**
- * Parses a Server-Sent Events byte stream into an async-iterator of structured
- * `{event, data, id, retry}` records. Pure async generator with no reactive
- * dependency — safe to consume anywhere an `AsyncIterable<SSEEvent>` is
- * expected (LLM provider adapters, tests, non-reactive transports).
- *
- * Handles:
- * - Arbitrary chunk boundaries (internal text buffer + `TextDecoder` streaming).
- * - `\n` and `\r\n` line endings.
- * - `event:` / `data:` (multi-line via repeated fields) / `id:` / `retry:`.
- * - Comments (`:` prefix).
- * - Cancels the underlying reader / iterator on external abort or consumer
- *   break, so a quiet stream doesn't leak pending `read()` calls.
- *
- * Used internally by {@link fromSSE} (reactive `Node<SSEEvent>`) — exposed as a
- * pure helper so LLM provider adapters (Anthropic, OpenAI, Google) can parse
- * their SSE streams without building a reactive node per call.
- *
- * @param source - SSE byte source (`ReadableStream`, `Response`, or `AsyncIterable<Uint8Array>`).
- * @param opts - `{ parse?, signal? }`.
- * @returns `AsyncGenerator<SSEEvent<T>>` — yields one event per SSE block; returns on stream end / abort.
- *
- * @category extra
- */
-declare function parseSSEStream<T = string>(source: ReadableStream<Uint8Array> | Response | AsyncIterable<Uint8Array>, opts?: ParseSSEStreamOptions<T>): AsyncGenerator<SSEEvent<T>, void, unknown>;
-/**
- * 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 & {
-    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(...)`. */
-    serialize?: (value: T) => string | ArrayBufferLike | Blob | ArrayBufferView;
-    /** Close socket when upstream emits COMPLETE. Default: `true`. */
-    closeOnComplete?: boolean;
-    /** Close socket when upstream emits ERROR. Default: `true`. */
-    closeOnError?: boolean;
-    /** Optional close code used when close is triggered by terminal tuples. */
-    closeCode?: number;
-    /** Optional close reason used when close is triggered by terminal tuples. */
-    closeReason?: string;
-    /** Structured callback — 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>): ReactiveSinkHandle<T>;
-/** Options for {@link fromWebSocketReconnect}. */
-type FromWebSocketReconnectOptions<T> = ExtraOpts & {
-    /** Optional parser applied to incoming messages. */
-    parse?: (payload: unknown, event: unknown) => T;
-    /** Max reconnect attempts. Default: `Infinity` (implied when `backoff` is set). */
-    maxRetries?: number;
-    /** Backoff strategy (ns) or preset name. Default: `"exponential"`. */
-    backoff?: Parameters<typeof retry>[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 retry} rebuilds the inner source and reconnects.
- *
- * For transient errors, {@link retry} 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.
- */
-type MCPClientLike = {
-    setNotificationHandler(method: string, handler: (notification: unknown) => void): void;
-};
-/** Options for {@link fromMCP}. */
-type FromMCPOptions = ExtraOpts & {
-    /** MCP notification method to subscribe to. Default `"notifications/message"`. */
-    method?: string;
-    onDisconnect?: (cb: (err?: unknown) => void) => void;
-};
-/**
- * Wraps an MCP client's server-push notifications as a reactive source.
- *
- * @category extra
- */
-declare function fromMCP<T = unknown>(client: MCPClientLike, opts?: FromMCPOptions): Node<T>;
-/** 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 = {
-    traceId: string;
-    spanId: string;
-    operationName: string;
-    serviceName: string;
-    startTimeNs: number;
-    endTimeNs: number;
-    status: "OK" | "ERROR" | "UNSET";
-    attributes: Record<string, unknown>;
-    events: Array<{
-        name: string;
-        timestampNs: number;
-        attributes?: Record<string, unknown>;
-    }>;
-};
-/** Structured OTel metric data point. */
-type OTelMetric = {
-    name: string;
-    description?: string;
-    unit?: string;
-    type: "gauge" | "sum" | "histogram" | "summary";
-    value: number;
-    attributes: Record<string, unknown>;
-    timestampNs: number;
-};
-/** Structured OTel log record. */
-type OTelLog = {
-    timestampNs: number;
-    severityNumber?: number;
-    severityText?: string;
-    body: unknown;
-    attributes: Record<string, unknown>;
-    traceId?: string;
-    spanId?: string;
-};
-/** Registration callback for the OTLP/HTTP receiver. */
-type OTelRegister = (handlers: {
-    onTraces: (spans: OTelSpan[]) => void;
-    onMetrics: (metrics: OTelMetric[]) => void;
-    onLogs: (logs: OTelLog[]) => void;
-    onError: (err: unknown) => void;
-}) => (() => void) | undefined;
-/** Options for {@link fromOTel}. */
-type FromOTelOptions = ExtraOpts & {};
-/** Bundle returned by {@link fromOTel}. */
-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.
- *
- * The caller owns the HTTP server. `fromOTel` receives a `register` callback that
- * wires OTLP POST endpoints to the three signal handlers. Each signal type gets
- * its own `Node` so downstream can subscribe selectively.
- *
- * @param register - Wires OTLP HTTP routes to `onTraces`, `onMetrics`, `onLogs` handlers.
- * @param opts - Optional producer options.
- * @returns {@link OTelBundle} — `{ traces, metrics, logs }` nodes.
- *
- * @example
- * ```ts
- * import express from "express";
- * import { fromOTel } from "@graphrefly/graphrefly-ts";
- *
- * const app = express();
- * app.use(express.json());
- *
- * const otel = fromOTel(({ onTraces, onMetrics, onLogs }) => {
- *   app.post("/v1/traces", (req, res) => { onTraces(req.body.resourceSpans ?? []); res.sendStatus(200); });
- *   app.post("/v1/metrics", (req, res) => { onMetrics(req.body.resourceMetrics ?? []); res.sendStatus(200); });
- *   app.post("/v1/logs", (req, res) => { onLogs(req.body.resourceLogs ?? []); res.sendStatus(200); });
- *   return () => {};
- * });
- * ```
- *
- * @category extra
- */
-declare function fromOTel(register: OTelRegister, opts?: FromOTelOptions): OTelBundle;
-/** Parsed syslog message (RFC 5424). */
-type SyslogMessage = {
-    facility: number;
-    severity: number;
-    timestamp: string;
-    hostname: string;
-    appName: string;
-    procId: string;
-    msgId: string;
-    message: string;
-    timestampNs: number;
-};
-/** Registration callback for syslog receiver. Alias of {@link ExternalRegister} over {@link EmitTriad}. */
-type SyslogRegister = ExternalRegister<EmitTriad<SyslogMessage>>;
-/** Options for {@link fromSyslog}. */
-type FromSyslogOptions = ExtraOpts & {};
-/**
- * RFC 5424 syslog receiver as a reactive source.
- *
- * The caller owns the UDP/TCP socket. `fromSyslog` receives a `register` callback
- * that wires socket data events to the `emit` handler with parsed syslog messages.
- *
- * @param register - Wires socket to emit/error/complete handlers.
- * @param opts - Optional producer options.
- * @returns `Node<SyslogMessage>` — one `DATA` per syslog message.
- *
- * @example
- * ```ts
- * import dgram from "node:dgram";
- * import { fromSyslog, parseSyslog } from "@graphrefly/graphrefly-ts";
- *
- * const server = dgram.createSocket("udp4");
- * const syslog$ = fromSyslog(({ emit, error }) => {
- *   server.on("message", (buf) => {
- *     try { emit(parseSyslog(buf.toString())); }
- *     catch (e) { error(e); }
- *   });
- *   server.bind(514);
- *   return () => server.close();
- * });
- * ```
- *
- * @category extra
- */
-declare function fromSyslog(register: SyslogRegister, opts?: FromSyslogOptions): Node<SyslogMessage>;
-/**
- * Parses a raw RFC 5424 syslog line into a structured {@link SyslogMessage}.
- *
- * Format: `<PRI>VERSION TIMESTAMP HOSTNAME APP-NAME PROCID MSGID MSG`
- *
- * @category extra
- */
-declare function parseSyslog(raw: string): SyslogMessage;
-/** Parsed StatsD metric. */
-type StatsDMetric = {
-    name: string;
-    value: number;
-    type: "counter" | "gauge" | "timer" | "histogram" | "set" | "distribution";
-    sampleRate?: number;
-    tags: Record<string, string>;
-    timestampNs: number;
-};
-/** Registration callback for StatsD receiver. Alias of {@link ExternalRegister} over {@link EmitTriad}. */
-type StatsDRegister = ExternalRegister<EmitTriad<StatsDMetric>>;
-/** Options for {@link fromStatsD}. */
-type FromStatsDOptions = ExtraOpts & {};
-/**
- * StatsD/DogStatsD UDP receiver as a reactive source.
- *
- * The caller owns the UDP socket. `fromStatsD` receives a `register` callback
- * that wires datagrams to the `emit` handler with parsed metrics.
- *
- * @param register - Wires socket to emit/error/complete handlers.
- * @param opts - Optional producer options.
- * @returns `Node<StatsDMetric>` — one `DATA` per metric line.
- *
- * @example
- * ```ts
- * import dgram from "node:dgram";
- * import { fromStatsD, parseStatsD } from "@graphrefly/graphrefly-ts";
- *
- * const server = dgram.createSocket("udp4");
- * const stats$ = fromStatsD(({ emit, error }) => {
- *   server.on("message", (buf) => {
- *     for (const line of buf.toString().split("\\n")) {
- *       if (line.trim()) {
- *         try { emit(parseStatsD(line)); }
- *         catch (e) { error(e); }
- *       }
- *     }
- *   });
- *   server.bind(8125);
- *   return () => server.close();
- * });
- * ```
- *
- * @category extra
- */
-declare function fromStatsD(register: StatsDRegister, opts?: FromStatsDOptions): Node<StatsDMetric>;
-/**
- * Parses a raw StatsD/DogStatsD line into a structured {@link StatsDMetric}.
- *
- * Format: `metric.name:value|type|@sampleRate|#tag1:val1,tag2:val2`
- *
- * @category extra
- */
-declare function parseStatsD(line: string): StatsDMetric;
-/** Parsed Prometheus metric. */
-type PrometheusMetric = {
-    name: string;
-    labels: Record<string, string>;
-    value: number;
-    timestampMs?: number;
-    type?: "counter" | "gauge" | "histogram" | "summary" | "untyped";
-    help?: string;
-    timestampNs: number;
-};
-/** Options for {@link fromPrometheus}. */
-type FromPrometheusOptions = AsyncSourceOpts & {
-    /** Scrape interval in nanoseconds. Default `15 * NS_PER_SEC` (15s). */
-    intervalNs?: number;
-    /** Request headers for the scrape. */
-    headers?: Record<string, string>;
-    /** Request timeout in nanoseconds. Default `10 * NS_PER_SEC` (10s). */
-    timeoutNs?: number;
-    /**
-     * 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.
- *
- * Each scrape parses the exposition format and emits one `DATA` per metric line.
- * Uses `fromTimer` semantics internally (reactive timer source, not polling).
- *
- * @param endpoint - URL of the Prometheus metrics endpoint.
- * @param opts - Scrape interval, headers, timeout.
- * @returns `Node<PrometheusMetric>` — one `DATA` per metric per scrape.
- *
- * @example
- * ```ts
- * import { fromPrometheus } from "@graphrefly/graphrefly-ts";
- *
- * const prom$ = fromPrometheus("http://localhost:9090/metrics", { intervalNs: 30 * NS_PER_SEC });
- * ```
- *
- * @category extra
- */
-declare function fromPrometheus(endpoint: string, opts?: FromPrometheusOptions): Node<PrometheusMetric>;
-/**
- * Parses Prometheus exposition format text into structured metrics.
- *
- * @category extra
- */
-declare function parsePrometheusText(text: string): PrometheusMetric[];
-/** Duck-typed Kafka consumer (compatible with kafkajs, confluent-kafka, Pulsar KoP). */
-type KafkaConsumerLike = {
-    subscribe(opts: {
-        topic: string;
-        fromBeginning?: boolean;
-    }): Promise<void>;
-    run(opts: {
-        eachMessage: (payload: {
-            topic: string;
-            partition: number;
-            message: {
-                key: Buffer | null;
-                value: Buffer | null;
-                headers?: Record<string, Buffer | string | undefined>;
-                offset: string;
-                timestamp: string;
-            };
-        }) => Promise<void>;
-    }): Promise<void>;
-    disconnect(): Promise<void>;
-};
-/** Duck-typed Kafka producer. */
-type KafkaProducerLike = {
-    send(record: {
-        topic: string;
-        messages: Array<{
-            key?: string | Buffer | null;
-            value: string | Buffer | null;
-            headers?: Record<string, string | Buffer>;
-        }>;
-    }): Promise<void>;
-    disconnect(): Promise<void>;
-};
-/** Structured Kafka message. */
-type KafkaMessage<T = unknown> = {
-    topic: string;
-    partition: number;
-    key: string | null;
-    value: T;
-    headers: Record<string, string>;
-    offset: string;
-    timestamp: string;
-    timestampNs: number;
-};
-/** Options for {@link fromKafka}. */
-type FromKafkaOptions = ExtraOpts & {
-    /** Start from beginning of topic. Default: `false`. */
-    fromBeginning?: boolean;
-    /** Deserialize message value. Default: `JSON.parse(buffer.toString())`. */
-    deserialize?: (value: Buffer | null) => unknown;
-};
-/**
- * Kafka consumer as a reactive source.
- *
- * Wraps a KafkaJS-compatible consumer. Each message becomes a `DATA` emission.
- * Compatible with Pulsar via KoP (Kafka-on-Pulsar).
- *
- * @param consumer - KafkaJS-compatible consumer instance (caller owns connect/disconnect lifecycle).
- * @param topic - Topic to consume from.
- * @param opts - Deserialization and source options.
- * @returns `Node<KafkaMessage<T>>` — one `DATA` per Kafka message.
- *
- * @example
- * ```ts
- * import { Kafka } from "kafkajs";
- * import { fromKafka } from "@graphrefly/graphrefly-ts";
- *
- * const kafka = new Kafka({ brokers: ["localhost:9092"] });
- * const consumer = kafka.consumer({ groupId: "my-group" });
- * await consumer.connect();
- *
- * const events$ = fromKafka(consumer, "events", { deserialize: (buf) => JSON.parse(buf!.toString()) });
- * ```
- *
- * @category extra
- */
-declare function fromKafka<T = unknown>(consumer: KafkaConsumerLike, topic: string, opts?: FromKafkaOptions): Node<KafkaMessage<T>>;
-/** Options for {@link toKafka}. */
-type ToKafkaOptions<T> = ExtraOpts & {
-    /** Serialize value for Kafka. Default: `JSON.stringify`. */
-    serialize?: (value: T) => string | Buffer;
-    /** Extract message key from value. Default: `null` (no key). */
-    keyExtractor?: (value: T) => string | null;
-    /** Called on serialization or send failures. */
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * Kafka producer sink — forwards upstream `DATA` to a Kafka topic.
- *
- * @param source - Upstream node to forward.
- * @param kafkaProducer - KafkaJS-compatible producer instance.
- * @param topic - Target topic.
- * @param opts - Serialization and key extraction options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-declare function toKafka<T>(source: Node<T>, kafkaProducer: KafkaProducerLike, topic: string, opts?: ToKafkaOptions<T>): ReactiveSinkHandle<T>;
-/** Duck-typed Redis client (compatible with ioredis, redis). */
-type RedisClientLike = {
-    xadd(key: string, id: string, ...fieldsAndValues: string[]): Promise<string>;
-    xread(...args: Array<string | number>): Promise<Array<[string, Array<[string, string[]]>]> | null>;
-    disconnect(): void;
-};
-/** Structured Redis Stream entry. */
-type RedisStreamEntry<T = unknown> = {
-    id: string;
-    key: string;
-    data: T;
-    timestampNs: number;
-};
-/** Options for {@link fromRedisStream}. */
-type FromRedisStreamOptions = ExtraOpts & {
-    /** Block timeout in ms for XREAD. Default: `5000`. */
-    blockMs?: number;
-    /** Start ID. Default: `"$"` (new entries only). */
-    startId?: string;
-    /** Parse raw Redis hash fields to structured data. Default: parses `data` field as JSON. */
-    parse?: (fields: string[]) => unknown;
-};
-/**
- * Redis Streams consumer as a reactive source.
- *
- * Uses XREAD with BLOCK to reactively consume stream entries.
- *
- * @param client - ioredis/redis-compatible client (caller owns connection).
- * @param key - Redis stream key.
- * @param opts - Block timeout, start ID, and parsing options.
- * @returns `Node<RedisStreamEntry<T>>` — one `DATA` per stream entry.
- *
- * @remarks
- * **COMPLETE:** This source never emits `COMPLETE` under normal operation — it
- * is a long-lived stream consumer that runs until teardown or error, same as
- * Kafka consumers. If you need a bounded read, wrap with `take()` or
- * `takeUntil()`.
- *
- * **Client lifecycle:** The caller owns the Redis client connection. The adapter
- * does not call `disconnect()` on teardown — the caller is responsible for
- * closing the connection (same contract as `fromKafka`).
- *
- * @category extra
- */
-declare function fromRedisStream<T = unknown>(client: RedisClientLike, key: string, opts?: FromRedisStreamOptions): Node<RedisStreamEntry<T>>;
-/** Options for {@link toRedisStream}. */
-type ToRedisStreamOptions<T> = ExtraOpts & {
-    /** Serialize value to Redis hash fields. Default: `["data", JSON.stringify(value)]`. */
-    serialize?: (value: T) => string[];
-    /** Max stream length (MAXLEN ~). Default: no trimming. */
-    maxLen?: number;
-    /** Called on serialization or send failures. */
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * Redis Streams producer sink — forwards upstream `DATA` to a Redis stream.
- *
- * @param source - Upstream node to forward.
- * @param client - ioredis/redis-compatible client.
- * @param key - Redis stream key.
- * @param opts - Serialization options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-declare function toRedisStream<T>(source: Node<T>, client: RedisClientLike, key: string, opts?: ToRedisStreamOptions<T>): ReactiveSinkHandle<T>;
-/** Parsed CSV row. */
-type CSVRow = Record<string, string>;
-/** Options for {@link fromCSV}. */
-type FromCSVOptions = ExtraOpts & {
-    /** Column delimiter. Default: `","`. */
-    delimiter?: string;
-    /** Whether the first row is a header. Default: `true`. */
-    hasHeader?: boolean;
-    /** Explicit column names (overrides header row). */
-    columns?: string[];
-    /** Custom line parser (e.g. wrapping a library like `csv-parse`). Overrides built-in parser + delimiter. */
-    parseLine?: (line: string) => string[];
-};
-/**
- * CSV file/stream ingest for batch replay.
- *
- * Reads a CSV from a `ReadableStream<string>` or an `AsyncIterable<string>` of lines,
- * emitting one `DATA` per row. `COMPLETE` after all rows are emitted.
- *
- * @param source - Async iterable of CSV text chunks (lines or multi-line chunks).
- * @param opts - Delimiter, header, and column options.
- * @returns `Node<CSVRow>` — one `DATA` per parsed row.
- *
- * @example
- * ```ts
- * import { createReadStream } from "node:fs";
- * import { fromCSV } from "@graphrefly/graphrefly-ts";
- *
- * const csv$ = fromCSV(createReadStream("data.csv", "utf-8"));
- * ```
- *
- * @category extra
- */
-declare function fromCSV(source: AsyncIterable<string>, opts?: FromCSVOptions): Node<CSVRow>;
-/**
- * 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): Node<T>;
-/** Options for {@link fromNDJSON}. */
-type FromNDJSONOptions = ExtraOpts & {};
-/**
- * Newline-delimited JSON stream ingest for batch replay.
- *
- * Reads an async iterable of text chunks, splits by newline, parses each line
- * as JSON, and emits one `DATA` per parsed object. `COMPLETE` after stream ends.
- *
- * @param source - Async iterable of NDJSON text chunks.
- * @param opts - Optional producer options.
- * @returns `Node<T>` — one `DATA` per JSON line.
- *
- * @example
- * ```ts
- * import { createReadStream } from "node:fs";
- * import { fromNDJSON } from "@graphrefly/graphrefly-ts";
- *
- * const logs$ = fromNDJSON(createReadStream("logs.ndjson", "utf-8"));
- * ```
- *
- * @category extra
- */
-declare function fromNDJSON<T = unknown>(source: AsyncIterable<string>, opts?: FromNDJSONOptions): Node<T>;
-/** Structured ClickHouse query result row. */
-type ClickHouseRow = Record<string, unknown>;
-/** Duck-typed ClickHouse client. */
-type ClickHouseClientLike = {
-    query(opts: {
-        query: string;
-        format?: string;
-    }): Promise<{
-        json<T = unknown>(): Promise<T[]>;
-    }>;
-};
-/** Options for {@link fromClickHouseWatch}. */
-type FromClickHouseWatchOptions = AsyncSourceOpts & {
-    /** Polling interval in nanoseconds. Default: `5 * NS_PER_SEC` (5s). */
-    intervalNs?: number;
-    /** JSON format to request. Default: `"JSONEachRow"`. */
-    format?: string;
-    /**
-     * 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.
- *
- * Polls a ClickHouse query on a reactive timer interval and emits new/changed rows.
- * Uses a timer-driven approach (not busy-wait polling).
- *
- * @param client - ClickHouse client instance (caller owns connection).
- * @param query - SQL query to execute on each interval.
- * @param opts - Polling interval and format options.
- * @returns `Node<ClickHouseRow>` — one `DATA` per result row per scrape.
- *
- * @example
- * ```ts
- * import { createClient } from "@clickhouse/client";
- * import { fromClickHouseWatch } from "@graphrefly/graphrefly-ts";
- *
- * const client = createClient({ url: "http://localhost:8123" });
- * const rows$ = fromClickHouseWatch(client, "SELECT * FROM errors_mv ORDER BY timestamp DESC LIMIT 100");
- * ```
- *
- * @category extra
- */
-declare function fromClickHouseWatch(client: ClickHouseClientLike, query: string, opts?: FromClickHouseWatchOptions): Node<ClickHouseRow>;
-/** Duck-typed Pulsar consumer (compatible with pulsar-client). */
-type PulsarConsumerLike = {
-    receive(): Promise<{
-        getData(): Buffer;
-        getMessageId(): {
-            toString(): string;
-        };
-        getPartitionKey(): string;
-        getProperties(): Record<string, string>;
-        getPublishTimestamp(): number;
-        getEventTimestamp(): number;
-        getTopicName(): string;
-    }>;
-    acknowledge(msg: unknown): Promise<void>;
-    close(): Promise<void>;
-};
-/** Duck-typed Pulsar producer. */
-type PulsarProducerLike = {
-    send(msg: {
-        data: Buffer;
-        partitionKey?: string;
-        properties?: Record<string, string>;
-    }): Promise<void>;
-    close(): Promise<void>;
-};
-/** Structured Pulsar message. */
-type PulsarMessage<T = unknown> = {
-    topic: string;
-    messageId: string;
-    key: string;
-    value: T;
-    properties: Record<string, string>;
-    publishTime: number;
-    eventTime: number;
-    timestampNs: number;
-};
-/** Options for {@link fromPulsar}. */
-type FromPulsarOptions = ExtraOpts & {
-    /** Deserialize message data. Default: `JSON.parse(buffer.toString())`. */
-    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).
- *
- * Wraps a `pulsar-client`-compatible consumer. Each message becomes a `DATA` emission.
- * For Kafka-on-Pulsar (KoP), use {@link fromKafka} instead.
- *
- * @param consumer - Pulsar consumer instance (caller owns create/close lifecycle).
- * @param opts - Deserialization and source options.
- * @returns `Node<PulsarMessage<T>>` — one `DATA` per Pulsar message.
- *
- * @remarks
- * Teardown sets an internal flag but cannot interrupt a pending `consumer.receive()`.
- * The loop exits on the next message or when the consumer is closed externally.
- * Callers should call `consumer.close()` after unsubscribing for prompt cleanup.
- *
- * @example
- * ```ts
- * import Pulsar from "pulsar-client";
- * import { fromPulsar } from "@graphrefly/graphrefly-ts";
- *
- * const client = new Pulsar.Client({ serviceUrl: "pulsar://localhost:6650" });
- * const consumer = await client.subscribe({ topic: "events", subscription: "my-sub" });
- * const events$ = fromPulsar(consumer);
- * ```
- *
- * @category extra
- */
-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 & {
-    /** Serialize value for Pulsar. Default: `JSON.stringify` → Buffer. */
-    serialize?: (value: T) => Buffer;
-    /** Extract partition key from value. Default: none. */
-    keyExtractor?: (value: T) => string | undefined;
-    /** Extract properties from value. */
-    propertiesExtractor?: (value: T) => Record<string, string> | undefined;
-    /** Called on serialization or send failures. */
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * Pulsar producer sink — forwards upstream `DATA` to a Pulsar topic.
- *
- * @param source - Upstream node to forward.
- * @param pulsarProducer - Pulsar producer instance (caller owns lifecycle).
- * @param opts - Serialization options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-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;
-    data: Uint8Array;
-    headers?: {
-        get(key: string): string;
-        keys(): string[];
-    };
-    reply?: string;
-    sid: number;
-}>;
-/** Duck-typed NATS client (compatible with nats.js). */
-type NATSClientLike = {
-    subscribe(subject: string, opts?: {
-        queue?: string;
-    }): NATSSubscriptionLike;
-    publish(subject: string, data?: Uint8Array, opts?: {
-        headers?: unknown;
-        reply?: string;
-    }): void;
-    drain(): Promise<void>;
-};
-/** Structured NATS message. */
-type NATSMessage<T = unknown> = {
-    subject: string;
-    data: T;
-    headers: Record<string, string>;
-    reply: string | undefined;
-    sid: number;
-    timestampNs: number;
-};
-/** Options for {@link fromNATS}. */
-type FromNATSOptions = ExtraOpts & {
-    /** Queue group name for load balancing. */
-    queue?: string;
-    /** Deserialize message data. Default: `JSON.parse(textDecoder.decode(data))`. */
-    deserialize?: (data: Uint8Array) => unknown;
-};
-/**
- * NATS consumer as a reactive source.
- *
- * Wraps a `nats.js`-compatible client subscription. Each message becomes a `DATA` emission.
- *
- * @param client - NATS client instance (caller owns connect/drain lifecycle).
- * @param subject - Subject to subscribe to (supports wildcards).
- * @param opts - Queue group, deserialization, and source options.
- * @returns `Node<NATSMessage<T>>` — one `DATA` per NATS message.
- *
- * @remarks
- * Teardown sets an internal flag but cannot break the async iterator. The loop
- * exits on the next message or when the subscription is drained/unsubscribed
- * externally. Call `client.drain()` after unsubscribing for prompt cleanup.
- *
- * @example
- * ```ts
- * import { connect } from "nats";
- * import { fromNATS } from "@graphrefly/graphrefly-ts";
- *
- * const nc = await connect({ servers: "localhost:4222" });
- * const events$ = fromNATS(nc, "events.>");
- * ```
- *
- * @category extra
- */
-declare function fromNATS<T = unknown>(client: NATSClientLike, subject: string, opts?: FromNATSOptions): Node<NATSMessage<T>>;
-/** Options for {@link toNATS}. */
-type ToNATSOptions<T> = ExtraOpts & {
-    /** Serialize value for NATS. Default: `JSON.stringify` → Uint8Array. */
-    serialize?: (value: T) => Uint8Array;
-    /** Called on serialization failures. */
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * NATS publisher sink — forwards upstream `DATA` to a NATS subject.
- *
- * @param source - Upstream node to forward.
- * @param client - NATS client instance.
- * @param subject - Target subject.
- * @param opts - Serialization options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-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: {
-        content: Buffer;
-        fields: {
-            routingKey: string;
-            exchange: string;
-            deliveryTag: number;
-            redelivered: boolean;
-        };
-        properties: Record<string, unknown>;
-    } | null) => void, opts?: {
-        noAck?: boolean;
-    }): Promise<{
-        consumerTag: string;
-    }>;
-    cancel(consumerTag: string): Promise<void>;
-    ack(msg: unknown): void;
-    publish(exchange: string, routingKey: string, content: Buffer, opts?: Record<string, unknown>): boolean;
-    sendToQueue(queue: string, content: Buffer, opts?: Record<string, unknown>): boolean;
-};
-/** Structured RabbitMQ message. */
-type RabbitMQMessage<T = unknown> = {
-    queue: string;
-    routingKey: string;
-    exchange: string;
-    content: T;
-    properties: Record<string, unknown>;
-    deliveryTag: number;
-    redelivered: boolean;
-    timestampNs: number;
-};
-/** Options for {@link fromRabbitMQ}. */
-type FromRabbitMQOptions = ExtraOpts & {
-    /** Deserialize message content. Default: `JSON.parse(buffer.toString())`. */
-    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.
- *
- * Wraps an `amqplib`-compatible channel. Each message becomes a `DATA` emission.
- *
- * @param channel - AMQP channel instance (caller owns connection/channel lifecycle).
- * @param queue - Queue to consume from.
- * @param opts - Deserialization and acknowledgment options.
- * @returns `Node<RabbitMQMessage<T>>` — one `DATA` per RabbitMQ message.
- *
- * @remarks
- * When `autoAck` is `false`, the adapter opens the channel with `noAck: false`
- * (broker requires acks) but does not call `channel.ack()`. The caller must ack
- * messages externally using the `deliveryTag` from the emitted {@link RabbitMQMessage}:
- * ```ts
- * channel.ack({ fields: { deliveryTag: msg.deliveryTag } } as any);
- * ```
- *
- * @example
- * ```ts
- * import amqplib from "amqplib";
- * import { fromRabbitMQ } from "@graphrefly/graphrefly-ts";
- *
- * const conn = await amqplib.connect("amqp://localhost");
- * const ch = await conn.createChannel();
- * await ch.assertQueue("events");
- * const events$ = fromRabbitMQ(ch, "events");
- * ```
- *
- * @category extra
- */
-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 & {
-    /** Serialize value for RabbitMQ. Default: `Buffer.from(JSON.stringify(value))`. */
-    serialize?: (value: T) => Buffer;
-    /** Extract routing key from value. Default: `""`. */
-    routingKeyExtractor?: (value: T) => string;
-    /** Called on serialization or send failures. */
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * RabbitMQ producer sink — forwards upstream `DATA` to a RabbitMQ exchange/queue.
- *
- * @param source - Upstream node to forward.
- * @param channel - AMQP channel instance.
- * @param exchange - Target exchange (use `""` for default exchange + queue routing).
- * @param opts - Serialization and routing options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-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. */
-    flush: () => Promise<void>;
-};
-/** Duck-typed writable file handle (compatible with `fs.createWriteStream`). */
-type FileWriterLike = {
-    write(data: string | Uint8Array): boolean | undefined;
-    end(): void;
-};
-/** Options for {@link toFile}. */
-type ToFileOptions<T> = ExtraOpts & {
-    /** Serialize a value to a string line. Default: `JSON.stringify(v) + "\n"`. */
-    serialize?: (value: T) => string;
-    /** `"append"` (default) or `"overwrite"` — controls initial file behavior hint. */
-    mode?: "append" | "overwrite";
-    /** Flush interval in ms. `0` = write-through (no buffering). Default: `0`. */
-    flushIntervalMs?: number;
-    /** Buffer size (item count) before auto-flush. Default: `Infinity` (timer only). */
-    batchSize?: number;
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * File sink — writes upstream `DATA` values to a file-like writable.
- *
- * When `flushIntervalMs > 0` or `batchSize` is set, values are buffered and
- * flushed in batches. Otherwise, each value is written immediately.
- *
- * @param source - Upstream node.
- * @param writer - Writable file handle (e.g. `fs.createWriteStream(path, { flags: "a" })`).
- * @param opts - Serialization, buffering, and mode options.
- * @returns `BufferedSinkHandle` with `dispose()` and `flush()`.
- *
- * @category extra
- */
-declare function toFile<T>(source: Node<T>, writer: FileWriterLike, opts?: ToFileOptions<T>): ReactiveSinkHandle<T>;
-/** Options for {@link toCSV}. */
-type ToCSVOptions<T> = ExtraOpts & {
-    /** Column names. Required — determines header row and field order. */
-    columns: string[];
-    /** Column delimiter. Default: `","`. */
-    delimiter?: string;
-    /** Whether to write a header row on first flush. Default: `true`. */
-    writeHeader?: boolean;
-    /** Extract a cell value from the row object. Default: `String(row[col] ?? "")`. */
-    cellExtractor?: (row: T, column: string) => string;
-    /** Flush interval in ms. Default: `0` (write-through). */
-    flushIntervalMs?: number;
-    /** Buffer size before auto-flush. Default: `Infinity`. */
-    batchSize?: number;
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * CSV file sink — writes upstream `DATA` as CSV rows.
- *
- * @param source - Upstream node.
- * @param writer - Writable file handle.
- * @param opts - Column definition, delimiter, and buffering options.
- * @returns `BufferedSinkHandle`.
- *
- * @category extra
- */
-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: {
-        table: string;
-        values: unknown[];
-        format?: string;
-    }): Promise<void>;
-};
-/** Options for {@link toClickHouse}. */
-type ToClickHouseOptions<T> = ExtraOpts & {
-    /** Batch size before auto-flush. Default: `1000`. */
-    batchSize?: number;
-    /** Flush interval in ms. Default: `5000`. */
-    flushIntervalMs?: number;
-    /** Insert format. Default: `"JSONEachRow"`. */
-    format?: string;
-    /** Transform value before insert. Default: identity. */
-    transform?: (value: T) => unknown;
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * ClickHouse buffered batch insert sink.
- *
- * Accumulates upstream `DATA` values and inserts in batches.
- *
- * @param source - Upstream node.
- * @param client - ClickHouse client with `insert()`.
- * @param table - Target table name.
- * @param opts - Batch size, flush interval, and transform options.
- * @returns `BufferedSinkHandle`.
- *
- * @category extra
- */
-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: {
-        Bucket: string;
-        Key: string;
-        Body: string | Uint8Array;
-        ContentType?: string;
-    }): Promise<unknown>;
-};
-/** Options for {@link toS3}. */
-type ToS3Options<T> = ExtraOpts & {
-    /** Output format. Default: `"ndjson"`. */
-    format?: "ndjson" | "json";
-    /** Generate the S3 key for each batch. Receives `(seq, wallClockNs)`. Default: ISO timestamp + sequence. */
-    keyGenerator?: (seq: number, timestampNs: number) => string;
-    /** Batch size before auto-flush. Default: `1000`. */
-    batchSize?: number;
-    /** Flush interval in ms. Default: `10000`. */
-    flushIntervalMs?: number;
-    /** Transform value before serialization. Default: identity. */
-    transform?: (value: T) => unknown;
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * S3 object storage sink — buffers values and uploads as NDJSON or JSON objects.
- *
- * @param source - Upstream node.
- * @param client - S3-compatible client with `putObject()`.
- * @param bucket - S3 bucket name.
- * @param opts - Format, key generation, batching options.
- * @returns `BufferedSinkHandle`.
- *
- * @category extra
- */
-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>;
-};
-/** Options for {@link toPostgres}. */
-type ToPostgresOptions<T> = ExtraOpts & {
-    /** Build the SQL + params for an insert. Default: JSON insert into `table`. */
-    toSQL?: (value: T, table: string) => {
-        sql: string;
-        params: unknown[];
-    };
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * PostgreSQL sink — inserts each upstream `DATA` value as a row.
- *
- * @param source - Upstream node.
- * @param client - Postgres client with `query()`.
- * @param table - Target table name.
- * @param opts - SQL builder and error options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-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>;
-};
-/** Options for {@link toMongo}. */
-type ToMongoOptions<T> = ExtraOpts & {
-    /** Transform value to a MongoDB document. Default: identity. */
-    toDocument?: (value: T) => unknown;
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * MongoDB sink — inserts each upstream `DATA` value as a document.
- *
- * @param source - Upstream node.
- * @param collection - MongoDB collection with `insertOne()`.
- * @param opts - Document transform and error options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-declare function toMongo<T>(source: Node<T>, collection: MongoCollectionLike, opts?: ToMongoOptions<T>): ReactiveSinkHandle<T>;
-/** Loki log stream entry. */
-type LokiStream = {
-    stream: Record<string, string>;
-    values: [string, string][];
-};
-/** Duck-typed Loki push client (HTTP push API). */
-type LokiClientLike = {
-    push(streams: {
-        streams: LokiStream[];
-    }): Promise<unknown>;
-};
-/** Options for {@link toLoki}. */
-type ToLokiOptions<T> = ExtraOpts & {
-    /** Static labels applied to every log entry. */
-    labels?: Record<string, string>;
-    /** Extract the log line from a value. Default: `JSON.stringify(v)`. */
-    toLine?: (value: T) => string;
-    /** Extract additional labels from a value. Default: none. */
-    toLabels?: (value: T) => Record<string, string>;
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * Grafana Loki sink — pushes upstream `DATA` values as log entries.
- *
- * @param source - Upstream node.
- * @param client - Loki-compatible client with `push()`.
- * @param opts - Label, serialization, and error options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-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: {
-        resourceSpans: unknown[];
-    }): Promise<unknown>;
-};
-/** Options for {@link toTempo}. */
-type ToTempoOptions<T> = ExtraOpts & {
-    /** Transform a value into OTLP resourceSpans entries. */
-    toResourceSpans?: (value: T) => unknown[];
-    onTransportError?: (err: SinkTransportError) => void;
-};
-/**
- * Grafana Tempo sink — pushes upstream `DATA` values as trace spans.
- *
- * @param source - Upstream node.
- * @param client - Tempo-compatible client with `push()`.
- * @param opts - Span transform and error options.
- * @returns Unsubscribe function.
- *
- * @category extra
- */
-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 on the S3 tier. Default: `500`. */
-    debounceMs?: number;
-    /** Full snapshot compaction interval. Default: `10`. */
-    compactEvery?: number;
-    onError?: (error: unknown) => void;
-};
-type AttachStorageGraphLike = {
-    attachSnapshotStorage: (tiers: readonly SnapshotStorageTier<GraphCheckpointRecord>[], opts?: unknown) => {
-        dispose(): void;
-    };
-    name: string;
-};
-/**
- * Wires `graph.attachSnapshotStorage()` with an S3-backed tier.
- *
- * @param graph - Graph instance to checkpoint.
- * @param client - S3-compatible client with `putObject()`.
- * @param bucket - S3 bucket name.
- * @param opts - Key prefix, debounce, and compaction options.
- * @returns Dispose handle.
- *
- * @category extra
- */
-declare function checkpointToS3(graph: AttachStorageGraphLike, client: S3ClientLike, bucket: string, opts?: CheckpointToS3Options): {
-    dispose(): void;
-};
-/** Duck-typed Redis client for checkpoint storage. */
-type RedisCheckpointClientLike = {
-    set(key: string, value: string): Promise<unknown>;
-    get(key: string): Promise<string | null>;
-};
-/** Options for {@link checkpointToRedis}. */
-type CheckpointToRedisOptions = {
-    /** Key prefix. Default: `"graphrefly:checkpoint:"`. */
-    prefix?: string;
-    /** Debounce ms on the Redis tier. Default: `500`. */
-    debounceMs?: number;
-    /** Full snapshot compaction interval. Default: `10`. */
-    compactEvery?: number;
-    onError?: (error: unknown) => void;
-};
-/**
- * Wires `graph.attachSnapshotStorage()` with a Redis-backed tier.
- *
- * @param graph - Graph instance to checkpoint.
- * @param client - Redis client with `set()`/`get()`.
- * @param opts - Key prefix, debounce, and compaction options.
- * @returns Dispose handle.
- *
- * @category extra
- */
-declare function checkpointToRedis(graph: AttachStorageGraphLike, client: RedisCheckpointClientLike, opts?: CheckpointToRedisOptions): {
-    dispose(): void;
-};
-/**
- * Duck-typed synchronous SQLite database.
- *
- * Compatible with `better-sqlite3` (`.prepare().all()` / `.prepare().run()`)
- * and Node.js `node:sqlite` `DatabaseSync`. The user wraps their driver behind
- * this uniform contract — method name `query` matches the project-wide
- * convention (`PostgresClientLike.query`, `ClickHouseClientLike.query`).
- */
-type SqliteDbLike = {
-    query(sql: string, params?: unknown[]): unknown[];
-};
-/** Options for {@link fromSqlite}. */
-type FromSqliteOptions<T> = ExtraOpts & {
-    /** Map a raw row object to the desired type. Default: identity cast. */
-    mapRow?: (row: unknown) => T;
-    /** Bind parameters for the query. */
-    params?: unknown[];
-};
-/**
- * One-shot SQLite query as a reactive source.
- *
- * 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` with the full row array, then `COMPLETE`.
- *
- * @example
- * ```ts
- * import Database from "better-sqlite3";
- * import { fromSqlite } from "@graphrefly/graphrefly-ts";
- *
- * const raw = new Database("app.db");
- * const db = { query: (sql, params) => raw.prepare(sql).all(...(params ?? [])) };
- * const rows$ = fromSqlite(db, "SELECT * FROM users WHERE active = ?", { params: [1] });
- * ```
- *
- * @category extra
- */
-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 & {
-    /** Build SQL + params for an insert. Default: JSON insert into `(data)` column. */
-    toSQL?: (value: T, table: string) => {
-        sql: string;
-        params: unknown[];
-    };
-    onTransportError?: (err: SinkTransportError) => void;
-    /**
-     * When `true`, buffer DATA values and execute all inserts inside a single
-     * `BEGIN`/`COMMIT` transaction when the batch drains.  This avoids per-row
-     * fsync overhead and dramatically reduces event-loop blocking for
-     * high-throughput sources.  The first insert error stops the batch and
-     * triggers a `ROLLBACK`; the error is reported via `onTransportError`.
-     */
-    batchInsert?: boolean;
-    /** Auto-flush when buffer reaches this size. Default: `1000`. Only applies when `batchInsert` is `true`. */
-    maxBatchSize?: number;
-    /** Periodic flush interval in ms. `0` = no timer (flush on terminal messages only). Default: `0`. Only applies when `batchInsert` is `true`. */
-    flushIntervalMs?: number;
-};
-/**
- * SQLite sink — inserts each upstream `DATA` value as a row.
- *
- * Follows the same pattern as {@link toPostgres} / {@link toMongo}. Since SQLite
- * is synchronous, errors propagate immediately (no `void promise.catch`).
- *
- * @param source - Upstream node.
- * @param db - SQLite database (caller owns connection).
- * @param table - Target table name.
- * @param opts - SQL builder and error options.
- * @returns Unsubscribe function.
- *
- * @example
- * ```ts
- * import Database from "better-sqlite3";
- * import { toSqlite, state } from "@graphrefly/graphrefly-ts";
- *
- * const raw = new Database("app.db");
- * const db = { query: (sql, params) => (raw.prepare(sql).run(...(params ?? [])), []) };
- * const source = state({ name: "Alice", score: 42 });
- * const unsub = toSqlite(source, db, "events");
- * ```
- *
- * @category extra
- */
-declare function toSqlite<T>(source: Node<T>, db: SqliteDbLike, table: string, opts?: ToSqliteOptions<T>): ReactiveSinkHandle<T>;
-/**
- * Duck-typed Prisma model delegate.
- *
- * Compatible with any Prisma model's `findMany` method (e.g. `prisma.user`).
- * The consumer passes the model delegate directly — no dependency on `@prisma/client`.
- */
-type PrismaModelLike<T = unknown> = {
-    findMany(args?: unknown): Promise<T[]>;
-};
-/** Options for {@link fromPrisma}. */
-type FromPrismaOptions<T, U = T> = ExtraOpts & {
-    /** Prisma `findMany` args (where, orderBy, select, include, take, skip, etc.). */
-    args?: unknown;
-    /** Map each row to the desired shape. Default: identity cast. */
-    mapRow?: (row: T) => U;
-};
-/**
- * One-shot Prisma query as a reactive source.
- *
- * Calls `model.findMany(args)`, emits one `DATA` per result row, then `COMPLETE`.
- * Compose with `switchMap` + `fromTimer` for periodic re-query.
- *
- * @param model - Prisma model delegate (e.g. `prisma.user`).
- * @param opts - `findMany` args, row mapper, and node options.
- * @returns `Node<U>` — one `DATA` per row, then `COMPLETE`.
- *
- * @example
- * ```ts
- * import { PrismaClient } from "@prisma/client";
- * import { fromPrisma } from "@graphrefly/graphrefly-ts";
- *
- * const prisma = new PrismaClient();
- * const activeUsers = fromPrisma(prisma.user, {
- *   args: { where: { active: true } },
- * });
- * ```
- *
- * @category extra
- */
-declare function fromPrisma<T = unknown, U = T>(model: PrismaModelLike<T>, opts?: FromPrismaOptions<T, U>): Node<U[]>;
-/**
- * Duck-typed Drizzle query builder result.
- *
- * Drizzle query builders (e.g. `db.select().from(users)`) expose `.execute()`
- * which returns `Promise<T[]>`. This interface captures that contract without
- * depending on `drizzle-orm`.
- */
-type DrizzleQueryLike<T = unknown> = {
-    execute(): Promise<T[]>;
-};
-/** Options for {@link fromDrizzle}. */
-type FromDrizzleOptions<T, U = T> = ExtraOpts & {
-    /** Map each row to the desired shape. Default: identity cast. */
-    mapRow?: (row: T) => U;
-};
-/**
- * One-shot Drizzle query as a reactive source.
- *
- * Calls `query.execute()`, emits one `DATA` per result row, then `COMPLETE`.
- * Compose with `switchMap` + `fromTimer` for periodic re-query.
- *
- * @param query - Drizzle query builder (e.g. `db.select().from(users).where(...)`).
- * @param opts - Row mapper and node options.
- * @returns `Node<U>` — one `DATA` per row, then `COMPLETE`.
- *
- * @example
- * ```ts
- * import { drizzle } from "drizzle-orm/node-postgres";
- * import { fromDrizzle } from "@graphrefly/graphrefly-ts";
- *
- * const db = drizzle(pool);
- * const rows$ = fromDrizzle(db.select().from(users).where(eq(users.active, true)));
- * ```
- *
- * @category extra
- */
-declare function fromDrizzle<T = unknown, U = T>(query: DrizzleQueryLike<T>, opts?: FromDrizzleOptions<T, U>): Node<U[]>;
-/**
- * Duck-typed Kysely query builder result.
- *
- * Kysely query builders expose `.execute()` which returns `Promise<T[]>`.
- * This interface captures that contract without depending on `kysely`.
- */
-type KyselyQueryLike<T = unknown> = {
-    execute(): Promise<T[]>;
-};
-/** Options for {@link fromKysely}. */
-type FromKyselyOptions<T, U = T> = ExtraOpts & {
-    /** Map each row to the desired shape. Default: identity cast. */
-    mapRow?: (row: T) => U;
-};
-/**
- * One-shot Kysely query as a reactive source.
- *
- * Calls `query.execute()`, emits one `DATA` per result row, then `COMPLETE`.
- * Compose with `switchMap` + `fromTimer` for periodic re-query.
- *
- * @param query - Kysely query builder (e.g. `db.selectFrom("users").selectAll()`).
- * @param opts - Row mapper and node options.
- * @returns `Node<U>` — one `DATA` per row, then `COMPLETE`.
- *
- * @example
- * ```ts
- * import { Kysely, PostgresDialect } from "kysely";
- * import { fromKysely } from "@graphrefly/graphrefly-ts";
- *
- * const db = new Kysely<DB>({ dialect: new PostgresDialect({ pool }) });
- * const rows$ = fromKysely(db.selectFrom("users").selectAll().where("active", "=", true));
- * ```
- *
- * @category extra
- */
-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.
- *
- * Purely synchronous, event-driven. No timers, no polling, no Promises.
- * Each controller instance uses a unique lockId so multiple controllers
- * on the same upstream node do not collide.
- *
- * @module
- */
-
-type WatermarkOptions = {
-    /** Pending count at which PAUSE is sent upstream. */
-    highWaterMark: number;
-    /** Pending count at which RESUME is sent upstream (after being paused). */
-    lowWaterMark: number;
-};
-type WatermarkController = {
-    /** Call when a DATA message is buffered/enqueued. Returns `true` if PAUSE was just sent. */
-    onEnqueue(): boolean;
-    /** Call when a buffered item is consumed. Returns `true` if RESUME was just sent. */
-    onDequeue(): boolean;
-    /** Current un-consumed item count. */
-    readonly pending: number;
-    /** Whether upstream is currently paused by this controller. */
-    readonly paused: boolean;
-    /** Dispose: if paused, sends RESUME to unblock upstream. */
-    dispose(): void;
-};
-/**
- * Creates a watermark-based backpressure controller.
- *
- * @param sendUp - Callback that delivers messages upstream (typically `handle.up`).
- * @param opts - High/low watermark thresholds (item counts).
- * @returns A {@link WatermarkController}.
- *
- * @example
- * ```ts
- * const handle = graph.observe("fast-source");
- * const wm = createWatermarkController(
- *   (msgs) => handle.up(msgs),
- *   { highWaterMark: 64, lowWaterMark: 16 },
- * );
- *
- * // In sink callback:
- * handle.subscribe((msgs) => {
- *   for (const msg of msgs) {
- *     if (msg[0] === DATA) {
- *       buffer.push(msg[1]);
- *       wm.onEnqueue();
- *     }
- *   }
- * });
- *
- * // When consumer drains:
- * const item = buffer.shift();
- * wm.onDequeue();
- * ```
- *
- * @category extra
- */
-declare function createWatermarkController(sendUp: (messages: Messages) => void, opts: WatermarkOptions): WatermarkController;
-
-/** Pluggable eviction policy for {@link cascadingCache}. */
-interface CacheEvictionPolicy<K> {
-    insert(key: K): void;
-    touch(key: K): void;
-    delete(key: K): void;
-    evict(count: number): K[];
-    size(): number;
-}
-/**
- * LRU eviction policy backed by a doubly-linked list + Map.
- *
- * @returns An {@link CacheEvictionPolicy} that evicts least-recently-used entries.
- *
- * @category extra
- */
-declare function lru<K>(): CacheEvictionPolicy<K>;
-interface CascadingCacheOptions {
-    /** Max entries before eviction. 0 = unlimited (default). */
-    maxSize?: number;
-    /** Eviction policy. Default: LRU. Only used when maxSize > 0. */
-    eviction?: CacheEvictionPolicy<string>;
-    /** Write-through: save() writes to all tiers, not just tier 0. Default: false. */
-    writeThrough?: boolean;
-}
-interface CascadingCache<V> {
-    /** Get or create a singleton state node for this key. Cascades tiers on miss. */
-    load(key: string): Node<V | undefined>;
-    /** Write value to tier(s) and update cache node in-place. */
-    save(key: string, value: V): void;
-    /** Re-cascade tiers into the existing cache node (subscribers see the update). */
-    invalidate(key: string): void;
-    /** Remove from all tiers, teardown the node, and delete cache entry. */
-    delete(key: string): void;
-    /** Check if key exists in cache map. */
-    has(key: string): boolean;
-    /** Number of cached entries. */
-    readonly size: number;
-}
-/**
- * Creates a singleton reactive cache with N-tier cascading lookup.
- *
- * 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 loads for the same key share the same state
- * instance — natural dedup.
- *
- * **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).
- * @returns A reactive cache where each entry is a `Node<V | undefined>`.
- *
- * @example
- * ```ts
- * import { cascadingCache, memoryKv, fileKv } from "@graphrefly/graphrefly-ts";
- *
- * const cache = cascadingCache<User>([memoryKv(), fileKv("./cache")]);
- * const user = cache.load("user:42"); // Node<User | undefined>
- * user.subscribe(msgs => console.log(msgs));
- * ```
- *
- * @category extra
- */
-declare function cascadingCache<V = unknown>(tiers: readonly KvStorageTier[], opts?: CascadingCacheOptions): CascadingCache<V>;
-
-/**
- * Minimal 5-field cron parser and matcher (minute hour day-of-month month day-of-week).
- * Ported from callbag-recharge `extra/cron.ts` for `fromCron` (roadmap §2.3).
- */
-interface CronSchedule {
-    minutes: Set<number>;
-    hours: Set<number>;
-    daysOfMonth: Set<number>;
-    months: Set<number>;
-    daysOfWeek: Set<number>;
-}
-/**
- * Parses a standard 5-field cron expression into a {@link CronSchedule}.
- *
- * Supports `*`, ranges (`1-5`), steps (`*\/5`, `0-30/10`), and comma-separated
- * lists. Fields are: minute (0–59), hour (0–23), day-of-month (1–31),
- * month (1–12), day-of-week (0–6, Sunday = 0).
- *
- * @param expr - Five-field whitespace-separated cron string (e.g. `"0 9 * * 1-5"`).
- * @returns Parsed {@link CronSchedule} with one `Set<number>` per field.
- * @throws Error when the expression does not have exactly 5 fields, contains
- *   out-of-range values, or uses an invalid step.
- *
- * @example
- * ```ts
- * import { parseCron } from "@graphrefly/graphrefly-ts";
- *
- * const sched = parseCron("0 9 * * 1-5"); // weekdays at 09:00
- * sched.hours;      // Set { 9 }
- * sched.daysOfWeek; // Set { 1, 2, 3, 4, 5 }
- * ```
- */
-declare function parseCron(expr: string): CronSchedule;
-/**
- * Returns `true` if `date` satisfies every field of `schedule`.
- *
- * @param schedule - Parsed schedule from {@link parseCron}.
- * @param date - Moment to test (local time via `getMinutes`, `getHours`, etc.).
- * @returns `true` when all five cron fields match the given date.
- *
- * @example
- * ```ts
- * import { parseCron, matchesCron } from "@graphrefly/graphrefly-ts";
- *
- * const sched = parseCron("30 8 * * 1"); // Mondays at 08:30
- * const monday = new Date("2026-03-30T08:30:00"); // a Monday
- * matchesCron(sched, monday); // true
- * ```
- */
-declare function matchesCron(schedule: CronSchedule, date: Date): boolean;
-
-/**
- * HTTP error builder — companion to {@link ./adapters.ts}'s `fromHTTP` /
- * `fromHTTPStream` / `toHTTP`. Pure, zero-dep function that turns a failed
- * `Response` into an `Error` exposing the `{status, headers, message}` shape
- * that `HttpErrorLike` consumers (rate-limit parsers, retry predicates,
- * observability layers) expect.
- *
- * Universal tier — safe for browser and Node. No Node-only imports.
- */
-/**
- * Construct an `Error` carrying `status` + `headers` fields from a non-ok
- * `Response`. Reads the body with `resp.text()` for diagnostic context; a
- * body read failure is swallowed (empty string) so the returned error always
- * reflects the original status/statusText at minimum.
- *
- * @param resp - The offending `Response` object.
- * @param provider - Optional prefix (e.g. `"Anthropic"`, `"openai"`) used in
- *   the error message. Defaults to `"HTTP"`.
- * @returns An `Error` whose `message` is `"${provider} API <status>: <statusText>[ — body]"`,
- *   with `status: number` and `headers: Headers` attached.
- *
- * @category extra
- */
-declare function makeHttpError(resp: Response, provider?: string): Promise<Error>;
-
-/**
- * Metadata helpers for pattern-layer nodes (Tier 2.2 promotion from
- * `patterns/_internal/`).
- *
- * Each domain (orchestration, messaging, reduction, ai, cqrs, domain_template,
- * memory, lens, audit, harness) shares the same metadata convention. Promoted
- * to `extra/` so non-patterns code (and downstream consumers building their
- * own domain primitives) can use the same shape.
- *
- * @module
- */
-/**
- * Build a domain metadata object for pattern-layer nodes.
- *
- * Each domain follows the same shape: `{ [domain]: true, [domain]_type: kind, ...extra }`.
- *
- * @param domain - The domain tag (e.g. `"orchestration"`, `"ai"`, `"cqrs"`).
- * @param kind - The specific type within the domain (e.g. `"gate"`, `"prompt"`).
- * @param extra - Additional metadata to merge.
- * @returns Metadata object.
- */
-declare function domainMeta(domain: string, kind: string, extra?: Record<string, unknown>): Record<string, unknown>;
-
-/**
- * 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.
- */
-
-/**
- * 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
- */
-interface PubSubHub {
-    /**
-     * Returns the topic node, creating it on first use.
-     *
-     * @param name - Topic key.
-     * @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>;
-    /** Publishes a value to the topic (lazily creating the topic if missing). */
-    publish(name: string, value: unknown): void;
-    /**
-     * Bulk publish — single outer batch for all entries. No-op if empty.
-     *
-     * **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 a lazy per-topic state hub.
- *
- * @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
- * import { pubsub } from "@graphrefly/graphrefly-ts";
- *
- * const hub = pubsub();
- * const t = hub.topic("events");
- * t.subscribe((msgs) => console.log(msgs));
- * hub.publish("events", { ok: true });
- * hub.publishMany([["events", 1], ["status", "ready"]]);
- * ```
- *
- * @category extra
- */
-declare function pubsub(options?: PubSubHubOptions): PubSubHub;
-
-/**
- * `singleFromAny` — keyed promise/Node de-duplication ("singleflight").
- *
- * Given a `factory: (key) => NodeInput<T>`, returns a callable that dedupes
- * concurrent invocations sharing the same key — all callers with the same
- * key while a request is in-flight receive the same `Promise<T>`. Once the
- * underlying source settles (DATA, ERROR, or COMPLETE), the cache entry is
- * cleared so the next call re-invokes the factory.
- *
- * This is the classic "singleflight" pattern from Go, generalised over the
- * library's `NodeInput<T>` bridge so callers can pass Promise-returning
- * factories, Node-returning factories, or plain value factories with
- * identical semantics.
- *
- * Use cases:
- * - `withReplayCache` cache-miss thundering-herd dedup
- * - Shared HTTP fetches keyed by URL
- * - Expensive compute keyed by request fingerprint
- *
- * @example
- * ```ts
- * const fetchUser = singleFromAny<string, User>((id) => fetch(`/users/${id}`).then(r => r.json()));
- * // Two concurrent callers with id="42" → one underlying fetch, two Promises resolving to the same User.
- * const [a, b] = await Promise.all([fetchUser("42"), fetchUser("42")]);
- * ```
- *
- * @category extra
- */
-
-interface SingleFromAnyOptions<K> {
-    /**
-     * Convert a typed key into a cache-string. Defaults to `String(key)`, which
-     * works for primitive keys; callers with object keys should provide a
-     * stable serializer (e.g., canonical JSON).
-     */
-    keyFn?: (key: K) => string;
-}
-/**
- * Dedupe concurrent `factory(key)` invocations. Returns a bound callable.
- *
- * @param factory - Produces a `NodeInput<T>` for each unique key.
- * @param opts - Optional key-stringification.
- * @returns A function `(key: K) => Promise<T>` whose inflight results are shared per key.
- */
-declare function singleFromAny<K, T>(factory: (key: K) => NodeInput<T>, opts?: SingleFromAnyOptions<K>): (key: K) => Promise<T>;
-/**
- * Reactive variant: returns a bound callable that hands out `Node<T>` values.
- * All concurrent callers with the same key during an in-flight source share
- * the same Node. When the underlying source **terminally** settles (ERROR
- * or COMPLETE), the Node is removed from the cache so the next call
- * re-invokes `factory`. DATA is NOT terminal — callers subscribing after
- * the first DATA still receive the shared Node (and push-on-subscribe per
- * the spec's cached-DATA contract).
- *
- * Use when downstream wants reactive subscription (not a one-shot Promise).
- *
- * @category extra
- */
-declare function singleNodeFromAny<K, T>(factory: (key: K) => NodeInput<T>, opts?: SingleFromAnyOptions<K>): (key: K) => Node<T>;
-
-/**
- * stratify — reactive branch routing over a classifier rule set.
- *
- * Protocol-level primitive (no domain assumptions) that routes a source value
- * to independent branch subgraphs. Rules are reactive — update the `"rules"`
- * state node to rewrite classification at runtime. Rule updates affect
- * **future items only** (streaming semantics, not retroactive).
- *
- * @module
- */
-
-/** A single routing rule for {@link stratify}. */
-type StratifyRule<T> = {
-    /** Branch name (used as node name under `branch/<name>`). */
-    name: string;
-    /** Classifier: returns `true` if the value belongs to this branch. */
-    classify: (value: T) => boolean;
-    /** Optional operator chain applied to the branch after classification. */
-    ops?: (n: Node<T>) => Node;
-};
-/** Options for {@link stratify}. */
-type StratifyOptions = GraphOptions & {
-    meta?: Record<string, unknown>;
-};
-/**
- * Route input to different branches based on classifier functions.
- *
- * Each branch gets an independent operator chain. Branch nodes are structural —
- * created at construction time and persist for the graph's lifetime. If a rule
- * name is removed from the rules array, the corresponding branch silently
- * drops items (classifier not found). To tear down a dead branch, call
- * `graph.remove("branch/<name>")`.
- *
- * @param name - Graph name.
- * @param source - Input node (registered as `"source"`).
- * @param rules - Initial routing rules.
- * @param opts - Optional graph/meta options.
- * @returns Graph with `"source"`, `"rules"`, and `"branch/<name>"` nodes.
- *
- * @category extra
- */
-declare function stratify<T>(name: string, source: Node<T>, rules: ReadonlyArray<StratifyRule<T>>, opts?: StratifyOptions): Graph;
-
-/**
- * Creates a resettable deadline timer for internal timeout, retry, and rate-limiting use.
- *
- * @remarks **Centralised primitive:** wraps `setTimeout`/`clearTimeout` with a generation guard
- * so that stale callbacks never fire after `cancel()` or a new `start()`.
- *
- * @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 { ResettableTimer } from "@graphrefly/graphrefly-ts";
- *
- * 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 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.
- *
- * Abstracts Worker, SharedWorker, ServiceWorker, BroadcastChannel, and
- * MessagePort behind a uniform post/listen/terminate interface.
- */
-/** Normalized bidirectional message channel. */
-interface WorkerTransport {
-    /** Send data to the other side. Optional transferables for zero-copy. */
-    post(data: unknown, transfer?: Transferable[]): void;
-    /** Listen for incoming messages. Returns unsubscribe function. */
-    listen(handler: (data: unknown) => void): () => void;
-    /** Terminate the connection (if supported by the underlying transport). */
-    terminate?(): void;
-}
-/**
- * Auto-detect transport type and create a normalized WorkerTransport.
- *
- * Supports:
- * - `Worker` — direct postMessage/onmessage
- * - `SharedWorker` — port-based postMessage/onmessage
- * - `ServiceWorker` — postMessage via controller, listen via navigator.serviceWorker
- * - `BroadcastChannel` — postMessage/onmessage (no Transferable support)
- * - `MessagePort` — direct postMessage/onmessage (worker-side SharedWorker port)
- */
-declare function createTransport(target: unknown): WorkerTransport;
-
-/**
- * workerBridge — main-thread reactive node bridge to a worker.
- *
- * Creates proxy nodes for imported worker nodes, subscribes to exposed
- * nodes and sends values across the wire. Uses derived() + effect() for
- * natural batch coalescing via two-phase push + bitmask resolution.
- *
- * Wire filtering: graph-local signals ({@link isLocalOnly}) stay local;
- * DATA values go through the coalescing path; RESOLVED, COMPLETE, ERROR,
- * TEARDOWN, and unknown {@link Symbol.for} types go through the signal
- * subscription.
- *
- * Handshake:
- *   1. Main creates bridge, starts listening
- *   2. Worker sends { t: 'r', stores: { name: initialValue, ... } }
- *   3. Main creates proxy nodes, marks meta.status "connected"
- *   4. Main sends { t: 'i', stores: { name: currentValue, ... } }
- *   5. Bidirectional value flow begins
- */
-
-interface WorkerBridgeOptions<TExpose extends Record<string, Node<any>>, TImport extends readonly string[]> {
-    /** Nodes to send to the worker. */
-    expose?: TExpose;
-    /** Node names the worker will provide. */
-    import?: TImport;
-    /** Per-node transferable extractors for zero-copy ArrayBuffer passing. */
-    transfer?: Partial<Record<keyof TExpose, (value: any) => Transferable[]>>;
-    /** Debug name. */
-    name?: string;
-    /**
-     * Handshake timeout in milliseconds. If the worker doesn't send READY
-     * within this window, `meta.status` transitions to `"closed"` and
-     * `meta.error` is set. Default: no timeout.
-     */
-    timeoutMs?: number;
-}
-/** Proxy nodes created from imported worker node names. */
-type ImportedNodes<T extends readonly string[]> = {
-    readonly [K in T[number]]: Node<any>;
-};
-type WorkerBridge<_TExpose extends Record<string, Node<any>>, TImport extends readonly string[]> = ImportedNodes<TImport> & {
-    /** Connection status meta node. */
-    meta: {
-        status: Node<"connecting" | "connected" | "closed">;
-        error: Node<Error | null>;
-    };
-    /** Destroy the bridge: sends TEARDOWN, disconnects, terminates worker. */
-    destroy(): void;
-};
-declare function workerBridge<TExpose extends Record<string, Node<any>>, TImport extends readonly string[]>(target: unknown | WorkerTransport, opts: WorkerBridgeOptions<TExpose, TImport>): WorkerBridge<TExpose, TImport>;
-
-/**
- * Wire protocol for worker bridge communication.
- *
- * Graph-local signals ({@link isLocalOnly}) stay local to each side's
- * reactive graph. DATA values cross via coalescing; RESOLVED/COMPLETE/TEARDOWN
- * as signals; ERROR as serialized payloads.
- *
- * Lifecycle signals serialize as string names since Symbols can't survive
- * structured clone. Unknown {@link Symbol.for} symbols are round-tripped
- * via their registered key.
- */
-/** Value update — one node changed. */
-interface ValueMessage {
-    t: "v";
-    /** Node name. */
-    s: string;
-    /** Serialized value. */
-    d: unknown;
-}
-/** Lifecycle signal — serialized symbol name. */
-interface SignalMessage {
-    t: "s";
-    /** Node name, or `"*"` for bridge-wide. */
-    s: string;
-    /** Signal name string (e.g. "TEARDOWN"). */
-    sig: string;
-    /** Optional payload for custom symbols (spec §1.3.6 forward unchanged). */
-    d?: unknown;
-}
-/** Ready — worker declares its exported nodes with initial values. */
-interface ReadyMessage {
-    t: "r";
-    stores: Record<string, unknown>;
-}
-/** Init — main sends initial values of its exposed nodes. */
-interface InitMessage {
-    t: "i";
-    stores: Record<string, unknown>;
-}
-/** Batch value update — multiple nodes changed in one reactive cycle. */
-interface BatchMessage {
-    t: "b";
-    u: Record<string, unknown>;
-    /** V0 versions per node for delta sync — peer skips if version <= lastSeen (§6.0b). */
-    v?: Record<string, number>;
-}
-/** Error payload — serialized since Error objects don't survive structured clone. */
-interface ErrorMessage {
-    t: "e";
-    /** Node name. */
-    s: string;
-    /** Serialized error. */
-    err: {
-        message: string;
-        name: string;
-        stack?: string;
-    };
-}
-type BridgeMessage = ValueMessage | SignalMessage | ReadyMessage | InitMessage | BatchMessage | ErrorMessage;
-/**
- * Serialize a message type symbol to a string for structured clone transfer.
- *
- * Known GraphReFly symbols map to their canonical names. Unknown symbols
- * registered via {@link Symbol.for} use their registered key. Unregistered
- * symbols return `"UNKNOWN"`.
- */
-declare function signalToName(s: symbol): string;
-/**
- * Deserialize a string back to a message type symbol.
- *
- * Known GraphReFly names map to their canonical symbols. Other non-empty
- * strings are reconstructed via {@link Symbol.for} (round-trip safe for
- * custom message types). Returns `undefined` for `"UNKNOWN"`.
- */
-declare function nameToSignal(name: string): symbol | undefined;
-/** Serialize an error for structured clone transfer. */
-declare function serializeError(err: unknown): {
-    message: string;
-    name: string;
-    stack?: string;
-};
-/** Deserialize an error payload back to an Error object. */
-declare function deserializeError(payload: {
-    message: string;
-    name: string;
-    stack?: string;
-}): Error;
-
-/**
- * workerSelf — worker-side reactive node bridge.
- *
- * Mirror of workerBridge() for the worker side. Creates proxy nodes for
- * imports from main thread, exposes local nodes via the same wire protocol.
- * Uses derived() + effect() for batch coalescing.
- *
- * Wire filtering: graph-local signals ({@link isLocalOnly}) stay local;
- * DATA values go through the coalescing path; RESOLVED, COMPLETE, ERROR,
- * TEARDOWN, and unknown {@link Symbol.for} types go through the signal
- * subscription.
- *
- * Handshake (worker perspective):
- *   1. workerSelf() called — creates proxy nodes for imports
- *   2. Runs expose factory with proxy nodes -> gets nodes to expose
- *   3. Sends { t: 'r', stores: { name: initialValue, ... } } to main
- *   4. Receives { t: 'i', stores: { name: value, ... } } from main
- *   5. Updates proxy nodes -> triggers local effects
- */
-
-interface WorkerSelfOptions<TImport extends readonly string[]> {
-    /** Node names that the main thread will provide. */
-    import?: TImport;
-    /** Factory that receives imported proxy nodes and returns nodes to expose. */
-    expose: (imported: WorkerImported<TImport>) => Record<string, Node<any>>;
-    /** Per-node transferable extractors for zero-copy ArrayBuffer passing. */
-    transfer?: Record<string, (value: any) => Transferable[]>;
-}
-/** Proxy nodes available inside the worker from main-thread exposed nodes. */
-type WorkerImported<T extends readonly string[]> = {
-    readonly [K in T[number]]: Node<any>;
-};
-interface WorkerSelfHandle {
-    /** Dispose all subscriptions and stop the bridge. */
-    destroy(): void;
-}
-declare function workerSelf<TImport extends readonly string[]>(target: unknown | WorkerTransport, opts: WorkerSelfOptions<TImport>): WorkerSelfHandle;
-
-/**
- * Extra layer: operators, sources, sinks (Phase 2+).
- */
-
-type index_AckableMessage<T> = AckableMessage<T>;
-type index_AdapterHandlers<T> = AdapterHandlers<T>;
-declare const index_AppendCursor: typeof AppendCursor;
-declare const index_AppendLoadResult: typeof AppendLoadResult;
-declare const index_AppendLogStorageOptions: typeof AppendLogStorageOptions;
-declare const index_AppendLogStorageTier: typeof AppendLogStorageTier;
-declare const index_AsyncSourceOpts: typeof AsyncSourceOpts;
-declare const index_AuditLogOpts: typeof AuditLogOpts;
-declare const index_BackoffPreset: typeof BackoffPreset;
-declare const index_BackoffStrategy: typeof BackoffStrategy;
-declare const index_BaseAuditRecord: typeof BaseAuditRecord;
-declare const index_BaseStorageTier: typeof BaseStorageTier;
-type index_BatchMessage = BatchMessage;
-type index_BridgeMessage = BridgeMessage;
-type index_BudgetConstraint<T = unknown> = BudgetConstraint<T>;
-type index_BudgetGateOptions = BudgetGateOptions;
-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_CascadingCache<V> = CascadingCache<V>;
-type index_CascadingCacheOptions = CascadingCacheOptions;
-type index_CheckpointToRedisOptions = CheckpointToRedisOptions;
-type index_CheckpointToS3Options = CheckpointToS3Options;
-declare const index_CircuitBreaker: typeof CircuitBreaker;
-declare const index_CircuitBreakerOptions: typeof CircuitBreakerOptions;
-declare const index_CircuitOpenError: typeof CircuitOpenError;
-declare const index_CircuitState: typeof CircuitState;
-type index_ClickHouseClientLike = ClickHouseClientLike;
-type index_ClickHouseInsertClientLike = ClickHouseInsertClientLike;
-type index_ClickHouseRow = ClickHouseRow;
-declare const index_Codec: typeof Codec;
-declare const index_ContentAddressedMissError: typeof ContentAddressedMissError;
-declare const index_ContentAddressedMode: typeof ContentAddressedMode;
-declare const index_ContentAddressedStorage: typeof ContentAddressedStorage;
-declare const index_ContentAddressedStorageOptions: typeof ContentAddressedStorageOptions;
-type index_CronSchedule = CronSchedule;
-declare const index_DEFAULT_AUDIT_GUARD: typeof DEFAULT_AUDIT_GUARD;
-declare const index_DescribeChangeset: typeof DescribeChangeset;
-declare const index_DescribeEvent: typeof DescribeEvent;
-declare const index_DistillBundle: typeof DistillBundle;
-declare const index_DistillOptions: typeof DistillOptions;
-type index_DrizzleQueryLike<T = unknown> = DrizzleQueryLike<T>;
-type index_EmitTriad<T> = EmitTriad<T>;
-type index_ErrorMessage = ErrorMessage;
-declare const index_EventTargetLike: typeof EventTargetLike;
-declare const index_ExponentialBackoffOptions: typeof ExponentialBackoffOptions;
-type index_ExternalBundleOptions<TChannels extends Record<string, unknown>> = ExternalBundleOptions<TChannels>;
-type index_ExternalRegister<H> = ExternalRegister<H>;
-declare const index_Extraction: typeof Extraction;
-declare const index_FailureMeta: typeof FailureMeta;
-declare const index_FallbackInput: typeof FallbackInput;
-type index_FileWriterLike = FileWriterLike;
-type index_FromCSVOptions = FromCSVOptions;
-type index_FromClickHouseWatchOptions = FromClickHouseWatchOptions;
-declare const index_FromCronOptions: typeof FromCronOptions;
-type index_FromDrizzleOptions<T, U = T> = FromDrizzleOptions<T, U>;
-type index_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;
-type index_FromNATSOptions = FromNATSOptions;
-type index_FromNDJSONOptions = FromNDJSONOptions;
-type index_FromOTelOptions = FromOTelOptions;
-type index_FromPrismaOptions<T, U = T> = FromPrismaOptions<T, U>;
-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_HTTPBundle<T> = HTTPBundle<T>;
-declare const index_IndexBackend: typeof IndexBackend;
-declare const index_IndexRow: typeof IndexRow;
-type index_InitMessage = InitMessage;
-declare const index_JitterMode: typeof JitterMode;
-type index_KafkaConsumerLike = KafkaConsumerLike;
-type index_KafkaMessage<T = unknown> = KafkaMessage<T>;
-type index_KafkaProducerLike = KafkaProducerLike;
-declare const index_KvStorageOptions: typeof KvStorageOptions;
-declare const index_KvStorageTier: typeof KvStorageTier;
-type index_KyselyQueryLike<T = unknown> = KyselyQueryLike<T>;
-declare const index_LightMutationOpts: typeof LightMutationOpts;
-declare const index_ListBackend: typeof ListBackend;
-declare const index_LogBackend: typeof LogBackend;
-type index_LokiClientLike = LokiClientLike;
-type index_LokiStream = LokiStream;
-type index_MCPClientLike = MCPClientLike;
-declare const index_MapBackend: typeof MapBackend;
-declare const index_MergeMapOptions: typeof MergeMapOptions;
-declare const index_MergedReactiveLog: typeof MergedReactiveLog;
-type index_MongoCollectionLike = MongoCollectionLike;
-declare const index_MutationOpts: typeof MutationOpts;
-type index_NATSClientLike = NATSClientLike;
-type index_NATSMessage<T = unknown> = NATSMessage<T>;
-type index_NATSSubscriptionLike = NATSSubscriptionLike;
-declare const index_NS_PER_MS: typeof NS_PER_MS;
-declare const index_NS_PER_SEC: typeof NS_PER_SEC;
-declare const index_NativeIndexBackend: typeof NativeIndexBackend;
-declare const index_NativeListBackend: typeof NativeListBackend;
-declare const index_NativeLogBackend: typeof NativeLogBackend;
-declare const index_NativeMapBackend: typeof NativeMapBackend;
-declare const index_NativeMapBackendOptions: typeof NativeMapBackendOptions;
-type index_NativePubSubBackend = NativePubSubBackend;
-declare const index_NativePubSubBackend: typeof NativePubSubBackend;
-declare const index_NodeInput: typeof NodeInput;
-type index_OTelBundle = OTelBundle;
-type index_OTelLog = OTelLog;
-type index_OTelMetric = OTelMetric;
-type index_OTelRegister = OTelRegister;
-type index_OTelSpan = OTelSpan;
-type index_ParseSSEStreamOptions<T = string> = ParseSSEStreamOptions<T>;
-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>;
-declare const index_RateLimiterOptions: typeof RateLimiterOptions;
-declare const index_RateLimiterOverflowError: typeof RateLimiterOverflowError;
-declare const index_RateLimiterOverflowPolicy: typeof RateLimiterOverflowPolicy;
-declare const index_ReactiveCounterBundle: typeof ReactiveCounterBundle;
-declare const index_ReactiveIndexBundle: typeof ReactiveIndexBundle;
-declare const index_ReactiveIndexOptions: typeof ReactiveIndexOptions;
-declare const index_ReactiveListBundle: typeof ReactiveListBundle;
-declare const index_ReactiveListOptions: typeof ReactiveListOptions;
-declare const index_ReactiveLogBundle: typeof ReactiveLogBundle;
-declare const index_ReactiveLogOptions: typeof ReactiveLogOptions;
-declare const index_ReactiveMapBundle: typeof ReactiveMapBundle;
-declare const index_ReactiveMapOptions: typeof ReactiveMapOptions;
-declare const index_ReactiveMapRetention: typeof ReactiveMapRetention;
-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;
-declare const index_RetryOptions: typeof RetryOptions;
-type index_S3ClientLike = S3ClientLike;
-type index_SSEEvent<T = string> = SSEEvent<T>;
-type index_SignalMessage = SignalMessage;
-type index_SingleFromAnyOptions<K> = SingleFromAnyOptions<K>;
-type index_SinkFailure<T> = SinkFailure<T>;
-type index_SinkHandle = SinkHandle;
-type index_SinkTransportError = SinkTransportError;
-declare const index_SnapshotStorageOptions: typeof SnapshotStorageOptions;
-declare const index_SnapshotStorageTier: typeof SnapshotStorageTier;
-type index_SqliteDbLike = SqliteDbLike;
-type index_SqliteIterableDbLike = SqliteIterableDbLike;
-type index_StatsDMetric = StatsDMetric;
-type index_StatsDRegister = StatsDRegister;
-declare const index_StatusValue: typeof StatusValue;
-declare const index_StorageBackend: typeof StorageBackend;
-declare const index_StorageHandle: typeof StorageHandle;
-type index_StratifyOptions = StratifyOptions;
-type index_StratifyRule<T> = StratifyRule<T>;
-declare const index_SuccessMeta: typeof SuccessMeta;
-type index_SyslogMessage = SyslogMessage;
-type index_SyslogRegister = SyslogRegister;
-declare const index_TapObserver: typeof TapObserver;
-type index_TempoClientLike = TempoClientLike;
-declare const index_ThrottleOptions: typeof ThrottleOptions;
-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>;
-type index_ToNATSOptions<T> = ToNATSOptions<T>;
-declare const index_ToObservableOptions: typeof ToObservableOptions;
-type index_ToPostgresOptions<T> = ToPostgresOptions<T>;
-type index_ToPulsarOptions<T> = ToPulsarOptions<T>;
-type index_ToRabbitMQOptions<T> = ToRabbitMQOptions<T>;
-type index_ToRedisStreamOptions<T> = ToRedisStreamOptions<T>;
-type index_ToS3Options<T> = ToS3Options<T>;
-type index_ToSSEOptions = ToSSEOptions;
-type index_ToSqliteOptions<T> = ToSqliteOptions<T>;
-type index_ToTempoOptions<T> = ToTempoOptions<T>;
-type index_ToWebSocketOptions<T> = ToWebSocketOptions<T>;
-declare const index_TokenBucket: typeof TokenBucket;
-declare const index_UpsertOptions: typeof UpsertOptions;
-type index_ValueMessage = ValueMessage;
-declare const index_VerifiableBundle: typeof VerifiableBundle;
-declare const index_VerifiableOptions: typeof VerifiableOptions;
-declare const index_VerifyValue: typeof VerifyValue;
-declare const index_ViewSpec: typeof ViewSpec;
-type index_WatermarkController = WatermarkController;
-type index_WatermarkOptions = WatermarkOptions;
-type index_WebSocketLike = WebSocketLike;
-type index_WebSocketMessageEventLike = WebSocketMessageEventLike;
-type index_WebSocketRegister<T> = WebSocketRegister<T>;
-type index_WebhookRegister<T> = WebhookRegister<T>;
-declare const index_WithBreakerBundle: typeof WithBreakerBundle;
-declare const index_WithStatusBundle: typeof WithStatusBundle;
-type index_WorkerBridge<_TExpose extends Record<string, Node<any>>, TImport extends readonly string[]> = WorkerBridge<_TExpose, TImport>;
-type index_WorkerBridgeOptions<TExpose extends Record<string, Node<any>>, TImport extends readonly string[]> = WorkerBridgeOptions<TExpose, TImport>;
-type index_WorkerSelfHandle = WorkerSelfHandle;
-type index_WorkerSelfOptions<TImport extends readonly string[]> = WorkerSelfOptions<TImport>;
-type index_WorkerTransport = WorkerTransport;
-declare const index_WrapMutationOpts: typeof WrapMutationOpts;
-declare const index_appendAudit: typeof appendAudit;
-declare const index_appendLogStorage: typeof appendLogStorage;
-declare const index_audit: typeof audit;
-declare const index_awaitSettled: typeof awaitSettled;
-declare const index_budgetGate: typeof budgetGate;
-declare const index_buffer: typeof buffer;
-declare const index_bufferCount: typeof bufferCount;
-declare const index_bufferTime: typeof bufferTime;
-declare const index_bumpCursor: typeof bumpCursor;
-declare const index_cached: typeof cached;
-declare const index_canonicalJson: typeof canonicalJson;
-declare const index_cascadingCache: typeof cascadingCache;
-declare const index_catchError: typeof catchError;
-declare const index_checkpointToRedis: typeof checkpointToRedis;
-declare const index_checkpointToS3: typeof checkpointToS3;
-declare const index_circuitBreaker: typeof circuitBreaker;
-declare const index_combine: typeof combine;
-declare const index_combineLatest: typeof combineLatest;
-declare const index_concat: typeof concat;
-declare const index_concatMap: typeof concatMap;
-declare const index_constant: typeof constant;
-declare const index_contentAddressedStorage: typeof contentAddressedStorage;
-declare const index_createAuditLog: typeof createAuditLog;
-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_decay: typeof decay;
-declare const index_decorrelatedJitter: typeof decorrelatedJitter;
-declare const index_defer: typeof defer;
-declare const index_delay: typeof delay;
-declare const index_deserializeError: typeof deserializeError;
-declare const index_dictKv: typeof dictKv;
-declare const index_dictSnapshot: typeof dictSnapshot;
-declare const index_distill: typeof distill;
-declare const index_distinctUntilChanged: typeof distinctUntilChanged;
-declare const index_domainMeta: typeof domainMeta;
-declare const index_elementAt: typeof elementAt;
-declare const index_empty: typeof empty;
-declare const index_escapeRegexChar: typeof escapeRegexChar;
-declare const index_exhaustMap: typeof exhaustMap;
-declare const index_exponential: typeof exponential;
-declare const index_externalBundle: typeof externalBundle;
-declare const index_externalProducer: typeof externalProducer;
-declare const index_fallback: typeof fallback;
-declare const index_fibonacci: typeof fibonacci;
-declare const index_filter: typeof filter;
-declare const index_find: typeof find;
-declare const index_first: typeof first;
-declare const index_firstValueFrom: typeof firstValueFrom;
-declare const index_firstWhere: typeof firstWhere;
-declare const index_flatMap: typeof flatMap;
-declare const index_forEach: typeof forEach;
-declare const index_fromAny: typeof fromAny;
-declare const index_fromAsyncIter: typeof fromAsyncIter;
-declare const index_fromCSV: typeof fromCSV;
-declare const index_fromClickHouseWatch: typeof fromClickHouseWatch;
-declare const index_fromCron: typeof fromCron;
-declare const index_fromDrizzle: typeof fromDrizzle;
-declare const index_fromEvent: typeof fromEvent;
-declare const index_fromHTTP: typeof fromHTTP;
-declare const index_fromHTTPPoll: typeof fromHTTPPoll;
-declare const index_fromHTTPStream: typeof fromHTTPStream;
-declare const index_fromIter: typeof fromIter;
-declare const index_fromKafka: typeof fromKafka;
-declare const index_fromKysely: typeof fromKysely;
-declare const index_fromMCP: typeof fromMCP;
-declare const index_fromNATS: typeof fromNATS;
-declare const index_fromNDJSON: typeof fromNDJSON;
-declare const index_fromOTel: typeof fromOTel;
-declare const index_fromPrisma: typeof fromPrisma;
-declare const index_fromPrometheus: typeof fromPrometheus;
-declare const index_fromPromise: typeof fromPromise;
-declare const index_fromPulsar: typeof fromPulsar;
-declare const index_fromRabbitMQ: typeof fromRabbitMQ;
-declare const index_fromRaf: typeof fromRaf;
-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_interval: typeof interval;
-declare const index_jsonCodec: typeof jsonCodec;
-declare const index_jsonCodecFor: typeof jsonCodecFor;
-declare const index_keepalive: typeof keepalive;
-declare const index_kvStorage: typeof kvStorage;
-declare const index_last: typeof last;
-declare const index_lightMutation: typeof lightMutation;
-declare const index_linear: typeof linear;
-declare const index_lru: typeof lru;
-declare const index_makeHttpError: typeof makeHttpError;
-declare const index_map: typeof map;
-declare const index_matchesAnyPattern: typeof matchesAnyPattern;
-declare const index_matchesCron: typeof matchesCron;
-declare const index_memoryAppendLog: typeof memoryAppendLog;
-declare const index_memoryBackend: typeof memoryBackend;
-declare const index_memoryKv: typeof memoryKv;
-declare const index_memorySnapshot: typeof memorySnapshot;
-declare const index_merge: typeof merge;
-declare const index_mergeMap: typeof mergeMap;
-declare const index_mergeReactiveLogs: typeof mergeReactiveLogs;
-declare const index_nameToSignal: typeof nameToSignal;
-declare const index_ndjsonRows: typeof ndjsonRows;
-declare const index_never: typeof never;
-declare const index_nodeSignal: typeof nodeSignal;
-declare const index_of: typeof of;
-declare const index_onFirstData: typeof onFirstData;
-declare const index_pairwise: typeof pairwise;
-declare const index_parseCron: typeof parseCron;
-declare const index_parsePrometheusText: typeof parsePrometheusText;
-declare const index_parseSSEStream: typeof parseSSEStream;
-declare const index_parseStatsD: typeof parseStatsD;
-declare const index_parseSyslog: typeof parseSyslog;
-declare const index_pausable: typeof pausable;
-declare const index_pubsub: typeof pubsub;
-declare const index_race: typeof race;
-declare const index_rateLimiter: typeof rateLimiter;
-declare const index_reactiveCounter: typeof reactiveCounter;
-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_registerCursor: typeof registerCursor;
-declare const index_registerCursorMap: typeof registerCursorMap;
-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_retry: typeof retry;
-declare const index_sample: typeof sample;
-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_singleFromAny: typeof singleFromAny;
-declare const index_singleNodeFromAny: typeof singleNodeFromAny;
-declare const index_skip: typeof skip;
-declare const index_snapshotStorage: typeof snapshotStorage;
-declare const index_sortJsonValue: typeof sortJsonValue;
-declare const index_stableJsonString: typeof stableJsonString;
-declare const index_stratify: typeof stratify;
-declare const index_switchMap: typeof switchMap;
-declare const index_take: typeof take;
-declare const index_takeUntil: typeof takeUntil;
-declare const index_takeWhile: typeof takeWhile;
-declare const index_tap: typeof tap;
-declare const index_tapFirst: typeof tapFirst;
-declare const index_throttle: typeof throttle;
-declare const index_throttleTime: typeof throttleTime;
-declare const index_throwError: typeof throwError;
-declare const index_timeout: typeof timeout;
-declare const index_toArray: typeof toArray;
-declare const index_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;
-declare const index_toNATS: typeof toNATS;
-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_topologyDiff: typeof topologyDiff;
-declare const index_tryIncrementBounded: typeof tryIncrementBounded;
-declare const index_valve: typeof valve;
-declare const index_verifiable: typeof verifiable;
-declare const index_window: typeof window;
-declare const index_windowCount: typeof windowCount;
-declare const index_windowTime: typeof windowTime;
-declare const index_withBreaker: typeof withBreaker;
-declare const index_withLatestFrom: typeof withLatestFrom;
-declare const index_withMaxAttempts: typeof withMaxAttempts;
-declare const index_withStatus: typeof withStatus;
-declare const index_workerBridge: typeof workerBridge;
-declare const index_workerSelf: typeof workerSelf;
-declare const index_wrapMutation: typeof wrapMutation;
-declare const index_zip: typeof zip;
-declare namespace index {
-  export { type index_AckableMessage as AckableMessage, type index_AdapterHandlers as AdapterHandlers, index_AppendCursor as AppendCursor, index_AppendLoadResult as AppendLoadResult, index_AppendLogStorageOptions as AppendLogStorageOptions, index_AppendLogStorageTier as AppendLogStorageTier, index_AsyncSourceOpts as AsyncSourceOpts, index_AuditLogOpts as AuditLogOpts, index_BackoffPreset as BackoffPreset, index_BackoffStrategy as BackoffStrategy, index_BaseAuditRecord as BaseAuditRecord, index_BaseStorageTier as BaseStorageTier, type index_BatchMessage as BatchMessage, type index_BridgeMessage as BridgeMessage, type index_BudgetConstraint as BudgetConstraint, type index_BudgetGateOptions as BudgetGateOptions, type index_BufferedSinkHandle as BufferedSinkHandle, type index_BundleTriad as BundleTriad, type index_CSVRow as CSVRow, type index_CacheEvictionPolicy as CacheEvictionPolicy, type index_CascadingCache as CascadingCache, type index_CascadingCacheOptions as CascadingCacheOptions, type index_CheckpointToRedisOptions as CheckpointToRedisOptions, type index_CheckpointToS3Options as CheckpointToS3Options, index_CircuitBreaker as CircuitBreaker, index_CircuitBreakerOptions as CircuitBreakerOptions, index_CircuitOpenError as CircuitOpenError, index_CircuitState as CircuitState, type index_ClickHouseClientLike as ClickHouseClientLike, type index_ClickHouseInsertClientLike as ClickHouseInsertClientLike, type index_ClickHouseRow as ClickHouseRow, index_Codec as Codec, index_ContentAddressedMissError as ContentAddressedMissError, index_ContentAddressedMode as ContentAddressedMode, index_ContentAddressedStorage as ContentAddressedStorage, index_ContentAddressedStorageOptions as ContentAddressedStorageOptions, type index_CronSchedule as CronSchedule, index_DEFAULT_AUDIT_GUARD as DEFAULT_AUDIT_GUARD, index_DescribeChangeset as DescribeChangeset, index_DescribeEvent as DescribeEvent, Meta as DescribeNodeMeta, index_DistillBundle as DistillBundle, index_DistillOptions as DistillOptions, type index_DrizzleQueryLike as DrizzleQueryLike, type index_EmitTriad as EmitTriad, type index_ErrorMessage as ErrorMessage, index_EventTargetLike as EventTargetLike, index_ExponentialBackoffOptions as ExponentialBackoffOptions, type index_ExternalBundleOptions as ExternalBundleOptions, type index_ExternalRegister as ExternalRegister, index_Extraction as Extraction, index_FailureMeta as FailureMeta, index_FallbackInput as FallbackInput, type index_FileWriterLike as FileWriterLike, type index_FromCSVOptions as FromCSVOptions, type index_FromClickHouseWatchOptions as FromClickHouseWatchOptions, index_FromCronOptions as FromCronOptions, type index_FromDrizzleOptions as FromDrizzleOptions, type index_FromHTTPOptions as FromHTTPOptions, type index_FromHTTPPollOptions as FromHTTPPollOptions, type index_FromHTTPStreamOptions as FromHTTPStreamOptions, type index_FromKafkaOptions as FromKafkaOptions, type index_FromKyselyOptions as FromKyselyOptions, type index_FromMCPOptions as FromMCPOptions, type index_FromNATSOptions as FromNATSOptions, type index_FromNDJSONOptions as FromNDJSONOptions, type index_FromOTelOptions as FromOTelOptions, type index_FromPrismaOptions as FromPrismaOptions, type index_FromPrometheusOptions as FromPrometheusOptions, type index_FromPulsarOptions as FromPulsarOptions, type index_FromRabbitMQOptions as FromRabbitMQOptions, type index_FromRedisStreamOptions as FromRedisStreamOptions, type index_FromSSEOptions as FromSSEOptions, type index_FromSqliteOptions as FromSqliteOptions, type index_FromStatsDOptions as FromStatsDOptions, type index_FromSyslogOptions as FromSyslogOptions, type index_FromWebSocketReconnectOptions as FromWebSocketReconnectOptions, type index_HTTPBundle as HTTPBundle, index_IndexBackend as IndexBackend, index_IndexRow as IndexRow, type index_InitMessage as InitMessage, index_JitterMode as JitterMode, type index_KafkaConsumerLike as KafkaConsumerLike, type index_KafkaMessage as KafkaMessage, type index_KafkaProducerLike as KafkaProducerLike, index_KvStorageOptions as KvStorageOptions, index_KvStorageTier as KvStorageTier, type index_KyselyQueryLike as KyselyQueryLike, index_LightMutationOpts as LightMutationOpts, index_ListBackend as ListBackend, index_LogBackend as LogBackend, type index_LokiClientLike as LokiClientLike, type index_LokiStream as LokiStream, type index_MCPClientLike as MCPClientLike, index_MapBackend as MapBackend, index_MergeMapOptions as MergeMapOptions, index_MergedReactiveLog as MergedReactiveLog, type index_MongoCollectionLike as MongoCollectionLike, index_MutationOpts as MutationOpts, type index_NATSClientLike as NATSClientLike, type index_NATSMessage as NATSMessage, type index_NATSSubscriptionLike as NATSSubscriptionLike, index_NS_PER_MS as NS_PER_MS, index_NS_PER_SEC as NS_PER_SEC, index_NativeIndexBackend as NativeIndexBackend, index_NativeListBackend as NativeListBackend, index_NativeLogBackend as NativeLogBackend, index_NativeMapBackend as NativeMapBackend, index_NativeMapBackendOptions as NativeMapBackendOptions, index_NativePubSubBackend as NativePubSubBackend, index_NodeInput as NodeInput, type index_OTelBundle as OTelBundle, type index_OTelLog as OTelLog, type index_OTelMetric as OTelMetric, type index_OTelRegister as OTelRegister, type index_OTelSpan as OTelSpan, type index_ParseSSEStreamOptions as ParseSSEStreamOptions, type index_PostgresClientLike as PostgresClientLike, type index_PrismaModelLike as PrismaModelLike, type index_PrometheusMetric as PrometheusMetric, type index_PubSubBackend as PubSubBackend, type index_PubSubHub as PubSubHub, type index_PubSubHubOptions as PubSubHubOptions, type index_PulsarConsumerLike as PulsarConsumerLike, type index_PulsarMessage as PulsarMessage, type index_PulsarProducerLike as PulsarProducerLike, type index_RabbitMQChannelLike as RabbitMQChannelLike, type index_RabbitMQMessage as RabbitMQMessage, index_RateLimiterOptions as RateLimiterOptions, index_RateLimiterOverflowError as RateLimiterOverflowError, index_RateLimiterOverflowPolicy as RateLimiterOverflowPolicy, index_ReactiveCounterBundle as ReactiveCounterBundle, index_ReactiveIndexBundle as ReactiveIndexBundle, index_ReactiveIndexOptions as ReactiveIndexOptions, index_ReactiveListBundle as ReactiveListBundle, index_ReactiveListOptions as ReactiveListOptions, index_ReactiveLogBundle as ReactiveLogBundle, index_ReactiveLogOptions as ReactiveLogOptions, index_ReactiveMapBundle as ReactiveMapBundle, index_ReactiveMapOptions as ReactiveMapOptions, index_ReactiveMapRetention as ReactiveMapRetention, type index_ReactiveSinkBackpressureOptions as ReactiveSinkBackpressureOptions, type index_ReactiveSinkConfig as ReactiveSinkConfig, type index_ReactiveSinkHandle as ReactiveSinkHandle, type index_ReactiveSinkOptions as ReactiveSinkOptions, type index_ReactiveSinkRetryOptions as ReactiveSinkRetryOptions, type index_ReadyMessage as ReadyMessage, type index_RedisCheckpointClientLike as RedisCheckpointClientLike, type index_RedisClientLike as RedisClientLike, type index_RedisStreamEntry as RedisStreamEntry, index_ResettableTimer as ResettableTimer, index_RetryOptions as RetryOptions, type index_S3ClientLike as S3ClientLike, type index_SSEEvent as SSEEvent, type index_SignalMessage as SignalMessage, type index_SingleFromAnyOptions as SingleFromAnyOptions, type index_SinkFailure as SinkFailure, type index_SinkHandle as SinkHandle, type index_SinkTransportError as SinkTransportError, index_SnapshotStorageOptions as SnapshotStorageOptions, index_SnapshotStorageTier as SnapshotStorageTier, type index_SqliteDbLike as SqliteDbLike, type index_SqliteIterableDbLike as SqliteIterableDbLike, type index_StatsDMetric as StatsDMetric, type index_StatsDRegister as StatsDRegister, index_StatusValue as StatusValue, index_StorageBackend as StorageBackend, index_StorageHandle as StorageHandle, type index_StratifyOptions as StratifyOptions, type index_StratifyRule as StratifyRule, index_SuccessMeta as SuccessMeta, type index_SyslogMessage as SyslogMessage, type index_SyslogRegister as SyslogRegister, index_TapObserver as TapObserver, type index_TempoClientLike as TempoClientLike, index_ThrottleOptions as ThrottleOptions, index_TimeoutError as TimeoutError, type index_ToCSVOptions as ToCSVOptions, type index_ToClickHouseOptions as ToClickHouseOptions, type index_ToFileOptions as ToFileOptions, type index_ToHTTPOptions as ToHTTPOptions, type index_ToKafkaOptions as ToKafkaOptions, type index_ToLokiOptions as ToLokiOptions, type index_ToMongoOptions as ToMongoOptions, type index_ToNATSOptions as ToNATSOptions, index_ToObservableOptions as ToObservableOptions, type index_ToPostgresOptions as ToPostgresOptions, type index_ToPulsarOptions as ToPulsarOptions, type index_ToRabbitMQOptions as ToRabbitMQOptions, type index_ToRedisStreamOptions as ToRedisStreamOptions, type index_ToS3Options as ToS3Options, type index_ToSSEOptions as ToSSEOptions, type index_ToSqliteOptions as ToSqliteOptions, type index_ToTempoOptions as ToTempoOptions, type index_ToWebSocketOptions as ToWebSocketOptions, index_TokenBucket as TokenBucket, index_UpsertOptions as UpsertOptions, type index_ValueMessage as ValueMessage, index_VerifiableBundle as VerifiableBundle, index_VerifiableOptions as VerifiableOptions, index_VerifyValue as VerifyValue, index_ViewSpec as ViewSpec, type index_WatermarkController as WatermarkController, type index_WatermarkOptions as WatermarkOptions, type index_WebSocketLike as WebSocketLike, type index_WebSocketMessageEventLike as WebSocketMessageEventLike, type index_WebSocketRegister as WebSocketRegister, type index_WebhookRegister as WebhookRegister, index_WithBreakerBundle as WithBreakerBundle, index_WithStatusBundle as WithStatusBundle, type index_WorkerBridge as WorkerBridge, type index_WorkerBridgeOptions as WorkerBridgeOptions, type index_WorkerSelfHandle as WorkerSelfHandle, type index_WorkerSelfOptions as WorkerSelfOptions, type index_WorkerTransport as WorkerTransport, index_WrapMutationOpts as WrapMutationOpts, index_appendAudit as appendAudit, index_appendLogStorage as appendLogStorage, index_audit as audit, index_awaitSettled as awaitSettled, index_budgetGate as budgetGate, index_buffer as buffer, index_bufferCount as bufferCount, index_bufferTime as bufferTime, index_bumpCursor as bumpCursor, index_cached as cached, index_canonicalJson as canonicalJson, 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_contentAddressedStorage as contentAddressedStorage, index_createAuditLog as createAuditLog, index_createTransport as createTransport, index_createWatermarkController as createWatermarkController, index_csvRows as csvRows, index_debounce as debounce, index_debounceTime as debounceTime, index_decay as decay, index_decorrelatedJitter as decorrelatedJitter, index_defer as defer, index_delay as delay, index_deserializeError as deserializeError, index_dictKv as dictKv, index_dictSnapshot as dictSnapshot, index_distill as distill, index_distinctUntilChanged as distinctUntilChanged, index_domainMeta as domainMeta, index_elementAt as elementAt, index_empty as empty, index_escapeRegexChar as escapeRegexChar, index_exhaustMap as exhaustMap, index_exponential as exponential, index_externalBundle as externalBundle, index_externalProducer as externalProducer, index_fallback as fallback, index_fibonacci as fibonacci, index_filter as filter, index_find as find, index_first as first, index_firstValueFrom as firstValueFrom, index_firstWhere as firstWhere, index_flatMap as flatMap, index_forEach as forEach, index_fromAny as fromAny, index_fromAsyncIter as fromAsyncIter, index_fromCSV as fromCSV, index_fromClickHouseWatch as fromClickHouseWatch, index_fromCron as fromCron, index_fromDrizzle as fromDrizzle, index_fromEvent as fromEvent, index_fromHTTP as fromHTTP, index_fromHTTPPoll as fromHTTPPoll, index_fromHTTPStream as fromHTTPStream, index_fromIter as fromIter, index_fromKafka as fromKafka, index_fromKysely as fromKysely, index_fromMCP as fromMCP, index_fromNATS as fromNATS, index_fromNDJSON as fromNDJSON, index_fromOTel as fromOTel, index_fromPrisma as fromPrisma, index_fromPrometheus as fromPrometheus, index_fromPromise as fromPromise, index_fromPulsar as fromPulsar, index_fromRabbitMQ as fromRabbitMQ, index_fromRaf as fromRaf, index_fromRedisStream as fromRedisStream, index_fromSSE as fromSSE, index_fromSqlite as fromSqlite, index_fromSqliteCursor as fromSqliteCursor, index_fromStatsD as fromStatsD, index_fromSyslog as fromSyslog, index_fromTimer as fromTimer, index_fromWebSocket as fromWebSocket, index_fromWebSocketReconnect as fromWebSocketReconnect, index_fromWebhook as fromWebhook, index_globToRegExp as globToRegExp, index_interval as interval, index_jsonCodec as jsonCodec, index_jsonCodecFor as jsonCodecFor, index_keepalive as keepalive, index_kvStorage as kvStorage, index_last as last, index_lightMutation as lightMutation, index_linear as linear, index_lru as lru, index_makeHttpError as makeHttpError, index_map as map, index_matchesAnyPattern as matchesAnyPattern, index_matchesCron as matchesCron, index_memoryAppendLog as memoryAppendLog, index_memoryBackend as memoryBackend, index_memoryKv as memoryKv, index_memorySnapshot as memorySnapshot, index_merge as merge, index_mergeMap as mergeMap, index_mergeReactiveLogs as mergeReactiveLogs, index_nameToSignal as nameToSignal, index_ndjsonRows as ndjsonRows, index_never as never, index_nodeSignal as nodeSignal, index_of as of, index_onFirstData as onFirstData, index_pairwise as pairwise, index_parseCron as parseCron, index_parsePrometheusText as parsePrometheusText, index_parseSSEStream as parseSSEStream, 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_registerCursor as registerCursor, index_registerCursorMap as registerCursorMap, index_repeat as repeat, index_replay as replay, index_rescue as rescue, index_resolveBackoffPreset as resolveBackoffPreset, index_retry as retry, index_sample as sample, index_scan as scan, index_serializeError as serializeError, index_share as share, index_shareReplay as shareReplay, index_signalToName as signalToName, index_singleFromAny as singleFromAny, index_singleNodeFromAny as singleNodeFromAny, index_skip as skip, index_snapshotStorage as snapshotStorage, index_sortJsonValue as sortJsonValue, index_stableJsonString as stableJsonString, index_stratify as stratify, index_switchMap as switchMap, index_take as take, index_takeUntil as takeUntil, index_takeWhile as takeWhile, index_tap as tap, index_tapFirst as tapFirst, 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_topologyDiff as topologyDiff, index_tryIncrementBounded as tryIncrementBounded, 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_wrapMutation as wrapMutation, index_zip as zip };
-}
-
-export { type LokiStream as $, type AckableMessage as A, type BatchMessage as B, type CSVRow as C, type DrizzleQueryLike as D, type EmitTriad as E, type FileWriterLike as F, type FromMCPOptions as G, type FromNATSOptions as H, type FromNDJSONOptions as I, type FromOTelOptions as J, type FromPrismaOptions as K, type FromPrometheusOptions as L, type FromPulsarOptions as M, type FromRabbitMQOptions as N, type FromRedisStreamOptions as O, type FromSSEOptions as P, type FromSqliteOptions as Q, type FromStatsDOptions as R, type FromSyslogOptions as S, type FromWebSocketReconnectOptions as T, type HTTPBundle as U, type InitMessage as V, type KafkaConsumerLike as W, type KafkaMessage as X, type KafkaProducerLike as Y, type KyselyQueryLike as Z, type LokiClientLike as _, type AdapterHandlers as a, type ToSqliteOptions as a$, type MCPClientLike as a0, type MongoCollectionLike as a1, type NATSClientLike as a2, type NATSMessage as a3, type NATSSubscriptionLike as a4, NativePubSubBackend as a5, type OTelBundle as a6, type OTelLog as a7, type OTelMetric as a8, type OTelRegister as a9, type SingleFromAnyOptions as aA, type SinkFailure as aB, type SinkHandle as aC, type SinkTransportError as aD, type SqliteDbLike as aE, type SqliteIterableDbLike as aF, type StatsDMetric as aG, type StatsDRegister as aH, type StratifyOptions as aI, type StratifyRule as aJ, type SyslogMessage as aK, type SyslogRegister as aL, type TempoClientLike as aM, type ToCSVOptions as aN, type ToClickHouseOptions as aO, type ToFileOptions as aP, type ToHTTPOptions as aQ, type ToKafkaOptions as aR, type ToLokiOptions as aS, type ToMongoOptions as aT, type ToNATSOptions as aU, type ToPostgresOptions as aV, type ToPulsarOptions as aW, type ToRabbitMQOptions as aX, type ToRedisStreamOptions as aY, type ToS3Options as aZ, type ToSSEOptions as a_, type OTelSpan as aa, type ParseSSEStreamOptions as ab, type PostgresClientLike as ac, type PrismaModelLike as ad, type PrometheusMetric as ae, type PubSubBackend as af, type PubSubHub as ag, type PubSubHubOptions as ah, type PulsarConsumerLike as ai, type PulsarMessage as aj, type PulsarProducerLike as ak, type RabbitMQChannelLike as al, type RabbitMQMessage as am, type ReactiveSinkBackpressureOptions as an, type ReactiveSinkConfig as ao, type ReactiveSinkHandle as ap, type ReactiveSinkOptions as aq, type ReactiveSinkRetryOptions as ar, type ReadyMessage as as, type RedisCheckpointClientLike as at, type RedisClientLike as au, type RedisStreamEntry as av, ResettableTimer as aw, type S3ClientLike as ax, type SSEEvent as ay, type SignalMessage as az, type BridgeMessage as b, serializeError as b$, type ToTempoOptions as b0, type ToWebSocketOptions as b1, type ValueMessage as b2, type WatermarkController as b3, type WatermarkOptions as b4, type WebSocketLike as b5, type WebSocketMessageEventLike as b6, type WebSocketRegister as b7, type WebhookRegister as b8, type WorkerBridge as b9, fromNDJSON as bA, fromOTel as bB, fromPrisma as bC, fromPrometheus as bD, fromPulsar as bE, fromRabbitMQ as bF, fromRedisStream as bG, fromSSE as bH, fromSqlite as bI, fromSqliteCursor as bJ, fromStatsD as bK, fromSyslog as bL, fromWebSocket as bM, fromWebSocketReconnect as bN, fromWebhook as bO, lru as bP, makeHttpError as bQ, matchesCron as bR, nameToSignal as bS, ndjsonRows as bT, parseCron as bU, parsePrometheusText as bV, parseSSEStream as bW, parseStatsD as bX, parseSyslog as bY, pubsub as bZ, reactiveSink as b_, type WorkerBridgeOptions as ba, type WorkerSelfHandle as bb, type WorkerSelfOptions as bc, type WorkerTransport as bd, budgetGate as be, cascadingCache as bf, checkpointToRedis as bg, checkpointToS3 as bh, createTransport as bi, createWatermarkController as bj, csvRows as bk, deserializeError as bl, domainMeta as bm, externalBundle as bn, externalProducer as bo, index as bp, fromCSV as bq, fromClickHouseWatch as br, fromDrizzle as bs, fromHTTP as bt, fromHTTPPoll as bu, fromHTTPStream as bv, fromKafka as bw, fromKysely as bx, fromMCP as by, fromNATS as bz, type BudgetConstraint as c, signalToName as c0, singleFromAny as c1, singleNodeFromAny as c2, stratify as c3, toCSV as c4, toClickHouse as c5, toFile as c6, toHTTP as c7, toKafka as c8, toLoki as c9, toMongo as ca, toNATS as cb, toPostgres as cc, toPulsar as cd, toRabbitMQ as ce, toReadableStream as cf, toRedisStream as cg, toS3 as ch, toSSE as ci, toSSEBytes as cj, toSqlite as ck, toTempo as cl, toWebSocket as cm, workerBridge as cn, workerSelf as co, type BudgetGateOptions as d, type BufferedSinkHandle as e, type BundleTriad as f, type CacheEvictionPolicy as g, type CascadingCache as h, type CascadingCacheOptions as i, type CheckpointToRedisOptions as j, type CheckpointToS3Options as k, type ClickHouseClientLike as l, type ClickHouseInsertClientLike as m, type ClickHouseRow as n, type CronSchedule as o, type ErrorMessage as p, type ExternalBundleOptions as q, type ExternalRegister as r, type FromCSVOptions as s, type FromClickHouseWatchOptions as t, type FromDrizzleOptions as u, type FromHTTPOptions as v, type FromHTTPPollOptions as w, type FromHTTPStreamOptions as x, type FromKafkaOptions as y, type FromKyselyOptions as z };