@rotorsoft/act 0.35.1 → 0.35.2

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

@@ -0,0 +1,14 @@
+import "./signals.js";
+/**
+ * @packageDocumentation
+ * @module act
+ * Main entry point for the Act framework. Re-exports all core APIs.
+ */
+export * from "./act.js";
+export * from "./adapters/index.js";
+export * from "./builders/index.js";
+export * from "./config.js";
+export * from "./ports.js";
+export * from "./types/index.js";
+export * from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,CAAC;AAEtB;;;;GAIG;AACH,cAAc,UAAU,CAAC;AACzB,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/@types/internal/build-classify.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @module build-classify
+ * @category Internal
+ *
+ * Build-time classification of the registry + state map. The Act constructor
+ * needs four pre-computed inputs to wire its runtime subsystems:
+ *
+ * - `staticTargets`     — known-up-front reaction targets (statics get
+ *                         subscribed once at init; dynamics scan per event)
+ * - `hasDynamicResolvers` — short-circuit flag for `correlate()`
+ * - `reactiveEvents`    — event names with at least one reaction (drives
+ *                         the drain skip-flag in `do()` and `reset()`)
+ * - `eventToState`      — event-name → owning state, for `close({restart})`
+ *                         seed loading in multi-state apps
+ *
+ * Pure function — single pass over events + states, fully testable without
+ * instantiating Act.
+ *
+ * @internal
+ */
+import type { Registry, Schema, SchemaRegister, Schemas, State } from "../types/index.js";
+import type { StaticTarget } from "./correlate-cycle.js";
+/**
+ * Classification result. Returned by {@link classifyRegistry}; consumed
+ * piecewise by Act's constructor.
+ *
+ * @internal
+ */
+export type Classification = {
+    readonly staticTargets: StaticTarget[];
+    readonly hasDynamicResolvers: boolean;
+    readonly reactiveEvents: ReadonlySet<string>;
+    readonly eventToState: ReadonlyMap<string, State<any, any, any>>;
+};
+/**
+ * Walk the registry once to collect static reaction targets, the dynamic-
+ * resolvers flag, the set of reactive event names, and the event-to-state
+ * map. Static targets are deduplicated by (target, source) — two reactions
+ * routing to the same projection produce one subscription.
+ *
+ * @internal
+ */
+export declare function classifyRegistry<TSchemaReg extends SchemaRegister<TActions>, TEvents extends Schemas, TActions extends Schemas>(registry: Registry<TSchemaReg, TEvents, TActions>, states: ReadonlyMap<string, State<Schema, any, any>>): Classification;
+//# sourceMappingURL=build-classify.d.ts.map

package/dist/@types/internal/build-classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-classify.d.ts","sourceRoot":"","sources":["../../../src/internal/build-classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EACV,QAAQ,EACR,MAAM,EACN,cAAc,EACd,OAAO,EACP,KAAK,EACN,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,aAAa,EAAE,YAAY,EAAE,CAAC;IACvC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7C,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;CAClE,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,SAAS,cAAc,CAAC,QAAQ,CAAC,EAC3C,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EAExB,QAAQ,EAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,EACjD,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,GACnD,cAAc,CA4ChB"}

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

