@graphrefly/graphrefly 0.34.0 → 0.35.0

package/dist/index-Cq7Uqgu4.d.ts

@@ -1,192 +0,0 @@
-import { a as Node } from './node-8qx0kgYt.js';
-import { a as GraphOptions, G as Graph } from './graph-BROUZPG9.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.
- *
- * `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;
-    /** V0 identity of the event log node at append time (§6.0b). */
-    v0?: {
-        id: string;
-        version: number;
-    };
-};
-/**
- * Opaque replay cursor returned by `loadEvents`. Pass it back to
- * `loadEvents` to resume from the last position.
- */
-type EventStoreCursor = {
-    readonly __brand?: "EventStoreCursor";
-    [key: string]: unknown;
-};
-/**
- * Result of `loadEvents` — events plus an opaque cursor for resumption.
- */
-type LoadEventsResult = {
-    events: CqrsEvent[];
-    cursor: EventStoreCursor | undefined;
-};
-/**
- * Pluggable persistence for CQRS events.
- *
- * **`persist`:** Must be synchronous. Called from the dispatch path inside
- * `batch()`. Adapters that need async I/O should buffer internally and
- * expose a `flush()` method for explicit drain.
- */
-interface EventStoreAdapter {
-    persist(event: CqrsEvent): void;
-    /**
-     * Load persisted events. When `cursor` is provided, returns only events
-     * after that position. The returned `cursor` should be passed to the next
-     * `loadEvents` call for incremental replay.
-     */
-    loadEvents(eventType: string, cursor?: EventStoreCursor): LoadEventsResult | Promise<LoadEventsResult>;
-    /** Optional explicit flush for adapters with async I/O. */
-    flush?(): Promise<void>;
-}
-declare class MemoryEventStore implements EventStoreAdapter {
-    private readonly _store;
-    persist(event: CqrsEvent): void;
-    loadEvents(eventType: string, cursor?: EventStoreCursor): LoadEventsResult;
-    clear(): void;
-}
-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. The `state` parameter is the
- * original `initial` value on every invocation (full event-sourcing replay),
- * so mutation would corrupt future recomputations.
- */
-type ProjectionReducer<TState = unknown, TEvent = unknown> = (state: TState, events: readonly CqrsEvent<TEvent>[]) => TState;
-type SagaHandler<T = unknown> = (event: CqrsEvent<T>) => void;
-type CqrsOptions = {
-    graph?: GraphOptions;
-};
-declare class CqrsGraph extends Graph {
-    private readonly _eventLogs;
-    private readonly _commandHandlers;
-    private readonly _projections;
-    private readonly _sagas;
-    private readonly _keepaliveDisposers;
-    private _eventStore;
-    private _seq;
-    constructor(name: string, opts?: CqrsOptions);
-    destroy(): void;
-    /**
-     * Register a named event stream backed by `reactiveLog`.
-     * Guard denies external `write` — only commands append internally.
-     */
-    event(name: string): Node<readonly CqrsEvent[]>;
-    /** 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, handler: CommandHandler<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.
-     */
-    dispatch<T = unknown>(commandName: string, payload: T): void;
-    /**
-     * Register a read-only projection derived from event streams.
-     * Guard denies `write` — value is computed from events only.
-     *
-     * **Purity contract:** The `reducer` must be a pure function — it receives
-     * the original `initial` on every invocation (full event-sourcing replay).
-     * Never mutate `initial`; always return a new value.
-     */
-    projection<TState>(name: string, eventNames: readonly string[], reducer: ProjectionReducer<TState>, initial: TState): Node<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>): Node<unknown>;
-    useEventStore(adapter: EventStoreAdapter): void;
-    /**
-     * Replay persisted events through a reducer to rebuild a read model.
-     * Requires an event store adapter wired via `useEventStore()`.
-     */
-    rebuildProjection<TState>(eventNames: readonly string[], reducer: ProjectionReducer<TState>, initial: TState): Promise<TState>;
-}
-/**
- * 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 });
- * });
- * app.projection("orderCount", ["orderPlaced"], (_s, events) => events.length, 0);
- * app.dispatch("placeOrder", { id: "1", amount: 100 });
- * ```
- */
-declare function cqrs(name: string, opts?: CqrsOptions): CqrsGraph;
-
-type index_CommandActions = CommandActions;
-type index_CommandHandler<T = unknown> = CommandHandler<T>;
-type index_CqrsEvent<T = unknown> = CqrsEvent<T>;
-type index_CqrsGraph = CqrsGraph;
-declare const index_CqrsGraph: typeof CqrsGraph;
-type index_CqrsOptions = CqrsOptions;
-type index_EventStoreAdapter = EventStoreAdapter;
-type index_EventStoreCursor = EventStoreCursor;
-type index_LoadEventsResult = LoadEventsResult;
-type index_MemoryEventStore = MemoryEventStore;
-declare const index_MemoryEventStore: typeof MemoryEventStore;
-type index_ProjectionReducer<TState = unknown, TEvent = unknown> = ProjectionReducer<TState, TEvent>;
-type index_SagaHandler<T = unknown> = SagaHandler<T>;
-declare const index_cqrs: typeof cqrs;
-declare namespace index {
-  export { type index_CommandActions as CommandActions, type index_CommandHandler as CommandHandler, type index_CqrsEvent as CqrsEvent, index_CqrsGraph as CqrsGraph, type index_CqrsOptions as CqrsOptions, type index_EventStoreAdapter as EventStoreAdapter, type index_EventStoreCursor as EventStoreCursor, type index_LoadEventsResult as LoadEventsResult, index_MemoryEventStore as MemoryEventStore, type index_ProjectionReducer as ProjectionReducer, type index_SagaHandler as SagaHandler, index_cqrs as cqrs };
-}
-
-export { type CqrsOptions as C, type EventStoreAdapter as E, type LoadEventsResult as L, MemoryEventStore as M, type ProjectionReducer as P, type SagaHandler as S, CqrsGraph as a, type CommandActions as b, type CommandHandler as c, type CqrsEvent as d, type EventStoreCursor as e, cqrs as f, index as i };

