@graphrefly/graphrefly 0.44.0 → 0.45.0

package/dist/index-CasX6Pfq.d.cts

@@ -1,358 +0,0 @@
-import { B as BaseAuditRecord } from './index-D0aciIex.cjs';
-import { a as ReactiveLogBundle } from './reactive-log-DIGdYqQ6.cjs';
-import { NodeInput } from './extra/sources.cjs';
-import { AppendLogStorageTier, KvStorageTier } from './extra/storage-tiers.cjs';
-import { C as CqrsEventMap, a as CqrsEvent, b as CqrsGraph } from './index-B-_tFaqV.cjs';
-
-/**
- * Process Manager pattern (Phase 7 — roadmap §4.6, Audit 3 — locked 2026-04-24).
- *
- * Reactive long-running workflow primitive over CQRS event nodes.
- * Correlates events across aggregates, tracks per-instance state, supports
- * retries with backoff, and runs compensation on failure or explicit cancel.
- *
- * ## Architecture
- *
- * - Per-instance state lives in a `Map<correlationId, TState>` closure (in-memory).
- *   The `_process_<name>_started` synthetic event is dispatched per `start()`
- *   for an event-sourced audit trail using `correlationId` as `aggregateId`.
- *   Cross-restart state recovery is opt-in via
- *   `opts.persistence.stateStorage` (kv-tier per-correlationId snapshot,
- *   Tier 6.5 3.5) plus an explicit `restore()` call after construction.
- * - Watched-event subscriptions are imperative (coordinator role) — each
- *   watched CQRS event type is subscribed to via `entries.subscribe(...)`.
- *   These are NOT reactive node edges; the process manager is intentionally
- *   a coordinator that bridges reactive CQRS events into imperative instance logic.
- * - Step execution uses `fromAny` to uniformly handle sync and async handlers.
- * - Retry delays use `setTimeout` (same sanctioned pattern as `extra/resilience.ts`
- *   retry helper — this primitive is a coordinator, not a reactive pipeline stage).
- * - Timer scheduling uses `fromTimer` from `extra/sources.ts` per spec §5.8.
- * - Audit log uses `createAuditLog` per Audit 2.
- *
- * @module
- */
-
-/**
- * Discriminated union returned by each step handler.
- *
- * - `"success"` — step ran cleanly; update state, optionally emit
- *   side-effect events and schedule a future synthetic event. The process
- *   instance stays `"running"`.
- * - `"terminate"` — workflow complete; instance moves to `"terminated"`.
- *   Process-specific extension to the canonical outcome enum.
- * - `"failure"` — triggers compensation; instance moves to `"compensated"` /
- *   `"errored"`.
- *
- * Field name is `outcome` (matching `cqrs.DispatchRecord.outcome` and the
- * canonical Tier 1.6.2 / 2.3 enum). `"success"` and `"failure"` are the
- * canonical values; `"terminate"` is the process-specific extension for
- * "early-return success".
- */
-type ProcessStepResult<TState> = {
-    outcome: "success";
-    state: TState;
-    emit?: readonly {
-        type: string;
-        payload: unknown;
-    }[];
-    schedule?: ProcessSchedule;
-} | {
-    outcome: "terminate";
-    state: TState;
-    emit?: readonly {
-        type: string;
-        payload: unknown;
-    }[];
-    reason?: string;
-} | {
-    outcome: "failure";
-    error: unknown;
-};
-/**
- * Schedule a synthetic timer event after `afterMs` milliseconds.
- * When the timer fires, the synthetic event of `eventType` is routed to the
- * matching step (if one is registered) for this correlationId.
- */
-type ProcessSchedule = {
-    afterMs: number;
-    eventType: string;
-};
-/**
- * Step handler signature.
- *
- * Receives the current instance state and the triggering CQRS event.
- * Returns a {@link ProcessStepResult} — sync value, Promise, or any
- * {@link NodeInput} consumed via `fromAny`.
- */
-type ProcessStep<TState, EM extends CqrsEventMap, K extends keyof EM & string> = (state: TState, event: CqrsEvent<EM[K]>) => NodeInput<ProcessStepResult<TState>>;
-/**
- * Compensation handler. Runs when a step returns `outcome: "failure"`, throws, or
- * when `cancel(correlationId)` is called on a running instance.
- *
- * Should undo any side effects performed by prior steps (refund, cancel
- * reservation, etc.). Errors thrown inside compensate are swallowed and
- * recorded in the audit log with `status: "errored"` to prevent cascading
- * failure loops.
- */
-type ProcessCompensate<TState> = (state: TState, error: unknown) => NodeInput<void>;
-/**
- * Audit record for a single process instance state transition.
- *
- * Every status change (start → running → terminated / errored / compensated)
- * appends one record. `correlationId` is the stable process key.
- *
- * Extends {@link BaseAuditRecord} so records carry `t_ns` / `seq` /
- * `handlerVersion` from the cross-cutting Audit 2 schema.
- */
-interface ProcessInstance<TState> extends BaseAuditRecord {
-    /** Stable correlation key that identifies this process instance. */
-    readonly correlationId: string;
-    /** Most-recent instance state at this transition. */
-    readonly state: TState;
-    /** Current lifecycle status after this transition. */
-    readonly status: "running" | "terminated" | "errored" | "compensated";
-    /** Wall-clock nanoseconds when `start()` was called. */
-    readonly startedAt: number;
-    /** Wall-clock nanoseconds of this transition. */
-    readonly updatedAt: number;
-    /** Handler version stamped at transition time (Audit 5). */
-    readonly handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-    /** Optional human-readable reason for cancellation. Present only on `"compensated"` records produced by `cancel()`. */
-    readonly reason?: string;
-}
-/**
- * Recommended `keyOf` for storage tiers keyed by correlationId (Audit 2).
- */
-declare const processInstanceKeyOf: <TState>(i: ProcessInstance<TState>) => string;
-/**
- * Per-correlationId state snapshot persisted via
- * {@link ProcessManagerOpts.persistence.stateStorage} (Tier 6.5 3.5,
- * 2026-04-29). Captures the running instance's current state plus
- * lifecycle metadata so a fresh `processManager` can resume in-flight
- * workflows after restart via {@link ProcessManagerResult.restore}.
- *
- * Terminal records (`status` ∈ `"terminated" | "errored" | "compensated"`)
- * are deleted from the kv tier on transition — only running instances
- * persist between restarts.
- */
-interface ProcessStateSnapshot<TState> {
-    readonly correlationId: string;
-    readonly state: TState;
-    readonly status: "running" | "terminated" | "errored" | "compensated";
-    readonly startedAt: number;
-    readonly updatedAt: number;
-    readonly handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-}
-/** Recommended `keyOf` for `KvStorageTier<ProcessStateSnapshot<...>>`. */
-declare const processStateKeyOf: <TState>(s: ProcessStateSnapshot<TState>) => string;
-/**
- * Options for {@link processManager}.
- */
-interface ProcessManagerOpts<TState, EM extends CqrsEventMap> {
-    /** Initial state value for every new process instance. */
-    readonly initial: TState;
-    /** CQRS event types to watch for correlation routing. */
-    readonly watching: readonly (keyof EM & string)[];
-    /**
-     * Per-event-type step handlers. A step is invoked when a watched event's
-     * `correlationId` matches a running instance and the event type is in
-     * `steps`. Events with no matching step are silently ignored.
-     */
-    readonly steps: {
-        [K in keyof EM & string]?: ProcessStep<TState, EM, K>;
-    };
-    /**
-     * Optional compensation handler. Runs on step `outcome: "failure"` / step throw
-     * and on explicit `cancel()`. If omitted, instances fail silently with
-     * status `"errored"` instead of `"compensated"`.
-     */
-    readonly compensate?: ProcessCompensate<TState>;
-    /**
-     * Optional predicate called after each `"success"` step. When it returns
-     * `true`, the instance is moved to `"terminated"` immediately without
-     * waiting for a `"terminate"` step result.
-     */
-    readonly isTerminal?: (state: TState) => boolean;
-    /**
-     * Maximum number of retry attempts after a step throws (not counting the
-     * first attempt). Default: `0` (no retry — fail immediately on throw).
-     */
-    readonly retryMax?: number;
-    /**
-     * Per-retry backoff delays in milliseconds. `backoffMs[i]` is the delay
-     * before attempt `i + 1`. If fewer entries than `retryMax`, the last entry
-     * is repeated. Default: `[0]` (no delay).
-     *
-     * **Implementation note:** retry delays are implemented with `setTimeout`
-     * (same sanctioned exception as `extra/resilience.ts`). This is a
-     * coordinator-layer primitive — `fromTimer` would require subscribing to
-     * an additional node per attempt, which would leak timer nodes without a
-     * clear disposal scope.
-     */
-    readonly backoffMs?: readonly number[];
-    /** Handler version tag stamped onto audit records (Audit 5). */
-    readonly handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-    /** Optional persistence wiring (Audit 4). */
-    readonly persistence?: {
-        /**
-         * Wire the per-process synthetic state event stream to append-log tiers.
-         * Reuses `CqrsGraph.attachEventStorage` so events persist across restarts.
-         */
-        eventStorage?: readonly AppendLogStorageTier<CqrsEvent>[];
-        /**
-         * Wire per-correlationId state snapshots to kv tiers (Tier 6.5 3.5,
-         * 2026-04-29). Each `start()` and step transition writes the running
-         * instance's state under its `correlationId`; terminal transitions
-         * (`terminated` / `errored` / `compensated`) `delete` the key. After
-         * restart, callers invoke {@link ProcessManagerResult.restore} to
-         * reload running instances from the first tier.
-         *
-         * Uses {@link KvStorageTier} (not snapshot tier) because per-instance
-         * state is N records keyed by correlationId, not a single global
-         * snapshot. {@link processStateKeyOf} is the recommended `keyOf`
-         * (already aligned with the kv tier's `save(key, value)` shape).
-         *
-         * Terminal records are NOT preserved — historical lifecycle is the
-         * audit log's job. State persistence covers crash-recovery only.
-         */
-        stateStorage?: readonly KvStorageTier<ProcessStateSnapshot<TState>>[];
-    };
-}
-/**
- * Result handle returned by {@link processManager}.
- */
-interface ProcessManagerResult<TState> {
-    /**
-     * Reactive audit log of every process instance state transition.
-     * Every `start()`, step result, retry, cancellation, and compensation
-     * appends a {@link ProcessInstance} record.
-     */
-    readonly instances: ReactiveLogBundle<ProcessInstance<TState>>;
-    /**
-     * Alias for {@link instances} (Audit 2 `.audit` duplication convention).
-     */
-    readonly audit: ReactiveLogBundle<ProcessInstance<TState>>;
-    /**
-     * Start a new process instance identified by `correlationId`.
-     *
-     * Emits a synthetic `_process_<name>_started` event into the CQRS graph
-     * with `correlationId` as `aggregateId` so per-aggregate streams record
-     * the process lifecycle. If the correlationId already has an active
-     * (running) instance, this call is a no-op (idempotent).
-     *
-     * @param correlationId - Stable key for this workflow instance.
-     * @param initialPayload - Optional payload carried on the start event.
-     */
-    start(correlationId: string, initialPayload?: unknown): void;
-    /**
-     * Cancel a running instance by correlationId.
-     *
-     * Triggers the `compensate` handler (if configured), then marks the
-     * instance as `"compensated"`. If the instance is not running, this is
-     * a no-op.
-     *
-     * @param correlationId - Instance to cancel.
-     * @param reason - Optional human-readable reason recorded in the audit log.
-     */
-    cancel(correlationId: string, reason?: string): void;
-    /**
-     * Synchronous read of the current in-memory state for a correlationId.
-     * Returns `undefined` if the instance does not exist or has terminated.
-     */
-    getState(correlationId: string): TState | undefined;
-    /**
-     * Restore running instances from the first {@link
-     * ProcessManagerOpts.persistence.stateStorage} tier (Tier 6.5 3.5,
-     * 2026-04-29). Loads every record in the tier and re-hydrates
-     * `instanceStates` / `activeInstances` / `startedAt` for any record
-     * whose `status === "running"`. Terminal records, if any persisted
-     * before delete fired, are silently skipped.
-     *
-     * Idempotent — calling twice doesn't double-restore (existing entries
-     * are overwritten). Returns the count of running instances rehydrated.
-     *
-     * No-op when no `stateStorage` tier is configured OR the first tier
-     * lacks a `list?` method (returns 0). Async because kv tier `load` /
-     * `list` may be async.
-     */
-    restore(): Promise<number>;
-    /**
-     * Release all watched-event subscriptions and stop processing new events.
-     *
-     * After `dispose()`, subsequent `start()` and `cancel()` calls are no-ops.
-     * In-flight async steps complete naturally; no new steps are dispatched.
-     */
-    dispose(): void;
-}
-/**
- * Create a process manager that coordinates long-running reactive workflows
- * over a {@link CqrsGraph}.
- *
- * Process instances are identified by `correlationId`. Events from the watched
- * event types are routed to per-instance step handlers when the event's
- * `correlationId` matches a running instance.
- *
- * ```ts
- * const app = cqrs<{ orderPlaced: { orderId: string }; paymentReceived: { amount: number } }>("orders");
- *
- * const pm = processManager(app, "fulfillment", {
- *   initial: { step: "awaiting-payment", total: 0 },
- *   watching: ["orderPlaced", "paymentReceived"],
- *   steps: {
- *     orderPlaced(state, event) {
- *       return { outcome: "success", state: { ...state, orderId: event.payload.orderId } };
- *     },
- *     paymentReceived(state, event) {
- *       return { outcome: "terminate", state: { ...state, total: event.payload.amount } };
- *     },
- *   },
- *   compensate(state, _error) {
- *     // undo reservation, issue refund, etc.
- *   },
- *   retryMax: 2,
- *   backoffMs: [100, 500],
- * });
- *
- * pm.start("order-123");
- * app.dispatch("orderPlaced", { orderId: "order-123" }, { correlationId: "order-123" });
- * ```
- *
- * @param cqrsGraph - The CQRS graph whose event streams the manager watches.
- * @param name - Stable identifier for this process type; used for the
- *   synthetic event-type prefix `_process_<name>_*`. Currently emits
- *   `_process_<name>_started` per `start()`; the prefix is reserved for
- *   future `_state` / `_timer` channels.
- * @param opts - Configuration: initial state, watched events, steps, retry,
- *   compensation, and optional persistence.
- * @returns {@link ProcessManagerResult} with `instances` audit log and
- *   `start`, `cancel`, `getState` imperative controls.
- *
- * @category patterns
- */
-declare function processManager<TState, EM extends CqrsEventMap = Record<string, unknown>>(cqrsGraph: CqrsGraph<EM>, name: string, opts: ProcessManagerOpts<TState, EM>): ProcessManagerResult<TState>;
-
-type index_ProcessCompensate<TState> = ProcessCompensate<TState>;
-type index_ProcessInstance<TState> = ProcessInstance<TState>;
-type index_ProcessManagerOpts<TState, EM extends CqrsEventMap> = ProcessManagerOpts<TState, EM>;
-type index_ProcessManagerResult<TState> = ProcessManagerResult<TState>;
-type index_ProcessSchedule = ProcessSchedule;
-type index_ProcessStateSnapshot<TState> = ProcessStateSnapshot<TState>;
-type index_ProcessStep<TState, EM extends CqrsEventMap, K extends keyof EM & string> = ProcessStep<TState, EM, K>;
-type index_ProcessStepResult<TState> = ProcessStepResult<TState>;
-declare const index_processInstanceKeyOf: typeof processInstanceKeyOf;
-declare const index_processManager: typeof processManager;
-declare const index_processStateKeyOf: typeof processStateKeyOf;
-declare namespace index {
-  export { type index_ProcessCompensate as ProcessCompensate, type index_ProcessInstance as ProcessInstance, type index_ProcessManagerOpts as ProcessManagerOpts, type index_ProcessManagerResult as ProcessManagerResult, type index_ProcessSchedule as ProcessSchedule, type index_ProcessStateSnapshot as ProcessStateSnapshot, type index_ProcessStep as ProcessStep, type index_ProcessStepResult as ProcessStepResult, index_processInstanceKeyOf as processInstanceKeyOf, index_processManager as processManager, index_processStateKeyOf as processStateKeyOf };
-}
-
-export { type ProcessCompensate as P, type ProcessInstance as a, type ProcessManagerOpts as b, type ProcessManagerResult as c, type ProcessSchedule as d, type ProcessStateSnapshot as e, type ProcessStep as f, type ProcessStepResult as g, processManager as h, index as i, processStateKeyOf as j, processInstanceKeyOf as p };

