@rotorsoft/act 0.33.3 → 0.34.0

package/dist/@types/internal/correlate-cycle.d.ts

@@ -1,73 +0,0 @@
-/**
- * @module correlate-cycle
- * @category Internal
- *
- * Correlation — the discovery half of the correlate→drain pair. Owns the
- * lazy init (subscribe static targets, read cold-start watermark), the
- * dynamic-resolver scan that registers new streams as events arrive, and
- * the periodic timer that drives background discovery.
- *
- * The Act orchestrator passes registry + classification (which static
- * targets to subscribe, whether any dynamic resolvers exist) at build
- * time; everything past that lives here.
- *
- * @internal
- */
-import type { Query, Registry, SchemaRegister, Schemas } from "../types/index.js";
-import type { DrainOps } from "./drain.js";
-/**
- * Static resolver target collected at build time. Subscribed once during
- * init; never re-evaluated.
- *
- * @internal
- */
-export type StaticTarget = {
-    readonly stream: string;
-    readonly source?: string;
-};
-/**
- * Drives correlation for one Act instance. Owns the checkpoint, the
- * subscribed-streams LRU, and the periodic timer.
- *
- * @internal
- */
-export declare class CorrelateCycle<TSchemaReg extends SchemaRegister<TActions>, TEvents extends Schemas, TActions extends Schemas> {
-    private readonly registry;
-    private readonly staticTargets;
-    private readonly hasDynamicResolvers;
-    private readonly cd;
-    private readonly onInit?;
-    private _checkpoint;
-    private _initialized;
-    private _timer;
-    private readonly _subscribed;
-    constructor(registry: Registry<TSchemaReg, TEvents, TActions>, staticTargets: ReadonlyArray<StaticTarget>, hasDynamicResolvers: boolean, cd: DrainOps<TEvents>, maxSubscribedStreams: number, onInit?: (() => void) | undefined);
-    /** Last correlated event id. */
-    get checkpoint(): number;
-    /**
-     * Initialize correlation state on first call.
-     * - Reads max(at) from store as cold-start checkpoint
-     * - Subscribes static resolver targets (idempotent upsert)
-     * - Populates the subscribed-streams LRU
-     * - Fires `onInit` once (Act uses this to flag a cold-start drain)
-     */
-    init(): Promise<void>;
-    /**
-     * Discover dynamic-resolver targets in the events past the checkpoint
-     * and register any new streams via `cd.subscribe`. Static targets are
-     * subscribed at init time, so this only walks dynamic resolvers.
-     */
-    correlate(query?: Query): Promise<{
-        subscribed: number;
-        last_id: number;
-    }>;
-    /**
-     * Start a periodic correlation worker. Returns false if one is already
-     * running. Errors from `correlate()` are routed through `log()` so they
-     * land in the configured logger (the timer keeps running on failure).
-     */
-    startPolling(query?: Query, frequency?: number, callback?: (subscribed: number) => void): boolean;
-    /** Stop the periodic correlation worker. Idempotent. */
-    stopPolling(): void;
-}
-//# sourceMappingURL=correlate-cycle.d.ts.map

package/dist/@types/internal/correlate-cycle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"correlate-cycle.d.ts","sourceRoot":"","sources":["../../../src/internal/correlate-cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EACV,KAAK,EAEL,QAAQ,EACR,cAAc,EACd,OAAO,EACR,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,cAAc,CACzB,UAAU,SAAS,cAAc,CAAC,QAAQ,CAAC,EAC3C,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO;IAQtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,EAAE;IAEnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAX1B,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAyD;IACvE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiB;gBAG1B,QAAQ,EAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,EACjD,aAAa,EAAE,aAAa,CAAC,YAAY,CAAC,EAC1C,mBAAmB,EAAE,OAAO,EAC5B,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,EACtC,oBAAoB,EAAE,MAAM,EACX,MAAM,CAAC,GAAE,MAAM,IAAI,aAAA;IAKtC,gCAAgC;IAChC,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;;;;;OAMG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAY3B;;;;OAIG;IACG,SAAS,CACb,KAAK,GAAE,KAAgC,GACtC,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IA+DnD;;;;OAIG;IACH,YAAY,CACV,KAAK,GAAE,KAAU,EACjB,SAAS,SAAS,EAClB,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,GACtC,OAAO;IAgBV,wDAAwD;IACxD,WAAW,IAAI,IAAI;CAMpB"}