package/dist/index-Dtpr2FIB.d.ts

@@ -1,101 +0,0 @@
-import { a as Node } from './node-8qx0kgYt.js';
-import { G as Graph, a as GraphOptions } from './graph-BROUZPG9.js';
-
-/**
- * Job queue patterns (roadmap §4.2).
- *
- * Queue / flow primitives modeled as graph factories:
- * - `jobQueue()` — claim/ack/nack workflow with reactive depth.
- * - `jobFlow()` — multi-stage queue chain.
- *
- * Topic / subscription / hub primitives live in `patterns/messaging`.
- */
-
-type JobState = "queued" | "inflight";
-type JobEnvelope<T> = {
-    id: string;
-    payload: T;
-    attempts: number;
-    metadata: Readonly<Record<string, unknown>>;
-    state: JobState;
-};
-type JobQueueOptions = {
-    graph?: GraphOptions;
-};
-declare class JobQueueGraph<T> extends Graph {
-    private readonly _pending;
-    private readonly _jobs;
-    private _seq;
-    readonly pending: Node<readonly string[]>;
-    readonly jobs: Node<ReadonlyMap<string, JobEnvelope<T>>>;
-    readonly depth: Node<number>;
-    constructor(name: string, opts?: JobQueueOptions);
-    enqueue(payload: T, opts?: {
-        id?: string;
-        metadata?: Record<string, unknown>;
-    }): string;
-    claim(limit?: number): readonly JobEnvelope<T>[];
-    ack(id: string): boolean;
-    nack(id: string, opts?: {
-        requeue?: boolean;
-    }): boolean;
-    /**
-     * Remove a job by id regardless of its current state. Returns `true` if
-     * the job existed and was removed, `false` if no job has this id.
-     *
-     * `ack` only works on inflight; `nack` only works on inflight.
-     * `removeById` is the state-agnostic escape hatch — useful for
-     * audit/observability layers that enqueue but never claim, and need to
-     * finalize a job when an external decision (e.g. harness verify
-     * outcome) resolves it. Distinct name from the inherited
-     * {@link Graph.remove}, which removes a mounted child subgraph by path.
-     *
-     * When the job is in `queued` state, its id is also pulled from the
-     * `pending` list — depth + pending snapshot stay consistent.
-     */
-    removeById(id: string): boolean;
-}
-type JobFlowOptions = {
-    graph?: GraphOptions;
-    stages?: readonly string[];
-    maxPerPump?: number;
-};
-declare class JobFlowGraph<T> extends Graph {
-    private readonly _stageNames;
-    private readonly _queues;
-    private readonly _completed;
-    readonly completed: Node<readonly JobEnvelope<T>[]>;
-    readonly completedCount: Node<number>;
-    constructor(name: string, opts?: JobFlowOptions);
-    stages(): readonly string[];
-    queue(stage: string): JobQueueGraph<T>;
-    enqueue(payload: T, opts?: {
-        id?: string;
-        metadata?: Record<string, unknown>;
-    }): string;
-    retainedCompleted(): readonly JobEnvelope<T>[];
-}
-/**
- * Creates a Pulsar-inspired job queue graph with claim/ack/nack workflow.
- */
-declare function jobQueue<T>(name: string, opts?: JobQueueOptions): JobQueueGraph<T>;
-/**
- * Creates an autonomous multi-stage queue chain graph.
- */
-declare function jobFlow<T>(name: string, opts?: JobFlowOptions): JobFlowGraph<T>;
-
-type index_JobEnvelope<T> = JobEnvelope<T>;
-type index_JobFlowGraph<T> = JobFlowGraph<T>;
-declare const index_JobFlowGraph: typeof JobFlowGraph;
-type index_JobFlowOptions = JobFlowOptions;
-type index_JobQueueGraph<T> = JobQueueGraph<T>;
-declare const index_JobQueueGraph: typeof JobQueueGraph;
-type index_JobQueueOptions = JobQueueOptions;
-type index_JobState = JobState;
-declare const index_jobFlow: typeof jobFlow;
-declare const index_jobQueue: typeof jobQueue;
-declare namespace index {
-  export { type index_JobEnvelope as JobEnvelope, index_JobFlowGraph as JobFlowGraph, type index_JobFlowOptions as JobFlowOptions, index_JobQueueGraph as JobQueueGraph, type index_JobQueueOptions as JobQueueOptions, type index_JobState as JobState, index_jobFlow as jobFlow, index_jobQueue as jobQueue };
-}
-
-export { JobQueueGraph as J, type JobEnvelope as a, JobFlowGraph as b, type JobFlowOptions as c, type JobQueueOptions as d, type JobState as e, jobQueue as f, index as i, jobFlow as j };

