@graphrefly/graphrefly 0.44.0 → 0.45.0

package/dist/index-CeFiHtAg.d.ts

@@ -1,468 +0,0 @@
-import { N as Node } from './node-kK3CvTrR.js';
-import { B as BaseAuditRecord } from './index-Yq60JP3s.js';
-import { a as ReactiveLogBundle } from './reactive-log-BKALbfal.js';
-import { AppendLogStorageTier } from './extra/storage-tiers.js';
-import { a as GraphOptions, G as Graph } from './graph-D9LFnda9.js';
-
-/**
- * CQRS patterns (roadmap §4.5).
- *
- * Composition layer over reactiveLog (3.2), pipeline/sagas (4.1), event bus (4.2),
- * projections (4.3). Guards (1.5) enforce command/query boundary.
- *
- * - `cqrs(name, opts?)` → `CqrsGraph` — top-level factory
- * - `CqrsGraph.command(name, handler)` — write-only node; guard rejects `observe`
- * - `CqrsGraph.event(name)` — backed by `reactiveLog`; append-only
- * - `CqrsGraph.projection(name, events, reducer, initial)` — read-only derived; guard rejects `write`
- * - `CqrsGraph.saga(name, events, handler)` — event-driven side effects
- */
-
-/**
- * Immutable envelope for events emitted by command handlers.
- *
- * **Wave C.1 Unit 17 (locked 2026-04-24):** Extended ES standard fields —
- * `aggregateId` / `aggregateVersion` for per-aggregate streams; correlation /
- * causation IDs for distributed tracing; `metadata` for free-form context.
- * Optional `handlerVersion` (Audit 5) traces which handler version produced
- * the event.
- *
- * `seq` is a per-graph monotonic counter that provides stable ordering when
- * multiple events share the same `timestampNs` (same wall-clock tick).
- */
-type CqrsEvent<T = unknown> = {
-    type: string;
-    payload: T;
-    /** Wall-clock nanoseconds (via `wallClockNs()`). */
-    timestampNs: number;
-    /** Monotonic sequence within this CqrsGraph instance. */
-    seq: number;
-    /** Aggregate identifier (per-aggregate streams). */
-    aggregateId?: string;
-    /** Per-aggregate monotonic version (set when `aggregateId` is provided). */
-    aggregateVersion?: number;
-    /** Distributed-trace correlation id. */
-    correlationId?: string;
-    /** Causation chain id (this event was caused by event `causationId`). */
-    causationId?: string;
-    /** Free-form metadata frozen at append. */
-    metadata?: Readonly<Record<string, unknown>>;
-    /** V0 identity of the event log node at append time (§6.0b). */
-    v0?: {
-        id: string;
-        version: number;
-    };
-    /** Handler version stamped on emit (Audit 5). */
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-};
-/** Compile-time event-map registry: `{ "orderPlaced": OrderPayload, ... }`. */
-type CqrsEventMap = Record<string, unknown>;
-/** Recommended `keyOf` for CQRS event-store storage tiers (Audit 4). */
-declare const cqrsEventKeyOf: (e: CqrsEvent) => string;
-interface DispatchRecord<T = unknown> extends BaseAuditRecord {
-    readonly commandName: string;
-    readonly payload: T;
-    /** Action result. Tier 1.6.2 canonical enum (renamed from `status`). */
-    readonly outcome: "success" | "failure";
-    readonly error?: unknown;
-    readonly errorType?: string;
-    /**
-     * Event names emitted by the handler.
-     * - `outcome: "success"`: events that persisted in the event log.
-     * - `outcome: "failure"`: events the handler ATTEMPTED to emit before throwing;
-     *   they were rolled back and did NOT persist. Documents the failed attempt's
-     *   intentions for debugging handler logic. The actual event log shows only
-     *   what's durable.
-     */
-    readonly emittedEvents?: readonly string[];
-}
-declare const dispatchKeyOf: <T>(r: DispatchRecord<T>) => string;
-interface SagaInvocation<T = unknown> extends BaseAuditRecord {
-    readonly eventType: string;
-    /** Action result. Tier 1.6.2 canonical enum (renamed from `status`). */
-    readonly outcome: "success" | "failure";
-    readonly error?: unknown;
-    readonly errorType?: string;
-    readonly aggregateId?: string;
-    readonly event?: CqrsEvent<T>;
-}
-declare const sagaInvocationKeyOf: <T>(i: SagaInvocation<T>) => string;
-/**
- * Saga registration result (M10) — a typed bundle replacing the prior
- * `Node<unknown>` return that side-attached `_saga` via an unsafe cast.
- *
- * `node` is the saga's effect node (subscribe to observe processing
- * activity). `invocations` is the per-event-type audit log; `audit` aliases
- * `invocations` (Audit 2 `.audit` duplication). `cursors` exposes the
- * per-event-type cursor state nodes for monitoring / testing.
- *
- * @category patterns
- */
-interface SagaController<T = unknown> {
-    readonly node: Node<unknown>;
-    readonly invocations: ReactiveLogBundle<SagaInvocation<T>>;
-    readonly audit: ReactiveLogBundle<SagaInvocation<T>>;
-    readonly cursors: {
-        readonly [eventName: string]: Node<number>;
-    };
-}
-type CommandActions = {
-    /** Append an event to a named event log (bypasses event guard). */
-    emit: (eventName: string, payload: unknown) => void;
-};
-/**
- * Command handler receives the dispatch payload and actions to emit events.
- *
- * **Purity:** Handlers should not mutate the payload. Event emission via
- * `actions.emit()` is the only sanctioned side effect.
- */
-type CommandHandler<T = unknown> = (payload: T, actions: CommandActions) => void;
-/**
- * Projection reducer folds events into a read model.
- *
- * **Purity contract:** Reducers MUST be pure — return a new state value
- * without mutating `state` or any event.
- *
- * - In **`"replay"`** mode the `state` parameter is always the original
- *   `initial` value (full event-sourcing replay on every recompute).
- * - In **`"scan"`** mode the `state` parameter is the _previous_ output
- *   (incremental fold); `events` contains only the events appended since
- *   the last computation.
- */
-type ProjectionReducer<TState = unknown, TEvent = unknown> = (state: TState, events: readonly CqrsEvent<TEvent>[]) => TState;
-/**
- * Snapshot integration for {@link ProjectionOptions}.
- *
- * `load` is called once at projection construction and the returned value
- * seeds the initial state. `save` (optional) is called after each reducer
- * run, debounced by `saveDebounceMs` (default 1000 ms) and capped by
- * `saveEvery` (default 1000 events).
- */
-type ProjectionSnapshotOpts<TState> = {
-    /** Load a previously-saved state. `undefined` → start from `initial`. */
-    load: () => TState | undefined | Promise<TState | undefined>;
-    /** Persist the current state. Called after reducer; may be async. */
-    save?: (state: TState) => void | Promise<void>;
-    /**
-     * Debounce window (ms) before `save` fires after the last event. Default 1000.
-     */
-    saveDebounceMs?: number;
-    /**
-     * Force a save after every Nth state change regardless of debounce.
-     * Default 1000. Both knobs compose: save fires at whichever condition is
-     * met first.
-     */
-    saveEvery?: number;
-};
-/**
- * Options for {@link CqrsGraph.projection}.
- *
- * **Wave C.3 Unit 21 (locked 2026-04-24):**
- * - `mode: "scan"` (default) — incremental fold; `"replay"` — full replay
- *   each wave.
- * - `snapshot` — load/save integration for cold-start + auto-checkpoint.
- * - `freezeInputs` (default `true`) — freeze event arrays before passing
- *   to reducer (purity enforcement).
- * - `rebuild()` / `reset()` on the returned {@link ProjectionController}.
- *
- * @category patterns
- */
-type ProjectionOptions<TState> = {
-    name: string;
-    events: readonly string[];
-    reducer: ProjectionReducer<TState>;
-    initial: TState;
-    /**
-     * Fold strategy. Default `"scan"` (incremental). `"replay"` = full replay.
-     *
-     * **Scan-mode ordering caveat:** scan-mode assumes monotonic per-stream
-     * arrival order. When multiple event streams are merged for a projection,
-     * events arriving with a `timestampNs` earlier than the current sort cursor
-     * are skipped from the incremental sweep. This is an acceptable trade-off
-     * for incremental fold; use `mode: "replay"` for strict cross-stream
-     * ordering.
-     */
-    mode?: "replay" | "scan";
-    /** Snapshot integration for rebuild + auto-checkpoint. */
-    snapshot?: ProjectionSnapshotOpts<TState>;
-    /**
-     * Freeze event arrays before passing to reducer (default `true`).
-     * Set to `false` only if your reducer intentionally mutates the input
-     * (strongly discouraged — prefer immutable reducers).
-     */
-    freezeInputs?: boolean;
-};
-/**
- * Controller returned by {@link CqrsGraph.projection}.
- *
- * `node` is the reactive read model. `rebuild()` performs a paginated
- * cold-storage replay (requires `attachEventStorage` tiers). `reset()`
- * reloads from `snapshot.load()` and re-folds the live event log on top.
- *
- * @category patterns
- */
-interface ProjectionController<TState> {
-    readonly node: Node<TState>;
-    /**
-     * Async paginated rebuild from attached storage tiers. Throws
-     * {@link RebuildError} on adapter / decode / reducer failure.
-     *
-     * @param opts.fromTier - Storage tier to read from (default: first attached).
-     * @param opts.pageSize - Entries per page (default 1000).
-     */
-    rebuild(opts?: {
-        fromTier?: AppendLogStorageTier<CqrsEvent>;
-        pageSize?: number;
-    }): Promise<TState>;
-    /**
-     * Reload from `snapshot.load()` (if configured) and re-fold the live
-     * in-memory event log on top. Returns the rebuilt state. No-op on the
-     * reactive node if the state is unchanged.
-     */
-    reset(): Promise<TState>;
-}
-type SagaHandler<T = unknown> = (event: CqrsEvent<T>) => void;
-type CqrsOptions = {
-    graph?: GraphOptions;
-    /** Bounded retention for event streams; default 1024 (cross-cutting). */
-    retainedLimit?: number;
-    /** Freeze command payloads on dispatch (default `true`). */
-    freezeCommandPayload?: boolean;
-    /** Freeze event payloads on emit (default `true`). */
-    freezeEventPayload?: boolean;
-    /** LRU eviction threshold for per-aggregate streams (default 10_000). */
-    maxAggregates?: number;
-};
-type CommandRegistration<TPayload = unknown> = {
-    handler: CommandHandler<TPayload>;
-    emits?: readonly string[];
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-};
-type DispatchOptions = {
-    correlationId?: string;
-    causationId?: string;
-    metadata?: Record<string, unknown>;
-    /**
-     * Optimistic-concurrency check: if set, dispatch verifies the aggregate
-     * (identified by `aggregateId`) is at this version. On mismatch, dispatch
-     * throws {@link OptimisticConcurrencyError} BEFORE the handler runs.
-     *
-     * Requires `aggregateId` to be set. Without it the check is a no-op.
-     */
-    expectedAggregateVersion?: number;
-    /**
-     * Aggregate this dispatch targets. Events emitted by the handler that
-     * also carry this `aggregateId` participate in per-aggregate versioning
-     * and LRU eviction (see {@link CqrsOptions.maxAggregates}). Events whose
-     * handler-supplied `aggregateId` differs from the dispatch's `aggregateId`
-     * are emitted untouched (their own `aggregateVersion` is computed from
-     * their own aggregate's stream).
-     */
-    aggregateId?: string;
-};
-type SagaOptions = {
-    aggregateId?: string;
-    errorPolicy?: "advance" | "hold";
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-};
-/**
- * Eviction record emitted on `aggregateEvictions` when an aggregate's
- * per-aggregate stream is removed under `maxAggregates` LRU pressure. The
- * eviction does NOT delete events from the fan-in stream — only the
- * per-aggregate dedicated stream and its version counter.
- */
-interface AggregateEvictionRecord {
-    readonly aggregateId: string;
-    readonly type: string;
-    readonly t_ns: number;
-    /** The version count the aggregate reached before eviction (for diagnostics). */
-    readonly lastVersion: number;
-}
-declare class CqrsGraph<EM extends CqrsEventMap = Record<string, unknown>> extends Graph {
-    /** Fan-in event streams (one per type, all aggregates merged). */
-    private readonly _eventLogs;
-    /**
-     * Per-aggregate event streams: type → aggregateId → entry. Used for
-     * `event(type, aggregateId)` dual-form access and per-aggregate version
-     * tracking. Only populated when an event with `aggregateId` is emitted.
-     */
-    private readonly _eventLogsByAggregate;
-    /** Per-aggregate version counters: `${type}::${aggregateId}` → current version. */
-    private readonly _aggregateVersions;
-    /**
-     * LRU access order for `${type}::${aggregateId}`. Map insertion order
-     * tracks recency — `delete` + `set` on access moves to the end.
-     */
-    private readonly _aggregateLru;
-    private readonly _commandRegs;
-    private readonly _projections;
-    private readonly _sagas;
-    private readonly _keepaliveDisposers;
-    private _seq;
-    private readonly _retainedLimit;
-    private readonly _freezeCommandPayload;
-    private readonly _freezeEventPayload;
-    private readonly _maxAggregates;
-    private readonly _dispatchSeqCursor;
-    /** Audit log of every command dispatch (Audit 2). */
-    readonly dispatches: ReactiveLogBundle<DispatchRecord>;
-    /** Alias for {@link CqrsGraph.dispatches} (Audit 2 `.audit` duplication). */
-    readonly audit: ReactiveLogBundle<DispatchRecord>;
-    /** Per-aggregate LRU eviction observability; secondary log to `dispatches`. */
-    readonly aggregateEvictions: ReactiveLogBundle<AggregateEvictionRecord>;
-    constructor(name: string, opts?: CqrsOptions);
-    /**
-     * Read the current per-aggregate version (last emitted `aggregateVersion`
-     * for that `(type, aggregateId)` pair). Returns `0` if no events have been
-     * emitted yet for this aggregate. Useful for callers preparing
-     * {@link DispatchOptions.expectedAggregateVersion}.
-     */
-    aggregateVersion(type: string, aggregateId: string): number;
-    /** LRU touch — moves the key to the end of the access order. */
-    private _touchAggregate;
-    /**
-     * Evict the oldest aggregate streams (least-recently-touched) until the
-     * aggregate count is back within `_maxAggregates`. Emits one
-     * `AggregateEvictionRecord` per eviction. The fan-in stream is NOT touched
-     * — events stay in the type-level log; only the per-aggregate stream and
-     * version counter are removed.
-     */
-    private _enforceAggregateLru;
-    destroy(): void;
-    /** Tiers attached via {@link attachEventStorage}; auto-wired into future event streams. */
-    private readonly _attachedEventTiers;
-    private readonly _attachedTierDisposers;
-    /**
-     * Wire append-log storage tiers for ALL CQRS event streams — both currently
-     * registered AND any future streams created via `event(name)` /
-     * `event(name, aggregateId)` / handler emit. (M4 fix.)
-     *
-     * Returns a disposer that releases all storage subscriptions wired by this
-     * call (including those for streams that were created after the call).
-     */
-    attachEventStorage(tiers: readonly AppendLogStorageTier<CqrsEvent>[]): () => void;
-    /** Wire newly-created event stream into all currently-attached tier sets. */
-    private _autoWireStreamStorage;
-    /**
-     * Register a named event stream backed by `reactiveLog`.
-     * Guard denies external `write` — only commands append internally.
-     */
-    event(name: string): Node<readonly CqrsEvent[]>;
-    event(name: string, aggregateId: string): Node<readonly CqrsEvent[]>;
-    /**
-     * Get-or-create the per-aggregate event stream for `(type, aggregateId)`.
-     * Mounts the stream as a sibling node named `<type>_<aggregateId>` so it
-     * appears in `describe()`. LRU access is touched on every call.
-     */
-    private _ensureAggregateStream;
-    /** Try `resolve(path)`; return `undefined` instead of throwing on missing. */
-    private resolveOptional;
-    /** Internal: append to an event log, auto-registering if needed. */
-    private _appendEvent;
-    /**
-     * Register a command with its handler. Guard denies `observe` (write-only).
-     * Use `dispatch(name, payload)` to execute.
-     *
-     * The command node carries dynamic `meta.error` — a reactive companion
-     * that holds the last handler error (or `null` on success).
-     */
-    command<T = unknown>(name: string, handlerOrReg: CommandHandler<T> | CommandRegistration<T>): Node<T>;
-    /**
-     * Execute a registered command. Wraps the entire dispatch in `batch()` so
-     * the command node DATA and all emitted events settle atomically.
-     *
-     * If the handler throws, `meta.error` on the command node is set to the
-     * error and the exception is re-thrown.
-     *
-     * **Tier 8 / COMPOSITION-GUIDE §35:** dispatch routes through the shared
-     * {@link wrapMutation} framework so freeze / rollback-on-throw / seq-cursor
-     * advance / audit-record stamping flow through one centralized helper.
-     * Failure records emit OUTSIDE the rolled-back batch (M5 / C4 invariants
-     * preserved by the framework).
-     */
-    dispatch<T = unknown>(commandName: string, payload: T, opts?: DispatchOptions): void;
-    /**
-     * Register a read-only projection derived from event streams.
-     * Guard denies `write` — value is computed from events only.
-     *
-     * **Wave C.3 Unit 21 (locked 2026-04-24):**
-     * - Object-bag signature replaces the positional `(name, events, reducer, initial)` form.
-     * - `mode: "scan"` (default) — incremental fold; `"replay"` — full replay each wave.
-     * - `snapshot` integration for cold-start load + auto-checkpoint save.
-     * - `freezeInputs` (default `true`) — freeze the event array before passing to reducer.
-     * - Returns `ProjectionController<TState>` with `.node`, `.rebuild()`, `.reset()`.
-     *
-     * Fan-in across `events` is implemented by depending on all event-type fan-in
-     * nodes directly, which preserves `describe()` edges (e.g. `orderPlaced →
-     * orderCount`). Events are sorted by `(timestampNs, seq, aggregateId)` before
-     * passing to the reducer (Option-3 cross-aggregate ordering, C.3).
-     */
-    projection<TState>(opts: ProjectionOptions<TState>): ProjectionController<TState>;
-    /**
-     * Register an event-driven side effect. Runs handler for each **new** event
-     * from the specified streams (tracks last-processed entry count per stream).
-     *
-     * The saga node carries dynamic `meta.error` — a reactive companion that
-     * holds the last handler error (or `null` on success). Handler errors do
-     * not propagate out of the saga run (the event cursor still advances so
-     * the same entry is not delivered twice).
-     */
-    saga<T = unknown>(name: string, eventNames: readonly string[], handler: SagaHandler<T>, opts?: SagaOptions): SagaController<T>;
-}
-/**
- * Create a CQRS graph container.
- *
- * @example
- * ```ts
- * const app = cqrs("orders");
- * app.event("orderPlaced");
- * app.command("placeOrder", (payload, { emit }) => {
- *   emit("orderPlaced", { orderId: payload.id, amount: payload.amount });
- * });
- * const { node: orderCount } = app.projection({
- *   name: "orderCount",
- *   events: ["orderPlaced"],
- *   reducer: (_s, events) => events.length,
- *   initial: 0,
- * });
- * app.dispatch("placeOrder", { id: "1", amount: 100 });
- * ```
- */
-declare function cqrs<EM extends CqrsEventMap = Record<string, unknown>>(name: string, opts?: CqrsOptions): CqrsGraph<EM>;
-
-type index_AggregateEvictionRecord = AggregateEvictionRecord;
-type index_CommandActions = CommandActions;
-type index_CommandHandler<T = unknown> = CommandHandler<T>;
-type index_CommandRegistration<TPayload = unknown> = CommandRegistration<TPayload>;
-type index_CqrsEvent<T = unknown> = CqrsEvent<T>;
-type index_CqrsEventMap = CqrsEventMap;
-type index_CqrsGraph<EM extends CqrsEventMap = Record<string, unknown>> = CqrsGraph<EM>;
-declare const index_CqrsGraph: typeof CqrsGraph;
-type index_CqrsOptions = CqrsOptions;
-type index_DispatchOptions = DispatchOptions;
-type index_DispatchRecord<T = unknown> = DispatchRecord<T>;
-type index_ProjectionController<TState> = ProjectionController<TState>;
-type index_ProjectionOptions<TState> = ProjectionOptions<TState>;
-type index_ProjectionReducer<TState = unknown, TEvent = unknown> = ProjectionReducer<TState, TEvent>;
-type index_ProjectionSnapshotOpts<TState> = ProjectionSnapshotOpts<TState>;
-type index_SagaController<T = unknown> = SagaController<T>;
-type index_SagaHandler<T = unknown> = SagaHandler<T>;
-type index_SagaInvocation<T = unknown> = SagaInvocation<T>;
-type index_SagaOptions = SagaOptions;
-declare const index_cqrs: typeof cqrs;
-declare const index_cqrsEventKeyOf: typeof cqrsEventKeyOf;
-declare const index_dispatchKeyOf: typeof dispatchKeyOf;
-declare const index_sagaInvocationKeyOf: typeof sagaInvocationKeyOf;
-declare namespace index {
-  export { type index_AggregateEvictionRecord as AggregateEvictionRecord, type index_CommandActions as CommandActions, type index_CommandHandler as CommandHandler, type index_CommandRegistration as CommandRegistration, type index_CqrsEvent as CqrsEvent, type index_CqrsEventMap as CqrsEventMap, index_CqrsGraph as CqrsGraph, type index_CqrsOptions as CqrsOptions, type index_DispatchOptions as DispatchOptions, type index_DispatchRecord as DispatchRecord, type index_ProjectionController as ProjectionController, type index_ProjectionOptions as ProjectionOptions, type index_ProjectionReducer as ProjectionReducer, type index_ProjectionSnapshotOpts as ProjectionSnapshotOpts, type index_SagaController as SagaController, type index_SagaHandler as SagaHandler, type index_SagaInvocation as SagaInvocation, type index_SagaOptions as SagaOptions, index_cqrs as cqrs, index_cqrsEventKeyOf as cqrsEventKeyOf, index_dispatchKeyOf as dispatchKeyOf, index_sagaInvocationKeyOf as sagaInvocationKeyOf };
-}
-
-export { type AggregateEvictionRecord as A, type CqrsEventMap as C, type DispatchOptions as D, type ProjectionController as P, type SagaController as S, type CqrsEvent as a, CqrsGraph as b, type CqrsOptions as c, type CommandActions as d, type CommandHandler as e, type CommandRegistration as f, type DispatchRecord as g, type ProjectionOptions as h, index as i, type ProjectionReducer as j, type ProjectionSnapshotOpts as k, type SagaHandler as l, type SagaInvocation as m, type SagaOptions as n, cqrs as o, cqrsEventKeyOf as p, dispatchKeyOf as q, sagaInvocationKeyOf as s };

package/dist/index-Cj3WohTd.d.cts

@@ -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.cjs';
-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-DQjFmVqb.cjs';
-
-/**
- * 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 };