package/dist/@types/internal/drain-cycle.d.ts

@@ -1,113 +0,0 @@
-/**
- * @module drain-cycle
- * @category Internal
- *
- * Two layers of the drain pipeline:
- *
- * - {@link runDrainCycle} — pure function for one round-trip of
- *   claim → fetch → group → dispatch → ack/block. No orchestrator state.
- *   Reusable for property tests and standalone benchmarks.
- *
- * - {@link DrainController} — stateful driver that owns the armed flag,
- *   the concurrency lock, and the adaptive lag/lead ratio. Wraps
- *   `runDrainCycle` with the lifecycle decisions Act used to make inline.
- *
- * @internal
- */
-import type { BatchHandler, BlockedLease, Drain, DrainOptions, Fetch, Lease, Logger, ReactionPayload, Registry, SchemaRegister, Schemas } from "../types/index.js";
-import type { DrainOps } from "./drain.js";
-/**
- * Outcome of processing a single leased stream — produced by Act's `handle`
- * / `handleBatch` dispatchers, consumed by `runDrainCycle` to drive ack/block.
- *
- * @internal
- */
-export type HandleResult = Readonly<{
-    lease: Lease;
-    handled: number;
-    at: number;
-    error?: string;
-    block?: boolean;
-}>;
-/**
- * Per-event reaction dispatcher signature (matches `Act.handle`).
- * @internal
- */
-export type Handle<TEvents extends Schemas> = (lease: Lease, payloads: ReactionPayload<TEvents>[]) => Promise<HandleResult>;
-/**
- * Bulk reaction dispatcher signature (matches `Act.handleBatch`).
- * @internal
- */
-export type HandleBatch<TEvents extends Schemas> = (lease: Lease, payloads: ReactionPayload<TEvents>[], batchHandler: BatchHandler<TEvents>) => Promise<HandleResult>;
-/**
- * One drain cycle's results. Returned by {@link runDrainCycle}; consumed by
- * `Act.drain()` to update lifecycle state, the lag/lead ratio, and emit the
- * `acked` / `blocked` lifecycle events.
- *
- * @internal
- */
-export type DrainCycle<TEvents extends Schemas> = {
-    readonly leased: Lease[];
-    readonly fetched: Fetch<TEvents>;
-    readonly handled: HandleResult[];
-    readonly acked: Lease[];
-    readonly blocked: BlockedLease[];
-};
-/**
- * Run one drain cycle: claim streams, fetch their events, dispatch
- * matching reactions, ack the successes, block the retries-exhausted.
- *
- * Returns `undefined` when nothing was claimed — caller can short-circuit
- * the rest of the drain pass.
- *
- * @internal
- */
-export declare function runDrainCycle<TEvents extends Schemas, TActions extends Schemas, TSchemaReg extends SchemaRegister<TActions>>(ops: DrainOps<TEvents>, registry: Registry<TSchemaReg, TEvents, TActions>, batchHandlers: Map<string, BatchHandler<TEvents>>, handle: Handle<TEvents>, handleBatch: HandleBatch<TEvents>, lagging: number, leading: number, eventLimit: number, leaseMillis: number): Promise<DrainCycle<TEvents> | undefined>;
-/**
- * Dependencies the {@link DrainController} needs from the orchestrator.
- * The lifecycle event sinks (`onAcked` / `onBlocked`) are callbacks so
- * this module doesn't reach back into Act's emitter.
- *
- * @internal
- */
-export type DrainControllerDeps<TEvents extends Schemas, TActions extends Schemas, TSchemaReg extends SchemaRegister<TActions>> = {
-    readonly logger: Logger;
-    readonly ops: DrainOps<TEvents>;
-    readonly registry: Registry<TSchemaReg, TEvents, TActions>;
-    readonly batchHandlers: Map<string, BatchHandler<TEvents>>;
-    readonly handle: Handle<TEvents>;
-    readonly handleBatch: HandleBatch<TEvents>;
-    readonly onAcked: (acked: Lease[]) => void;
-    readonly onBlocked: (blocked: BlockedLease[]) => void;
-};
-/**
- * Stateful driver around {@link runDrainCycle}. Owns:
- *
- * - `_armed`  — has any commit / reset / cold-start signaled work to do?
- * - `_locked` — concurrent-call guard (overlapping `drain()` calls return
- *               an empty result instead of running twice)
- * - `_ratio`  — adaptive lag-to-lead frontier split, updated per cycle
- *
- * The orchestrator owns commits, lifecycle emission, and `arm()` triggers
- * — the controller owns everything between those edges.
- *
- * @internal
- */
-export declare class DrainController<TEvents extends Schemas, TActions extends Schemas, TSchemaReg extends SchemaRegister<TActions>> {
-    private readonly deps;
-    private _armed;
-    private _locked;
-    private _ratio;
-    constructor(deps: DrainControllerDeps<TEvents, TActions, TSchemaReg>);
-    /**
-     * Signal that a commit (or reset / cold-start) may have produced work.
-     * Subsequent `drain()` calls will run the pipeline; once the pipeline
-     * settles to no-progress, the controller disarms itself.
-     */
-    arm(): void;
-    /** Read-only flag — true while a commit / reset is unprocessed. */
-    get armed(): boolean;
-    /** Run one drain pass. Short-circuits when not armed or already running. */
-    drain({ streamLimit, eventLimit, leaseMillis, }?: DrainOptions): Promise<Drain<TEvents>>;
-}
-//# sourceMappingURL=drain-cycle.d.ts.map

