@graphrefly/graphrefly 0.43.0 → 0.45.0

package/dist/index-BwLvVVsy.d.cts

@@ -1,189 +0,0 @@
-import { N as Node } from './node-ClS5yC-B.cjs';
-import { B as BaseAuditRecord } from './index-C9pjcz3l.cjs';
-import { a as ReactiveLogBundle } from './reactive-log-B00laMSQ.cjs';
-import { NodeInput } from './extra/sources.cjs';
-import { AppendLogStorageTier } from './extra/storage-tiers.cjs';
-import { G as Graph, a as GraphOptions } from './graph-C4SHb3Ly.cjs';
-
-/**
- * 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;
-};
-/** Audit record for a job-queue mutation (Audit 2 cross-cutting). */
-type JobEventAction = "enqueue" | "claim" | "ack" | "nack" | "remove";
-interface JobEvent<T = unknown> extends BaseAuditRecord {
-    readonly action: JobEventAction;
-    readonly id: string;
-    readonly attempts?: number;
-    readonly payload?: T;
-}
-/** Recommended `keyOf` for keyed-storage adapters (Audit 2 #7). */
-declare const jobEventKeyOf: <T>(e: JobEvent<T>) => string;
-type JobQueueOptions = {
-    graph?: GraphOptions;
-};
-declare class JobQueueGraph<T> extends Graph {
-    private readonly _pending;
-    private readonly _jobs;
-    private readonly _seqCursor;
-    readonly pending: Node<readonly string[]>;
-    readonly jobs: Node<ReadonlyMap<string, JobEnvelope<T>>>;
-    readonly depth: Node<number>;
-    /** Audit log of every queue mutation (Audit 2). */
-    readonly events: ReactiveLogBundle<JobEvent<T>>;
-    /** Alias for {@link JobQueueGraph.events} — Audit 2 `.audit` duplication. */
-    readonly audit: ReactiveLogBundle<JobEvent<T>>;
-    private readonly _enqueueImpl;
-    private readonly _ackImpl;
-    private readonly _nackImpl;
-    private readonly _removeByIdImpl;
-    constructor(name: string, opts?: JobQueueOptions);
-    /**
-     * Wire append-log storage tiers (Audit 4). Returns a disposer.
-     *
-     * Named `attachEventStorage` to avoid colliding with {@link Graph.attachSnapshotStorage}.
-     */
-    attachEventStorage(tiers: readonly AppendLogStorageTier<JobEvent<T>>[]): () => void;
-    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;
-    /**
-     * Subscribe to a Node and enqueue each DATA payload into this queue.
-     * Returns a disposer that stops consuming when called.
-     *
-     * Used internally by {@link JobFlowGraph} for stage-to-stage wiring but
-     * also useful for users wiring an external source into a job queue.
-     *
-     * @param source - Node whose DATA values are enqueued.
-     * @param opts - Optional enqueue options (id generator, metadata prefix).
-     */
-    consumeFrom(source: Node<T>, opts?: {
-        metadata?: Record<string, unknown>;
-    }): () => void;
-}
-/**
- * Work function for a job flow stage. Receives the full job envelope,
- * returns a `NodeInput<T>` — raw value (sync), Promise (async), or Node
- * (composed pipeline). `fromAny` coerces any of these shapes.
- *
- * On error / rejection: the stage nacks the job (no requeue by default).
- */
-type WorkFn<T> = (job: JobEnvelope<T>) => NodeInput<T>;
-/**
- * Stage definition for {@link JobFlowGraph}. Either a bare name string
- * (no work hook, pure pass-through) or a full definition object.
- */
-type StageDef<T> = string | {
-    name: string;
-    work?: WorkFn<T>;
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-    /**
-     * Per-stage cap on `claim → work → ack` cycles per pump tick.
-     * Overrides {@link JobFlowOptions.maxPerPump} for this stage. Useful
-     * when stages have asymmetric cost (e.g. an LLM-execute stage capped
-     * at 4 concurrent calls while a cheap verify stage runs unbounded).
-     *
-     * Falls back to the top-level `JobFlowOptions.maxPerPump`, which in
-     * turn falls back to `DEFAULT_MAX_PER_PUMP` (256).
-     */
-    maxPerPump?: number;
-};
-type JobFlowOptions<T = unknown> = {
-    graph?: GraphOptions;
-    /**
-     * Stage definitions. Each stage is either a bare name string (pure
-     * pass-through) or a `{ name, work?, handlerVersion?, maxPerPump? }` object.
-     *
-     * For back-compat, `string[]` values behave as stages with no work hook.
-     */
-    stages?: readonly StageDef<T>[];
-    /**
-     * Default cap on claims per pump tick across all stages. Per-stage
-     * overrides can be set on each {@link StageDef.maxPerPump}; if neither is
-     * set, falls back to `DEFAULT_MAX_PER_PUMP` (256).
-     */
-    maxPerPump?: number;
-};
-declare class JobFlowGraph<T> extends Graph {
-    private readonly _stageNames;
-    private readonly _stageWorkFns;
-    private readonly _queues;
-    private readonly _completed;
-    readonly completed: Node<readonly JobEnvelope<T>[]>;
-    readonly completedCount: Node<number>;
-    constructor(name: string, opts?: JobFlowOptions<T>);
-    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<T>): JobFlowGraph<T>;
-
-type index_JobEnvelope<T> = JobEnvelope<T>;
-type index_JobEvent<T = unknown> = JobEvent<T>;
-type index_JobEventAction = JobEventAction;
-type index_JobFlowGraph<T> = JobFlowGraph<T>;
-declare const index_JobFlowGraph: typeof JobFlowGraph;
-type index_JobFlowOptions<T = unknown> = JobFlowOptions<T>;
-type index_JobQueueGraph<T> = JobQueueGraph<T>;
-declare const index_JobQueueGraph: typeof JobQueueGraph;
-type index_JobQueueOptions = JobQueueOptions;
-type index_JobState = JobState;
-type index_StageDef<T> = StageDef<T>;
-type index_WorkFn<T> = WorkFn<T>;
-declare const index_jobEventKeyOf: typeof jobEventKeyOf;
-declare const index_jobFlow: typeof jobFlow;
-declare const index_jobQueue: typeof jobQueue;
-declare namespace index {
-  export { type index_JobEnvelope as JobEnvelope, type index_JobEvent as JobEvent, type index_JobEventAction as JobEventAction, index_JobFlowGraph as JobFlowGraph, type index_JobFlowOptions as JobFlowOptions, index_JobQueueGraph as JobQueueGraph, type index_JobQueueOptions as JobQueueOptions, type index_JobState as JobState, type index_StageDef as StageDef, type index_WorkFn as WorkFn, index_jobEventKeyOf as jobEventKeyOf, index_jobFlow as jobFlow, index_jobQueue as jobQueue };
-}
-
-export { type JobEnvelope as J, type StageDef as S, type WorkFn as W, JobFlowGraph as a, JobQueueGraph as b, type JobEvent as c, type JobEventAction as d, type JobFlowOptions as e, type JobQueueOptions as f, type JobState as g, jobFlow as h, index as i, jobEventKeyOf as j, jobQueue as k };

