@graphrefly/ts 0.0.0

package/dist/types-h12mNYbq.d.ts

@@ -0,0 +1,732 @@
+import { L as LockId, W as Wave, M as Message } from './messages-BZqrGGm1.js';
+
+/**
+ * Dispatcher, pools, and the pure-data Handle.
+ *
+ * Canonical authority: ~/src/graphrefly/spec/rules.jsonl
+ *   R-handle (D7), R-dispatch-all (D21), R-sync-core (D20/D21).
+ *
+ * Lifted from the validated handle-dispatch PoC (packages/pure-ts r8-poc, R8/R9):
+ * fn lives in an external pool, indexed by handle; `dispatcher.invoke` is uniformly
+ * SYNC void — async/remote behavior lives in the fn body (it kicks off async work
+ * and emits later via `ctx.down`), not in a different call mechanism.
+ */
+
+/** A pool kind label. LocalSync + LocalAsync ship in 1.0 (D20). */
+type PoolKind = "sync" | "async";
+/**
+ * Handle = pure data `(poolId, handleId)`, NO methods (R-handle / D7). A serializable
+ * index into a pool's dispatch table. node != handle.
+ */
+interface Handle {
+    readonly poolId: number;
+    readonly handleId: number;
+}
+/** A dispatch pool: a flat fn table + an array-indexed sync invoke. */
+interface Pool {
+    readonly kind: PoolKind;
+    register(fn: NodeFn): number;
+    /** Free a handle's slot so its fn closure is GC'd and the id is reused (B15). */
+    unregister(handleId: number): void;
+    invoke(handleId: number, ctx: Ctx): void;
+}
+/**
+ * First-class dispatcher (D21). Owns pools; graph binds to one (default = process-global,
+ * D26 — the only global singleton). Pool trait is pluggable for WorkerPool/RemotePool (D20).
+ */
+/** Per-handle profiling counters (D39 / R-profile). Lives on the dispatcher — the invoke
+ * funnel (F-DISPATCH-ALL) — NEVER on the thin node (R-node-thin). */
+interface HandleStat {
+    invokes: number;
+    totalDurationNs: number;
+    lastDurationNs: number;
+}
+declare class Dispatcher {
+    private pools;
+    readonly syncPoolId: number;
+    readonly asyncPoolId: number;
+    private _recording;
+    private _stats;
+    private _totalInvokes;
+    constructor();
+    /** Turn the profile recorder on/off (D39). Off = zero overhead on invoke. */
+    setRecording(on: boolean): void;
+    /** Reset accumulated profiling counters. */
+    clearStats(): void;
+    /** Read a handle's accumulated counters (undefined if it never ran while recording). */
+    statFor(handle: Handle): HandleStat | undefined;
+    /** Total fn invocations recorded across the dispatcher. */
+    get totalInvokes(): number;
+    addPool(pool: Pool): number;
+    /** Register a fn in a pool, returning its Handle. Default pool = sync (R-sync-core). */
+    register(fn: NodeFn, pool?: PoolKind | number): Handle;
+    /**
+     * Release a handle (B15): frees the pool slot (closure GC'd, id reusable) and drops any
+     * accumulated profile stat so a reused id never inherits the previous tenant's counters.
+     * Called on rewire fn-swap (node._rewire) — the old handle is dropped before the node
+     * adopts the new one. Idempotent. NOT called on deactivate (a node's handle survives
+     * activate↔deactivate and is reused on reactivation; only a rewire swaps it).
+     */
+    unregister(handle: Handle): void;
+    /** Uniform sync-void invoke (R-sync-core / R-dispatch-all). */
+    invoke(handle: Handle, ctx: Ctx): void;
+    poolKind(poolId: number): PoolKind;
+}
+/** The only global singleton (D26). Overridable by passing an explicit dispatcher. */
+declare const defaultDispatcher: Dispatcher;
+
+/**
+ * Graph-owned environment driver bag (D130/D131).
+ *
+ * Drivers host process/network/messaging/runtime boundary work outside the synchronous wave core.
+ * The bag is graph-local and is read from ctx by source/adapter bodies.
+ */
+type DriverCancel = () => void;
+type DriverResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: unknown;
+};
+interface ProcessCommand {
+    readonly program: string;
+    readonly args: readonly string[];
+    readonly cwd?: string;
+    readonly env?: readonly (readonly [string, string])[];
+}
+interface ProcessResult {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode: number | null;
+    readonly signal: string | null;
+}
+interface HttpRequest {
+    readonly method: string;
+    readonly url: string;
+    readonly headers?: readonly (readonly [string, string])[];
+    readonly body?: Uint8Array | string;
+}
+interface HttpResponse {
+    readonly status: number;
+    readonly headers: readonly (readonly [string, string])[];
+    readonly body: Uint8Array;
+}
+interface SseRequest {
+    readonly url: string;
+    readonly headers?: readonly (readonly [string, string])[];
+}
+interface SseEvent {
+    readonly event?: string;
+    readonly data: string;
+    readonly id?: string;
+    readonly retryMs?: number;
+}
+type SseDriverEvent = {
+    readonly kind: "event";
+    readonly event: SseEvent;
+} | {
+    readonly kind: "error";
+    readonly error: unknown;
+} | {
+    readonly kind: "complete";
+};
+interface WebSocketRequest {
+    readonly url: string;
+    readonly headers?: readonly (readonly [string, string])[];
+}
+type WebSocketEvent = {
+    readonly kind: "open";
+} | {
+    readonly kind: "text";
+    readonly data: string;
+} | {
+    readonly kind: "binary";
+    readonly data: Uint8Array;
+} | {
+    readonly kind: "close";
+    readonly code?: number;
+    readonly reason?: string;
+};
+interface WebSocketSend {
+    readonly data: string | Uint8Array;
+}
+interface WebSocketSendResult {
+    readonly sent: true;
+}
+/** Live WebSocket session handle for D133 SessionBundle adapters. */
+interface WebSocketSessionHandle {
+    send(message: WebSocketSend, callback: (result: DriverResult<WebSocketSendResult>) => void): DriverCancel;
+    close(code?: number, reason?: string): void;
+    cancel(): void;
+}
+type WebSocketDriverEvent = {
+    readonly kind: "event";
+    readonly event: WebSocketEvent;
+} | {
+    readonly kind: "error";
+    readonly error: unknown;
+} | {
+    readonly kind: "complete";
+};
+interface WebhookRegistration {
+    readonly id: string;
+    readonly method?: string;
+    readonly path?: string;
+}
+interface WebhookEvent {
+    readonly registrationId: string;
+    readonly method: string;
+    readonly path: string;
+    readonly headers: readonly (readonly [string, string])[];
+    readonly query: readonly (readonly [string, string])[];
+    readonly body: Uint8Array;
+}
+type WebhookDriverEvent = {
+    readonly kind: "event";
+    readonly event: WebhookEvent;
+} | {
+    readonly kind: "error";
+    readonly error: unknown;
+} | {
+    readonly kind: "complete";
+};
+interface LocalProcessDriver {
+    run(command: ProcessCommand, callback: (result: DriverResult<ProcessResult>) => void): DriverCancel;
+}
+interface LocalHttpDriver {
+    request(request: HttpRequest, callback: (result: DriverResult<HttpResponse>) => void): DriverCancel;
+}
+interface LocalSseDriver {
+    connect(request: SseRequest, callback: (event: SseDriverEvent) => void): DriverCancel;
+}
+interface LocalWebSocketDriver {
+    connect(request: WebSocketRequest, callback: (event: WebSocketDriverEvent) => void): DriverCancel;
+    send?(request: WebSocketRequest, message: WebSocketSend, callback: (result: DriverResult<WebSocketSendResult>) => void): DriverCancel;
+    /** Open a live bidirectional session; unlike send(), outbound messages use this same connection. */
+    connectSession?(request: WebSocketRequest, callback: (event: WebSocketDriverEvent) => void): WebSocketSessionHandle;
+}
+interface LocalWebhookDriver {
+    register(registration: WebhookRegistration, callback: (event: WebhookDriverEvent) => void): DriverCancel;
+}
+interface FetchResponseLike {
+    readonly status: number;
+    readonly headers?: {
+        forEach?(fn: (value: string, key: string) => void): void;
+    };
+    arrayBuffer(): PromiseLike<ArrayBuffer>;
+}
+type FetchLike = (url: string, init?: {
+    readonly method?: string;
+    readonly headers?: readonly (readonly [string, string])[];
+    readonly body?: Uint8Array | string;
+    readonly signal?: AbortSignal;
+}) => PromiseLike<FetchResponseLike>;
+interface WebSocketLike {
+    send(data: string | Uint8Array): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: "open" | "message" | "error" | "close", listener: (event: unknown) => void): void;
+    removeEventListener(type: "open" | "message" | "error" | "close", listener: (event: unknown) => void): void;
+}
+type WebSocketConstructorLike = new (url: string) => WebSocketLike;
+interface EnvironmentDriversInit {
+    readonly process?: LocalProcessDriver;
+    readonly http?: LocalHttpDriver;
+    readonly sse?: LocalSseDriver;
+    readonly websocket?: LocalWebSocketDriver;
+    readonly webhook?: LocalWebhookDriver;
+}
+declare class EnvironmentDrivers {
+    readonly process?: LocalProcessDriver;
+    readonly http?: LocalHttpDriver;
+    readonly sse?: LocalSseDriver;
+    readonly websocket?: LocalWebSocketDriver;
+    readonly webhook?: LocalWebhookDriver;
+    constructor(init?: EnvironmentDriversInit);
+    static empty(): EnvironmentDrivers;
+    withProcess(driver: LocalProcessDriver): EnvironmentDrivers;
+    withHttp(driver: LocalHttpDriver): EnvironmentDrivers;
+    withSse(driver: LocalSseDriver): EnvironmentDrivers;
+    withWebSocket(driver: LocalWebSocketDriver): EnvironmentDrivers;
+    withWebhook(driver: LocalWebhookDriver): EnvironmentDrivers;
+    processDriver(): LocalProcessDriver | undefined;
+    httpDriver(): LocalHttpDriver | undefined;
+    sseDriver(): LocalSseDriver | undefined;
+    webSocketDriver(): LocalWebSocketDriver | undefined;
+    webhookDriver(): LocalWebhookDriver | undefined;
+}
+declare function fetchHttpDriver(fetchFn?: FetchLike): LocalHttpDriver;
+declare function domWebSocketDriver(WebSocketCtor?: WebSocketConstructorLike): LocalWebSocketDriver;
+
+type NodeVersioningLevel = 0 | 1;
+/**
+ * D112 V1 node-version hash callback.
+ *
+ * The callback receives strict canonical JSON UTF-8 DATA bytes, not the raw host value.
+ * Runtime V1 versioning encodes DATA with `strictCanonicalJsonBytes(value)` before calling hash.
+ */
+type NodeVersionHashFn = (bytes: Uint8Array) => string;
+type NodeVersioningPolicy = false | 0 | 1 | {
+    level: NodeVersioningLevel;
+    hash?: NodeVersionHashFn;
+};
+type NodeVersionV0 = {
+    readonly level: 0;
+    readonly counter: number;
+};
+type NodeVersionV1 = {
+    readonly level: 1;
+    readonly counter: number;
+    readonly cid: string;
+    readonly prev: string | null;
+};
+type NodeVersion = NodeVersionV0 | NodeVersionV1;
+type NodeVersionJson = NodeVersion;
+/**
+ * Default synchronous D112 V1 node-version hash over strict canonical JSON UTF-8 bytes.
+ *
+ * When hashing a host value directly, encode first:
+ * `defaultNodeVersionHash(strictCanonicalJsonBytes(value))`.
+ */
+declare function defaultNodeVersionHash(bytes: Uint8Array): string;
+
+/**
+ * The node primitive — the thinnest substrate object (R-node-thin / D5).
+ *
+ * Holds a fn handle + deps + the wave state machine; ZERO inspection cruft
+ * (naming/find/describe are the graph layer, CSP-2). Canonical authority:
+ * ~/src/graphrefly/spec/rules.jsonl (R-node-*, R-two-phase, R-diamond, R-resolved-undirty,
+ * R-first-run-gate, R-push-subscribe, R-rom-ram, R-fn-contract, R-initial, R-ctx-up).
+ *
+ * Slice 1 = core wave: state node, compute node, two-phase DIRTY->DATA, diamond
+ * pending-counter join, first-run gate, substrate-synthesized undirty RESOLVED
+ * (R-resolved-undirty / D49 — no equals-substitution; every occurrence is DATA),
+ * push-on-subscribe, lazy activation, ROM/RAM. Lifecycle (terminal/INVALIDATE/cleanup),
+ * control (PAUSE/async), batch, and dynamicNode land in later slices.
+ */
+
+type Status = "sentinel" | "pending" | "dirty" | "settled" | "resolved" | "completed" | "errored";
+interface NodeOptions<T = unknown> {
+    /** Pre-populate cache; source pushes [DATA, initial] on subscribe (R-initial). `null` is valid. */
+    initial?: T | null;
+    /** First-run gate off when true; fn body must guard SENTINEL per dep (R-first-run-gate). */
+    partial?: boolean;
+    /** A dep terminal also settles the first-run gate (Reduce-class, R-first-run-gate). */
+    terminalAsRealInput?: boolean;
+    /** Auto-emit COMPLETE when ALL deps complete (R-deps-terminal). Default true. */
+    completeWhenDepsComplete?: boolean;
+    /** Auto-emit ERROR when any dep errors (R-deps-terminal). Default true. */
+    errorWhenDepsError?: boolean;
+    /** Allow re-activation after terminal; late subscribe resets the lifecycle (R-terminal). Default false. */
+    resubscribable?: boolean;
+    /** Clear cached value on TEARDOWN. Default false. */
+    resetOnTeardown?: boolean;
+    /** PAUSE/RESUME behavior (R-pause-modes). Default true. */
+    pausable?: boolean | "resumeAll";
+    /**
+     * Pull-mode node (R-pull / D55,D59): a quiet-until-demanded source, identified by this
+     * author-supplied `pullId` (a unique LockId — a `Symbol` recommended; NOT the node name, NOT a
+     * bare string which collides with a same-string pause lock). The node self-holds the pullId as
+     * its demand lock. QUIET by default: it ABSORBS an upstream DIRTY WITHOUT relaying it downstream
+     * (the wedge fix) and does NOT push-on-subscribe its cached value (START only). A DEMAND = a
+     * cone-routed `RESUME` of this pullId (R-up-routing — NO new message type): a downstream consumer
+     * issues `ctx.up([[RESUME, pullId]])` (broadcast up the declared cone) or `ctx.up(msgs, towardDep)`
+     * (directed) WITHOUT holding this node's reference; the RESUME travels up to the pullId-holder,
+     * which fires EXACTLY ONE delivery (DIRTY-before-DATA) then RE-QUIETS (1:1). Delivery content =
+     * the orthogonal `pausable` mode: `true` → coalesced LATEST (one DATA); `'resumeAll'` → buffered
+     * BACKLOG. `pullId` + `pausable:false` is REJECTED at construction. A SELF-triggered demand (a
+     * consumer demanding a dep it ALSO reads) must defer via {@link Ctx.upNext} (R-rewire-deferred /
+     * D37). Author the pullId as a shared module const used at both this node and the demander's fn.
+     */
+    pullId?: LockId;
+    /** Buffer the last N outgoing DATA for late subscribers (R-replay-buffer). */
+    replayBuffer?: number;
+    /**
+     * D109 node runtime versioning policy. Default is nodev0 (`{level:0,counter}`); `false`
+     * disables runtime version metadata for this node.
+     */
+    versioning?: NodeVersioningPolicy;
+    /** Mark this as a dynamicNode — fn gets ctx.track(i) for read-selection (R-dynamic-node / D35). */
+    dynamic?: boolean;
+    /** Dispatch pool for the fn (R-sync-core). Default sync. */
+    pool?: "sync" | "async";
+    /** Dispatcher to register/invoke against. Default = process-global (D26). */
+    dispatcher?: Dispatcher;
+    /** Optional debug name (graph layer owns real naming/inspection). */
+    name?: string;
+    /**
+     * Real operator/source factory name for a STANDALONE graph-less node (D43-reserved; D51).
+     * The graph index (`_entries`) carries the factory for g.*-registered nodes, so this is only
+     * read for a node NOT in any graph index — a runtime *Map inner (bare `fromAny`/`initNode`
+     * node) auto-discovered by `describe` (R-describe / R-edges-derived / D51). Off the canonical
+     * wave path (R-node-thin intact — a pure annotation, never touched by the wave machinery).
+     */
+    factory?: string;
+}
+declare class Node<T = unknown> {
+    private readonly _core;
+    private readonly _id;
+    private readonly _slot;
+    private readonly _dep;
+    private readonly _value;
+    private readonly _wave;
+    private readonly _control;
+    private readonly _lifecycle;
+    private readonly _privateState;
+    private readonly _hooks;
+    private readonly _syncCtxState;
+    private readonly _version;
+    private _restoredActivationPending;
+    private _released;
+    private get _syncCtx();
+    private set _syncCtx(value);
+    constructor(deps: Node<unknown>[], handleOrFn: Handle | NodeFn | null, opts?: NodeOptions<T>);
+    /** R-pull (D55): true while a pull node is quiet (holds its own pullId/demand lock). */
+    private _isPullQuiet;
+    /**
+     * R-pull (D55/D59): this pull node's pullId (pure data, like {@link cache}/{@link handle} — never
+     * triggers computation). A consumer demands one delivery by cone-routing a RESUME of it (no node
+     * reference): `ctx.up([["RESUME", pullId]])` (immediate; loops back → D37 for a self-read dep) or
+     * `ctx.upNext([["RESUME", pullId]])` (boundary-deferred self-demand, R-up-routing/R-rewire-deferred).
+     * Undefined for a non-pull node. The author writes the pullId verbatim, so this getter is mainly
+     * for inspection/describe; routing matches by the pullId value carried in the RESUME, by identity.
+     */
+    get pullId(): LockId | undefined;
+    get cache(): T | undefined;
+    get status(): Status;
+    get version(): NodeVersion | undefined;
+    get name(): string | undefined;
+    /** R-describe/D51: real factory name for a standalone graph-less node (a runtime *Map inner). */
+    get factory(): string | undefined;
+    /**
+     * The node's CURRENT/LIVE deps (R-describe / R-edges-derived / D51) — readonly view of the
+     * live `_deps`, which a rewire (C-8 / C-11) mutates. The graph's describe() reads this (NOT a
+     * construction-time snapshot) so every edge corresponds to a real current subscription (D3).
+     * Inspection-only, like cache/status; never triggers computation.
+     */
+    get deps(): readonly Node<unknown>[];
+    /**
+     * The fn handle (pure data `(poolId, handleId)`, D7) or null for state/passthrough
+     * nodes. Inspection-only (L1.6 handle is referenceable/inspectable) — lets the graph
+     * layer key a dispatcher-backed profile recorder WITHOUT putting counters on the node
+     * (R-node-thin / D39).
+     */
+    get handle(): Handle | null;
+    /** R-push-subscribe: a new sink receives START, then cached DATA (or DIRTY if dirty). */
+    subscribe(sink: Sink): () => void;
+    /** External emission toward sinks (state-node push, or async late-emit). One call = one wave. */
+    down(msgs: Wave): void;
+    /**
+     * Emit upstream toward deps — control tiers only (R-ctx-up). `towardDep` (a dep index) routes up
+     * ONE declared edge (R-up-routing directed-up); omitted = broadcast up all deps.
+     */
+    up(msgs: Wave, towardDep?: number): void;
+    /**
+     * Enqueue a deferred self-rewire op (issued from this node's fn via `ctx.rewireNext`).
+     * Applied at the committed wave boundary (boundary.ts drain), never in place — the in-fn
+     * immediate path (`subscribeDep`/`replaceDeps`/`unsubscribeDep`) still throws mid-run (D37/R-reentrancy).
+     */
+    private _requestRewireNext;
+    /**
+     * Enqueue a deferred up-going control wave (R-up-routing / R-pull / D59): at the committed wave
+     * boundary, route `msgs` up from THIS node (broadcast, or up the single `towardDep` edge). The
+     * deferred form of `ctx.up` — the SELF-demand path: a consumer issues `ctx.upNext([[RESUME,
+     * pullId]])` to demand a dep it ALSO reads; the demand applies at the boundary (not mid-fn), so
+     * the pull node's delivery loops back as a FRESH wave rather than re-entering the consumer (D37 /
+     * R-reentrancy). Rides the same R-rewire-deferred (D47) drain as ctx.rewireNext.
+     */
+    private _requestUpNext;
+    /** Apply one queued self-rewire at the boundary (drain thunk). */
+    private _applyRewireNext;
+    /**
+     * Replace this node's deps atomically (surgical, Option-C). Requires an explicit
+     * `fn` (SD-1 fn-deps pairing — user fns read dep input positionally). Kept deps
+     * keep their subscription + per-dep state; only removed deps unsubscribe and only
+     * added deps fresh-subscribe (push-on-subscribe for an added cached dep). The
+     * first-run gate and cache are PRESERVED (R-rewire Q2/Q7). Intra-graph only (D22).
+     */
+    replaceDeps(newDeps: Node<unknown>[], fn: NodeFn): void;
+    /** Subscribe to one dep (special case of replaceDeps); returns its index. fn required (SD-1). */
+    subscribeDep(depNode: Node<unknown>, fn: NodeFn): number;
+    /** Unsubscribe from one dep (special case of replaceDeps); idempotent if absent (fn swap still applies). */
+    unsubscribeDep(depNode: Node<unknown>, fn: NodeFn): void;
+    private _dedupDeps;
+    /** Is `target` reachable upstream from `from` (following deps)? Cycle-prevention DFS. */
+    private _reachableUpstream;
+    private _assertRewireDepOwner;
+    private _rewire;
+    private _activate;
+    /**
+     * Subscribe to a dep. The dispatch callback reads the dep's CURRENT index from a
+     * mutable box (O(1)); a surgical rewire that reorders kept deps just updates the box
+     * (R-rewire Option-C / D42) — no re-subscribe, no per-message indexOf scan. A removed
+     * dep's box is set to -1 so any stale in-flight callback drops (drain).
+     */
+    private _subscribeDepAt;
+    private _seedRestoredDepAt;
+    private _deactivate;
+    private _assertNotReleased;
+    private _subscriberCount;
+    private _isRuntimeQuiescentForRelease;
+    private _releaseRuntime;
+    private _resetDepState;
+    private _recordDepProjection;
+    private _depProjectionHasData;
+    private _receiveFromDep;
+    /**
+     * R-terminal-settles-dirty (B35): release a dep's outstanding in-wave DIRTY contribution.
+     * A settle-class event for that dep (DATA/RESOLVED inline above, INVALIDATE, and now
+     * COMPLETE/ERROR) clears its dirty flag + decrements _pending. No-op if the dep already
+     * settled this wave (DATA/RESOLVED ran first) — so the normal DATA-then-COMPLETE flow is
+     * unaffected. This makes the exactly-one-settle invariant a single, shared step.
+     */
+    private _releaseDepDirty;
+    /**
+     * R-terminal-settles-dirty (B35): settle a node whose dirtied dep was released by an ABSORBED
+     * terminal that is NOT a real input (a plain derived/effect — the common default-node case when
+     * one of several deps completes while others stay live). Runs only when the release drained
+     * _pending while the node still owes a downstream settle (it broadcast DIRTY this wave):
+     *   - if some OTHER dep delivered real DATA this wave (a value occurred) → recompute (→ DATA);
+     *   - else the terminal's signalled change did not materialise (no value) → one undirty RESOLVED
+     *     (R-resolved-undirty), keeping the cache (a terminal, unlike INVALIDATE, leaves the value).
+     * A terminalAsRealInput node instead recomputes unconditionally (its fn reads the terminal).
+     */
+    private _settleAfterAbsorbedTerminal;
+    private _markDirty;
+    private _maybeRun;
+    /**
+     * R-rewire atomic settle (after a rewire that warrants a recompute): emit a proper
+     * two-phase DIRTY→DATA wave (R-dirty-before-data — a rewire-triggered settle is a wave),
+     * once, with every added dep already wired. Mirrors _maybeRun/_tryRun's pause + gate +
+     * pending guards, then injects the phase-1 DIRTY the added dep's [START,DATA] handshake
+     * did not carry.
+     */
+    private _settleRewire;
+    private _tryRun;
+    private _allDepsSettled;
+    private _passthroughEmit;
+    private _runWave;
+    private _buildCtx;
+    private _makeCtx;
+    private _refreshCtx;
+    private _makeState;
+    private _down;
+    private _up;
+    private _markDemandRouted;
+    /**
+     * Forward one up-going control message toward deps (R-up-routing): up the single declared edge
+     * `towardDep` (directed — prunes other branches; only meaningful on the issuer's FIRST hop) or
+     * broadcast up ALL deps. A depless source has no deps → the message DROPS here (the terminus —
+     * e.g. a cone-routed RESUME whose pullId no node up this cone holds, R-up-at-source). Recursive
+     * forwarding carries the same per-wave route state and no `towardDep` → broadcast beyond the
+     * first hop.
+     */
+    private _forwardUp;
+    private _isPaused;
+    private _hasBoundaryPauseLock;
+    private _isAsyncPool;
+    private _pauseAcquire;
+    private _pauseRelease;
+    private _onResume;
+    /**
+     * R-pull (D59): can this pull node fire a demand NOW? — not terminal, settle-ready (_pending===0),
+     * and no OTHER (non-pullId) lock holds it paused. The gate that decides fire-now vs OWE.
+     */
+    private _canFireDemand;
+    /**
+     * R-pull (D59): deliver ONE demand pulse — release the pullId so the demand wave RELAYS (not
+     * absorbed), fire it, then RE-QUIET (1:1). The pullId re-add + the re-entrancy flag are in a
+     * `finally` so a throwing pull fn (graph-less node, no D30 catch) cannot leave the node
+     * permanently non-quiet (the wedge-fix silently disabled) — QA-found robustness fix.
+     */
+    private _deliverPullDemand;
+    /**
+     * R-pull (D59): a cone-routed RESUME of THIS node's pullId arrived (R-up-routing) = a DEMAND.
+     * Fire immediately if able; else OWE it — pin-5 (a dep DIRTY in flight, _pending>0) or F4/F5 (an
+     * external PAUSE lock co-holds the node) — and fire when the node next becomes able. A demand
+     * arriving WHILE a delivery is in flight (synchronous re-entry) is DROPPED (1:1, QA guard).
+     */
+    private _onDemand;
+    /**
+     * R-pull (D55): service ONE demand. Delivery content = the orthogonal pausable mode:
+     *   - 'resumeAll' → drain the buffered BACKLOG (each `_down` re-synthesizes a leading DIRTY, so
+     *     the per-entry replay is DIRTY-before-DATA — R-pause-modes per-entry arrival order);
+     *   - true → deliver the coalesced LATEST as ONE DIRTY-before-DATA wave (pin 2: the quiet absorb
+     *     suppressed the dep's original DIRTY, so the demand wave restores it before the value).
+     * Neither branch fires when nothing changed since the last demand → the demand is SILENT.
+     * Called by `_deliverPullDemand` only when settle-ready; the caller has released the pullId, so
+     * `_markDirty` relays the leading DIRTY (not absorbed).
+     */
+    private _firePullDemand;
+    /**
+     * R-pull (D55/D59): fire a demand that was OWED (deferred at demand time) once the node becomes
+     * able — called from the dep-settle arms (DATA/RESOLVED/INVALIDATE/terminal drain _pending, pin-5
+     * + B1/F6) and from `_pauseRelease` (an external PAUSE lock releases, F4/F5).
+     */
+    private _fireOwedDemandIfReady;
+    /** Should an outgoing settle slice be deferred into the pause buffer? */
+    private _shouldBufferOnPause;
+    /** R-invalidate-idempotent: clear cache + flush + cascade; no-op if nothing cached. */
+    private _invalidate;
+    private _allDepsTerminal;
+    /** R-terminal: resubscribable reset clears terminal + dep state + re-arms the gate. */
+    private _resetLifecycle;
+    private _emitToSubs;
+    /** Batch commit (R-batch-coalesce): deliver the deferred tier-3 wave now. */
+    __commitBatchedWave(wave: Wave): void;
+    /** Batch rollback: balance the immediate DIRTY with a RESOLVED so downstream un-dirties. */
+    __rollbackBatched(): void;
+    /** B49: enqueue a committed-boundary task on this node's graph-local core. */
+    __deferBoundary(fn: () => void, batchToken?: object): void;
+}
+/**
+ * Construct a node (R-node-iface / D5 / L1.9 deps-first).
+ *   node([], null, { initial })       — state node (manual source; emit via .down)
+ *   node([], fn)                        — producer (runs on activation)
+ *   node([a, b], fn)                    — compute / derived
+ *   node([dep])                         — passthrough wire
+ */
+declare function node<T = unknown>(deps?: Node<unknown>[], handleOrFn?: Handle | NodeFn | null, opts?: NodeOptions<T>): Node<T>;
+/**
+ * Construct a dynamicNode (R-dynamic-node / D35) — a node variant whose fn reads a
+ * subset of a fixed superset of deps per invocation via `ctx.track(i)`. All declared
+ * deps participate in wave tracking; an unread dep's change re-runs the fn, which re-emits
+ * its current value as DATA (D49 removed equals-absorption — dedup is opt-in via
+ * distinctUntilChanged). Intra-graph only (D22).
+ */
+declare function dynamicNode<T = unknown>(deps: Node<unknown>[], fn: NodeFn, opts?: NodeOptions<T>): Node<T>;
+
+/**
+ * The fn-invocation context and per-dep input shapes.
+ *
+ * Canonical authority: ~/src/graphrefly/spec/rules.jsonl
+ *   R-fn-contract (D8/D27), R-ctx-state (D23/D29), R-cleanup-hooks (D28), R-ctx-up.
+ */
+
+/** A downstream sink callback (the only way to connect to a node's output). */
+type Sink = (msg: Message, delivery?: DeliveryMeta) => void;
+/** Internal delivery metadata used to preserve the upstream `ctx.down(msgs)` wave boundary. */
+interface DeliveryMeta {
+    readonly wave: object;
+    readonly last: boolean;
+}
+/**
+ * Internal current-value reader. It is deliberately a symbol-backed implementation detail:
+ * raw ctx exposes `waveData` + `terminal`; helpers below derive from that plus this dep cache.
+ */
+declare const CTX_DEP_CACHE: unique symbol;
+interface CtxDepCache {
+    readonly latest: readonly unknown[];
+}
+/** Internal node-construction binding for graph-local helper-created deps. */
+declare const CTX_NODE_BINDING: unique symbol;
+interface CtxNodeBinding {
+    readonly dispatcher: Dispatcher;
+    create<T>(factory: () => Node<T>): Node<T>;
+}
+/** Per-dep wave projections: dep -> waves -> values/SENTINEL markers. */
+type WaveData = readonly (readonly (readonly unknown[])[])[];
+/** Terminal metadata parallel to `waveData`: false = none, true = COMPLETE, otherwise ERROR payload. */
+type TerminalData = readonly unknown[];
+declare function isTerminalNone(t: unknown): boolean;
+declare function isTerminalComplete(t: unknown): t is true;
+declare function isTerminalError(t: unknown): boolean;
+declare function terminalErrorValue(t: unknown): unknown;
+/**
+ * Per-node private cross-wave state (R-ctx-state / D23,D29). Default fresh-lifecycle
+ * wipe; `persist(true)` keeps it across lifecycle transitions.
+ */
+interface CtxState {
+    get<S = unknown>(): S | undefined;
+    set<S = unknown>(v: S): void;
+    persist(on?: boolean): void;
+}
+/**
+ * Deferred SELF-rewire (R-rewire-deferred / D47). A node fn may, DURING its run, request a
+ * mutation of its OWN dep set; the request is QUEUED and applied at the committed wave boundary
+ * (after the current wave settles / batch commit / final-lock RESUME) as a fresh wave, reusing
+ * R-rewire surgical/Option-C semantics (D42). This is the ONLY legal self-triggered rewire — an
+ * IMMEDIATE in-fn `node.subscribeDep/unsubscribeDep/replaceDeps` is the D37 mid-fn feedback-cycle ERROR. An
+ * added cached dep pushes `[DIRTY,DATA]` on the boundary wave (R-push-subscribe); a removed dep
+ * is drained and, if it loses its last subscriber, `_deactivate`s + fires `onDeactivation`
+ * (input-side teardown — the basis for higher-order operator cancellation / abortInFlight).
+ */
+interface RewireNext {
+    /** Defer subscribing to a dep (paired with the re-supplied fn — positional fn-deps lock, SD-1). */
+    subscribeDep(dep: Node<unknown>, fn: NodeFn): void;
+    /** Defer unsubscribing from a dep (its source is torn down if it loses its last subscriber). */
+    unsubscribeDep(dep: Node<unknown>, fn: NodeFn): void;
+    /** Defer replacing the whole dep set (surgical: kept deps untouched, removed drained, added fresh-subscribe). */
+    replaceDeps(deps: Node<unknown>[], fn: NodeFn): void;
+}
+/**
+ * The single argument to a node fn: `(ctx) => void` (R-fn-contract / D8). All emission
+ * is explicit via `ctx.down`; there is no return-value framing.
+ */
+interface Ctx {
+    /**
+     * Emit upstream toward deps — control tiers only (R-ctx-up). IMMEDIATE. `towardDep` (a dep index)
+     * routes the wave up ONE declared edge (R-up-routing directed-up); omitted = broadcast up all deps.
+     * A pull DEMAND is `up([[RESUME, pullId]])` — but for a SELF-demand (demanding a dep this fn also
+     * reads) use {@link Ctx.upNext} instead, since an immediate demand whose delivery loops back
+     * re-enters this fn mid-wave (D37 / R-reentrancy).
+     */
+    up(msgs: Wave, towardDep?: number): void;
+    /** Emit downstream toward sinks. */
+    down(msgs: Wave): void;
+    /**
+     * The single raw dep-value input surface (R-ctx-wave-data / D77): dep -> upstream waves ->
+     * per-wave DATA payloads and INVALIDATE/SENTINEL markers. `waveData[i] = []` means dep i
+     * delivered no wave to this invocation; `waveData[i] = [[]]` means RESOLVED-only.
+     */
+    waveData: WaveData;
+    /** Terminal metadata for the same invocation; terminal values never enter `waveData`. */
+    terminal: TerminalData;
+    state: CtxState;
+    /** Release external resources on deactivation (R-cleanup-hooks). */
+    onDeactivation(fn: () => void): void;
+    /** Flush on INVALIDATE (R-cleanup-hooks). */
+    onInvalidate(fn: () => void): void;
+    /** Graph-owned environment drivers for source/adapter boundaries (D130/D131). */
+    environment(): EnvironmentDrivers;
+    /**
+     * Deferred SELF-rewire (R-rewire-deferred / D47) — the substrate affordance higher-order
+     * operators (switchMap/mergeMap/concatMap/exhaustMap/flatMap) use to grow/shrink their own
+     * inner-source dep set in response to their own data. Always present; see {@link RewireNext}.
+     */
+    rewireNext: RewireNext;
+    /**
+     * Deferred up — the boundary-deferred form of {@link Ctx.up} (R-up-routing / R-pull / D59). Routes
+     * `msgs` up from this node at the COMMITTED wave boundary (broadcast, or up the single `towardDep`
+     * edge), riding the same R-rewire-deferred (D47) drain as {@link RewireNext}. This is the
+     * SELF-DEMAND path: a consumer issues `ctx.upNext([[RESUME, pullId]])` to demand a pull dep it
+     * ALSO reads — the cone-routed RESUME reaches the pullId-holder, whose delivery loops back as a
+     * FRESH wave (not a mid-fn re-entry → no D37). The consumer accepts one-wave latency (the
+     * HTTP-request model). No node reference needed: the author writes the pullId verbatim.
+     */
+    upNext(msgs: Wave, towardDep?: number): void;
+    /**
+     * Read a dep's latest value by index (dynamicNode only, R-dynamic-node / D35).
+     * Present only on dynamicNode fns; all declared deps still participate in wave
+     * tracking. Under D49/R-resolved-undirty an unread dep's change still fires the fn,
+     * which re-emits its (unchanged) output as a DATA occurrence — there is NO equals-
+     * absorption; pair with distinctUntilChanged to suppress unchanged re-emits (opt-in).
+     */
+    track?(depIndex: number): unknown;
+    [CTX_DEP_CACHE]?: CtxDepCache;
+    [CTX_NODE_BINDING]?: CtxNodeBinding;
+}
+/** A node fn (R-fn-contract). Registered in a dispatcher pool, indexed by Handle. */
+type NodeFn = (ctx: Ctx) => void;
+/** Number of declared dep slots visible in this invocation. */
+declare function depCount(ctx: Ctx): number;
+/** DATA/SENTINEL projection batches delivered by one dep in this invocation. */
+declare function depWaves(ctx: Ctx, depIndex: number): readonly (readonly unknown[])[];
+/** Flattened DATA projection for old event-counting operator bodies; null = no wave. */
+declare function depBatch(ctx: Ctx, depIndex: number): readonly unknown[] | null;
+/** Latest cached DATA for a dep, derived from implementation-owned dep cache. */
+declare function depLatest(ctx: Ctx, depIndex: number): unknown;
+/** Terminal metadata for one dep: false = none, true = COMPLETE, otherwise ERROR payload. */
+declare function depTerminal(ctx: Ctx, depIndex: number): unknown;
+
+export { depBatch as $, type SseRequest as A, type Status as B, type Ctx as C, Dispatcher as D, EnvironmentDrivers as E, type FetchLike as F, type WebSocketConstructorLike as G, type Handle as H, type WebSocketDriverEvent as I, type WebSocketEvent as J, type WebSocketLike as K, type LocalHttpDriver as L, type WebSocketRequest as M, Node as N, type WebSocketSend as O, type Pool as P, type WebSocketSendResult as Q, type RewireNext as R, type Sink as S, type TerminalData as T, type WebSocketSessionHandle as U, type WebhookDriverEvent as V, type WaveData as W, type WebhookEvent as X, type WebhookRegistration as Y, defaultDispatcher as Z, defaultNodeVersionHash as _, type CtxState as a, depCount as a0, depLatest as a1, depTerminal as a2, depWaves as a3, domWebSocketDriver as a4, dynamicNode as a5, fetchHttpDriver as a6, isTerminalComplete as a7, isTerminalError as a8, isTerminalNone as a9, node as aa, terminalErrorValue as ab, type DriverCancel as b, type DriverResult as c, type EnvironmentDriversInit as d, type FetchResponseLike as e, type HandleStat as f, type HttpRequest as g, type HttpResponse as h, type LocalProcessDriver as i, type LocalSseDriver as j, type LocalWebSocketDriver as k, type LocalWebhookDriver as l, type NodeFn as m, type NodeOptions as n, type NodeVersion as o, type NodeVersionHashFn as p, type NodeVersionJson as q, type NodeVersionV0 as r, type NodeVersionV1 as s, type NodeVersioningLevel as t, type NodeVersioningPolicy as u, type PoolKind as v, type ProcessCommand as w, type ProcessResult as x, type SseDriverEvent as y, type SseEvent as z };