package/dist/@types/internal/drain-cycle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drain-cycle.d.ts","sourceRoot":"","sources":["../../../src/internal/drain-cycle.ts"],"names":[],"mappings":"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"}

package/dist/@types/internal/drain-ratio.d.ts

@@ -1,26 +0,0 @@
-/**
- * @module drain-ratio
- * @category Internal
- *
- * Adaptive lag-to-lead ratio for the dual-frontier drain strategy.
- *
- * The orchestrator splits its per-cycle stream budget between two frontiers:
- *
- * - **lagging** — newly subscribed or behind streams catching up.
- * - **leading** — actively-processing streams at the head of the log.
- *
- * After each cycle, this helper looks at how many events were actually
- * handled in each frontier and shifts the next cycle's split toward
- * whichever frontier had the higher per-stream throughput. The result is
- * clamped to `[0.2, 0.8]` so neither frontier can be starved.
- *
- * @internal
- */
-import type { HandleResult } from "./drain-cycle.js";
-/**
- * Compute the next lag-to-lead ratio from the cycle's handled events and
- * the frontier sizes used to claim them. Returns `RATIO_DEFAULT` when no
- * progress was made (nothing to base a decision on).
- */
-export declare function computeLagLeadRatio(handled: ReadonlyArray<HandleResult>, lagging: number, leading: number): number;
-//# sourceMappingURL=drain-ratio.d.ts.map

package/dist/@types/internal/drain-ratio.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drain-ratio.d.ts","sourceRoot":"","sources":["../../../src/internal/drain-ratio.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAQrD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,MAAM,CAYR"}

package/dist/@types/internal/drain.d.ts

@@ -1,41 +0,0 @@
-/**
- * @module drain
- * @category Internal
- *
- * Pipeline operations consumed by the drain/correlate loop. Each op is a
- * single async step the orchestrator invokes per drain cycle:
- *
- * - `claim` — atomically discover and lock streams for processing
- * - `fetch` — read events for each leased stream
- * - `ack` — release leases for successfully handled streams
- * - `block` — flag leases that exceeded the retry budget
- * - `subscribe` — register newly correlated streams with the store
- *
- * This module exposes only the bare implementations as plain async functions,
- * mirroring the shape of {@link "event-sourcing"}. Trace decoration is
- * layered on top in {@link "tracing"} and selected by the orchestrator at
- * construction time. No tracing imports here.
- *
- * @internal
- */
-import type { BlockedLease, Fetch, Lease, Schemas } from "../types/index.js";
-/** @internal */
-export interface DrainOps<TEvents extends Schemas> {
-    claim: typeof claim;
-    fetch: typeof fetch<TEvents>;
-    ack: typeof ack;
-    block: typeof block;
-    subscribe: typeof subscribe;
-}
-export declare const claim: (lagging: number, leading: number, by: string, millis: number) => Promise<Lease[]>;
-export declare function fetch<TEvents extends Schemas>(leased: Lease[], eventLimit: number): Promise<Fetch<TEvents>>;
-export declare const ack: (leases: Lease[]) => Promise<Lease[]>;
-export declare const block: (leases: BlockedLease[]) => Promise<BlockedLease[]>;
-export declare const subscribe: (streams: Array<{
-    stream: string;
-    source?: string;
-}>) => Promise<{
-    subscribed: number;
-    watermark: number;
-}>;
-//# sourceMappingURL=drain.d.ts.map