package/dist/index-HvJ90_tX.d.ts

@@ -1,152 +0,0 @@
-import { a as Node, N as NodeOptions, c as NodeActions } from './node-8qx0kgYt.js';
-import { D as DerivedFn } from './sugar-CQkn_rxB.js';
-import { G as Graph, a as GraphOptions } from './graph-BROUZPG9.js';
-
-/**
- * Orchestration patterns (roadmap §4.1).
- *
- * Domain-layer helpers that build workflow shapes on top of core + extra primitives.
- * Exported under the `patterns.orchestration` namespace to avoid collisions with
- * Phase 2 operator names (for example `gate`, `forEach`).
- */
-
-type StepRef = string | Node<unknown>;
-type OrchestrationMeta = {
-    orchestration?: true;
-    orchestration_type?: string;
-};
-type OrchestrationStepOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
-    deps?: ReadonlyArray<StepRef>;
-    meta?: Record<string, unknown> & OrchestrationMeta;
-};
-type BranchResult<T> = {
-    branch: "then" | "else";
-    value: T;
-};
-type SensorControls<T> = {
-    node: Node<T>;
-    push(value: T): void;
-    error(err: unknown): void;
-    complete(): void;
-};
-type LoopOptions = Omit<OrchestrationStepOptions, "deps"> & {
-    iterations?: number | StepRef;
-};
-type SubPipelineBuilder = (sub: Graph) => void;
-/**
- * Creates an orchestration graph container.
- */
-declare function pipeline(name: string, opts?: GraphOptions): Graph;
-/**
- * Registers a workflow task node.
- */
-declare function task<T>(graph: Graph, name: string, run: DerivedFn<T>, opts?: OrchestrationStepOptions): Node<T>;
-/**
- * Emits tagged branch outcomes (`then` / `else`) for each source value.
- */
-declare function branch<T>(graph: Graph, name: string, source: StepRef, predicate: (value: T) => boolean, opts?: Omit<OrchestrationStepOptions, "deps">): Node<BranchResult<T>>;
-type ApprovalOptions = Omit<OrchestrationStepOptions, "deps"> & {
-    isApproved?: (value: unknown) => boolean;
-};
-/**
- * Human/LLM approval gate over a source value.
- */
-declare function approval<T>(graph: Graph, name: string, source: StepRef, approver: StepRef, opts?: ApprovalOptions): Node<T>;
-interface GateOptions {
-    /** Maximum queue size. Oldest values are FIFO-dropped when exceeded. Default: Infinity. */
-    maxPending?: number;
-    /** Start in open mode (auto-approve). Default: false. */
-    startOpen?: boolean;
-    meta?: Record<string, unknown>;
-}
-/** Control surface returned by {@link gate}. */
-interface GateController<T> {
-    /** The output node registered in the graph (subscribe to receive approved values). */
-    node: Node<T>;
-    /** Reactive queue of values waiting for approval. */
-    pending: Node<T[]>;
-    /** Derived count of pending items. */
-    count: Node<number>;
-    /** Whether the gate is currently open (auto-approving). */
-    isOpen: Node<boolean>;
-    /**
-     * Reactive observable of the most recently rejected item, or `null` until
-     * {@link GateController.reject reject} has been called. Subscribe to wire
-     * an audit log, retry-policy hook, or dead-letter sink without having to
-     * intercept `reject()` imperatively. `reject` still drops the value from
-     * the queue; the observation is emitted before the discard so downstream
-     * subscribers see the payload.
-     */
-    lastRejected: Node<T | null>;
-    /** Approve and forward the next `count` pending values (default: 1). */
-    approve(count?: number): void;
-    /** Reject (discard) the next `count` pending values (default: 1). */
-    reject(count?: number): void;
-    /**
-     * Transform and forward `count` pending values (default: 1).
-     * `fn` receives `(value, index, pending)` — Array.map-style.
-     */
-    modify(fn: (value: T, index: number, pending: readonly T[]) => T, count?: number): void;
-    /** Flush all pending values and auto-approve future values. */
-    open(): void;
-    /** Re-enable manual gating (stop auto-approving). */
-    close(): void;
-}
-/**
- * Human-in-the-loop gate: queues incoming values from `source` and lets an external
- * controller {@link GateController.approve approve}, {@link GateController.reject reject},
- * or {@link GateController.modify modify} them before forwarding downstream.
- *
- * Observable surfaces (`pending`, `count`, `isOpen`) are reactive nodes registered in
- * the graph. The gate output node is also registered.
- */
-declare function gate<T>(graph: Graph, name: string, source: StepRef, opts?: GateOptions): GateController<T>;
-/**
- * Registers a join step that emits a tuple of latest dependency values.
- */
-declare function join<T extends readonly unknown[]>(graph: Graph, name: string, deps: {
-    [K in keyof T]: StepRef;
-}, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
-/**
- * Registers a loop step that applies `iterate` to each source value N times.
- */
-declare function loop<T>(graph: Graph, name: string, source: StepRef, iterate: (value: T, iteration: number, actions: NodeActions) => T, opts?: LoopOptions): Node<T>;
-/**
- * Mounts and returns a child workflow graph.
- */
-declare function subPipeline(graph: Graph, name: string, childOrBuild?: Graph | SubPipelineBuilder, opts?: GraphOptions): Graph;
-/**
- * Registers a producer-style sensor source and returns imperative controls.
- */
-declare function sensor<T>(graph: Graph, name: string, initial?: T, opts?: Omit<NodeOptions<unknown>, "name" | "describeKind" | "meta"> & {
-    meta?: Record<string, unknown>;
-}): SensorControls<T>;
-/**
- * Registers an error-recovery step for a source.
- */
-declare function onFailure<T>(graph: Graph, name: string, source: StepRef, recover: (err: unknown, actions: NodeActions) => T, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
-
-type index_ApprovalOptions = ApprovalOptions;
-type index_BranchResult<T> = BranchResult<T>;
-type index_GateController<T> = GateController<T>;
-type index_GateOptions = GateOptions;
-type index_LoopOptions = LoopOptions;
-type index_OrchestrationStepOptions = OrchestrationStepOptions;
-type index_SensorControls<T> = SensorControls<T>;
-type index_StepRef = StepRef;
-type index_SubPipelineBuilder = SubPipelineBuilder;
-declare const index_approval: typeof approval;
-declare const index_branch: typeof branch;
-declare const index_gate: typeof gate;
-declare const index_join: typeof join;
-declare const index_loop: typeof loop;
-declare const index_onFailure: typeof onFailure;
-declare const index_pipeline: typeof pipeline;
-declare const index_sensor: typeof sensor;
-declare const index_subPipeline: typeof subPipeline;
-declare const index_task: typeof task;
-declare namespace index {
-  export { type index_ApprovalOptions as ApprovalOptions, type index_BranchResult as BranchResult, type index_GateController as GateController, type index_GateOptions as GateOptions, type index_LoopOptions as LoopOptions, type index_OrchestrationStepOptions as OrchestrationStepOptions, type index_SensorControls as SensorControls, type index_StepRef as StepRef, type index_SubPipelineBuilder as SubPipelineBuilder, index_approval as approval, index_branch as branch, index_gate as gate, index_join as join, index_loop as loop, index_onFailure as onFailure, index_pipeline as pipeline, index_sensor as sensor, index_subPipeline as subPipeline, index_task as task };
-}
-
-export { type ApprovalOptions as A, type BranchResult as B, type GateController as G, type LoopOptions as L, type OrchestrationStepOptions as O, type SensorControls as S, type GateOptions as a, type StepRef as b, type SubPipelineBuilder as c, approval as d, branch as e, subPipeline as f, gate as g, index as i, join as j, loop as l, onFailure as o, pipeline as p, sensor as s, task as t };

package/dist/index-wcfc7W-f.d.cts

@@ -1,192 +0,0 @@
-import { a as Node } from './node-8qx0kgYt.cjs';
-import { a as GraphOptions, G as Graph } from './graph-DaoydJ_u.cjs';
-
-/**
- * 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.
- *
- * `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;
-    /** V0 identity of the event log node at append time (§6.0b). */
-    v0?: {
-        id: string;
-        version: number;
-    };
-};
-/**
- * Opaque replay cursor returned by `loadEvents`. Pass it back to
- * `loadEvents` to resume from the last position.
- */
-type EventStoreCursor = {
-    readonly __brand?: "EventStoreCursor";
-    [key: string]: unknown;
-};
-/**
- * Result of `loadEvents` — events plus an opaque cursor for resumption.
- */
-type LoadEventsResult = {
-    events: CqrsEvent[];
-    cursor: EventStoreCursor | undefined;
-};
-/**
- * Pluggable persistence for CQRS events.
- *
- * **`persist`:** Must be synchronous. Called from the dispatch path inside
- * `batch()`. Adapters that need async I/O should buffer internally and
- * expose a `flush()` method for explicit drain.
- */
-interface EventStoreAdapter {
-    persist(event: CqrsEvent): void;
-    /**
-     * Load persisted events. When `cursor` is provided, returns only events
-     * after that position. The returned `cursor` should be passed to the next
-     * `loadEvents` call for incremental replay.
-     */
-    loadEvents(eventType: string, cursor?: EventStoreCursor): LoadEventsResult | Promise<LoadEventsResult>;
-    /** Optional explicit flush for adapters with async I/O. */
-    flush?(): Promise<void>;
-}
-declare class MemoryEventStore implements EventStoreAdapter {
-    private readonly _store;
-    persist(event: CqrsEvent): void;
-    loadEvents(eventType: string, cursor?: EventStoreCursor): LoadEventsResult;
-    clear(): void;
-}
-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. The `state` parameter is the
- * original `initial` value on every invocation (full event-sourcing replay),
- * so mutation would corrupt future recomputations.
- */
-type ProjectionReducer<TState = unknown, TEvent = unknown> = (state: TState, events: readonly CqrsEvent<TEvent>[]) => TState;
-type SagaHandler<T = unknown> = (event: CqrsEvent<T>) => void;
-type CqrsOptions = {
-    graph?: GraphOptions;
-};
-declare class CqrsGraph extends Graph {
-    private readonly _eventLogs;
-    private readonly _commandHandlers;
-    private readonly _projections;
-    private readonly _sagas;
-    private readonly _keepaliveDisposers;
-    private _eventStore;
-    private _seq;
-    constructor(name: string, opts?: CqrsOptions);
-    destroy(): void;
-    /**
-     * Register a named event stream backed by `reactiveLog`.
-     * Guard denies external `write` — only commands append internally.
-     */
-    event(name: string): Node<readonly CqrsEvent[]>;
-    /** 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, handler: CommandHandler<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.
-     */
-    dispatch<T = unknown>(commandName: string, payload: T): void;
-    /**
-     * Register a read-only projection derived from event streams.
-     * Guard denies `write` — value is computed from events only.
-     *
-     * **Purity contract:** The `reducer` must be a pure function — it receives
-     * the original `initial` on every invocation (full event-sourcing replay).
-     * Never mutate `initial`; always return a new value.
-     */
-    projection<TState>(name: string, eventNames: readonly string[], reducer: ProjectionReducer<TState>, initial: TState): Node<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>): Node<unknown>;
-    useEventStore(adapter: EventStoreAdapter): void;
-    /**
-     * Replay persisted events through a reducer to rebuild a read model.
-     * Requires an event store adapter wired via `useEventStore()`.
-     */
-    rebuildProjection<TState>(eventNames: readonly string[], reducer: ProjectionReducer<TState>, initial: TState): Promise<TState>;
-}
-/**
- * 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 });
- * });
- * app.projection("orderCount", ["orderPlaced"], (_s, events) => events.length, 0);
- * app.dispatch("placeOrder", { id: "1", amount: 100 });
- * ```
- */
-declare function cqrs(name: string, opts?: CqrsOptions): CqrsGraph;
-
-type index_CommandActions = CommandActions;
-type index_CommandHandler<T = unknown> = CommandHandler<T>;
-type index_CqrsEvent<T = unknown> = CqrsEvent<T>;
-type index_CqrsGraph = CqrsGraph;
-declare const index_CqrsGraph: typeof CqrsGraph;
-type index_CqrsOptions = CqrsOptions;
-type index_EventStoreAdapter = EventStoreAdapter;
-type index_EventStoreCursor = EventStoreCursor;
-type index_LoadEventsResult = LoadEventsResult;
-type index_MemoryEventStore = MemoryEventStore;
-declare const index_MemoryEventStore: typeof MemoryEventStore;
-type index_ProjectionReducer<TState = unknown, TEvent = unknown> = ProjectionReducer<TState, TEvent>;
-type index_SagaHandler<T = unknown> = SagaHandler<T>;
-declare const index_cqrs: typeof cqrs;
-declare namespace index {
-  export { type index_CommandActions as CommandActions, type index_CommandHandler as CommandHandler, type index_CqrsEvent as CqrsEvent, index_CqrsGraph as CqrsGraph, type index_CqrsOptions as CqrsOptions, type index_EventStoreAdapter as EventStoreAdapter, type index_EventStoreCursor as EventStoreCursor, type index_LoadEventsResult as LoadEventsResult, index_MemoryEventStore as MemoryEventStore, type index_ProjectionReducer as ProjectionReducer, type index_SagaHandler as SagaHandler, index_cqrs as cqrs };
-}
-
-export { type CqrsOptions as C, type EventStoreAdapter as E, type LoadEventsResult as L, MemoryEventStore as M, type ProjectionReducer as P, type SagaHandler as S, CqrsGraph as a, type CommandActions as b, type CommandHandler as c, type CqrsEvent as d, type EventStoreCursor as e, cqrs as f, index as i };