@@ -0,0 +1,38 @@
+/**
+ * @module close-cycle
+ * @category Internal
+ *
+ * Pure orchestration of the close-the-books flow: scan stream heads,
+ * partition by reaction safety, guard with tombstones, optionally seed
+ * restart state, run user archive callbacks, atomically truncate, and
+ * update the cache.
+ *
+ * The Act orchestrator owns lifecycle (correlate gate, emit("closed")) and
+ * the registry-derived inputs (reactive-event count, event→state map). All
+ * sequential phase work between those state touches lives here.
+ *
+ * @internal
+ */
+import type { CloseResult, CloseTarget, Logger, State } from "../types/index.js";
+import type { EsOps } from "./event-sourcing.js";
+/**
+ * Dependencies the close cycle needs from the Act orchestrator. Decoupled
+ * from `Act` itself so the cycle can be exercised from tests in isolation.
+ *
+ * @internal
+ */
+export type CloseCycleDeps = {
+    readonly reactiveEventsSize: number;
+    readonly eventToState: ReadonlyMap<string, State<any, any, any>>;
+    readonly load: EsOps["load"];
+    readonly tombstone: EsOps["tombstone"];
+    readonly logger: Logger;
+};
+/**
+ * Run the full close cycle for the given targets. Caller owns the
+ * lifecycle event emission.
+ *
+ * @internal
+ */
+export declare function runCloseCycle(targets: CloseTarget[], deps: CloseCycleDeps): Promise<CloseResult>;
+//# sourceMappingURL=close-cycle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"close-cycle.d.ts","sourceRoot":"","sources":["../../../src/internal/close-cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,MAAM,EAEN,KAAK,EACN,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACjE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAcF;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,WAAW,EAAE,EACtB,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,WAAW,CAAC,CAmDtB"}

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

@@ -0,0 +1,78 @@
+/**
+ * @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.
+ *
+ * @property priority - Scheduling priority for the resolved target stream.
+ *   Combined with peers via `max()` at build time when multiple reactions
+ *   target the same stream — see `build-classify.ts`.
+ *
+ * @internal
+ */
+export type StaticTarget = {
+    readonly stream: string;
+    readonly source?: string;
+    readonly priority?: number;
+};
+/**
+ * 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

@@ -0,0 +1 @@
+{"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;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,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;IA8EnD;;;;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

@@ -0,0 +1,113 @@
+/**
+ * @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

@@ -0,0 +1 @@
+{"version":3,"file":"drain-cycle.d.ts","sourceRoot":"","sources":["../../../src/internal/drain-cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,KAAK,EACL,YAAY,EACZ,KAAK,EACL,KAAK,EACL,MAAM,EACN,eAAe,EACf,QAAQ,EACR,cAAc,EACd,OAAO,EACR,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,MAAM,CAAC,OAAO,SAAS,OAAO,IAAI,CAC5C,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,KACjC,OAAO,CAAC,YAAY,CAAC,CAAC;AAE3B;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,OAAO,SAAS,OAAO,IAAI,CACjD,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,EACpC,YAAY,EAAE,YAAY,CAAC,OAAO,CAAC,KAChC,OAAO,CAAC,YAAY,CAAC,CAAC;AAE3B;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,OAAO,SAAS,OAAO,IAAI;IAChD,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,YAAY,EAAE,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,YAAY,EAAE,CAAC;CAClC,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EACxB,UAAU,SAAS,cAAc,CAAC,QAAQ,CAAC,EAE3C,GAAG,EAAE,QAAQ,CAAC,OAAO,CAAC,EACtB,QAAQ,EAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,EACjD,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,EACjD,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EACvB,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,EACjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,CAqE1C;AAgBD;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,CAC7B,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EACxB,UAAU,SAAS,cAAc,CAAC,QAAQ,CAAC,IACzC;IACF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3D,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,IAAI,CAAC;IAC3C,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,IAAI,CAAC;CACvD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAe,CAC1B,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EACxB,UAAU,SAAS,cAAc,CAAC,QAAQ,CAAC;IAOzC,OAAO,CAAC,QAAQ,CAAC,IAAI;IALvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAO;gBAGF,IAAI,EAAE,mBAAmB,CAAC,OAAO,EAAE,QAAQ,EAAE,UAAU,CAAC;IAG3E;;;;OAIG;IACH,GAAG,IAAI,IAAI;IAIX,mEAAmE;IACnE,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,4EAA4E;IACtE,KAAK,CAAC,EACV,WAAgB,EAChB,UAAe,EACf,WAAoB,GACrB,GAAE,YAAiB,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;CAgD/C"}

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

@@ -0,0 +1,26 @@
+/**
+ * @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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,41 @@
+/**
+ * @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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,96 @@
+/**
+ * @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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,29 @@
+/**
+ * @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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,54 @@
+/**
+ * @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

@@ -0,0 +1 @@
+{"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"}