package/dist/index-C59mYFKp.d.ts

@@ -1,121 +0,0 @@
-import { i as index$2 } from './index-Dmqp7KjD.js';
-import { i as index$3 } from './index-CCq87F7t.js';
-import { i as index$4 } from './index-cm1GNcWE.js';
-import { i as index$5 } from './index-BG0BN3PB.js';
-import { N as Node } from './node-ClS5yC-B.js';
-import { i as index$6 } from './index-CJK1JkYy.js';
-import { i as index$7 } from './index-DIOoAZUX.js';
-import { i as index$8 } from './index-CvrqGfNS.js';
-import { i as index$9 } from './index-C7O6r5fV.js';
-
-/**
- * Options for creating signals.
- *
- * @category compat
- */
-interface SignalOptions {
-    /** Optional identifier for the underlying node. */
-    name?: string;
-    /** Custom equality function for change detection. */
-    equals?: (a: any, b: any) => boolean;
-}
-/**
- * Common interface for all reactive signals.
- *
- * @category compat
- */
-interface AnySignal<T> {
-    /** Returns the current value of the signal. */
-    get(): T;
-    /** @internal The underlying GraphReFly node. */
-    _node: Node<T>;
-}
-/**
- * TC39 `Signal.State` — a writable signal backed by a GraphReFly `state` node.
- * Automatically registers itself as a dependency if read inside a `Computed`.
- *
- * @example
- * ```ts
- * const count = new Signal.State(0);
- * count.get(); // 0
- * count.set(1);
- * count.get(); // 1
- * ```
- */
-declare class SignalState<T> implements AnySignal<T> {
-    /** @internal */
-    _node: Node<T>;
-    private readonly _equals;
-    constructor(initial: T, opts?: SignalOptions);
-    get(): T;
-    set(value: T): void;
-}
-/**
- * TC39 `Signal.Computed` — a read-only signal backed by `dynamicNode`.
- * Automatically tracks dependencies when `get()` is called on other signals
- * during its computation.
- *
- * @example
- * ```ts
- * const count = new Signal.State(0);
- * const doubled = new Signal.Computed(() => count.get() * 2);
- * ```
- */
-declare class SignalComputed<T> implements AnySignal<T> {
-    /** @internal */
-    _node: Node<T>;
-    constructor(computation: () => T, opts?: SignalOptions);
-    get(): T;
-}
-/**
- * TC39 Signals-compatible namespace. Wraps GraphReFly primitives.
- * Provides auto-tracking conforming to the TS39 signals proposal.
- *
- * @category compat
- */
-declare const Signal: {
-    readonly State: typeof SignalState;
-    readonly Computed: typeof SignalComputed;
-    /**
-     * Subscribes to changes on a signal.
-     * Returns an unsubscribe callback.
-     *
-     * @example
-     * ```ts
-     * const count = new Signal.State(0);
-     * const unsub = Signal.sub(count, v => console.log(v));
-     * ```
-     */
-    readonly sub: <T>(signal: AnySignal<T>, callback: ((value: T) => void) | {
-        data?: (value: T) => void;
-        error?: (err: unknown) => void;
-        complete?: () => void;
-    }) => (() => void);
-};
-
-type index$1_AnySignal<T> = AnySignal<T>;
-declare const index$1_Signal: typeof Signal;
-type index$1_SignalComputed<T> = SignalComputed<T>;
-declare const index$1_SignalComputed: typeof SignalComputed;
-type index$1_SignalOptions = SignalOptions;
-type index$1_SignalState<T> = SignalState<T>;
-declare const index$1_SignalState: typeof SignalState;
-declare namespace index$1 {
-  export { type index$1_AnySignal as AnySignal, index$1_Signal as Signal, index$1_SignalComputed as SignalComputed, type index$1_SignalOptions as SignalOptions, index$1_SignalState as SignalState };
-}
-
-/**
- * Compat layer: compatibility wrappers for other state management libraries (Phase 5.1b).
- *
- * Framework adapters are optional peers. Install only what you use:
- * - `@graphrefly/graphrefly-ts/compat/react` -> `react`, `react-dom`
- * - `@graphrefly/graphrefly-ts/compat/vue` -> `vue`
- * - `@graphrefly/graphrefly-ts/compat/svelte` -> `svelte`
- * - `@graphrefly/graphrefly-ts/compat/solid` -> `solid-js`
- */
-
-declare namespace index {
-  export { index$2 as jotai, index$3 as nanostores, index$4 as nestjs, index$5 as react, index$1 as signals, index$6 as solid, index$7 as svelte, index$8 as vue, index$9 as zustand };
-}
-
-export { index$1 as a, index as i };