package/dist/@types/internal/drain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drain.d.ts","sourceRoot":"","sources":["../../../src/internal/drain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EACV,YAAY,EAEZ,KAAK,EACL,KAAK,EACL,OAAO,EACR,MAAM,mBAAmB,CAAC;AAE3B,gBAAgB;AAChB,MAAM,WAAW,QAAQ,CAAC,OAAO,SAAS,OAAO;IAC/C,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,KAAK,EAAE,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC;IAC7B,GAAG,EAAE,OAAO,GAAG,CAAC;IAChB,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,SAAS,EAAE,OAAO,SAAS,CAAC;CAC7B;AAED,eAAO,MAAM,KAAK,GAChB,SAAS,MAAM,EACf,SAAS,MAAM,EACf,IAAI,MAAM,EACV,QAAQ,MAAM,KACb,OAAO,CAAC,KAAK,EAAE,CAAgD,CAAC;AAEnE,wBAAsB,KAAK,CAAC,OAAO,SAAS,OAAO,EACjD,MAAM,EAAE,KAAK,EAAE,EACf,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAYzB;AAED,eAAO,MAAM,GAAG,GAAI,QAAQ,KAAK,EAAE,KAAG,OAAO,CAAC,KAAK,EAAE,CAAwB,CAAC;AAE9E,eAAO,MAAM,KAAK,GAAI,QAAQ,YAAY,EAAE,KAAG,OAAO,CAAC,YAAY,EAAE,CAC9C,CAAC;AAExB,eAAO,MAAM,SAAS,GACpB,SAAS,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,KAClD,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CACxB,CAAC"}

package/dist/@types/internal/event-sourcing.d.ts

