@graphrefly/graphrefly 0.21.0 → 0.22.0

package/dist/index-Bc_diYYJ.d.cts

@@ -1,629 +0,0 @@
-import { b as NodeActions, N as Node, a as NodeOptions, l as Messages, a4 as NodeBase, q as NodeTransportOptions, A as Actor, C as CLEANUP_RESULT, c as COMPLETE, d as CleanupResult, D as DATA, e as DEFAULT_ACTOR, f as DIRTY, g as DescribeDetail, h as DescribeField, i as DescribeNodeOutput, E as ERROR, G as GuardAction, j as GuardDenied, k as GuardDeniedDetails, H as HashFn, I as INVALIDATE, M as Message, m as NodeDescribeKind, n as NodeGuard, o as NodeSink, p as NodeStatus, r as NodeVersionInfo, O as OnMessageHandler, P as PAUSE, s as PolicyAllow, t as PolicyDeny, u as PolicyRuleData, R as RESOLVED, v as RESUME, S as START, w as SubscribeHints, T as TEARDOWN, V as V0, x as V1, y as VersioningLevel, z as VersioningOptions, B as accessHintForGuard, F as advanceVersion, J as cleanupResult, K as createVersioning, L as defaultHash, Q as isKnownMessageType, U as isLocalOnly, W as isPhase2Message, X as isTerminalMessage, Y as isV1, Z as knownMessageTypes, _ as messageTier, $ as normalizeActor, a0 as policy, a1 as policyFromRules, a2 as propagatesToMeta, a3 as resolveDescribeFields } from './meta-BnG7XAaE.cjs';
-
-/**
- * `NodeImpl` — the canonical node primitive for static (compile-time known)
- * dependency graphs. Covers state, producer, derived, effect, operator, and
- * passthrough shapes from a single class.
- *
- * Lifecycle machinery (subscribe + START handshake + `_downInternal` pipeline)
- * lives in {@link NodeBase}. This file only adds:
- * - Dep-wave tracking via pre-set dirty masks (first run and subsequent waves
- *   share the same code path — see `_connectUpstream` + `_handleDepMessages`)
- * - `_runFn` with identity-skip optimization on `_lastDepValues`
- * - Producer start/stop tied to sink count
- * - ROM/RAM cache semantics: compute nodes clear `_cached` on disconnect,
- *   state sources preserve it (see `_onDeactivate`).
- *
- * See GRAPHREFLY-SPEC §§2.1–2.8 and COMPOSITION-GUIDE §§1, 9.
- */
-
-/**
- * Compute function passed to `node(deps, fn, opts?)`.
- *
- * @returns A value to emit, `undefined` to skip emission, or a cleanup
- *   function invoked before the next run or on teardown.
- */
-type NodeFn<T = unknown> = (deps: readonly unknown[], actions: NodeActions) => T | undefined | (() => void);
-/**
- * Creates a reactive {@link Node} — the single GraphReFly primitive (§2).
- *
- * Typical shapes: `node([])` / `node([], opts)` for a manual source;
- * `node(producerFn, opts)` for a producer; `node(deps, computeFn, opts)` for
- * derived nodes and operators.
- *
- * @param depsOrFn - Dependency nodes, a {@link NodeFn} (producer), or {@link NodeOptions} alone.
- * @param fnOrOpts - With deps: compute function or options. Omitted for producer-only form.
- * @param optsArg - Options when both `deps` and `fn` are provided.
- * @returns `Node<T>` — lazy until subscribed.
- *
- * @remarks
- * **Protocol:** START handshake, DIRTY / DATA / RESOLVED ordering, completion,
- * and batch deferral follow `~/src/graphrefly/GRAPHREFLY-SPEC.md`.
- *
- * **`equals` and mutable values:** The default `Object.is` identity check is
- * correct for the common immutable-value case. If your node produces mutable
- * objects, provide a custom `equals` — otherwise `Object.is` always returns
- * `true` for the same reference and the node emits `RESOLVED` instead of `DATA`.
- *
- * **ROM/RAM (§2.2):** State nodes (no fn) preserve their cache across
- * disconnect — runtime writes survive. Compute nodes (derived, producer)
- * clear their cache on disconnect; reconnect re-runs fn.
- *
- * @example
- * ```ts
- * import { node, state } from "@graphrefly/graphrefly-ts";
- *
- * const a = state(1);
- * const b = node([a], ([x]) => (x as number) + 1);
- * ```
- *
- * @category core
- */
-declare function node<T = unknown>(depsOrFn?: readonly Node[] | NodeFn<T> | NodeOptions, fnOrOpts?: NodeFn<T> | NodeOptions, optsArg?: NodeOptions): Node<T>;
-
-/**
- * Returns whether the current call stack is inside a batch scope **or** while
- * deferred phase-2 work is draining.
- *
- * Matching Python's `is_batching()` semantics: nested emissions during drain
- * are deferred until the current drain pass completes, preventing ordering
- * bugs when callbacks trigger further DATA/RESOLVED.
- *
- * @returns `true` while inside `batch()` or while the drain loop is running.
- *
- * @example
- * ```ts
- * import { batch, isBatching } from "@graphrefly/graphrefly-ts";
- *
- * batch(() => {
- *   console.log(isBatching()); // true
- * });
- * ```
- *
- * @category core
- */
-declare function isBatching(): boolean;
-/**
- * Runs `fn` inside a batch scope. Nested `batch()` calls share one deferral queue.
- * If `fn` throws (including from a nested `batch`), deferred DATA/RESOLVED for
- * that **outer** `batch` frame are discarded — phase-2 is not flushed after an
- * error. While the drain loop is running (`flushInProgress`), a nested `batch`
- * that throws must **not** clear the global queue (cross-language decision A4).
- *
- * During the drain loop, `isBatching()` remains true so nested `downWithBatch`
- * calls still defer phase-2 messages. The drain loop runs until the queue is
- * quiescent (no pending work remains). Per-emission try/catch ensures one
- * throwing callback does not orphan remaining emissions; the first error is
- * re-thrown after all emissions drain. Callbacks that ran before the throw may
- * have applied phase-2 — partial graph state is intentional (decision C1).
- *
- * @param fn — Synchronous work that may call `downWithBatch` / `node.down()`.
- * @returns `void` — all side-effects happen through `downWithBatch` and the
- *   phase-2 drain that runs after `fn` returns.
- *
- * @example
- * ```ts
- * import { core } from "@graphrefly/graphrefly-ts";
- *
- * core.batch(() => {
- *   core.downWithBatch(sink, [[core.DATA, 1]]);
- * });
- * ```
- *
- * @category core
- */
-declare function batch(fn: () => void): void;
-/**
- * Splits a message array into three groups by signal tier (see `messages.ts`):
- *
- * - **immediate** — tier 0–2, 5: START, DIRTY, INVALIDATE, PAUSE, RESUME, TEARDOWN, unknown
- * - **deferred** — tier 3: DATA, RESOLVED (phase-2, deferred inside `batch()`)
- * - **terminal** — tier 4: COMPLETE, ERROR (delivered after phase-2)
- *
- * Order within each group is preserved.
- *
- * @param messages — One `down()` payload.
- * @returns Three groups in canonical delivery order.
- *
- * @example
- * ```ts
- * import { DATA, DIRTY, COMPLETE, partitionForBatch } from "@graphrefly/graphrefly-ts";
- *
- * partitionForBatch([[DIRTY], [DATA, 1], [COMPLETE]]);
- * // { immediate: [[DIRTY]], deferred: [[DATA, 1]], terminal: [[COMPLETE]] }
- * ```
- *
- * @category core
- */
-declare function partitionForBatch(messages: Messages): {
-    immediate: Messages;
-    deferred: Messages;
-    terminal: Messages;
-};
-/**
- * Delivers messages downstream through `sink`, applying batch semantics and
- * canonical tier-based ordering (see `messages.ts`):
- *
- * 1. **Immediate** (tier 0–2, 5): START, DIRTY, INVALIDATE, PAUSE, RESUME, TEARDOWN,
- *    unknown — delivered synchronously.
- * 2. **Phase-2** (tier 3): DATA, RESOLVED — deferred while `isBatching()`.
- * 3. **Terminal** (tier 4): COMPLETE, ERROR — always delivered after phase-2.
- *    When batching, terminal is queued after deferred phase-2 in the pending list.
- *    When not batching, terminal is delivered after phase-2 synchronously.
- *
- * This ordering prevents the "COMPLETE-before-DATA" class of bugs: terminal
- * signals never make a node terminal before phase-2 values reach sinks,
- * regardless of how the source assembled the message array.
- *
- * @param sink — Sink callback. May be called up to three times per invocation
- *   (immediate, deferred, terminal) when not batching.
- * @param messages — Full `[[Type, Data?], ...]` array for one downstream delivery.
- * @param phase — Starting delivery phase (`2` = data, `3` = terminal). Default `2`.
- * @param options - Optional configuration.
- * @option strategy | `"partition"` or `"sequential"` | `"partition"` | `"partition"` groups by tier; `"sequential"` preserves message order within each tier using `messageTier()` classification.
- * @returns `void` — delivery is performed through `sink` callbacks, synchronously
- *   or deferred into the active batch queue.
- *
- * @example
- * ```ts
- * import { core } from "@graphrefly/graphrefly-ts";
- *
- * core.downWithBatch((msgs) => console.log(msgs), [[core.DIRTY], [core.DATA, 42]]);
- * ```
- *
- * @category core
- */
-/** Delivery strategy for {@link downWithBatch}. Mirrors Python `DownStrategy`. */
-type DownStrategy = "partition" | "sequential";
-declare function downWithBatch(sink: (messages: Messages) => void, messages: Messages, phase?: 2 | 3, options?: {
-    strategy?: DownStrategy;
-}): void;
-
-/**
- * bridge — graph-visible message forwarding between two nodes.
- *
- * Replaces ad-hoc `subscribe()` bridges that bypass graph topology.
- * The returned node is an effect that intercepts messages from `from`
- * and forwards them to `to.down()`. Register it with `graph.add()` to
- * make the bridge visible in `describe()` and `snapshot()`.
- *
- * **Upstream path:** The bridge node has `from` as its dep, so anything
- * downstream of the bridge that calls `up()` naturally reaches `from`.
- * If `to` is used as a dep by other nodes and those nodes send `up()`,
- * the messages reach `to`'s deps (not `from`). For full upstream relay
- * across the bridge boundary, wire the bridge as a dep of `to`'s
- * consumers or use `graph.connect()`.
- *
- * **ABAC / guards:** `to.down()` is called without `NodeTransportOptions`,
- * so any ABAC guard on `to` receives `actor = undefined`. Upstream (`up()`)
- * messages propagate through the dep chain the same way — no actor is
- * injected on either path. Both paths are intentionally unguarded; if `to`
- * requires a specific actor, provide a guarded wrapper node and bridge to
- * that instead.
- *
- * **Default forwarding:** All standard message types are forwarded by
- * default, including TEARDOWN, PAUSE, RESUME, and INVALIDATE. Use the
- * `down` option to restrict which types are forwarded. Callers that need
- * to exclude TEARDOWN (e.g. inter-stage wiring in `funnel()`) pass an
- * explicit `down` array without TEARDOWN.
- *
- * @module
- */
-
-/** Options for {@link bridge}. */
-type BridgeOptions = {
-    /** Node name (for graph registration / describe). */
-    name?: string;
-    /**
-     * Standard message types to forward downstream. Default: all standard
-     * types. Unknown (non-standard) types always forward per spec §1.3.6
-     * regardless of this option.
-     */
-    down?: readonly symbol[];
-};
-/** All standard types forwarded by default. Export for callers that
- *  need to customize (e.g. exclude TEARDOWN). */
-declare const DEFAULT_DOWN: readonly symbol[];
-/**
- * Create a graph-visible bridge node that forwards messages from `from` to `to`.
- *
- * The bridge is a real node (effect) — it shows up in `describe()`, participates
- * in two-phase push, and cleans up on TEARDOWN. Register it via `graph.add()`
- * to make it part of the graph topology.
- *
- * **Unknown message types** (custom domain signals not in the standard protocol
- * set) are always forwarded to `to`, regardless of the `down` option. This
- * satisfies spec §1.3.6 ("unknown types forward unchanged").
- *
- * **COMPLETE / ERROR**: when forwarded, the bridge also transitions to terminal
- * state so graph-wide completion detection works correctly.
- *
- * @param from - Source node to observe.
- * @param to - Target node to forward messages to via `to.down()`.
- * @param opts - Optional configuration.
- * @returns A bridge effect node. Add it to a graph with `graph.add(name, bridge(...))`.
- *
- * @example
- * ```ts
- * import { bridge, state } from "@graphrefly/graphrefly-ts";
- *
- * const a = state(0);
- * const b = state(0);
- * const br = bridge(a, b, { name: "__bridge_a_b" });
- * graph.add("__bridge_a_b", br);
- * // Now a's messages flow to b, visible in describe()
- * ```
- *
- * @category core
- */
-declare function bridge<T = unknown>(from: Node<T>, to: Node, opts?: BridgeOptions): Node<unknown>;
-
-/**
- * Centralised timestamp utilities.
- *
- * Convention: all graphrefly-ts timestamps use nanoseconds (`_ns` suffix).
- *
- * - {@link monotonicNs} — monotonic clock (ordering, durations, timeline events).
- * - {@link wallClockNs} — wall-clock (mutation attribution, cron emission).
- *
- * **Precision limits (JS platform):**
- *
- * - `monotonicNs`: effective ~microsecond precision. `performance.now()` returns
- *   milliseconds with ~5µs resolution; the last 3 digits of the nanosecond value
- *   are always zero. Python's `time.monotonic_ns()` gives true nanoseconds.
- *
- * - `wallClockNs`: ~256ns precision loss at current epoch. `Date.now() * 1e6`
- *   produces values around 1.8×10¹⁸ which exceed IEEE 754's 2⁵³ safe integer
- *   limit. Python's `time.time_ns()` (arbitrary-precision `int`) has no loss.
- *   In practice this is irrelevant — JS is single-threaded, so sub-microsecond
- *   timestamp collisions cannot occur.
- */
-/** Monotonic nanosecond timestamp via `performance.now()`. */
-declare function monotonicNs(): number;
-/** Wall-clock nanosecond timestamp via `Date.now()`. */
-declare function wallClockNs(): number;
-
-/**
- * `dynamicNode` — runtime dep tracking with diamond resolution (Phase 0.3b).
- *
- * Unlike `node()` where deps are fixed at construction, `dynamicNode`
- * discovers deps at runtime via a tracking `get()` proxy. After each
- * recompute, deps are diffed: new deps are connected, removed deps are
- * disconnected, and bitmasks are rebuilt.
- *
- * Shares subscribe / sink / lifecycle machinery with {@link NodeImpl} via
- * {@link NodeBase}. The only things that diverge from static nodes:
- * - deps are discovered inside `_runFn` via a tracking `get` proxy
- * - `_rewire` installs subscriptions lazily during `_runFn`
- * - during rewire, new dep messages are **buffered** (option C from the
- *   Apr-2026 refactor); after rewire we scan the buffer for DATA values
- *   that differ from what fn tracked, and re-run fn if any found
- *   (bounded by `MAX_RERUN`)
- */
-
-/**
- * The tracking `get` function passed to `dynamicNode`'s compute function.
- * Each call to `get(dep)` reads the dep's current value and records it as a dependency.
- */
-type DynGet = <V>(dep: Node<V>) => V | undefined;
-/**
- * Compute function for `dynamicNode`. Receives a tracking `get` proxy.
- * Deps are discovered by which nodes are passed to `get()` during execution.
- */
-type DynamicNodeFn<T> = (get: DynGet) => T;
-/** Options for `dynamicNode`. */
-type DynamicNodeOptions = Pick<NodeOptions, "name" | "equals" | "meta" | "resubscribable" | "resetOnTeardown" | "guard" | "onMessage" | "onResubscribe" | "completeWhenDepsComplete" | "describeKind">;
-/**
- * Creates a node with runtime dep tracking. Deps are discovered each time the
- * compute function runs by tracking which nodes are passed to the `get()` proxy.
- *
- * After each recompute:
- * - New deps (not in previous set) are subscribed
- * - Removed deps (not in current set) are unsubscribed
- * - Kept deps retain their existing subscriptions
- *
- * The node participates in diamond resolution via the pre-set dirty mask
- * (shared with {@link NodeImpl}).
- *
- * **Lazy-dep composition:** when a tracked dep is itself a lazy compute node
- * whose first subscribe causes a fresh value to arrive, the rewire buffer
- * detects the discrepancy and re-runs fn once so it observes the real value.
- * Capped at {@link MAX_RERUN} iterations.
- *
- * @param fn - Compute function receiving a tracking `get` proxy.
- * @param opts - Optional configuration.
- * @returns `Node<T>` with dynamic dep tracking.
- *
- * @example
- * ```ts
- * import { dynamicNode, state } from "@graphrefly/graphrefly-ts";
- *
- * const cond = state(true);
- * const a = state(1);
- * const b = state(2);
- *
- * const d = dynamicNode((get) => {
- *   const useA = get(cond);
- *   return useA ? get(a) : get(b);
- * });
- * ```
- *
- * @category core
- */
-declare function dynamicNode<T = unknown>(fn: DynamicNodeFn<T>, opts?: DynamicNodeOptions): Node<T>;
-/** @internal — exported for {@link describeNode} `instanceof` check. */
-declare class DynamicNodeImpl<T = unknown> extends NodeBase<T> {
-    private readonly _fn;
-    private readonly _autoComplete;
-    /** @internal Read by `describeNode`. */
-    _deps: Node[];
-    private _depUnsubs;
-    private _depIndexMap;
-    private _depDirtyBits;
-    private _depSettledBits;
-    private _depCompleteBits;
-    private _running;
-    private _rewiring;
-    private _bufferedDepMessages;
-    private _trackedValues;
-    private _rerunCount;
-    constructor(fn: DynamicNodeFn<T>, opts: DynamicNodeOptions);
-    protected _createMetaNode(key: string, initialValue: unknown, opts: NodeOptions): Node;
-    /** Versioning not supported on DynamicNodeImpl (override base). */
-    get v(): undefined;
-    up(messages: Messages, options?: NodeTransportOptions): void;
-    protected _upInternal(messages: Messages): void;
-    unsubscribe(): void;
-    protected _onActivate(): void;
-    protected _doDeactivate(): void;
-    private _disconnect;
-    private _runFn;
-    private _rewire;
-    private _handleDepMessages;
-    /**
-     * Update dep masks for a message without triggering `_runFn` — used
-     * during post-rewire drain so the wave state is consistent with the
-     * buffered activation cascade without recursing.
-     */
-    private _updateMasksForMessage;
-    private _allDirtySettled;
-    /**
-     * True if any current dep value differs from what the last `_runFn`
-     * saw via `get()`. Used to suppress redundant re-runs when deferred
-     * handshake messages arrive after `_rewire` for a dep whose value
-     * already matches `_trackedValues`.
-     */
-    private _depValuesDifferFromTracked;
-}
-
-/**
- * Creates a manual source with no upstream deps. Emit values with {@link Node.down}.
- *
- * Spec: `state(initial, opts?)` is `node([], { initial, ...opts })` (GRAPHREFLY-SPEC §2.7).
- *
- * @param initial - Initial cached value. Because `initial` is provided, `equals` is
- *   called on the first {@link Node.down | down()} emission — if the value matches
- *   `initial`, the node emits `RESOLVED` instead of `DATA` (spec §2.5).
- * @param opts - Optional {@link NodeOptions} (excluding `initial`).
- * @returns `Node<T>` - Stateful node you drive imperatively.
- *
- * @example
- * ```ts
- * import { DATA, state } from "@graphrefly/graphrefly-ts";
- *
- * const n = state(0);
- * n.down([[DATA, 1]]);
- * ```
- *
- * @category core
- */
-declare function state<T>(initial: T, opts?: Omit<NodeOptions, "initial">): Node<T>;
-/**
- * Creates a producer node with no deps; `fn` runs when the first subscriber connects.
- *
- * @param fn - Receives deps (empty) and {@link NodeActions}; use `emit` / `down` to push.
- * @param opts - Optional {@link NodeOptions}.
- * @returns `Node<T>` - Producer node.
- *
- * @example
- * ```ts
- * import { producer } from "@graphrefly/graphrefly-ts";
- *
- * const tick = producer((_d, a) => {
- *   a.emit(1);
- * });
- * ```
- *
- * @category core
- */
-declare function producer<T = unknown>(fn: NodeFn<T>, opts?: NodeOptions): Node<T>;
-/**
- * Creates a derived node from dependencies and a compute function (same primitive as operators).
- *
- * @param deps - Upstream nodes.
- * @param fn - Compute function; return value is emitted, or use `actions` explicitly.
- * @param opts - Optional {@link NodeOptions}.
- * @returns `Node<T>` - Derived node.
- *
- * @example
- * ```ts
- * import { derived, state } from "@graphrefly/graphrefly-ts";
- *
- * const a = state(1);
- * const b = derived([a], ([x]) => (x as number) * 2);
- * ```
- *
- * @category core
- */
-declare function derived<T = unknown>(deps: readonly Node[], fn: NodeFn<T>, opts?: NodeOptions): Node<T>;
-/**
- * Runs a side-effect when deps settle; return value is not auto-emitted.
- *
- * @param deps - Nodes to watch.
- * @param fn - Side-effect body.
- * @returns `Node<unknown>` - Effect node.
- *
- * @example
- * ```ts
- * import { effect, state } from "@graphrefly/graphrefly-ts";
- *
- * const n = state(1);
- * effect([n], ([v]) => {
- *   console.log(v);
- * });
- * ```
- *
- * @category core
- */
-declare function effect(deps: readonly Node[], fn: NodeFn<unknown>, opts?: NodeOptions): Node<unknown>;
-/** Unary transform used by {@link pipe} (typically returns a new node wrapping `n`). */
-type PipeOperator = (n: Node) => Node;
-/**
- * Composes unary operators left-to-right; returns the final node. Does not register a {@link Graph}.
- *
- * @param source - Starting node.
- * @param ops - Each operator maps `Node` to `Node` (curried operators from `extra` use a factory pattern — wrap or use direct calls).
- * @returns `Node` - Result of the last operator.
- *
- * @example
- * ```ts
- * import { filter, map, pipe, state } from "@graphrefly/graphrefly-ts";
- *
- * const src = state(1);
- * const out = pipe(
- *   src,
- *   (n) => map(n, (x) => x + 1),
- *   (n) => filter(n, (x) => x > 0),
- * );
- * ```
- *
- * @category core
- */
-declare function pipe(source: Node, ...ops: PipeOperator[]): Node;
-
-/**
- * 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.
- *
- * @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 core
- */
-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;
-}
-
-/**
- * Core layer: message protocol, node primitive, lifecycle (Phase 0).
- */
-
-declare const index_Actor: typeof Actor;
-type index_BridgeOptions = BridgeOptions;
-declare const index_CLEANUP_RESULT: typeof CLEANUP_RESULT;
-declare const index_COMPLETE: typeof COMPLETE;
-declare const index_CleanupResult: typeof CleanupResult;
-declare const index_DATA: typeof DATA;
-declare const index_DEFAULT_ACTOR: typeof DEFAULT_ACTOR;
-declare const index_DEFAULT_DOWN: typeof DEFAULT_DOWN;
-declare const index_DIRTY: typeof DIRTY;
-declare const index_DescribeDetail: typeof DescribeDetail;
-declare const index_DescribeField: typeof DescribeField;
-declare const index_DescribeNodeOutput: typeof DescribeNodeOutput;
-type index_DownStrategy = DownStrategy;
-type index_DynGet = DynGet;
-type index_DynamicNodeFn<T> = DynamicNodeFn<T>;
-type index_DynamicNodeImpl<T = unknown> = DynamicNodeImpl<T>;
-declare const index_DynamicNodeImpl: typeof DynamicNodeImpl;
-type index_DynamicNodeOptions = DynamicNodeOptions;
-declare const index_ERROR: typeof ERROR;
-declare const index_GuardAction: typeof GuardAction;
-declare const index_GuardDenied: typeof GuardDenied;
-declare const index_GuardDeniedDetails: typeof GuardDeniedDetails;
-declare const index_HashFn: typeof HashFn;
-declare const index_INVALIDATE: typeof INVALIDATE;
-declare const index_Message: typeof Message;
-declare const index_Messages: typeof Messages;
-declare const index_Node: typeof Node;
-declare const index_NodeActions: typeof NodeActions;
-declare const index_NodeDescribeKind: typeof NodeDescribeKind;
-type index_NodeFn<T = unknown> = NodeFn<T>;
-declare const index_NodeGuard: typeof NodeGuard;
-declare const index_NodeOptions: typeof NodeOptions;
-declare const index_NodeSink: typeof NodeSink;
-declare const index_NodeStatus: typeof NodeStatus;
-declare const index_NodeTransportOptions: typeof NodeTransportOptions;
-declare const index_NodeVersionInfo: typeof NodeVersionInfo;
-declare const index_OnMessageHandler: typeof OnMessageHandler;
-declare const index_PAUSE: typeof PAUSE;
-type index_PipeOperator = PipeOperator;
-declare const index_PolicyAllow: typeof PolicyAllow;
-declare const index_PolicyDeny: typeof PolicyDeny;
-declare const index_PolicyRuleData: typeof PolicyRuleData;
-declare const index_RESOLVED: typeof RESOLVED;
-declare const index_RESUME: typeof RESUME;
-type index_ResettableTimer = ResettableTimer;
-declare const index_ResettableTimer: typeof ResettableTimer;
-declare const index_START: typeof START;
-declare const index_SubscribeHints: typeof SubscribeHints;
-declare const index_TEARDOWN: typeof TEARDOWN;
-declare const index_V0: typeof V0;
-declare const index_V1: typeof V1;
-declare const index_VersioningLevel: typeof VersioningLevel;
-declare const index_VersioningOptions: typeof VersioningOptions;
-declare const index_accessHintForGuard: typeof accessHintForGuard;
-declare const index_advanceVersion: typeof advanceVersion;
-declare const index_batch: typeof batch;
-declare const index_bridge: typeof bridge;
-declare const index_cleanupResult: typeof cleanupResult;
-declare const index_createVersioning: typeof createVersioning;
-declare const index_defaultHash: typeof defaultHash;
-declare const index_derived: typeof derived;
-declare const index_downWithBatch: typeof downWithBatch;
-declare const index_dynamicNode: typeof dynamicNode;
-declare const index_effect: typeof effect;
-declare const index_isBatching: typeof isBatching;
-declare const index_isKnownMessageType: typeof isKnownMessageType;
-declare const index_isLocalOnly: typeof isLocalOnly;
-declare const index_isPhase2Message: typeof isPhase2Message;
-declare const index_isTerminalMessage: typeof isTerminalMessage;
-declare const index_isV1: typeof isV1;
-declare const index_knownMessageTypes: typeof knownMessageTypes;
-declare const index_messageTier: typeof messageTier;
-declare const index_monotonicNs: typeof monotonicNs;
-declare const index_node: typeof node;
-declare const index_normalizeActor: typeof normalizeActor;
-declare const index_partitionForBatch: typeof partitionForBatch;
-declare const index_pipe: typeof pipe;
-declare const index_policy: typeof policy;
-declare const index_policyFromRules: typeof policyFromRules;
-declare const index_producer: typeof producer;
-declare const index_propagatesToMeta: typeof propagatesToMeta;
-declare const index_resolveDescribeFields: typeof resolveDescribeFields;
-declare const index_state: typeof state;
-declare const index_wallClockNs: typeof wallClockNs;
-declare namespace index {
-  export { index_Actor as Actor, type index_BridgeOptions as BridgeOptions, index_CLEANUP_RESULT as CLEANUP_RESULT, index_COMPLETE as COMPLETE, index_CleanupResult as CleanupResult, index_DATA as DATA, index_DEFAULT_ACTOR as DEFAULT_ACTOR, index_DEFAULT_DOWN as DEFAULT_DOWN, index_DIRTY as DIRTY, index_DescribeDetail as DescribeDetail, index_DescribeField as DescribeField, index_DescribeNodeOutput as DescribeNodeOutput, type index_DownStrategy as DownStrategy, type index_DynGet as DynGet, type index_DynamicNodeFn as DynamicNodeFn, index_DynamicNodeImpl as DynamicNodeImpl, type index_DynamicNodeOptions as DynamicNodeOptions, index_ERROR as ERROR, index_GuardAction as GuardAction, index_GuardDenied as GuardDenied, index_GuardDeniedDetails as GuardDeniedDetails, index_HashFn as HashFn, index_INVALIDATE as INVALIDATE, index_Message as Message, index_Messages as Messages, index_Node as Node, index_NodeActions as NodeActions, index_NodeDescribeKind as NodeDescribeKind, type index_NodeFn as NodeFn, index_NodeGuard as NodeGuard, index_NodeOptions as NodeOptions, index_NodeSink as NodeSink, index_NodeStatus as NodeStatus, index_NodeTransportOptions as NodeTransportOptions, index_NodeVersionInfo as NodeVersionInfo, index_OnMessageHandler as OnMessageHandler, index_PAUSE as PAUSE, type index_PipeOperator as PipeOperator, index_PolicyAllow as PolicyAllow, index_PolicyDeny as PolicyDeny, index_PolicyRuleData as PolicyRuleData, index_RESOLVED as RESOLVED, index_RESUME as RESUME, index_ResettableTimer as ResettableTimer, index_START as START, index_SubscribeHints as SubscribeHints, index_TEARDOWN as TEARDOWN, index_V0 as V0, index_V1 as V1, index_VersioningLevel as VersioningLevel, index_VersioningOptions as VersioningOptions, index_accessHintForGuard as accessHintForGuard, index_advanceVersion as advanceVersion, index_batch as batch, index_bridge as bridge, index_cleanupResult as cleanupResult, index_createVersioning as createVersioning, index_defaultHash as defaultHash, index_derived as derived, index_downWithBatch as downWithBatch, index_dynamicNode as dynamicNode, index_effect as effect, index_isBatching as isBatching, index_isKnownMessageType as isKnownMessageType, index_isLocalOnly as isLocalOnly, index_isPhase2Message as isPhase2Message, index_isTerminalMessage as isTerminalMessage, index_isV1 as isV1, index_knownMessageTypes as knownMessageTypes, index_messageTier as messageTier, index_monotonicNs as monotonicNs, index_node as node, index_normalizeActor as normalizeActor, index_partitionForBatch as partitionForBatch, index_pipe as pipe, index_policy as policy, index_policyFromRules as policyFromRules, index_producer as producer, index_propagatesToMeta as propagatesToMeta, index_resolveDescribeFields as resolveDescribeFields, index_state as state, index_wallClockNs as wallClockNs };
-}
-
-export { type BridgeOptions as B, DEFAULT_DOWN as D, type NodeFn as N, type PipeOperator as P, ResettableTimer as R, type DownStrategy as a, type DynGet as b, type DynamicNodeFn as c, DynamicNodeImpl as d, type DynamicNodeOptions as e, batch as f, bridge as g, derived as h, index as i, downWithBatch as j, dynamicNode as k, effect as l, isBatching as m, monotonicNs as n, node as o, partitionForBatch as p, pipe as q, producer as r, state as s, wallClockNs as w };