package/dist/index-C7O6r5fV.d.ts

@@ -1,37 +0,0 @@
-import { G as Graph } from './graph-7VguS7a4.js';
-
-/** Zustand-compatible Store API. */
-interface StoreApi<T> {
-    getState: () => T;
-    setState: (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean) => void;
-    getInitialState: () => T;
-    subscribe: (listener: (state: T, prevState: T) => void) => () => void;
-    destroy: () => void;
-}
-/** Function type for initializing the store. */
-type StateCreator<T> = (set: StoreApi<T>["setState"], get: StoreApi<T>["getState"], api: StoreApi<T>) => T;
-/**
- * Creates a Zustand-compatible store backed by a GraphReFly state node.
- * returns an object that is both a Graph and a StoreApi.
- *
- * @example
- * ```ts
- * const store = create((set) => ({
- *   count: 0,
- *   inc: () => set((s) => ({ count: s.count + 1 }))
- * }));
- * store.getState().inc();
- * ```
- *
- * @category compat
- */
-declare function create<T extends object>(initializer: StateCreator<T>): Graph & StoreApi<T>;
-
-type index_StateCreator<T> = StateCreator<T>;
-type index_StoreApi<T> = StoreApi<T>;
-declare const index_create: typeof create;
-declare namespace index {
-  export { type index_StateCreator as StateCreator, type index_StoreApi as StoreApi, index_create as create };
-}
-
-export { type StateCreator as S, type StoreApi as a, create as c, index as i };