@@ -1,96 +0,0 @@
-/**
- * @module event-sourcing
- * @category Internal
- *
- * Pure event-sourcing primitives: `snap` persists state checkpoints, `load`
- * reconstructs state by replaying events through reducers, and `action`
- * validates an action, runs invariants, emits events, and commits them
- * atomically. `tombstone` commits the close-the-books guard with optimistic
- * concurrency.
- *
- * These are the bare implementations — observability is layered on top in
- * {@link "tracing"} and wired by the orchestrator at construction time.
- * No tracing imports here, no module-level mutable state.
- *
- * @internal
- */
-import type { AsOf, Committed, Schema, Schemas, Snapshot, State, Target } from "../types/index.js";
-/** @internal */
-export interface EsOps {
-    snap: typeof snap;
-    load: typeof load;
-    action: typeof action;
-    tombstone: typeof tombstone;
-}
-/**
- * Event sourcing utilities for snapshotting, loading, and committing actions/events.
- * Used internally by Act and state machines.
- */
-/**
- * Saves a snapshot of the state to the store.
- *
- * Snapshots are used to optimize state reconstruction for aggregates with long event streams.
- *
- * @template TState The type of state
- * @template TEvents The type of events
- * @param snapshot The snapshot to save
- * @returns Promise that resolves when the snapshot is saved
- *
- * @example
- * await snap(snapshot);
- */
-export declare function snap<TState extends Schema, TEvents extends Schemas>(snapshot: Snapshot<TState, TEvents>): Promise<void>;
-/**
- * Commits a tombstone event with optimistic concurrency, returning the
- * committed record on success or `undefined` if the stream moved past
- * `expectedVersion` (concurrent write detected). Other store errors
- * propagate.
- *
- * Used by `close()` to guard a stream while archive/truncate runs:
- * subsequent `action()` calls see the tombstone at head and reject with
- * {@link StreamClosedError} until the close completes.
- *
- * @internal
- */
-export declare function tombstone(stream: string, expectedVersion: number, correlation: string): Promise<Committed<Schemas, keyof Schemas> | undefined>;
-/**
- * Loads a snapshot of the state from the store by replaying events and applying patches.
- *
- * First checks the cache for a checkpoint, then queries the store for events
- * committed after the cached position. On cache miss, replays from the store
- * (using snapshots if available to avoid full replay).
- *
- * @template TState The type of state
- * @template TEvents The type of events
- * @template TActions The type of actions
- * @param me The state machine definition
- * @param stream The stream (instance) to load
- * @param callback (Optional) Callback to receive the loaded snapshot as it is built
- * @returns The snapshot of the loaded state
- *
- * @example
- * const snapshot = await load(Counter, "counter1");
- */
-export declare function load<TState extends Schema, TEvents extends Schemas, TActions extends Schemas>(me: State<TState, TEvents, TActions>, stream: string, callback?: (snapshot: Snapshot<TState, TEvents>) => void, asOf?: AsOf): Promise<Snapshot<TState, TEvents>>;
-/**
- * Executes an action and emits an event to be committed by the store.
- *
- * This function validates the action, applies business invariants, emits events, and commits them to the event store.
- *
- * @template TState The type of state
- * @template TEvents The type of events
- * @template TActions The type of actionSchemas
- * @template TKey The type of action to execute
- * @param me The state machine definition
- * @param action The action to execute
- * @param target The target (stream, actor, etc.)
- * @param payload The payload of the action
- * @param reactingTo (Optional) The event that the action is reacting to
- * @param skipValidation (Optional) Whether to skip validation (not recommended)
- * @returns The snapshot of the committed event
- *
- * @example
- * const snapshot = await action(Counter, "increment", { stream: "counter1", actor }, { by: 1 });
- */
-export declare function action<TState extends Schema, TEvents extends Schemas, TActions extends Schemas, TKey extends keyof TActions>(me: State<TState, TEvents, TActions>, action: TKey, target: Target, payload: Readonly<TActions[TKey]>, reactingTo?: Committed<Schemas, keyof Schemas>, skipValidation?: boolean): Promise<Snapshot<TState, TEvents>[]>;
-//# sourceMappingURL=event-sourcing.d.ts.map

package/dist/@types/internal/event-sourcing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"event-sourcing.d.ts","sourceRoot":"","sources":["../../../src/internal/event-sourcing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAUH,OAAO,KAAK,EACV,IAAI,EACJ,SAAS,EAGT,MAAM,EACN,OAAO,EACP,QAAQ,EACR,KAAK,EACL,MAAM,EACP,MAAM,mBAAmB,CAAC;AAG3B,gBAAgB;AAChB,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,OAAO,IAAI,CAAC;IAClB,IAAI,EAAE,OAAO,IAAI,CAAC;IAClB,MAAM,EAAE,OAAO,MAAM,CAAC;IACtB,SAAS,EAAE,OAAO,SAAS,CAAC;CAC7B;AAED;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAsB,IAAI,CAAC,MAAM,SAAS,MAAM,EAAE,OAAO,SAAS,OAAO,EACvE,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,OAAO,CAAC,IAAI,CAAC,CAef;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,SAAS,CAC7B,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,GAAG,SAAS,CAAC,CAaxD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,IAAI,CACxB,MAAM,SAAS,MAAM,EACrB,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EAExB,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,EACpC,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,EACxD,IAAI,CAAC,EAAE,IAAI,GACV,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA0EpC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,MAAM,CAC1B,MAAM,SAAS,MAAM,EACrB,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EACxB,IAAI,SAAS,MAAM,QAAQ,EAE3B,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,EACpC,MAAM,EAAE,IAAI,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EACjC,UAAU,CAAC,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,EAC9C,cAAc,UAAQ,GACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAiItC"}

package/dist/@types/internal/index.d.ts