package/dist/index-CdAlHFEt.d.ts

@@ -1,44 +0,0 @@
-import { N as Node } from './node-kK3CvTrR.js';
-
-/**
- * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.
- * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
- *
- * @param node - Any `Node<T>`.
- * @returns `T | undefined` — the current node value, kept in sync via `useSyncExternalStore`.
- */
-declare function useSubscribe<T>(node: Node<T>): T | undefined | null;
-/**
- * Bind a writable `Node<T>` as a React `[value, setter]` tuple.
- * Setting the value always pushes `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
- *
- * @param node - A `Node<T>` (e.g. state node).
- * @returns `[T | undefined, (value: T) => void]` — current value and setter function.
- */
-declare function useStore<T>(node: Node<T>): [T | undefined | null, (value: T) => void];
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
-type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
-    [P in keyof R]: Node<R[P]>;
-};
-/**
- * Subscribe to a dynamic set of keyed node records.
- * Re-subscribes all per-key fields whenever `keysNode` changes.
- * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
- * Guaranteed to clean up strictly with React hook lifecycle, utilizing no global mappings.
- *
- * @param keysNode - Node of current keys (e.g. node IDs)
- * @param factory - Function returning `{ [field]: Node<V> }` for each key.
- * @returns `Record<K, R>` — snapshot of resolved values for all keys.
- */
-declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Record<K, R>;
-
-type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
-declare const index_useStore: typeof useStore;
-declare const index_useSubscribe: typeof useSubscribe;
-declare const index_useSubscribeRecord: typeof useSubscribeRecord;
-declare namespace index {
-  export { type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
-}
-
-export { type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/index-CdTelp1M.d.ts

@@ -1,202 +0,0 @@
-import { M as Messages, A as Actor, C as COMPLETE, d as COMPLETE_MSG, e as COMPLETE_ONLY_BATCH, D as DATA, f as DEFAULT_ACTOR, g as DIRTY, h as DIRTY_MSG, i as DIRTY_ONLY_BATCH, j as DepRecord, E as ERROR, F as FnCtx, G as GlobalInspectorEvent, k as GlobalInspectorHook, l as GraphReFlyConfig, m as GuardAction, n as GuardDenied, o as GuardDeniedDetails, H as HashFn, I as INVALIDATE, p as INVALIDATE_MSG, q as INVALIDATE_ONLY_BATCH, r as Message, s as MessageContext, t as MessageTypeRegistration, u as MessageTypeRegistrationInput, N as Node, c as NodeActions, v as NodeCtx, w as NodeDescribeKind, x as NodeFn, y as NodeFnCleanup, b as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, a as NodeOptions, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, P as NodeVersionInfo, Q as OnMessageHandler, R as OnSubscribeHandler, S as PAUSE, T as PolicyAllow, U as PolicyDeny, W as PolicyRuleData, X as RESOLVED, Y as RESOLVED_MSG, Z as RESOLVED_ONLY_BATCH, _ as RESUME, $ as RigorRecorder, a0 as START, a1 as START_MSG, a2 as SubscribeContext, a3 as TEARDOWN, a4 as TEARDOWN_MSG, a5 as TEARDOWN_ONLY_BATCH, a6 as V0, a7 as V1, V as VersioningLevel, a8 as VersioningOptions, a9 as accessHintForGuard, aa as advanceVersion, ab as configure, ac as createVersioning, ad as defaultConfig, ae as defaultHash, af as isV1, ag as node, ah as normalizeActor, ai as policy, aj as policyFromRules, ak as registerBuiltins } from './node-kK3CvTrR.js';
-import { A as AutoTrackOptions, a as DerivedFn, b as DerivedTFn, c as DescribeDetail, d as DescribeField, D as DescribeNodeOutput, e as DynamicFn, E as EffectFn, f as EffectTFn, N as NodeValues, P as PipeOperator, g as ProducerFn, T as TrackFn, h as autoTrackNode, i as derived, j as derivedT, k as dynamicNode, l as effect, m as effectT, n as factoryTag, p as pipe, o as placeholderArgs, q as producer, r as resolveDescribeFields, s as state } from './sugar-fhLIE7TT.js';
-
-/**
- * Batch deferral for tier-3+ messages, plus per-node emit coalescing inside
- * explicit `batch()` scopes.
- *
- * **Canonical invariant:** GRAPHREFLY-SPEC.md §1.3.7 — inside a batch,
- * tier 0–2 signals propagate immediately; tier 3 (DATA/RESOLVED), tier 4
- * (COMPLETE/ERROR), and tier 5 (TEARDOWN) are queued and drained in ascending
- * phase order after the outermost `batch()` callback returns.
- *
- * **Per-node emit coalescing (Bug 2 fix, 2026-04-17).** Inside an explicit
- * `batch()` scope, consecutive emissions from the same node accumulate in
- * `NodeImpl._batchPendingMessages` (see JSDoc there) instead of each producing
- * a separate downstream wave. K `.emit()` calls to the same source collapse to
- * one coalesced `downWithBatch` call per child edge at batch end. Outside batch
- * (or during drain), coalescing does NOT apply — each emit produces its own wave.
- *
- * **Phase vocabulary:**
- * - Phase 1 = tiers 0–2 — immediate, never queued.
- * - Phase 2 = tier 3 — {@link drainPhase2}. Value settlements.
- * - Phase 3 = tier 4 — {@link drainPhase3}. Terminal signals.
- * - Phase 4 = tier 5 — {@link drainPhase4}. TEARDOWN (unified deferral).
- *
- * Drain rule: fire any pending flush hooks first, then the lowest non-empty
- * phase. Re-enqueues during drain (and hooks registered by reentrant batches
- * inside subscriber callbacks) bump the loop back to the top so newly-added
- * hooks and closures get processed.
- */
-
-/**
- * Returns whether the current call stack is inside a batch scope **or** while
- * a deferred drain is in progress. Nested `downWithBatch` calls during drain
- * still defer (they bump the drain loop).
- */
-declare function isBatching(): boolean;
-/**
- * Runs `fn` inside a batch scope. Nested `batch()` calls share one deferral
- * queue. If `fn` throws, deferred work for the outer frame is discarded
- * (unless a drain is already in progress — cross-language decision A4).
- */
-declare function batch(fn: () => void): void;
-/**
- * Deliver pre-sorted messages through `sink` with tier-based deferral applied.
- *
- * `messages` MUST be in ascending tier order (produced by `_frameBatch` in
- * `node.ts`); the walker exploits that invariant to find phase cuts in one
- * pass without re-sorting.
- *
- * Behavior:
- * - Tier 0–2 — delivered synchronously.
- * - Tier 3 — deferred to {@link drainPhase2} when batching, else synchronous.
- * - Tier 4 — deferred to {@link drainPhase3} when batching, else synchronous.
- * - Tier 5 — deferred to {@link drainPhase4} when batching, else synchronous.
- *
- * Tier-classification uses the caller-supplied `tierOf` so that batch stays
- * decoupled from `GraphReFlyConfig`. NodeImpl passes `config.tierOf` (a
- * pre-bound closure built once in the config constructor) at the emit site;
- * alternate configs can pass their own lookup.
- */
-declare function downWithBatch(sink: (messages: Messages) => void, messages: Messages, tierOf: (t: symbol) => number): void;
-
-/**
- * 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;
-
-/**
- * Core layer: message protocol, node primitive, lifecycle (Phase 0).
- */
-
-declare const index_Actor: typeof Actor;
-declare const index_AutoTrackOptions: typeof AutoTrackOptions;
-declare const index_COMPLETE: typeof COMPLETE;
-declare const index_COMPLETE_MSG: typeof COMPLETE_MSG;
-declare const index_COMPLETE_ONLY_BATCH: typeof COMPLETE_ONLY_BATCH;
-declare const index_DATA: typeof DATA;
-declare const index_DEFAULT_ACTOR: typeof DEFAULT_ACTOR;
-declare const index_DIRTY: typeof DIRTY;
-declare const index_DIRTY_MSG: typeof DIRTY_MSG;
-declare const index_DIRTY_ONLY_BATCH: typeof DIRTY_ONLY_BATCH;
-declare const index_DepRecord: typeof DepRecord;
-declare const index_DerivedFn: typeof DerivedFn;
-declare const index_DerivedTFn: typeof DerivedTFn;
-declare const index_DescribeDetail: typeof DescribeDetail;
-declare const index_DescribeField: typeof DescribeField;
-declare const index_DescribeNodeOutput: typeof DescribeNodeOutput;
-declare const index_DynamicFn: typeof DynamicFn;
-declare const index_ERROR: typeof ERROR;
-declare const index_EffectFn: typeof EffectFn;
-declare const index_EffectTFn: typeof EffectTFn;
-declare const index_FnCtx: typeof FnCtx;
-declare const index_GlobalInspectorEvent: typeof GlobalInspectorEvent;
-declare const index_GlobalInspectorHook: typeof GlobalInspectorHook;
-declare const index_GraphReFlyConfig: typeof GraphReFlyConfig;
-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_INVALIDATE_MSG: typeof INVALIDATE_MSG;
-declare const index_INVALIDATE_ONLY_BATCH: typeof INVALIDATE_ONLY_BATCH;
-declare const index_Message: typeof Message;
-declare const index_MessageContext: typeof MessageContext;
-declare const index_MessageTypeRegistration: typeof MessageTypeRegistration;
-declare const index_MessageTypeRegistrationInput: typeof MessageTypeRegistrationInput;
-declare const index_Messages: typeof Messages;
-declare const index_Node: typeof Node;
-declare const index_NodeActions: typeof NodeActions;
-declare const index_NodeCtx: typeof NodeCtx;
-declare const index_NodeDescribeKind: typeof NodeDescribeKind;
-declare const index_NodeFn: typeof NodeFn;
-declare const index_NodeFnCleanup: typeof NodeFnCleanup;
-declare const index_NodeGuard: typeof NodeGuard;
-declare const index_NodeImpl: typeof NodeImpl;
-declare const index_NodeInspectorHook: typeof NodeInspectorHook;
-declare const index_NodeInspectorHookEvent: typeof NodeInspectorHookEvent;
-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_NodeValues: typeof NodeValues;
-declare const index_NodeVersionInfo: typeof NodeVersionInfo;
-declare const index_OnMessageHandler: typeof OnMessageHandler;
-declare const index_OnSubscribeHandler: typeof OnSubscribeHandler;
-declare const index_PAUSE: typeof PAUSE;
-declare const index_PipeOperator: typeof PipeOperator;
-declare const index_PolicyAllow: typeof PolicyAllow;
-declare const index_PolicyDeny: typeof PolicyDeny;
-declare const index_PolicyRuleData: typeof PolicyRuleData;
-declare const index_ProducerFn: typeof ProducerFn;
-declare const index_RESOLVED: typeof RESOLVED;
-declare const index_RESOLVED_MSG: typeof RESOLVED_MSG;
-declare const index_RESOLVED_ONLY_BATCH: typeof RESOLVED_ONLY_BATCH;
-declare const index_RESUME: typeof RESUME;
-declare const index_RigorRecorder: typeof RigorRecorder;
-declare const index_START: typeof START;
-declare const index_START_MSG: typeof START_MSG;
-declare const index_SubscribeContext: typeof SubscribeContext;
-declare const index_TEARDOWN: typeof TEARDOWN;
-declare const index_TEARDOWN_MSG: typeof TEARDOWN_MSG;
-declare const index_TEARDOWN_ONLY_BATCH: typeof TEARDOWN_ONLY_BATCH;
-declare const index_TrackFn: typeof TrackFn;
-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_autoTrackNode: typeof autoTrackNode;
-declare const index_batch: typeof batch;
-declare const index_configure: typeof configure;
-declare const index_createVersioning: typeof createVersioning;
-declare const index_defaultConfig: typeof defaultConfig;
-declare const index_defaultHash: typeof defaultHash;
-declare const index_derived: typeof derived;
-declare const index_derivedT: typeof derivedT;
-declare const index_downWithBatch: typeof downWithBatch;
-declare const index_dynamicNode: typeof dynamicNode;
-declare const index_effect: typeof effect;
-declare const index_effectT: typeof effectT;
-declare const index_factoryTag: typeof factoryTag;
-declare const index_isBatching: typeof isBatching;
-declare const index_isV1: typeof isV1;
-declare const index_monotonicNs: typeof monotonicNs;
-declare const index_node: typeof node;
-declare const index_normalizeActor: typeof normalizeActor;
-declare const index_pipe: typeof pipe;
-declare const index_placeholderArgs: typeof placeholderArgs;
-declare const index_policy: typeof policy;
-declare const index_policyFromRules: typeof policyFromRules;
-declare const index_producer: typeof producer;
-declare const index_registerBuiltins: typeof registerBuiltins;
-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, index_AutoTrackOptions as AutoTrackOptions, index_COMPLETE as COMPLETE, index_COMPLETE_MSG as COMPLETE_MSG, index_COMPLETE_ONLY_BATCH as COMPLETE_ONLY_BATCH, index_DATA as DATA, index_DEFAULT_ACTOR as DEFAULT_ACTOR, index_DIRTY as DIRTY, index_DIRTY_MSG as DIRTY_MSG, index_DIRTY_ONLY_BATCH as DIRTY_ONLY_BATCH, index_DepRecord as DepRecord, index_DerivedFn as DerivedFn, index_DerivedTFn as DerivedTFn, index_DescribeDetail as DescribeDetail, index_DescribeField as DescribeField, index_DescribeNodeOutput as DescribeNodeOutput, index_DynamicFn as DynamicFn, index_ERROR as ERROR, index_EffectFn as EffectFn, index_EffectTFn as EffectTFn, index_FnCtx as FnCtx, index_GlobalInspectorEvent as GlobalInspectorEvent, index_GlobalInspectorHook as GlobalInspectorHook, index_GraphReFlyConfig as GraphReFlyConfig, index_GuardAction as GuardAction, index_GuardDenied as GuardDenied, index_GuardDeniedDetails as GuardDeniedDetails, index_HashFn as HashFn, index_INVALIDATE as INVALIDATE, index_INVALIDATE_MSG as INVALIDATE_MSG, index_INVALIDATE_ONLY_BATCH as INVALIDATE_ONLY_BATCH, index_Message as Message, index_MessageContext as MessageContext, index_MessageTypeRegistration as MessageTypeRegistration, index_MessageTypeRegistrationInput as MessageTypeRegistrationInput, index_Messages as Messages, index_Node as Node, index_NodeActions as NodeActions, index_NodeCtx as NodeCtx, index_NodeDescribeKind as NodeDescribeKind, index_NodeFn as NodeFn, index_NodeFnCleanup as NodeFnCleanup, index_NodeGuard as NodeGuard, index_NodeImpl as NodeImpl, index_NodeInspectorHook as NodeInspectorHook, index_NodeInspectorHookEvent as NodeInspectorHookEvent, index_NodeOptions as NodeOptions, index_NodeSink as NodeSink, index_NodeStatus as NodeStatus, index_NodeTransportOptions as NodeTransportOptions, index_NodeValues as NodeValues, index_NodeVersionInfo as NodeVersionInfo, index_OnMessageHandler as OnMessageHandler, index_OnSubscribeHandler as OnSubscribeHandler, index_PAUSE as PAUSE, index_PipeOperator as PipeOperator, index_PolicyAllow as PolicyAllow, index_PolicyDeny as PolicyDeny, index_PolicyRuleData as PolicyRuleData, index_ProducerFn as ProducerFn, index_RESOLVED as RESOLVED, index_RESOLVED_MSG as RESOLVED_MSG, index_RESOLVED_ONLY_BATCH as RESOLVED_ONLY_BATCH, index_RESUME as RESUME, index_RigorRecorder as RigorRecorder, index_START as START, index_START_MSG as START_MSG, index_SubscribeContext as SubscribeContext, index_TEARDOWN as TEARDOWN, index_TEARDOWN_MSG as TEARDOWN_MSG, index_TEARDOWN_ONLY_BATCH as TEARDOWN_ONLY_BATCH, index_TrackFn as TrackFn, 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_autoTrackNode as autoTrackNode, index_batch as batch, index_configure as configure, index_createVersioning as createVersioning, index_defaultConfig as defaultConfig, index_defaultHash as defaultHash, index_derived as derived, index_derivedT as derivedT, index_downWithBatch as downWithBatch, index_dynamicNode as dynamicNode, index_effect as effect, index_effectT as effectT, index_factoryTag as factoryTag, index_isBatching as isBatching, index_isV1 as isV1, index_monotonicNs as monotonicNs, index_node as node, index_normalizeActor as normalizeActor, index_pipe as pipe, index_placeholderArgs as placeholderArgs, index_policy as policy, index_policyFromRules as policyFromRules, index_producer as producer, index_registerBuiltins as registerBuiltins, index_resolveDescribeFields as resolveDescribeFields, index_state as state, index_wallClockNs as wallClockNs };
-}
-
-export { isBatching as a, batch as b, downWithBatch as d, index as i, monotonicNs as m, wallClockNs as w };