package/dist/index-C9kSENB4.d.cts

@@ -1,127 +0,0 @@
-import { N as Node } from './node-ClS5yC-B.cjs';
-
-/**
- * A Nanostores-compatible atom.
- *
- * @category compat
- */
-interface NanoAtom<T> {
-    /** Get current value. */
-    get(): T;
-    /** Set a new value (writable atoms only). */
-    set(value: T): void;
-    /** Subscribe to value changes. Callback receives the new value.
-     * Returns unsubscribe function. Called immediately with current value. */
-    subscribe(cb: (value: T) => void): () => void;
-    /** Listen to value changes (no immediate call). Returns unsubscribe. */
-    listen(cb: (value: T) => void): () => void;
-    /** The underlying GraphReFly node. */
-    readonly _node: Node<T>;
-}
-/**
- * A Nanostores-compatible computed store.
- *
- * @category compat
- */
-interface NanoComputed<T> {
-    /** Get current value. */
-    get(): T;
-    /** Subscribe to value changes. Called immediately with current value.
-     * Returns unsubscribe function. */
-    subscribe(cb: (value: T) => void): () => void;
-    /** Listen to value changes (no immediate call). Returns unsubscribe. */
-    listen(cb: (value: T) => void): () => void;
-    /** The underlying GraphReFly node. */
-    readonly _node: Node<T>;
-}
-/**
- * A Nanostores-compatible map.
- *
- * @category compat
- */
-interface NanoMap<T extends Record<string, unknown>> extends NanoAtom<T> {
-    /** Set a single key. */
-    setKey<K extends keyof T>(key: K, value: T[K]): void;
-}
-/**
- * Creates a nanostores-compatible atom.
- *
- * @param initial - Initial value.
- * @returns `NanoAtom<T>`
- *
- * @category compat
- */
-declare function atom<T>(initial: T): NanoAtom<T>;
-/**
- * Creates a nanostores-compatible computed store.
- *
- * @param stores - One or more atoms/computed stores.
- * @param fn - Compute function.
- * @returns `NanoComputed<T>`
- *
- * @category compat
- */
-declare function computed<T, A>(storeA: NanoAtom<A> | NanoComputed<A>, fn: (a: A) => T): NanoComputed<T>;
-declare function computed<T, A, B>(stores: [NanoAtom<A> | NanoComputed<A>, NanoAtom<B> | NanoComputed<B>], fn: (a: A, b: B) => T): NanoComputed<T>;
-declare function computed<T, A, B, C>(stores: [
-    NanoAtom<A> | NanoComputed<A>,
-    NanoAtom<B> | NanoComputed<B>,
-    NanoAtom<C> | NanoComputed<C>
-], fn: (a: A, b: B, c: C) => T): NanoComputed<T>;
-/**
- * Creates a nanostores-compatible map.
- *
- * @param initial - Initial object value.
- * @returns `NanoMap<T>`
- *
- * @category compat
- */
-declare function map<T extends Record<string, unknown>>(initial: T): NanoMap<T>;
-/**
- * Returns the current value of the store.
- *
- * @category compat
- */
-declare function getValue<T>(store: NanoAtom<T> | NanoComputed<T>): T;
-/**
- * Adds a listener for the store start (first listener connected).
- *
- * @category compat
- */
-declare function onStart(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
-/**
- * Adds a listener for the store stop (last listener disconnected).
- *
- * @category compat
- */
-declare function onStop(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
-/**
- * Adds a listener for the store mount (first listener connected).
- *
- * @returns A cleanup function called when the last listener is removed.
- * @category compat
- */
-declare function onMount(store: NanoAtom<any> | NanoComputed<any>, cb: () => (() => void) | undefined): void;
-/**
- * Batches multiple store updates.
- *
- * @category compat
- */
-declare function action<Args extends any[], Return>(_store: NanoAtom<any> | NanoComputed<any>, _name: string, fn: (...args: Args) => Return): (...args: Args) => Return;
-
-type index_NanoAtom<T> = NanoAtom<T>;
-type index_NanoComputed<T> = NanoComputed<T>;
-type index_NanoMap<T extends Record<string, unknown>> = NanoMap<T>;
-declare const index_action: typeof action;
-declare const index_atom: typeof atom;
-declare const index_computed: typeof computed;
-declare const index_getValue: typeof getValue;
-declare const index_map: typeof map;
-declare const index_onMount: typeof onMount;
-declare const index_onStart: typeof onStart;
-declare const index_onStop: typeof onStop;
-declare namespace index {
-  export { type index_NanoAtom as NanoAtom, type index_NanoComputed as NanoComputed, type index_NanoMap as NanoMap, index_action as action, index_atom as atom, index_computed as computed, index_getValue as getValue, index_map as map, index_onMount as onMount, index_onStart as onStart, index_onStop as onStop };
-}
-
-export { type NanoAtom as N, type NanoComputed as a, type NanoMap as b, action as c, atom as d, computed as e, onStart as f, getValue as g, onStop as h, index as i, map as m, onMount as o };

package/dist/index-C9pjcz3l.d.cts

@@ -1,209 +0,0 @@
-import { b as NodeGuard, N as Node } from './node-ClS5yC-B.cjs';
-import { G as Graph } from './graph-C4SHb3Ly.cjs';
-import { R as ReactiveLogOptions, a as ReactiveLogBundle } from './reactive-log-B00laMSQ.cjs';
-
-/**
- * Audited-mutation framework (Audit 2 — locked 2026-04-24; promoted to
- * `extra/mutation/` per consolidation plan §1, Tier 2.2).
- *
- * Phase-4 primitives share the same shape: imperative mutation methods +
- * closure state + reactive audit log + freeze-at-entry + rollback-on-throw.
- * This module factors out the common machinery so each primitive becomes
- * declarative wiring over typed audit records:
- *  - `approvalGate`, `pipeline.approvalGate`  (Wave A.2 Unit 8)
- *  - `JobQueueGraph`                          (Wave B.3 Unit 15)
- *  - `CqrsGraph.dispatch`                     (Wave C.2 Unit 20)
- *  - `CqrsGraph.saga`                         (Wave C.3 Unit 22)
- *  - `processManager`                         (Wave 7)
- */
-
-/**
- * Bounded increment for a self-owned counter state node.
- *
- * Reads `counter.cache`, bumps by 1 if under `cap`, writes back. Returns
- * `false` when the cap is reached. Documented P3 exception: the counter is
- * not a declared dep of the caller — it's a private budget read+written from
- * a single call site. This helper keeps the `.cache` access in one named
- * place.
- *
- * **Safety today:**
- *   1. Single-threaded JS runner never invokes the caller concurrently.
- *   2. `counter.down` writes the cache synchronously before returning, so
- *      synchronous re-entry through a downstream publish reads the
- *      freshly-incremented value — no double-count.
- *
- * **Future risk:** under a free-threaded runner (PY no-GIL or hypothetical
- * concurrent TS runner), two concurrent firings could still race. Revisit
- * when that surfaces.
- */
-declare function tryIncrementBounded(counter: Node<number>, cap: number): boolean;
-/** Shared base shape for every audit record. Per-primitive types extend this. */
-interface BaseAuditRecord {
-    readonly t_ns: number;
-    readonly seq?: number;
-    readonly handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-}
-/**
- * Allow `observe` and `signal`; deny external `write` on the audit log so
- * consumers can subscribe + signal-bridge but cannot inject fake records.
- */
-declare const DEFAULT_AUDIT_GUARD: NodeGuard;
-type AuditLogOpts<R extends BaseAuditRecord> = {
-    name: string;
-    /** Bounded retention; default 1024 per Audit 2 / cross-cutting bounded-default policy. */
-    retainedLimit?: number;
-    /** Override the default audit guard. */
-    guard?: NodeGuard;
-    /** Mount the audit `entries` Node under this graph (and activate withLatest). */
-    graph?: Graph;
-    /** Pass-through to {@link reactiveLog}. */
-    versioning?: ReactiveLogOptions<R>["versioning"];
-};
-/**
- * Build a reactive audit log with sane defaults: bounded retention, deny-write
- * guard, `withLatest()` companions activated. Returns the {@link ReactiveLogBundle}
- * directly — primitives expose this as `<primitive>.events` / `.decisions` /
- * `.dispatches` / `.invocations` and alias it as `.audit`.
- *
- * @category internal
- */
-declare function createAuditLog<R extends BaseAuditRecord>(opts: AuditLogOpts<R>): ReactiveLogBundle<R>;
-type FailureMeta = {
-    t_ns: number;
-    seq?: number;
-    errorType: string;
-};
-type SuccessMeta = {
-    t_ns: number;
-    seq?: number;
-};
-/** Common opts shared by both tiers. */
-type MutationOpts<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord> = {
-    /**
-     * Optional audit log. When omitted, the wrapper still provides freeze /
-     * seq-advance / rollback-on-throw (`wrapMutation`) but skips audit-record
-     * emission entirely — useful for primitives that want centralized mutation
-     * semantics without a dedicated audit log surface (e.g. `Topic.publish`).
-     * Pair with `onSuccess` / `onFailure` to emit records.
-     */
-    audit?: ReactiveLogBundle<R>;
-    /** Build the success record from the action's args + result + meta. */
-    onSuccess?: (args: TArgs, result: TResult, meta: SuccessMeta) => R | undefined;
-    /** Build the failure record from the args + error + meta. */
-    onFailure?: (args: TArgs, error: unknown, meta: FailureMeta) => R | undefined;
-    /** Freeze inputs at entry (default `true`). Pass `false` for hot paths. */
-    freeze?: boolean;
-    /** Optional sequence cursor — auto-advanced and stamped onto records. */
-    seq?: Node<number>;
-    /** Optional handler version — stamped into the record (Audit 5). */
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-};
-type WrapMutationOpts<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord> = MutationOpts<TArgs, TResult, R>;
-type LightMutationOpts<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord> = MutationOpts<TArgs, TResult, R>;
-declare function bumpCursor(seq: Node<number>): number;
-/**
- * Build a record via the supplied builder, stamp `handlerVersion` if present,
- * and append it to the audit log. `undefined` records are skipped (callers
- * pass an `onSuccess` / `onFailure` that returns `undefined` to opt out per
- * call).
- *
- * @category internal
- */
-declare function appendAudit<TArgs extends readonly unknown[], TValue, R extends BaseAuditRecord, M extends SuccessMeta | FailureMeta>(audit: ReactiveLogBundle<R>, builder: (args: TArgs, value: TValue, meta: M) => R | undefined, args: TArgs, value: TValue, meta: M, handlerVersion?: {
-    id: string;
-    version: string | number;
-}): void;
-/**
- * Substrate-tier wrapper: run `action`, optionally append a typed audit record
- * on success or failure, advance an optional `seq` cursor. No batch frame —
- * this is the hot-path-friendly variant for atomic single-write mutations.
- *
- * Behavior contract:
- * 1. Freeze args at entry (default `true`; opt out with `freeze: false` for
- *    hot paths — e.g. wrapping `vectorIndex.upsert(id, vector[768], meta)`
- *    where the deep-freeze of a 768-dim vector is a measurable tax).
- * 2. Bump `seq` (if provided) BEFORE the action runs. There is no batch frame,
- *    so the bump persists even on throw — the failure-audit record stamps the
- *    same `seq` so audit consumers see a contiguous sequence.
- * 3. Run `action(args)`. On success, if `audit` is provided AND `onSuccess`
- *    is set, `appendAudit(onSuccess, ...)`.
- * 4. On throw, if `audit` is provided AND `onFailure` is set,
- *    `appendAudit(onFailure, ...)` then re-throw. When `audit` is omitted the
- *    wrapper still provides freeze + seq + re-throw semantics — useful for
- *    primitives that want centralized mutation contracts without an audit log
- *    surface (e.g. `Topic.publish`).
- *
- * **Distinguish from {@link wrapMutation}:** `wrapMutation` opens a `batch()`
- * frame (rollback-on-throw, seq advance discarded on rollback) and is the
- * right choice when the action runs a user-supplied handler or a multi-step
- * sequence that could leave inconsistent state mid-throw.
- *
- * **Cursor / log alignment caveat (substrate-tier):** `seq` is bumped BEFORE
- * `action()` runs, and the audit-log append happens AFTER. There is no batch
- * frame, so a synchronous subscriber to `seq` that fires between the two —
- * including a subscriber on `audit.entries` itself if the substrate causes
- * it to fire transitively — observes `seq=N` while the corresponding record
- * is not yet in the log. Audit consumers that join `seq` and `audit.entries`
- * reactively must tolerate this one-tick lag, or use {@link wrapMutation}
- * (whose `batch()` frame defers downstream delivery until commit, so cursor
- * and log appear together to subscribers). The same caveat applies to
- * **re-entrant** invocation: if an `audit.entries` / `seq` subscriber
- * triggers another `lightMutation`, the inner record can land on the log
- * before the outer call's success/failure record.
- *
- * @category internal
- */
-declare function lightMutation<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord>(action: (...args: TArgs) => TResult, opts: LightMutationOpts<TArgs, TResult, R>): (...args: TArgs) => TResult;
-/**
- * Orchestration-tier wrapper: like {@link lightMutation} but adds a `batch()`
- * frame around the action so an in-flight throw rolls back partial state.
- *
- * Behavior contract:
- *  1. Freeze args at entry (default `true`).
- *  2. Open a batch frame (rollback-on-throw via core batch — Audit 2 #6).
- *  3. Bump `seq` INSIDE the batch so a framework-level rollback discards the
- *     cursor advance (cursor stays in sync with audit log). M5.
- *  4. Run `action(args)` and capture result.
- *  5. On success: if `audit` is provided AND `onSuccess` is set,
- *     `appendAudit(onSuccess, ...)` inside the batch.
- *  6. On throw: catch OUTSIDE the batch so the failure record (if any) emits
- *     in a fresh transaction after rollback — it persists. Re-throw so callers
- *     see the failure. When `audit` is omitted the wrapper still provides
- *     batch + freeze + rollback + re-throw semantics — useful for primitives
- *     that want orchestration-tier mutation contracts without an audit log
- *     surface.
- *
- * **Distinguish from the file-private `wrapMutation` in
- * `src/extra/reactive-map.ts:540`:** that helper is a transactional wrapper
- * for the reactiveMap version counter (`pre/post-version` snapshot diffing,
- * read vs. mutation gating). Different concern, file-private, not exported.
- * This `wrapMutation` is the public Phase-4 audit framework.
- *
- * @category internal
- */
-declare function wrapMutation<TArgs extends readonly unknown[], TResult, R extends BaseAuditRecord>(action: (...args: TArgs) => TResult, opts: WrapMutationOpts<TArgs, TResult, R>): (...args: TArgs) => TResult;
-/**
- * Promote a closure counter to a state node mounted under `graph`.
- * Replaces ad-hoc `let _seq = 0` patterns with a node observable in
- * `describe()` and persistable via storage tiers.
- *
- * @category internal
- */
-declare function registerCursor(graph: Graph, name: string, initial?: number): Node<number>;
-/**
- * Promote a closure `Map<K, number>` to N state nodes (one per key) mounted
- * under `<graph>::<name>::<key>`. Used by saga (per-event-type cursor).
- *
- * @category internal
- */
-declare function registerCursorMap<K extends string>(graph: Graph, name: string, keys: readonly K[], initial?: number): {
-    readonly [P in K]: Node<number>;
-};
-
-export { type AuditLogOpts as A, type BaseAuditRecord as B, DEFAULT_AUDIT_GUARD as D, type FailureMeta as F, type LightMutationOpts as L, type MutationOpts as M, type SuccessMeta as S, type WrapMutationOpts as W, appendAudit as a, bumpCursor as b, createAuditLog as c, registerCursorMap as d, lightMutation as l, registerCursor as r, tryIncrementBounded as t, wrapMutation as w };