@@ -1,29 +0,0 @@
-/**
- * @module internal
- * @category Internal
- *
- * Barrel for framework-internal modules. These exports are not part of the
- * public package API and may change between minors. Anything reachable from
- * `@rotorsoft/act`'s top-level barrel (`src/index.ts`) is the public surface;
- * what lives here is implementation detail used by `Act`, the builders, and
- * the orchestrator's pipelines.
- *
- * Only symbols actually consumed *via this barrel* from outside `internal/`
- * are re-exported here. Modules within `internal/` import each other
- * directly by file path; production code in `adapters/` and tests that
- * need bare ops (e.g., `action`, `load`, `LruMap`) likewise import from
- * the specific source file.
- *
- * @internal
- */
-export { classifyRegistry } from "./build-classify.js";
-export { runCloseCycle } from "./close-cycle.js";
-export { CorrelateCycle } from "./correlate-cycle.js";
-export type { DrainOps } from "./drain.js";
-export { DrainController, type Handle, type HandleBatch, } from "./drain-cycle.js";
-export type { EsOps } from "./event-sourcing.js";
-export { _this_, mergeEventRegister, mergeProjection, registerState, } from "./merge.js";
-export { buildHandle, buildHandleBatch } from "./reactions.js";
-export { SettleLoop } from "./settle.js";
-export { buildDrain, buildEs } from "./tracing.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/@types/internal/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/internal/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EACL,eAAe,EACf,KAAK,MAAM,EACX,KAAK,WAAW,GACjB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EACL,MAAM,EACN,kBAAkB,EAClB,eAAe,EACf,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/@types/internal/merge.d.ts

@@ -1,31 +0,0 @@
-import type { Projection } from "../builders/projection-builder.js";
-import type { State } from "../types/index.js";
-/**
- * Registers a state into a states map and action/event registries,
- * merging with existing same-name states (partial state support).
- */
-export declare function registerState(state: State<any, any, any>, states: Map<string, State<any, any, any>>, actions: Record<string, any>, events: Record<string, any>): void;
-/**
- * Merges reactions from one event register into another. The target is
- * assumed to already contain entries for every event name in the source
- * (e.g., act-builder's `.withSlice()` registers the slice's states first,
- * which seeds the target events). Reaction names collide by `set()`
- * semantics — last write wins.
- */
-export declare function mergeEventRegister(target: Record<string, {
-    reactions: Map<string, unknown>;
-}>, source: Record<string, {
-    reactions: Map<string, unknown>;
-}>): void;
-/**
- * Merges a projection's event schemas and reactions into an event registry,
- * deduplicating reaction names by appending "_p" on collision.
- */
-export declare function mergeProjection(proj: Projection<any>, events: Record<string, any>): void;
-export declare const _this_: ({ stream }: {
-    stream: string;
-}) => {
-    source: string;
-    target: string;
-};
-//# sourceMappingURL=merge.d.ts.map

package/dist/@types/internal/merge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../src/internal/merge.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,KAAK,EAAU,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAuDvD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAC3B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EACzC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,IAAI,CAON;AAwHD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,EAC3D,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GAC1D,IAAI,CAQN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,EACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,IAAI,CAiBN;AAGD,eAAO,MAAM,MAAM,GAAI,YAAY;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE;;;CAGnD,CAAC"}

package/dist/@types/internal/reactions.d.ts

@@ -1,54 +0,0 @@
-/**
- * @module reactions
- * @category Internal
- *
- * Reaction dispatch — what runs inside the drain pipeline once `runDrainCycle`
- * has fetched events for a leased stream. Two shapes:
- *
- * - per-event `handle`: walks payloads sequentially, builds a scoped `IAct`
- *   that auto-injects `reactingTo` so handlers don't have to thread it
- *   through manually
- * - bulk `handleBatch`: hands every event for a static-target projection to
- *   a single batch callback, enabling one-transaction replays
- *
- * Both share `_finalize`, which collapses the retry-vs-block decision and
- * the "report error only when nothing was handled" rule.
- *
- * @internal
- */
-import type { Actor, IAct, Logger, Schemas } from "../types/index.js";
-import type { Handle, HandleBatch } from "./drain-cycle.js";
-/**
- * Dependencies a reaction handler needs from the orchestrator: the logger
- * for retry/error breadcrumbs, plus the bound `IAct` methods that the scoped
- * proxy hands to user reaction code.
- *
- * @internal
- */
-export type ReactionDeps<TEvents extends Schemas, TActions extends Schemas, TActor extends Actor = Actor> = {
-    readonly logger: Logger;
-    readonly boundDo: IAct<TEvents, TActions, TActor>["do"];
-    readonly boundLoad: IAct<TEvents, TActions, TActor>["load"];
-    readonly boundQuery: IAct<TEvents, TActions, TActor>["query"];
-    readonly boundQueryArray: IAct<TEvents, TActions, TActor>["query_array"];
-};
-/**
- * Builds the per-event reaction dispatcher passed to `runDrainCycle`.
- *
- * The scoped `IAct` proxy auto-injects the triggering event as `reactingTo`
- * when handlers call `do()` without it (#587), keeping the correlation
- * chain by default. The non-do methods are reused across all dispatches —
- * only `do` rebinds per payload because it captures the triggering event.
- *
- * @internal
- */
-export declare function buildHandle<TEvents extends Schemas, TActions extends Schemas, TActor extends Actor = Actor>(deps: ReactionDeps<TEvents, TActions, TActor>): Handle<TEvents>;
-/**
- * Builds the bulk reaction dispatcher passed to `runDrainCycle`. All events
- * for a static-target projection are handed to a single callback so the
- * projection can do one transaction per drain (catch-up replays especially).
- *
- * @internal
- */
-export declare function buildHandleBatch<TEvents extends Schemas>(logger: Logger): HandleBatch<TEvents>;
-//# sourceMappingURL=reactions.d.ts.map

package/dist/@types/internal/reactions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reactions.d.ts","sourceRoot":"","sources":["../../../src/internal/reactions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EACV,KAAK,EAGL,IAAI,EAEJ,MAAM,EAGN,OAAO,EAER,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAgB,MAAM,kBAAkB,CAAC;AAE1E;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,CACtB,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EACxB,MAAM,SAAS,KAAK,GAAG,KAAK,IAC1B;IACF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;IACxD,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;IAC5D,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC;IAC9D,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC;CAC1E,CAAC;AA6BF;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EACxB,MAAM,SAAS,KAAK,GAAG,KAAK,EAC5B,IAAI,EAAE,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,CAoDhE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,OAAO,EACtD,MAAM,EAAE,MAAM,GACb,WAAW,CAAC,OAAO,CAAC,CA2BtB"}

package/dist/@types/internal/settle.d.ts

@@ -1,60 +0,0 @@
-/**
- * @module settle
- * @category Internal
- *
- * Debounced correlate→drain loop. Sits one level above both correlation
- * and drain: schedule() coalesces rapid callers into a single cycle, then
- * runs correlate+drain in a loop until a pass produces no progress.
- *
- * Owns the debounce timer and the reentrancy flag. Everything else is
- * supplied via the `SettleDeps` callbacks so this module stays free of
- * orchestrator state.
- *
- * @internal
- */
-import type { Drain, DrainOptions, Logger, Query, Schemas, SettleOptions } from "../types/index.js";
-/**
- * Callbacks the settle loop needs from the orchestrator. Modeled as an
- * input bag so this file doesn't import `Act` (avoids a cycle) and stays
- * independently testable.
- *
- * @internal
- */
-export type SettleDeps<TEvents extends Schemas> = {
-    readonly logger: Logger;
-    readonly init: () => Promise<void>;
-    readonly checkpoint: () => number;
-    readonly correlate: (query: Query) => Promise<{
-        subscribed: number;
-        last_id: number;
-    }>;
-    readonly drain: (options: DrainOptions) => Promise<Drain<TEvents>>;
-    readonly onSettled: (drain: Drain<TEvents>) => void;
-};
-/**
- * Drives the debounced correlate→drain catch-up cycle. One instance per
- * Act orchestrator.
- *
- * @internal
- */
-export declare class SettleLoop<TEvents extends Schemas> {
-    private readonly deps;
-    /** Debounce window applied when the caller doesn't override via `SettleOptions.debounceMs`. */
-    private readonly defaultDebounceMs;
-    private _timer;
-    private _running;
-    constructor(deps: SettleDeps<TEvents>, 
-    /** Debounce window applied when the caller doesn't override via `SettleOptions.debounceMs`. */
-    defaultDebounceMs: number);
-    /**
-     * Schedule a settle pass. Multiple calls inside the debounce window
-     * coalesce into one cycle. The cycle runs correlate→drain in a loop
-     * until no progress is made (no new subscriptions, no acks, no blocks)
-     * or `maxPasses` is reached, then emits the `"settled"` lifecycle event
-     * via {@link SettleDeps.onSettled}.
-     */
-    schedule(options?: SettleOptions): void;
-    /** Cancel any pending or active settle cycle. Idempotent. */
-    stop(): void;
-}
-//# sourceMappingURL=settle.d.ts.map

package/dist/@types/internal/settle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"settle.d.ts","sourceRoot":"","sources":["../../../src/internal/settle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,KAAK,EACL,YAAY,EACZ,MAAM,EACN,KAAK,EACL,OAAO,EACP,aAAa,EACd,MAAM,mBAAmB,CAAC;AAE3B;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,OAAO,SAAS,OAAO,IAAI;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,MAAM,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,CAClB,KAAK,EAAE,KAAK,KACT,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;IACnE,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;CACrD,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,UAAU,CAAC,OAAO,SAAS,OAAO;IAK3C,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,+FAA+F;IAC/F,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IANpC,OAAO,CAAC,MAAM,CAAwD;IACtE,OAAO,CAAC,QAAQ,CAAS;gBAGN,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC;IAC1C,+FAA+F;IAC9E,iBAAiB,EAAE,MAAM;IAG5C;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,GAAE,aAAkB,GAAG,IAAI;IA0C3C,6DAA6D;IAC7D,IAAI,IAAI,IAAI;CAMb"}

package/dist/@types/internal/tracing.d.ts

@@ -1,45 +0,0 @@
-/**
- * @module tracing
- * @category Internal
- *
- * Centralized observability for the framework's internal pipelines.
- *
- * Trace decorators wrap a bare implementation with `logger.trace(...)` calls
- * at well-defined moments — entry points for {@link "event-sourcing"} (`load`,
- * `snap`, `action`) and exit points for the {@link "drain"} pipeline (`claim`,
- * `fetch`, `ack`, `block`, `subscribe`). `action` carries both an entry log
- * and a post-commit log to preserve the diagnostic value of the historical
- * mid-function trace points.
- *
- * Output styles:
- * - **Pretty mode** (`config().env !== "production"`) — event-sourcing logs
- *   show only the colored target body (color carries the operation/phase),
- *   drain logs keep a colored caption.
- * - **Plain mode** (production / log aggregators) — every log gets a textual
- *   prefix; event-sourcing uses `caption: body`, drain uses `caption body`.
- *
- * The two factories — {@link buildEs} and {@link buildDrain} — let the
- * orchestrator choose bare or traced variants once at `.build()` time based
- * on the configured log level. Outside this module, no other source file
- * imports tracing primitives.
- *
- * @internal
- */
-import type { Logger, Schemas } from "../types/index.js";
-import type { DrainOps } from "./drain.js";
-import type { EsOps } from "./event-sourcing.js";
-/**
- * Selects bare or traced event-sourcing handlers. Called once by the
- * orchestrator constructor.
- *
- * @internal
- */
-export declare function buildEs(logger: Logger): EsOps;
-/**
- * Selects bare or traced drain-pipeline ops. Called once by the orchestrator
- * constructor.
- *
- * @internal
- */
-export declare function buildDrain<TEvents extends Schemas>(logger: Logger): DrainOps<TEvents>;
-//# sourceMappingURL=tracing.d.ts.map

package/dist/@types/internal/tracing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../../src/internal/tracing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAQ,MAAM,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AA4GjD;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CA+D7C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,SAAS,OAAO,EAChD,MAAM,EAAE,MAAM,GACb,QAAQ,CAAC,OAAO,CAAC,CAyDnB"}