@rotorsoft/act 1.4.0 → 1.5.0

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

@@ -99,11 +99,32 @@ export type ActOptions<TLanes extends string = string> = {
     readonly correlator?: Correlator;
     /** Restrict this process to a subset of declared lanes (ACT-1103). */
     readonly onlyLanes?: ReadonlyArray<TLanes>;
+    /**
+     * Subscribe to {@link Store.notify} on this instance (#803). Defaults
+     * to `true`. Set `false` on instances that only commit and never
+     * react — the subscriber-connection budget is the practical scaling
+     * ceiling for the notify/listen pattern, and writer-only fleets
+     * spend it for nothing when they subscribe to a channel they never
+     * read. Commits still emit notifications (that's part of the
+     * store's commit protocol); only the subscriber side is gated.
+     */
+    readonly listen?: boolean;
+    /**
+     * Run the local reaction pipeline on this instance (#803). Defaults
+     * to `true`. Set `false` on writer-only or sidecar instances: drain
+     * controllers' auto-cycle workers don't start, `correlate()` /
+     * `drain()` / `settle()` become no-ops, and the notify handler
+     * skips its drain-wakeup arm (but still emits the `notified`
+     * lifecycle event so observability sidecars work).
+     */
+    readonly drain?: boolean;
 };
 export declare class Act<TSchemaReg extends SchemaRegister<TActions>, TEvents extends Schemas, TActions extends Schemas, TStateMap extends Record<string, Schema> = Record<string, never>, TActor extends Actor = Actor> implements IAct<TEvents, TActions, TActor> {
-    readonly registry: Registry<TSchemaReg, TEvents, TActions>;
-    private readonly _states;
     private _emitter;
+    /** #803: gate the `Store.notify` subscription side. */
+    private readonly _listen;
+    /** #803: gate the local reaction pipeline (drain controllers, settle, correlate). */
+    private readonly _drain;
     /** Event names with at least one registered reaction (computed at build time) */
     private readonly _reactive_events;
     /** One DrainController per active lane, keyed by lane name. */
@@ -126,6 +147,10 @@ export declare class Act<TSchemaReg extends SchemaRegister<TActions>, TEvents ex
      * construction time — late injection after build is unsupported.
      */
     private readonly _notify_disposer;
+    /** Public registry — kept as-is per the no-prefix-on-public convention. */
+    readonly registry: Registry<TSchemaReg, TEvents, TActions>;
+    /** Map of state name → state definition; populated by the builder. */
+    private readonly _states;
     /**
      * Emit a lifecycle event. The payload type is inferred from the event name
      * via {@link ActLifecycleEvents}.
@@ -210,7 +235,7 @@ export declare class Act<TSchemaReg extends SchemaRegister<TActions>, TEvents ex
      *   these from `.withLane(...)` calls. Slice 1 records them on the
      *   instance; later slices fan out one `DrainController` per lane.
      */
-    constructor(registry: Registry<TSchemaReg, TEvents, TActions>, _states?: Map<string, State<any, any, any>>, batchHandlers?: Map<string, BatchHandler<any>>, options?: ActOptions, lanes?: ReadonlyArray<LaneConfig>);
+    constructor(registry: Registry<TSchemaReg, TEvents, TActions>, states?: Map<string, State<any, any, any>>, batchHandlers?: Map<string, BatchHandler<any>>, options?: ActOptions, lanes?: ReadonlyArray<LaneConfig>);
     /** True after the first `shutdown()` call. Guards idempotency. */
     private _shutdown_promise;
     /**

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

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

package/dist/@types/adapters/in-memory-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory-store.d.ts","sourceRoot":"","sources":["../../../src/adapters/in-memory-store.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"in-memory-store.d.ts","sourceRoot":"","sources":["../../../src/adapters/in-memory-store.ts"],"names":[],"mappings":"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"}

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

@@ -38,16 +38,16 @@ export type StaticTarget = {
  * @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);
+    private readonly _registry;
+    private readonly _static_targets;
+    private readonly _has_dynamic_resolvers;
+    private readonly _cd;
+    private readonly _on_init;
+    constructor(registry: Registry<TSchemaReg, TEvents, TActions>, staticTargets: ReadonlyArray<StaticTarget>, hasDynamicResolvers: boolean, cd: DrainOps<TEvents>, maxSubscribedStreams: number, onInit?: () => void);
     /** Last correlated event id. */
     get checkpoint(): number;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"correlate-cycle.d.ts","sourceRoot":"","sources":["../../../src/internal/correlate-cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EACV,KAAK,EAEL,QAAQ,EACR,cAAc,EACd,OAAO,EACR,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;;;;;;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;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,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;IAiFnD;;;;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"}
+{"version":3,"file":"correlate-cycle.d.ts","sourceRoot":"","sources":["../../../src/internal/correlate-cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EACV,KAAK,EAEL,QAAQ,EACR,cAAc,EACd,OAAO,EACR,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;;;;;;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;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,cAAc,CACzB,UAAU,SAAS,cAAc,CAAC,QAAQ,CAAC,EAC3C,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO;IAExB,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAyD;IACvE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiB;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;IACpE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA8B;IAC9D,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAU;IACjD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAoB;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2B;gBAGlD,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,EACrB,oBAAoB,EAAE,MAAM,EAC5B,MAAM,CAAC,EAAE,MAAM,IAAI;IAUrB,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;IAiFnD;;;;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

@@ -132,7 +132,6 @@ export type DrainControllerDeps<TEvents extends Schemas, TActions extends Schema
  * @internal
  */
 export declare class DrainController<TEvents extends Schemas, TActions extends Schemas, TSchemaReg extends SchemaRegister<TActions>> {
-    private readonly deps;
     private _armed;
     private _locked;
     private _ratio;
@@ -148,6 +147,7 @@ export declare class DrainController<TEvents extends Schemas, TActions extends S
     /** Worker timer (ACT-1103). Set when `start()` is active, undefined otherwise. */
     private _worker;
     private _stopped;
+    private readonly _deps;
     constructor(deps: DrainControllerDeps<TEvents, TActions, TSchemaReg>);
     /**
      * Signal that a commit (or reset / cold-start) may have produced work.

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

@@ -1 +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;AAI3C;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,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;;;;;;;;;;;;;;;;GAgBG;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,EACnB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,EACxC,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,CAiG1C;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;IACtD,2FAA2F;IAC3F,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAClB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;KAC/B,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAe,CAC1B,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EACxB,UAAU,SAAS,cAAc,CAAC,QAAQ,CAAC;IAmBzC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAjBvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAO;IACrB;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAA6B;IAC7C,qEAAqE;IACrE,OAAO,CAAC,aAAa,CAA4C;IACjE,kFAAkF;IAClF,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,QAAQ,CAAS;gBAGN,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,uEAAuE;IACvE,OAAO,CAAC,UAAU,CAGhB;IAEF;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAwB3B,yEAAyE;IACzE,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAkB5B,4CAA4C;IAC5C,IAAI,IAAI,IAAI;IAQZ,4EAA4E;IACtE,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;CA8EjE"}
+{"version":3,"file":"drain-cycle.d.ts","sourceRoot":"","sources":["../../../src/internal/drain-cycle.ts"],"names":[],"mappings":"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"}

package/dist/@types/internal/lru-map.d.ts

@@ -21,9 +21,9 @@
  * @internal
  */
 export declare class LruMap<K, V> {
-    private readonly _maxSize;
     private readonly _entries;
-    constructor(_maxSize: number);
+    private readonly _max_size;
+    constructor(maxSize: number);
     get(key: K): V | undefined;
     has(key: K): boolean;
     set(key: K, value: V): void;

package/dist/@types/internal/lru-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lru-map.d.ts","sourceRoot":"","sources":["../../../src/internal/lru-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;GAKG;AACH,qBAAa,MAAM,CAAC,CAAC,EAAE,CAAC;IAGV,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAFrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;gBAEf,QAAQ,EAAE,MAAM;IAE7C,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAS1B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAW3B,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIvB,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;;;;;GAMG;AACH,qBAAa,MAAM,CAAC,CAAC;IACnB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;gBAE3B,OAAO,EAAE,MAAM;IAI3B,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAItB,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAInB,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAIzB,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}
+{"version":3,"file":"lru-map.d.ts","sourceRoot":"","sources":["../../../src/internal/lru-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;GAKG;AACH,qBAAa,MAAM,CAAC,CAAC,EAAE,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,OAAO,EAAE,MAAM;IAI3B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAS1B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAW3B,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIvB,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;;;;;GAMG;AACH,qBAAa,MAAM,CAAC,CAAC;IACnB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;gBAE3B,OAAO,EAAE,MAAM;IAI3B,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAItB,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAInB,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAIzB,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

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

@@ -38,14 +38,12 @@ export type SettleDeps<TEvents extends Schemas> = {
  * @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>, 
+    private readonly _deps;
     /** Debounce window applied when the caller doesn't override via `SettleOptions.debounceMs`. */
-    defaultDebounceMs: number);
+    private readonly _default_debounce_ms;
+    constructor(deps: SettleDeps<TEvents>, defaultDebounceMs: number);
     /**
      * Schedule a settle pass. Multiple calls inside the debounce window
      * coalesce into one cycle. The cycle runs correlate→drain in a loop

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

@@ -1 +1 @@
-{"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"}
+{"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;IAC7C,OAAO,CAAC,MAAM,CAAwD;IACtE,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;IAC5C,+FAA+F;IAC/F,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;gBAElC,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,iBAAiB,EAAE,MAAM;IAKhE;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,GAAE,aAAkB,GAAG,IAAI;IA0C3C,6DAA6D;IAC7D,IAAI,IAAI,IAAI;CAMb"}

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

@@ -64,13 +64,7 @@ export declare class ValidationError extends Error {
     readonly payload: any;
     /** Zod validation error details */
     readonly details: any;
-    constructor(
-    /** The type of target being validated (e.g., "action", "event") */
-    target: string, 
-    /** The invalid payload that failed validation */
-    payload: any, 
-    /** Zod validation error details */
-    details: any);
+    constructor(target: string, payload: any, details: any);
 }
 /**
  * Thrown when a business rule (invariant) is violated during action execution.
@@ -152,17 +146,7 @@ export declare class InvariantError<TState extends Schema, TEvents extends Schem
     readonly snapshot: Snapshot<TState, TEvents>;
     /** Human-readable description of why the invariant failed */
     readonly description: string;
-    constructor(
-    /** The action that was attempted */
-    action: TKey, 
-    /** The action payload that was provided */
-    payload: Readonly<TActions[TKey]>, 
-    /** The target stream and actor context */
-    target: Target<TActor>, 
-    /** The current state snapshot when invariant was checked */
-    snapshot: Snapshot<TState, TEvents>, 
-    /** Human-readable description of why the invariant failed */
-    description: string);
+    constructor(action: TKey, payload: Readonly<TActions[TKey]>, target: Target<TActor>, snapshot: Snapshot<TState, TEvents>, description: string);
 }
 /**
  * Thrown when optimistic concurrency control detects a conflict.
@@ -242,15 +226,7 @@ export declare class ConcurrencyError extends Error {
     readonly events: Message<Schemas, keyof Schemas>[];
     /** The version number that was expected */
     readonly expectedVersion: number;
-    constructor(
-    /** The stream that had the concurrent modification */
-    stream: string, 
-    /** The actual current version in the store */
-    lastVersion: number, 
-    /** The events that were being committed */
-    events: Message<Schemas, keyof Schemas>[], 
-    /** The version number that was expected */
-    expectedVersion: number);
+    constructor(stream: string, lastVersion: number, events: Message<Schemas, keyof Schemas>[], expectedVersion: number);
 }
 /**
  * Thrown when attempting to write to a stream that has been closed
@@ -278,9 +254,7 @@ export declare class ConcurrencyError extends Error {
 export declare class StreamClosedError extends Error {
     /** The stream that is closed */
     readonly stream: string;
-    constructor(
-    /** The stream that is closed */
-    stream: string);
+    constructor(stream: string);
 }
 /**
  * Thrown by a reaction handler to signal that the failure is permanent

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/types/errors.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/types/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,OAAO,EACP,MAAM,EACN,OAAO,EACP,QAAQ,EACR,MAAM,EACP,MAAM,aAAa,CAAC;AAErB;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM;;;;;;CAMT,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,mEAAmE;IACnE,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,iDAAiD;IACjD,SAAgB,OAAO,EAAE,GAAG,CAAC;IAC7B,mCAAmC;IACnC,SAAgB,OAAO,EAAE,GAAG,CAAC;gBAEjB,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG;CAOvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,qBAAa,cAAc,CACzB,MAAM,SAAS,MAAM,EACrB,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EACxB,IAAI,SAAS,MAAM,QAAQ,EAC3B,MAAM,SAAS,KAAK,GAAG,KAAK,CAC5B,SAAQ,KAAK;IACb,oCAAoC;IACpC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,0CAA0C;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7C,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAG3B,MAAM,EAAE,IAAI,EACZ,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EACjC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EACtB,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,WAAW,EAAE,MAAM;CAUtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,sDAAsD;IACtD,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,8CAA8C;IAC9C,SAAgB,WAAW,EAAE,MAAM,CAAC;IACpC,2CAA2C;IAC3C,SAAgB,MAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,EAAE,CAAC;IAC1D,2CAA2C;IAC3C,SAAgB,eAAe,EAAE,MAAM,CAAC;gBAGtC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,EAAE,EACzC,eAAe,EAAE,MAAM;CAmB1B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,gCAAgC;IAChC,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEnB,MAAM,EAAE,MAAM;CAK3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,8EAA8E;IAC9E,SAAyB,KAAK,CAAC,EAAE,OAAO,CAAC;gBAE7B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAK3D"}

package/dist/{chunk-XKCTGUW2.js → chunk-I4L224TZ.js}

@@ -3,7 +3,7 @@ import {
   Environments,
   LogLevels,
   ValidationError
-} from "./chunk-TZWDSNSN.js";
+} from "./chunk-PMAZTOSO.js";
 
 // src/adapters/console-logger.ts
 var LEVEL_VALUES = {
@@ -131,10 +131,11 @@ var ConsoleLogger = class _ConsoleLogger {
 
 // src/internal/lru-map.ts
 var LruMap = class {
-  constructor(_maxSize) {
-    this._maxSize = _maxSize;
-  }
   _entries = /* @__PURE__ */ new Map();
+  _max_size;
+  constructor(maxSize) {
+    this._max_size = maxSize;
+  }
   get(key) {
     const v = this._entries.get(key);
     if (v === void 0) return void 0;
@@ -147,7 +148,7 @@ var LruMap = class {
   }
   set(key, value) {
     this._entries.delete(key);
-    if (this._entries.size >= this._maxSize) {
+    if (this._entries.size >= this._max_size) {
       const oldest = this._entries.keys().next().value;
       this._entries.delete(oldest);
     }
@@ -249,12 +250,8 @@ async function sleep(ms) {
 
 // src/adapters/in-memory-store.ts
 var InMemoryStream = class {
-  constructor(stream, source, priority = 0, lane = DEFAULT_LANE) {
-    this.stream = stream;
-    this.source = source;
-    this._priority = priority;
-    this._lane = lane;
-  }
+  stream;
+  source;
   _at = -1;
   _retry = -1;
   _blocked = false;
@@ -263,6 +260,12 @@ var InMemoryStream = class {
   _leased_until = void 0;
   _priority = 0;
   _lane = DEFAULT_LANE;
+  constructor(stream, source, priority = 0, lane = DEFAULT_LANE) {
+    this.stream = stream;
+    this.source = source;
+    this._priority = priority;
+    this._lane = lane;
+  }
   get priority() {
     return this._priority;
   }
@@ -1090,4 +1093,4 @@ export {
   TOMBSTONE_EVENT,
   DEFAULT_LANE
 };
-//# sourceMappingURL=chunk-XKCTGUW2.js.map
+//# sourceMappingURL=chunk-I4L224TZ.js.map

package/dist/chunk-I4L224TZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/console-logger.ts","../src/internal/lru-map.ts","../src/adapters/in-memory-cache.ts","../src/config.ts","../src/ports.ts","../src/utils.ts","../src/adapters/in-memory-store.ts"],"sourcesContent":["/**\n * @module adapters/console-logger\n *\n * High-performance console logger inspired by pino's design:\n * - Numeric level comparison for O(1) gating\n * - stdout.write() in production for raw JSON lines (no console overhead)\n * - Colorized single-line output in development\n * - No-op method replacement when level is above threshold\n * - Child logger support with merged bindings\n */\nimport type { Logger } from \"../types/index.js\";\n\nconst LEVEL_VALUES: Record<string, number> = {\n  fatal: 60,\n  error: 50,\n  warn: 40,\n  info: 30,\n  debug: 20,\n  trace: 10,\n};\n\nconst LEVEL_COLORS: Record<string, string> = {\n  fatal: \"\\x1b[41m\\x1b[37m\", // white on red bg\n  error: \"\\x1b[31m\", // red\n  warn: \"\\x1b[33m\", // yellow\n  info: \"\\x1b[32m\", // green\n  debug: \"\\x1b[36m\", // cyan\n  trace: \"\\x1b[90m\", // gray\n};\n\nconst RESET = \"\\x1b[0m\";\n\nconst noop = () => {};\n\n/**\n * Default console logger for the Act framework.\n *\n * Production mode emits newline-delimited JSON (compatible with GCP, AWS\n * CloudWatch, Datadog, and other structured log ingestion systems).\n *\n * Development mode emits colorized, human-readable output.\n */\nexport class ConsoleLogger implements Logger {\n  level: string;\n  private readonly _pretty: boolean;\n\n  readonly fatal: Logger[\"fatal\"];\n  readonly error: Logger[\"error\"];\n  readonly warn: Logger[\"warn\"];\n  readonly info: Logger[\"info\"];\n  readonly debug: Logger[\"debug\"];\n  readonly trace: Logger[\"trace\"];\n\n  constructor(\n    options: {\n      level?: string;\n      pretty?: boolean;\n      bindings?: Record<string, unknown>;\n    } = {}\n  ) {\n    const {\n      level = \"info\",\n      pretty = process.env.NODE_ENV !== \"production\",\n      bindings,\n    } = options;\n    this._pretty = pretty;\n    this.level = level;\n\n    const threshold = LEVEL_VALUES[level] ?? 30;\n    const write = pretty\n      ? this._prettyWrite.bind(this, bindings)\n      : this._jsonWrite.bind(this, bindings);\n\n    // Assign methods — noop when level is gated (like pino's level-based replacement)\n    this.fatal = write.bind(this, \"fatal\", 60); // fatal is always enabled\n    this.error = threshold <= 50 ? write.bind(this, \"error\", 50) : noop;\n    this.warn = threshold <= 40 ? write.bind(this, \"warn\", 40) : noop;\n    this.info = threshold <= 30 ? write.bind(this, \"info\", 30) : noop;\n    this.debug = threshold <= 20 ? write.bind(this, \"debug\", 20) : noop;\n    this.trace = threshold <= 10 ? write.bind(this, \"trace\", 10) : noop;\n  }\n\n  /** No-op — `console.log` has no resources to release. */\n  async dispose(): Promise<void> {}\n\n  /** @inheritDoc */\n  child(bindings: Record<string, unknown>): Logger {\n    return new ConsoleLogger({\n      level: this.level,\n      pretty: this._pretty,\n      bindings,\n    });\n  }\n\n  private _jsonWrite(\n    bindings: Record<string, unknown> | undefined,\n    level: string,\n    _num: number,\n    objOrMsg: unknown,\n    msg?: string\n  ): void {\n    let obj: Record<string, unknown>;\n    let message: string | undefined;\n\n    if (typeof objOrMsg === \"string\") {\n      message = objOrMsg;\n      obj = {};\n    } else if (objOrMsg instanceof Error) {\n      // Error instances spread to `{}` — capture the salient fields\n      // explicitly so structured log aggregators see them.\n      message = msg ?? objOrMsg.message;\n      obj = {\n        error: { message: objOrMsg.message, name: objOrMsg.name },\n        stack: objOrMsg.stack,\n      };\n    } else if (objOrMsg !== null && typeof objOrMsg === \"object\") {\n      message = msg;\n      obj = { ...(objOrMsg as Record<string, unknown>) };\n    } else {\n      message = msg;\n      obj = { value: objOrMsg };\n    }\n\n    const entry = Object.assign({ level, time: Date.now() }, bindings, obj);\n    if (message) entry.msg = message;\n\n    let line: string;\n    try {\n      line = JSON.stringify(entry);\n    } catch {\n      // Cyclic or unserializable payload — emit a minimal line rather\n      // than crash the log call site.\n      line = JSON.stringify({\n        level,\n        time: entry.time,\n        msg: message ?? \"[unserializable]\",\n        unserializable: true,\n      });\n    }\n    process.stdout.write(line + \"\\n\");\n  }\n\n  private _prettyWrite(\n    bindings: Record<string, unknown> | undefined,\n    level: string,\n    _num: number,\n    objOrMsg: unknown,\n    msg?: string\n  ): void {\n    const color = LEVEL_COLORS[level];\n    const tag = `${color}${level.toUpperCase().padEnd(5)}${RESET}`;\n    const ts = new Date().toISOString().slice(11, 23); // HH:mm:ss.SSS\n\n    let message: string;\n    let data: string | undefined;\n\n    if (typeof objOrMsg === \"string\") {\n      message = objOrMsg;\n    } else if (objOrMsg instanceof Error) {\n      // Error instances don't serialize their `message`/`stack` via\n      // JSON.stringify — `JSON.stringify(err) === \"{}\"`. Render the\n      // message inline and the stack as the data payload so operators\n      // see something useful instead of an empty object.\n      message = msg ?? objOrMsg.message;\n      data = objOrMsg.stack;\n    } else {\n      message = msg ?? \"\";\n      if (objOrMsg !== undefined && objOrMsg !== null) {\n        try {\n          data = JSON.stringify(objOrMsg);\n        } catch {\n          data = \"[unserializable]\";\n        }\n      }\n    }\n\n    const bindStr =\n      bindings && Object.keys(bindings).length\n        ? ` ${JSON.stringify(bindings)}`\n        : \"\";\n\n    const parts = [ts, tag, message, data, bindStr].filter(Boolean);\n    process.stdout.write(parts.join(\" \") + \"\\n\");\n  }\n}\n","/**\n * @module lru-map\n * @category Internal\n *\n * Tiny bounded LRU map / set built on insertion-ordered `Map`. Used to cap\n * memory in long-running orchestrators that mint large numbers of keys —\n * notably:\n *\n * - {@link InMemoryCache}: stream → state checkpoint\n * - `Act._subscribed_streams`: stream → presence (LruSet)\n *\n * Apps with millions of dynamic streams (one target per aggregate) can't\n * afford an unbounded `Set<string>` — eviction is required.\n *\n * @internal\n */\n\n/**\n * Bounded LRU map. `get()` promotes; `has()` does not. `set()` always\n * promotes and evicts the oldest entry when at capacity.\n *\n * @internal\n */\nexport class LruMap<K, V> {\n  private readonly _entries = new Map<K, V>();\n  private readonly _max_size: number;\n\n  constructor(maxSize: number) {\n    this._max_size = maxSize;\n  }\n\n  get(key: K): V | undefined {\n    const v = this._entries.get(key);\n    if (v === undefined) return undefined;\n    // promote: delete + re-insert moves to most-recent position\n    this._entries.delete(key);\n    this._entries.set(key, v);\n    return v;\n  }\n\n  has(key: K): boolean {\n    return this._entries.has(key);\n  }\n\n  set(key: K, value: V): void {\n    this._entries.delete(key);\n    if (this._entries.size >= this._max_size) {\n      // size >= maxSize ≥ 1 → at least one entry exists → next().value\n      // is the oldest key (asserted with `!`).\n      const oldest = this._entries.keys().next().value!;\n      this._entries.delete(oldest);\n    }\n    this._entries.set(key, value);\n  }\n\n  delete(key: K): boolean {\n    return this._entries.delete(key);\n  }\n\n  clear(): void {\n    this._entries.clear();\n  }\n\n  get size(): number {\n    return this._entries.size;\n  }\n}\n\n/**\n * Bounded LRU set built on top of {@link LruMap}. `has()` does not promote;\n * `add()` does (re-inserting if already present, evicting the oldest at\n * capacity).\n *\n * @internal\n */\nexport class LruSet<T> {\n  private readonly _map: LruMap<T, true>;\n\n  constructor(maxSize: number) {\n    this._map = new LruMap(maxSize);\n  }\n\n  has(value: T): boolean {\n    return this._map.has(value);\n  }\n\n  add(value: T): void {\n    this._map.set(value, true);\n  }\n\n  delete(value: T): boolean {\n    return this._map.delete(value);\n  }\n\n  clear(): void {\n    this._map.clear();\n  }\n\n  get size(): number {\n    return this._map.size;\n  }\n}\n","import { LruMap } from \"../internal/lru-map.js\";\nimport type { Cache, CacheEntry, Schema } from \"../types/index.js\";\n\n/**\n * In-memory LRU cache for stream snapshots.\n *\n * Backed by an internal `LruMap` for O(1) get/set with LRU eviction.\n * Configurable `maxSize` bounds memory usage.\n *\n * @example\n * ```typescript\n * import { cache } from \"@rotorsoft/act\";\n * import { InMemoryCache } from \"@rotorsoft/act\";\n *\n * cache(new InMemoryCache({ maxSize: 500 }));\n * ```\n */\n/* eslint-disable @typescript-eslint/require-await -- async interface for Redis-compatibility */\nexport class InMemoryCache implements Cache {\n  // CacheEntry<any> lets `get<TState>` and `set<TState>` flow without casts:\n  // any is bidirectionally compatible with the per-call TState binding, while\n  // the public Cache interface still presents a typed surface to callers.\n  private readonly _entries: LruMap<string, CacheEntry<any>>;\n\n  constructor(options?: { maxSize?: number }) {\n    this._entries = new LruMap(options?.maxSize ?? 1000);\n  }\n\n  /** @inheritDoc */\n  async get<TState extends Schema>(\n    stream: string\n  ): Promise<CacheEntry<TState> | undefined> {\n    return this._entries.get(stream);\n  }\n\n  /** @inheritDoc */\n  async set<TState extends Schema>(\n    stream: string,\n    entry: CacheEntry<TState>\n  ): Promise<void> {\n    this._entries.set(stream, entry);\n  }\n\n  /** @inheritDoc */\n  async invalidate(stream: string): Promise<void> {\n    this._entries.delete(stream);\n  }\n\n  /** @inheritDoc */\n  async clear(): Promise<void> {\n    this._entries.clear();\n  }\n\n  /** @inheritDoc */\n  async dispose(): Promise<void> {\n    this._entries.clear();\n  }\n\n  /** Current number of entries held by the LRU. */\n  get size(): number {\n    return this._entries.size;\n  }\n}\n","/**\n * @packageDocumentation\n * Configuration utilities for Act Framework environment, logging, and package metadata.\n *\n * Provides type-safe configuration loading and validation using Zod schemas.\n *\n * @module config\n */\nimport * as fs from \"node:fs\";\nimport { z } from \"zod\";\nimport { log } from \"./ports.js\";\nimport {\n  type Environment,\n  Environments,\n  type LogLevel,\n  LogLevels,\n} from \"./types/index.js\";\nimport { extend } from \"./utils.js\";\n\n/**\n * Zod schema for validating package.json metadata.\n * @internal\n */\nexport const PackageSchema = z.object({\n  name: z.string().min(1),\n  version: z.string().min(1),\n  description: z.string().min(1).optional(),\n  author: z\n    .object({ name: z.string().min(1), email: z.string().optional() })\n    .optional()\n    .or(z.string().min(1))\n    .optional(),\n  license: z.string().min(1).optional(),\n  dependencies: z.record(z.string(), z.string()).optional(),\n});\n\n/**\n * Type representing the validated package.json metadata.\n *\n * @internal\n */\nexport type Package = z.infer<typeof PackageSchema>;\n\n/**\n * Fallback package metadata when `package.json` can't be read at module\n * load — happens when the framework is consumed from a CWD that doesn't\n * have one (bundled CLIs, Lambda layers, embedded scripts) or when the\n * file exists but is malformed.\n *\n * The values are deliberately synthetic so callers spot them immediately:\n * `config().name === \"act-fallback\"` is a runtime signal that the framework\n * couldn't load the host project's package.json.\n *\n * @internal\n */\nconst FALLBACK_PACKAGE: Package = {\n  name: \"act-fallback\",\n  version: \"0.0.0-fallback\",\n  description: \"Synthetic fallback — package.json could not be loaded\",\n};\n\n/**\n * Loads and parses the local package.json file as a Package object. On\n * any read or parse failure, falls back to {@link FALLBACK_PACKAGE} and\n * stashes the error so {@link config} can surface it on first access —\n * we can't call `log()` here because the logger port memoizes on first\n * call and locking it at module load defeats user injection.\n *\n * @internal\n */\nconst getPackage = (): Package => {\n  try {\n    const raw = fs.readFileSync(\"package.json\");\n    return JSON.parse(raw.toString()) as Package;\n  } catch (err) {\n    pkgLoadError = err;\n    return FALLBACK_PACKAGE;\n  }\n};\n\n/** Stashed read/parse error from {@link getPackage}, surfaced by config(). */\nlet pkgLoadError: unknown;\n\n/**\n * Zod schema for the full Act Framework configuration object.\n * Includes package metadata, environment, logging, and timing options.\n * @internal\n */\nconst BaseSchema = PackageSchema.extend({\n  env: z.enum(Environments),\n  logLevel: z.enum(LogLevels),\n  logSingleLine: z.boolean(),\n  sleepMs: z.number().int().min(0).max(5000),\n});\n\n/**\n * Type representing the validated Act Framework configuration object.\n */\nexport type Config = z.infer<typeof BaseSchema>;\n\nconst { NODE_ENV, LOG_LEVEL, LOG_SINGLE_LINE, SLEEP_MS } = process.env;\n\nconst env = (NODE_ENV || \"development\") as Environment;\nconst logLevel = (LOG_LEVEL ||\n  (NODE_ENV === \"test\"\n    ? \"fatal\"\n    : NODE_ENV === \"production\"\n      ? \"info\"\n      : \"trace\")) as LogLevel;\nconst logSingleLine = (LOG_SINGLE_LINE || \"true\") === \"true\";\nconst sleepMs = parseInt(NODE_ENV === \"test\" ? \"0\" : (SLEEP_MS ?? \"100\"), 10);\n\nconst pkg = getPackage();\n\n// Lazily validated on first call. Cannot run extend() at module load\n// because of a utils.ts <-> config.ts cycle (utils imports config for\n// sleep()'s default). Inputs are frozen after import, so the cached\n// result is stable for the life of the process.\nlet _validated: Config | undefined;\n\n/**\n * Gets the current Act Framework configuration.\n *\n * Configuration is loaded from package.json and environment variables, providing\n * type-safe access to application metadata and runtime settings.\n *\n * **Environment Variables:**\n * - `NODE_ENV`: \"development\" | \"test\" | \"staging\" | \"production\" (default: \"development\")\n * - `LOG_LEVEL`: \"fatal\" | \"error\" | \"warn\" | \"info\" | \"debug\" | \"trace\"\n * - `LOG_SINGLE_LINE`: \"true\" | \"false\" (default: \"true\")\n * - `SLEEP_MS`: Milliseconds for sleep utility (default: 100, 0 for tests)\n *\n * **Defaults by environment:**\n * - test: logLevel=\"error\", sleepMs=0\n * - production: logLevel=\"info\"\n * - development: logLevel=\"trace\"\n *\n * @returns The validated configuration object\n *\n * @example Basic usage\n * ```typescript\n * import { config } from \"@rotorsoft/act\";\n *\n * const cfg = config();\n * console.log(`App: ${cfg.name} v${cfg.version}`);\n * console.log(`Environment: ${cfg.env}`);\n * console.log(`Log level: ${cfg.logLevel}`);\n * ```\n *\n * @example Environment-specific behavior\n * ```typescript\n * import { config } from \"@rotorsoft/act\";\n *\n * const cfg = config();\n *\n * if (cfg.env === \"production\") {\n *   // Use PostgreSQL in production\n *   store(new PostgresStore(prodConfig));\n * } else {\n *   // Use in-memory store for dev/test\n *   store(new InMemoryStore());\n * }\n * ```\n *\n * @example Adjusting log levels\n * ```typescript\n * // Set via environment variable:\n * // LOG_LEVEL=debug npm start\n *\n * // Or check in code:\n * const cfg = config();\n * if (cfg.logLevel === \"trace\") {\n *   logger.trace(\"Detailed debugging enabled\");\n * }\n * ```\n *\n * @see {@link Config} for configuration type\n */\nexport const config = (): Config => {\n  if (!_validated) {\n    _validated = extend(\n      { ...pkg, env, logLevel, logSingleLine, sleepMs },\n      BaseSchema\n    );\n    if (pkgLoadError) {\n      // Surface the fallback once, after _validated is set so the\n      // recursive log() → config() call short-circuits. log() resolves\n      // through the port singleton — respects user injection and level.\n      const msg =\n        pkgLoadError instanceof Error\n          ? pkgLoadError.message\n          : typeof pkgLoadError === \"string\"\n            ? pkgLoadError\n            : \"unknown error\";\n      log().warn(\n        `[act] Could not read package.json (${msg}); using synthetic ` +\n          `name=\"${FALLBACK_PACKAGE.name}\" version=\"${FALLBACK_PACKAGE.version}\".`\n      );\n      pkgLoadError = undefined;\n    }\n  }\n  return _validated;\n};\n","import { AsyncLocalStorage } from \"node:async_hooks\";\nimport { ConsoleLogger } from \"./adapters/console-logger.js\";\nimport { InMemoryCache } from \"./adapters/in-memory-cache.js\";\nimport { InMemoryStore } from \"./adapters/in-memory-store.js\";\nimport { config } from \"./config.js\";\nimport type {\n  Cache,\n  Disposable,\n  Disposer,\n  Logger,\n  Store,\n} from \"./types/index.js\";\n\n/** Per-Act ports bag (ACT-501). Both required together — a shared cache across stores would collide on stream keys. */\nexport type Scoped = {\n  readonly store: Store;\n  readonly cache: Cache;\n};\n\n/** AsyncLocalStorage carrying the active Act's ports. Internal — not re-exported. */\nexport const scoped = new AsyncLocalStorage<Scoped>();\n\n/**\n * Port/adapter infrastructure for the Act framework.\n *\n * All infrastructure concerns (logging, storage, caching) are managed as\n * singleton adapters injected via port functions. Each port follows the same\n * pattern: first call wins with a sensible default, optional adapter injection.\n *\n * - `log()` — structured logging (default: ConsoleLogger)\n * - `store()` — event persistence (default: InMemoryStore)\n * - `cache()` — state checkpoints (default: InMemoryCache)\n * - `dispose()` — register cleanup functions for graceful shutdown\n *\n * @module ports\n */\n\n/**\n * List of exit codes for process termination. Consumed by signal handlers\n * and {@link disposeAndExit}; not part of the user-facing surface.\n *\n * @internal\n */\nexport const ExitCodes = [\"ERROR\", \"EXIT\"] as const;\n\n/**\n * Type for allowed exit codes.\n *\n * - `\"ERROR\"` — abnormal termination (uncaught exception, unhandled rejection)\n * - `\"EXIT\"` — clean shutdown (SIGINT, SIGTERM, or manual trigger)\n *\n * @internal\n */\nexport type ExitCode = (typeof ExitCodes)[number];\n\n// ---------------------------------------------------------------------------\n// Port factory\n// ---------------------------------------------------------------------------\n\n/**\n * Factory function that creates or returns the injected adapter.\n * @internal\n */\ntype Injector<Port extends Disposable> = (adapter?: Port) => Port;\n\n/** Singleton adapter registry, keyed by injector function name. */\nconst adapters = new Map<string, Disposable>();\n\n/**\n * Creates a singleton port with optional adapter injection.\n *\n * The first call initializes the adapter (using the provided adapter or the\n * injector's default). Subsequent calls return the cached singleton. Adapters\n * are disposed in reverse registration order during {@link disposeAndExit}.\n *\n * @param injector - Named function that creates the default adapter\n * @returns Port function: call with no args to get the singleton, or pass an\n *          adapter on the first call to override the default\n *\n * @example\n * ```typescript\n * const store = port(function store(adapter?: Store) {\n *   return adapter || new InMemoryStore();\n * });\n * const s = store(); // InMemoryStore\n * ```\n */\nexport function port<Port extends Disposable>(injector: Injector<Port>) {\n  return (adapter?: Port): Port => {\n    if (!adapters.has(injector.name)) {\n      const injected = injector(adapter);\n      adapters.set(injector.name, injected);\n      // log() is now in adapters (or this IS the log port we just registered),\n      // so the recursive call resolves immediately. Routing through the logger\n      // means level gating (e.g. silenced in tests at fatal) takes effect.\n      log().info(`[act] + ${injector.name}:${injected.constructor.name}`);\n    }\n    return adapters.get(injector.name) as Port;\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Ports: log, store, cache\n// ---------------------------------------------------------------------------\n\n/**\n * Gets or injects the singleton logger.\n *\n * By default, Act uses a built-in {@link ConsoleLogger} that emits JSON lines\n * in production (compatible with GCP, AWS CloudWatch, Datadog) and colorized\n * output in development — zero external dependencies.\n *\n * For pino, inject a `PinoLogger` from `@rotorsoft/act-pino` before building\n * your application.\n *\n * @param adapter - Optional logger implementation to inject\n * @returns The singleton logger instance\n *\n * @example Default console logger\n * ```typescript\n * import { log } from \"@rotorsoft/act\";\n * const logger = log();\n * logger.info(\"Application started\");\n * ```\n *\n * @example Injecting pino\n * ```typescript\n * import { log } from \"@rotorsoft/act\";\n * import { PinoLogger } from \"@rotorsoft/act-pino\";\n * log(new PinoLogger({ level: \"debug\", pretty: true }));\n * ```\n *\n * @see {@link Logger} for the interface contract\n * @see {@link ConsoleLogger} for the default implementation\n */\nexport const log = port(function log(adapter?: Logger) {\n  const cfg = config();\n  return (\n    adapter ||\n    new ConsoleLogger({\n      level: cfg.logLevel,\n      pretty: cfg.env !== \"production\",\n    })\n  );\n});\n\n/**\n * Gets or injects the singleton event store.\n *\n * By default, Act uses an {@link InMemoryStore} suitable for development and\n * testing. For production, inject a persistent store like `PostgresStore` from\n * `@rotorsoft/act-pg` before building your application.\n *\n * **Important:** Store injection must happen before creating any Act instances.\n * Once set, the store cannot be changed without restarting the application.\n *\n * @param adapter - Optional store implementation to inject\n * @returns The singleton store instance\n *\n * @example Default in-memory store\n * ```typescript\n * import { store } from \"@rotorsoft/act\";\n * const s = store();\n * ```\n *\n * @example Injecting PostgreSQL\n * ```typescript\n * import { store } from \"@rotorsoft/act\";\n * import { PostgresStore } from \"@rotorsoft/act-pg\";\n *\n * store(new PostgresStore({\n *   host: \"localhost\",\n *   port: 5432,\n *   database: \"myapp\",\n *   user: \"postgres\",\n *   password: \"secret\",\n * }));\n * ```\n *\n * @see {@link Store} for the interface contract\n * @see {@link InMemoryStore} for the default implementation\n */\n// ALS check lives outside `port()` — its cache fires only once, so the\n// per-call branch on a scoped Act has to be in the public wrapper.\nconst _store = port(function store(adapter?: Store): Store {\n  return adapter ?? new InMemoryStore();\n});\n\nexport const store = ((adapter?: Store): Store => {\n  return scoped.getStore()?.store ?? _store(adapter);\n}) as (adapter?: Store) => Store;\n\n/**\n * Gets or injects the singleton cache.\n *\n * By default, Act uses an {@link InMemoryCache} (LRU, maxSize 1000). For\n * distributed deployments, inject a Redis-backed cache before building your\n * application.\n *\n * @param adapter - Optional cache implementation to inject\n * @returns The singleton cache instance\n *\n * @see {@link Cache} for the interface contract\n * @see {@link InMemoryCache} for the default implementation\n */\nconst _cache = port(function cache(adapter?: Cache) {\n  return adapter ?? new InMemoryCache();\n});\n\nexport const cache = ((adapter?: Cache): Cache => {\n  return scoped.getStore()?.cache ?? _cache(adapter);\n}) as (adapter?: Cache) => Cache;\n\n// ---------------------------------------------------------------------------\n// Disposal\n// ---------------------------------------------------------------------------\n\n/** Registered cleanup functions, executed in reverse order during shutdown. */\nconst disposers: Disposer[] = [];\n\n/**\n * Disposes all registered adapters and disposers, then exits the process.\n *\n * Execution order:\n * 1. Custom disposers (registered via {@link dispose}) — in reverse order\n * 2. Port adapters (log, store, cache) — in reverse registration order\n * 3. Adapter registry is cleared\n * 4. Process exits (skipped in test environment)\n *\n * In production, `\"ERROR\"` exits are silently ignored to avoid crashing on\n * transient failures (e.g. an uncaught promise in a non-critical path).\n *\n * @param code - Exit code: `\"EXIT\"` for clean shutdown (exit 0),\n *               `\"ERROR\"` for abnormal termination (exit 1)\n */\nexport async function disposeAndExit(code: ExitCode = \"EXIT\"): Promise<void> {\n  if (code === \"ERROR\" && config().env === \"production\") {\n    // Surface the swallow so incident triage can see it. Without this\n    // log the framework looks unresponsive after an uncaught exception\n    // in prod — exactly when operators most need a breadcrumb.\n    log().warn(\n      \"disposeAndExit('ERROR') ignored in production — process kept alive\"\n    );\n    return;\n  }\n\n  // Run sequentially in reverse registration order so a disposer can rely on\n  // later-registered disposers (and adapters on later-registered adapters)\n  // having already finished — Promise.all would race them.\n  for (const disposer of [...disposers].reverse()) {\n    await disposer();\n  }\n  for (const adapter of [...adapters.values()].reverse()) {\n    await adapter.dispose();\n    log().info(`[act] - ${adapter.constructor.name}`);\n  }\n  adapters.clear();\n  config().env !== \"test\" && process.exit(code === \"ERROR\" ? 1 : 0);\n}\n\n/**\n * Registers a cleanup function for graceful shutdown.\n *\n * Disposers are called automatically on SIGINT, SIGTERM, uncaught exceptions,\n * and unhandled rejections. They execute in reverse registration order before\n * port adapters are disposed.\n *\n * @param disposer - Async function to call during cleanup. Omit to get a\n *                   reference to {@link disposeAndExit} without registering.\n * @returns Function to manually trigger disposal and exit\n *\n * @example\n * ```typescript\n * import { dispose } from \"@rotorsoft/act\";\n *\n * const db = connectDatabase();\n * dispose(async () => await db.close());\n *\n * // In tests\n * afterAll(async () => await dispose()());\n * ```\n *\n * @see {@link disposeAndExit} for the full shutdown sequence\n */\nexport function dispose(\n  disposer?: Disposer\n): (code?: ExitCode) => Promise<void> {\n  disposer && disposers.push(disposer);\n  return disposeAndExit;\n}\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\n\n/**\n * Event name used internally for snapshot events in the event store.\n * Snapshot events store a full state checkpoint, enabling efficient cold-start\n * recovery without replaying the entire event stream.\n */\nexport const SNAP_EVENT = \"__snapshot__\";\n\n/**\n * Event name used internally for tombstone events in the event store.\n * A tombstone marks a stream as permanently closed — no further writes\n * are permitted until the stream is explicitly restarted via `close()`.\n *\n * @see {@link Act.close} for the close-the-books API\n */\nexport const TOMBSTONE_EVENT = \"__tombstone__\";\n\n/**\n * Name of the implicit lane every reaction lands in unless its `.to({lane})`\n * declaration says otherwise (ACT-1103). Acts that don't call\n * `.withLane(...)` see only this lane, and behavior is identical to\n * pre-1103 single-controller drain.\n *\n * Persisted on `streams.lane` and threaded as the strict-typed default in\n * builder generics — `lane?: TLanes` always includes `\"default\"`.\n */\nexport const DEFAULT_LANE = \"default\";\n","import { prettifyError, ZodError, type ZodType } from \"zod\";\nimport { config } from \"./config.js\";\nimport { ValidationError } from \"./types/index.js\";\n\n/**\n * @module utils\n * @category Utilities\n *\n * Small utilities used across the framework:\n * - {@link validate} — parse a payload against a Zod schema, throwing\n *   {@link ValidationError} on failure.\n * - {@link extend} — validate a source object and merge into defaults.\n * - {@link sleep} — async delay (default duration from `config().sleepMs`).\n */\n\n/**\n * Parse `payload` against `schema`, returning the validated value or throwing\n * a {@link ValidationError} with prettified Zod details. When `schema` is\n * omitted, returns `payload` unchanged. The framework calls this for every\n * `app.do()` action, every emitted event, and every state init.\n *\n * @example\n * ```typescript\n * const UserSchema = z.object({ email: z.string().email() });\n * const user = validate(\"User\", { email: \"alice@example.com\" }, UserSchema);\n * ```\n *\n * @see {@link ValidationError}\n */\nexport const validate = <S>(\n  target: string,\n  payload: Readonly<S>,\n  schema?: ZodType<S>\n): Readonly<S> => {\n  try {\n    return schema ? schema.parse(payload) : payload;\n  } catch (error) {\n    if (error instanceof ZodError) {\n      throw new ValidationError(target, payload, prettifyError(error));\n    }\n    throw new ValidationError(target, payload, error);\n  }\n};\n\n/**\n * Validate `source` against `schema` and return a new object that merges\n * `source` over the optional `target` defaults. Used by {@link config} for\n * env-var-overrides-defaults patterns; safe to call elsewhere — it never\n * mutates `target`.\n *\n * @example\n * ```typescript\n * const schema = z.object({ host: z.string(), port: z.number() });\n * const cfg = extend({ port: 8080 }, schema, { host: \"localhost\", port: 80 });\n * // → { host: \"localhost\", port: 8080 }\n * ```\n *\n * @throws {@link ValidationError} if `source` fails the schema.\n */\nexport const extend = <\n  S extends Record<string, unknown>,\n  T extends Record<string, unknown>,\n>(\n  source: Readonly<S>,\n  schema: ZodType<S>,\n  target?: Readonly<T>\n): Readonly<S & T> => {\n  const value = validate(\"config\", source, schema);\n  return { ...target, ...value } as Readonly<S & T>;\n};\n\n/**\n * Pause for `ms` milliseconds (or `config().sleepMs` when omitted — `100ms`\n * in dev, `0ms` in tests). Used by adapters to simulate async I/O.\n *\n * @example\n * ```typescript\n * await sleep();      // default delay from config\n * await sleep(500);   // explicit 500ms\n * ```\n */\nexport async function sleep(ms?: number) {\n  return new Promise((resolve) => setTimeout(resolve, ms ?? config().sleepMs));\n}\n","/**\n * @packageDocumentation\n * @module act/adapters\n * In-memory event store adapter for the Act Framework.\n *\n * This adapter implements the Store interface and is suitable for development, testing, and demonstration purposes.\n * All data is stored in memory and lost on process exit.\n *\n * @category Adapters\n */\nimport { DEFAULT_LANE, SNAP_EVENT, TOMBSTONE_EVENT } from \"../ports.js\";\nimport { ConcurrencyError } from \"../types/errors.js\";\nimport type {\n  BlockedLease,\n  Committed,\n  EventMeta,\n  Lease,\n  Message,\n  Query,\n  QueryStatsOptions,\n  QueryStreams,\n  QueryStreamsResult,\n  Schema,\n  Schemas,\n  Store,\n  StreamFilter,\n  StreamPosition,\n  StreamStats,\n} from \"../types/index.js\";\nimport { sleep } from \"../utils.js\";\n\n/**\n * @internal\n * Represents an in-memory stream for event processing and leasing.\n */\nclass InMemoryStream {\n  readonly stream: string;\n  readonly source: string | undefined;\n  private _at = -1;\n  private _retry = -1;\n  private _blocked = false;\n  private _error = \"\";\n  private _leased_by: string | undefined = undefined;\n  private _leased_until: Date | undefined = undefined;\n  private _priority = 0;\n  private _lane: string = DEFAULT_LANE;\n\n  constructor(\n    stream: string,\n    source: string | undefined,\n    priority = 0,\n    lane: string = DEFAULT_LANE\n  ) {\n    this.stream = stream;\n    this.source = source;\n    this._priority = priority;\n    this._lane = lane;\n  }\n\n  get priority() {\n    return this._priority;\n  }\n\n  get lane() {\n    return this._lane;\n  }\n\n  /** Replace on every subscribe — current builder config wins on restart. */\n  set lane(value: string) {\n    this._lane = value;\n  }\n\n  /**\n   * Bump the priority via {@link subscribe}: keeps the maximum across\n   * reactions so the highest-priority registrant wins.\n   */\n  bumpPriority(priority: number) {\n    if (priority > this._priority) this._priority = priority;\n  }\n\n  /**\n   * Set the priority outright via {@link prioritize}: operator\n   * runtime override that ignores the build-time `max()` invariant.\n   */\n  setPriority(priority: number) {\n    this._priority = priority;\n  }\n\n  get is_available() {\n    return (\n      !this._blocked &&\n      (!this._leased_until || this._leased_until <= new Date())\n    );\n  }\n\n  get at() {\n    return this._at;\n  }\n\n  get retry() {\n    return this._retry;\n  }\n\n  get blocked() {\n    return this._blocked;\n  }\n\n  get error() {\n    return this._error;\n  }\n\n  get leased_by() {\n    return this._leased_by;\n  }\n\n  get leased_until() {\n    return this._leased_until;\n  }\n\n  /**\n   * Attempt to lease this stream for processing.\n   * @param lease - The lease request.\n   * @param millis - Lease duration in milliseconds.\n   * @returns The granted lease or undefined if blocked.\n   */\n  lease(lease: Lease, millis: number): Lease {\n    if (millis > 0) {\n      this._leased_by = lease.by;\n      this._leased_until = new Date(Date.now() + millis);\n    }\n    this._retry = this._retry + 1;\n    return {\n      stream: this.stream,\n      source: this.source,\n      at: lease.at,\n      by: lease.by,\n      retry: this._retry,\n      lagging: lease.lagging,\n      lane: this._lane,\n    };\n  }\n\n  /**\n   * Acknowledge completion of processing for this stream.\n   * @param lease - The lease request.\n   */\n  ack(lease: Lease) {\n    if (this._leased_by === lease.by) {\n      this._leased_by = undefined;\n      this._leased_until = undefined;\n      this._at = lease.at;\n      this._retry = -1;\n      return {\n        stream: this.stream,\n        source: this.source,\n        at: this._at,\n        by: lease.by,\n        retry: this._retry,\n        lagging: lease.lagging,\n        lane: this._lane,\n      };\n    }\n  }\n\n  /**\n   * Block a stream for processing after failing to process and reaching max retries with blocking enabled.\n   * @param lease - The lease request.\n   * @param error Blocked error message.\n   */\n  block(lease: Lease, error: string) {\n    if (this._leased_by === lease.by) {\n      this._blocked = true;\n      this._error = error;\n      return {\n        stream: this.stream,\n        source: this.source,\n        at: this._at,\n        by: this._leased_by,\n        retry: this._retry,\n        error: this._error,\n        lagging: lease.lagging,\n        lane: this._lane,\n      };\n    }\n  }\n\n  /**\n   * Reset this stream's watermark and state for replay. The retry counter\n   * resets to -1 to match the constructor + ack() invariant (\"released\n   * stream\"); the next claim() bumps it to 0 (first attempt).\n   */\n  reset() {\n    this._at = -1;\n    this._retry = -1;\n    this._blocked = false;\n    this._error = \"\";\n    this._leased_by = undefined;\n    this._leased_until = undefined;\n  }\n\n  /**\n   * Clear the blocked flag and lease bookkeeping without touching the\n   * watermark. Returns true if the stream was actually blocked (and is\n   * now flipped); false otherwise.\n   */\n  unblock(): boolean {\n    if (!this._blocked) return false;\n    this._blocked = false;\n    this._retry = -1;\n    this._error = \"\";\n    this._leased_by = undefined;\n    this._leased_until = undefined;\n    return true;\n  }\n}\n\n/**\n * In-memory event store implementation.\n *\n * This is the default store used by Act when no other store is injected.\n * It stores all events in memory and is suitable for:\n * - Development and prototyping\n * - Unit and integration testing\n * - Demonstrations and examples\n *\n * **Not suitable for production** - all data is lost when the process exits.\n * Use {@link PostgresStore} for production deployments.\n *\n * The in-memory store provides:\n * - Full {@link Store} interface implementation\n * - Optimistic concurrency control\n * - Stream leasing for distributed processing simulation\n * - Snapshot support\n * - Fast performance (no I/O overhead)\n *\n * **`Store.notify` is intentionally not implemented.** The notify hook is a\n * cross-process wake-up signal — local commits already arm the drain via\n * `do()`. An in-memory store is single-process by definition, so there is\n * no remote writer to be notified of. The {@link Act} orchestrator\n * detects the absence and falls back to the existing debounce/poll path.\n *\n * @example Using in tests\n * ```typescript\n * import { store } from \"@rotorsoft/act\";\n *\n * describe(\"Counter\", () => {\n *   beforeEach(async () => {\n *     // Reset store between tests\n *     await store().seed();\n *   });\n *\n *   it(\"increments\", async () => {\n *     await app.do(\"increment\", target, { by: 5 });\n *     const snapshot = await app.load(Counter, \"counter-1\");\n *     expect(snapshot.state.count).toBe(5);\n *   });\n * });\n * ```\n *\n * @example Explicit instantiation\n * ```typescript\n * import { InMemoryStore } from \"@rotorsoft/act\";\n *\n * const testStore = new InMemoryStore();\n * await testStore.seed();\n *\n * // Use for specific test scenarios\n * await testStore.commit(\"test-stream\", events, meta);\n * ```\n *\n * @example Querying events\n * ```typescript\n * const events: any[] = [];\n * await store().query(\n *   (event) => events.push(event),\n *   { stream: \"test-stream\" }\n * );\n * console.log(`Found ${events.length} events`);\n * ```\n *\n * @see {@link Store} for the interface definition\n * @see {@link PostgresStore} for production use\n * @see {@link store} for injecting stores\n *\n * @category Adapters\n */\nexport class InMemoryStore implements Store {\n  // stored events\n  private _events: Committed<Schemas, keyof Schemas>[] = [];\n  // stored stream positions and other metadata\n  private _streams: Map<string, InMemoryStream> = new Map();\n  // last committed version per stream — O(1) replacement for filter-on-commit\n  private _streamVersions: Map<string, number> = new Map();\n  // max non-snapshot event id per stream — drives the source-pattern probe in claim()\n  // without scanning the full event log.\n  private _maxEventIdByStream: Map<string, number> = new Map();\n  // global max non-snapshot event id — fast pre-check for source-less streams in claim()\n  private _maxNonSnapEventId = -1;\n\n  private _resetIndexes() {\n    this._events.length = 0;\n    this._streamVersions.clear();\n    this._maxEventIdByStream.clear();\n    this._maxNonSnapEventId = -1;\n  }\n\n  /**\n   * Dispose of the store and clear all events.\n   * @returns Promise that resolves when disposal is complete.\n   */\n  async dispose() {\n    await sleep();\n    this._resetIndexes();\n  }\n\n  /**\n   * Seed the store with initial data (no-op for in-memory).\n   * @returns Promise that resolves when seeding is complete.\n   */\n  async seed() {\n    await sleep();\n  }\n\n  /**\n   * Drop all data from the store.\n   * @returns Promise that resolves when the store is cleared.\n   */\n  async drop() {\n    await sleep();\n    this._resetIndexes();\n    this._streams = new Map();\n  }\n\n  private in_query<E extends Schemas>(query: Query, e: Committed<E, keyof E>) {\n    if (query.stream) {\n      if (query.stream_exact) {\n        if (e.stream !== query.stream) return false;\n      } else if (!RegExp(query.stream).test(e.stream)) return false;\n    }\n    if (query.names && !query.names.includes(e.name as string)) return false;\n    if (query.correlation && e.meta?.correlation !== query.correlation)\n      return false;\n    if (e.name === SNAP_EVENT && !query.with_snaps) return false;\n    return true;\n  }\n\n  /**\n   * Query events in the store, optionally filtered by query options.\n   * @param callback - Function to call for each event.\n   * @param query - Optional query options.\n   * @returns The number of events processed.\n   */\n  async query<E extends Schemas>(\n    callback: (event: Committed<E, keyof E>) => void,\n    query?: Query\n  ) {\n    await sleep();\n    let count = 0;\n    if (query?.backward) {\n      let i = (query?.before || this._events.length) - 1;\n      while (i >= 0) {\n        const e = this._events[i--];\n        if (query && !this.in_query(query, e)) continue;\n        if (query?.created_before && e.created >= query.created_before)\n          continue;\n        if (query.after && e.id <= query.after) break;\n        if (query.created_after && e.created <= query.created_after) break;\n        await Promise.resolve(callback(e as Committed<E, keyof E>));\n        count++;\n        if (query?.limit && count >= query.limit) break;\n      }\n    } else {\n      let i = (query?.after ?? -1) + 1;\n      while (i < this._events.length) {\n        const e = this._events[i++];\n        if (query && !this.in_query(query, e)) continue;\n        if (query?.created_after && e.created <= query.created_after) continue;\n        if (query?.before && e.id >= query.before) break;\n        if (query?.created_before && e.created >= query.created_before) break;\n        await Promise.resolve(callback(e as Committed<E, keyof E>));\n        count++;\n        if (query?.limit && count >= query.limit) break;\n      }\n    }\n    return count;\n  }\n\n  /**\n   * Commit one or more events to a stream.\n   * @param stream - The stream name.\n   * @param msgs - The events/messages to commit.\n   * @param meta - Event metadata.\n   * @param expectedVersion - Optional optimistic concurrency check.\n   * @returns The committed events with metadata.\n   * @throws ConcurrencyError if expectedVersion does not match.\n   */\n  async commit<E extends Schemas>(\n    stream: string,\n    msgs: Message<E, keyof E>[],\n    meta: EventMeta,\n    expectedVersion?: number\n  ) {\n    await sleep();\n    const currentVersion = this._streamVersions.get(stream) ?? -1;\n    if (\n      typeof expectedVersion === \"number\" &&\n      currentVersion !== expectedVersion\n    ) {\n      throw new ConcurrencyError(\n        stream,\n        currentVersion,\n        msgs as Message<Schemas, keyof Schemas>[],\n        expectedVersion\n      );\n    }\n\n    let version = currentVersion + 1;\n    let lastNonSnapId = -1;\n    const committed = msgs.map(({ name, data }) => {\n      const c: Committed<E, keyof E> = {\n        id: this._events.length,\n        stream,\n        version,\n        created: new Date(),\n        name,\n        data,\n        meta,\n      };\n      this._events.push(c as Committed<Schemas, keyof Schemas>);\n      if (name !== SNAP_EVENT) lastNonSnapId = c.id;\n      version++;\n      return c;\n    });\n    this._streamVersions.set(stream, version - 1);\n    if (lastNonSnapId >= 0) {\n      this._maxEventIdByStream.set(stream, lastNonSnapId);\n      // commit always assigns a fresh id from this._events.length, so any\n      // non-snap commit strictly raises the global max.\n      this._maxNonSnapEventId = lastNonSnapId;\n    }\n    return committed;\n  }\n\n  /**\n   * Atomically discovers and leases streams for processing.\n   * Fuses poll + lease into a single operation.\n   * @param lagging - Max streams from lagging frontier.\n   * @param leading - Max streams from leading frontier.\n   * @param by - Lease holder identifier.\n   * @param millis - Lease duration in milliseconds.\n   * @returns Granted leases.\n   */\n  async claim(\n    lagging: number,\n    leading: number,\n    by: string,\n    millis: number,\n    lane?: string\n  ) {\n    await sleep();\n    // Cache compiled regexes — multiple subscribed streams typically share the\n    // same source pattern, and the inner loop can run thousands of times per claim.\n    const sourceRegex = new Map<string, RegExp>();\n    const getRegex = (source: string) => {\n      let re = sourceRegex.get(source);\n      if (!re) {\n        re = new RegExp(source);\n        sourceRegex.set(source, re);\n      }\n      return re;\n    };\n    const hasWork = (s: InMemoryStream): boolean => {\n      if (s.at < 0) return true;\n      if (!s.source) return s.at < this._maxNonSnapEventId;\n      const re = getRegex(s.source);\n      for (const [streamName, maxId] of this._maxEventIdByStream) {\n        if (maxId > s.at && re.test(streamName)) return true;\n      }\n      return false;\n    };\n    const available = [...this._streams.values()].filter(\n      (s) =>\n        s.is_available && hasWork(s) && (lane === undefined || s.lane === lane)\n    );\n    // Lagging frontier orders by priority DESC (higher first), then by\n    // watermark ASC (most-behind first). Mirrors the PG `claim()` SQL\n    // — see `libs/act-pg/PERFORMANCE.md` for the benchmark that\n    // motivated the priority dimension.\n    const lag = available\n      .sort((a, b) => b.priority - a.priority || a.at - b.at)\n      .slice(0, lagging)\n      .map((s) => ({\n        stream: s.stream,\n        source: s.source,\n        at: s.at,\n        lagging: true,\n      }));\n    const lead = available\n      .sort((a, b) => b.at - a.at)\n      .slice(0, leading)\n      .map((s) => ({\n        stream: s.stream,\n        source: s.source,\n        at: s.at,\n        lagging: false,\n      }));\n    // deduplicate (a stream can appear in both frontiers)\n    const seen = new Set<string>();\n    const combined = [...lag, ...lead].filter((p) => {\n      if (seen.has(p.stream)) return false;\n      seen.add(p.stream);\n      return true;\n    });\n    // lease each atomically\n    return combined\n      .map((p) =>\n        this._streams.get(p.stream)?.lease({ ...p, by, retry: 0 }, millis)\n      )\n      .filter((l) => !!l);\n  }\n\n  /**\n   * Registers streams for event processing. When the same stream is\n   * resubscribed with a different priority, the **maximum** wins — so\n   * the highest-priority registered reaction sets the scheduling lane.\n   * Use {@link prioritize} for operator runtime overrides.\n   *\n   * @param streams - Streams to register with optional source + priority.\n   * @returns subscribed count and current max watermark.\n   */\n  async subscribe(\n    streams: Array<{\n      stream: string;\n      source?: string;\n      priority?: number;\n      lane?: string;\n    }>\n  ) {\n    await sleep();\n    let subscribed = 0;\n    for (const {\n      stream,\n      source,\n      priority = 0,\n      lane = DEFAULT_LANE,\n    } of streams) {\n      const existing = this._streams.get(stream);\n      if (existing) {\n        existing.bumpPriority(priority);\n        existing.lane = lane;\n      } else {\n        this._streams.set(\n          stream,\n          new InMemoryStream(stream, source, priority, lane)\n        );\n        subscribed++;\n      }\n    }\n    let watermark = -1;\n    for (const s of this._streams.values()) {\n      if (s.at > watermark) watermark = s.at;\n    }\n    return { subscribed, watermark };\n  }\n\n  /**\n   * Acknowledge completion of processing for leased streams.\n   * @param leases - Leases to acknowledge, including last processed watermark and lease holder.\n   */\n  async ack(leases: Lease[]) {\n    await sleep();\n    return leases\n      .map((l) => this._streams.get(l.stream)?.ack(l))\n      .filter((l) => !!l);\n  }\n\n  /**\n   * Block a stream for processing after failing to process and reaching max retries with blocking enabled.\n   * @param leases - Leases to block, including lease holder and last error message.\n   * @returns Blocked leases.\n   */\n  async block(leases: BlockedLease[]) {\n    await sleep();\n    return leases\n      .map((l) => this._streams.get(l.stream)?.block(l, l.error))\n      .filter((l) => !!l);\n  }\n\n  /**\n   * Build a predicate from a {@link StreamFilter}. Compiled regexes are\n   * cached in the closure so callers can apply it across the streams\n   * map without re-compiling per iteration.\n   */\n  private _filterPredicate(\n    filter: StreamFilter\n  ): (s: InMemoryStream) => boolean {\n    const streamRe =\n      filter.stream && !filter.stream_exact\n        ? new RegExp(filter.stream)\n        : undefined;\n    const sourceRe =\n      filter.source && !filter.source_exact\n        ? new RegExp(filter.source)\n        : undefined;\n    return (s) => {\n      if (filter.stream !== undefined) {\n        if (\n          filter.stream_exact\n            ? s.stream !== filter.stream\n            : !streamRe!.test(s.stream)\n        )\n          return false;\n      }\n      if (filter.source !== undefined) {\n        if (s.source === undefined) return false;\n        if (\n          filter.source_exact\n            ? s.source !== filter.source\n            : !sourceRe!.test(s.source)\n        )\n          return false;\n      }\n      if (filter.blocked !== undefined && s.blocked !== filter.blocked)\n        return false;\n      if (filter.lane !== undefined && s.lane !== filter.lane) return false;\n      return true;\n    };\n  }\n\n  /**\n   * Reset watermarks to -1, clearing retry, blocked, error, and lease\n   * state so the matched streams can be replayed from the beginning.\n   * Accepts either an explicit list of names or a {@link StreamFilter}.\n   *\n   * @param input - Stream names or a filter selecting the streams to reset.\n   * @returns Count of streams that were actually reset.\n   */\n  async reset(input: string[] | StreamFilter) {\n    await sleep();\n    let count = 0;\n    if (Array.isArray(input)) {\n      for (const name of input) {\n        const s = this._streams.get(name);\n        if (s) {\n          s.reset();\n          count++;\n        }\n      }\n    } else {\n      const matches = this._filterPredicate(input);\n      for (const s of this._streams.values()) {\n        if (matches(s)) {\n          s.reset();\n          count++;\n        }\n      }\n    }\n    return count;\n  }\n\n  /**\n   * Clear the blocked flag (and retry / error / lease) on the matched\n   * streams without touching the watermark. Streams that aren't blocked\n   * at call time are silently skipped. Accepts either an explicit list\n   * of names or a {@link StreamFilter}. The filter form always restricts\n   * to blocked streams — passing `blocked: false` matches nothing.\n   * See {@link Store.unblock}.\n   *\n   * @param input - Stream names or a filter selecting the streams to unblock.\n   * @returns Count of streams that were actually flipped (were blocked).\n   */\n  async unblock(input: string[] | StreamFilter) {\n    await sleep();\n    let count = 0;\n    if (Array.isArray(input)) {\n      for (const name of input) {\n        const s = this._streams.get(name);\n        if (s?.unblock()) count++;\n      }\n    } else {\n      // Filter form: always restrict to blocked streams. An explicit\n      // `blocked: false` in the filter is silently overridden — there\n      // is no use case for \"unblock unblocked streams.\"\n      const matches = this._filterPredicate({ ...input, blocked: true });\n      for (const s of this._streams.values()) {\n        if (matches(s) && s.unblock()) count++;\n      }\n    }\n    return count;\n  }\n\n  /**\n   * Bulk-update priority of streams matching `filter`. Mirrors\n   * {@link query_streams}'s filter semantics — see {@link Store.prioritize}.\n   * Unlike {@link subscribe} (which keeps `max()` of registered\n   * priorities), this sets the priority outright — operator override\n   * for the build-time scheduling policy.\n   *\n   * @returns Count of streams whose priority changed.\n   */\n  async prioritize(filter: StreamFilter, priority: number) {\n    await sleep();\n    const matches = this._filterPredicate(filter);\n    let count = 0;\n    for (const s of this._streams.values()) {\n      if (!matches(s)) continue;\n      if (s.priority !== priority) {\n        s.setPriority(priority);\n        count++;\n      }\n    }\n    return count;\n  }\n\n  /**\n   * Streams registered subscription positions to the callback, ordered by\n   * stream name. Returns the highest event id in the store and the count\n   * of positions emitted.\n   */\n  async query_streams(\n    callback: (position: StreamPosition) => void,\n    query?: QueryStreams\n  ): Promise<QueryStreamsResult> {\n    await sleep();\n    const limit = query?.limit ?? 100;\n    const after = query?.after;\n    const blocked = query?.blocked;\n    const streamRe =\n      query?.stream && !query.stream_exact\n        ? new RegExp(query.stream)\n        : undefined;\n    const sourceRe =\n      query?.source && !query.source_exact\n        ? new RegExp(query.source)\n        : undefined;\n\n    const sorted = [...this._streams.values()].sort((a, b) =>\n      a.stream.localeCompare(b.stream)\n    );\n\n    let count = 0;\n    for (const s of sorted) {\n      if (after !== undefined && s.stream <= after) continue;\n      if (query?.stream !== undefined) {\n        if (\n          query.stream_exact\n            ? s.stream !== query.stream\n            : !streamRe!.test(s.stream)\n        )\n          continue;\n      }\n      if (query?.source !== undefined) {\n        if (s.source === undefined) continue;\n        if (\n          query.source_exact\n            ? s.source !== query.source\n            : !sourceRe!.test(s.source)\n        )\n          continue;\n      }\n      if (blocked !== undefined && s.blocked !== blocked) continue;\n      if (query?.lane !== undefined && s.lane !== query.lane) continue;\n      callback({\n        stream: s.stream,\n        source: s.source,\n        at: s.at,\n        retry: s.retry,\n        blocked: s.blocked,\n        error: s.error,\n        priority: s.priority,\n        leased_by: s.leased_by,\n        leased_until: s.leased_until,\n        lane: s.lane,\n      });\n      count++;\n      if (count >= limit) break;\n    }\n    return { maxEventId: this._events.length - 1, count };\n  }\n\n  /**\n   * Per-stream aggregated stats — see {@link Store.query_stats}.\n   *\n   * Single forward scan over the in-memory event list, accumulating per\n   * stream. The \"cheap heads\" cost tier from durable adapters doesn't\n   * apply here (InMemory has no indexes); correctness is the goal, perf\n   * is a non-issue.\n   *\n   * Scope rules:\n   * - Array `input` — explicit stream names, regardless of subscription.\n   * - Filter `input` — `stream`/`stream_exact` match against event-bearing\n   *   stream names; `source`/`source_exact`/`blocked` require a\n   *   corresponding subscription in `_streams` (those are subscription\n   *   concepts, not event concepts). Empty filter `{}` matches every\n   *   event-bearing stream.\n   */\n  async query_stats<E extends Schemas>(\n    input: string[] | Pick<StreamFilter, \"stream\" | \"stream_exact\">,\n    options?: QueryStatsOptions<E>\n  ): Promise<Map<string, StreamStats<E>>> {\n    await sleep();\n    const exclude = new Set<string>(options?.exclude ?? []);\n    const wantTail = options?.tail ?? false;\n    const wantCount = options?.count ?? false;\n    const wantNames = options?.names ?? false;\n    const before = options?.before;\n\n    // Pre-compile per-stream scope predicate, cached as we go so each\n    // distinct stream evaluates the regex once.\n    const arrayTargets = Array.isArray(input) ? new Set(input) : null;\n    const filter = Array.isArray(input) ? null : input;\n    const streamRe =\n      filter?.stream && !filter.stream_exact\n        ? new RegExp(filter.stream)\n        : undefined;\n\n    const scopeCache = new Map<string, boolean>();\n    const inScope = (stream: string): boolean => {\n      const cached = scopeCache.get(stream);\n      if (cached !== undefined) return cached;\n      let ok = true;\n      if (arrayTargets) {\n        ok = arrayTargets.has(stream);\n      } else if (filter?.stream !== undefined) {\n        ok = filter.stream_exact\n          ? stream === filter.stream\n          : // biome-ignore lint/style/noNonNullAssertion: streamRe set when stream is regex\n            streamRe!.test(stream);\n      }\n      scopeCache.set(stream, ok);\n      return ok;\n    };\n\n    type Acc = {\n      head: Committed<Schemas, keyof Schemas>;\n      tail?: Committed<Schemas, keyof Schemas>;\n      count: number;\n      names?: Record<string, number>;\n    };\n    const acc = new Map<string, Acc>();\n    for (const e of this._events) {\n      if (before !== undefined && e.id >= before) continue;\n      if (!inScope(e.stream)) continue;\n      if (exclude.has(e.name as string)) continue;\n      let a = acc.get(e.stream);\n      if (!a) {\n        a = { head: e, count: 0 };\n        if (wantTail) a.tail = e;\n        if (wantNames) a.names = {};\n        acc.set(e.stream, a);\n      }\n      a.head = e;\n      a.count++;\n      if (wantNames) {\n        const n = String(e.name);\n        // biome-ignore lint/style/noNonNullAssertion: a.names initialized above when wantNames\n        a.names![n] = (a.names![n] ?? 0) + 1;\n      }\n    }\n\n    const out = new Map<string, StreamStats<E>>();\n    for (const [stream, a] of acc) {\n      const stats: {\n        head: Committed<Schemas, keyof Schemas>;\n        tail?: Committed<Schemas, keyof Schemas>;\n        count?: number;\n        names?: Record<string, number>;\n      } = { head: a.head };\n      if (wantTail) stats.tail = a.tail;\n      if (wantCount) stats.count = a.count;\n      if (wantNames) stats.names = a.names;\n      out.set(stream, stats as StreamStats<E>);\n    }\n    return out;\n  }\n\n  /**\n   * Atomically truncates streams and seeds each with a snapshot or tombstone.\n   * @param targets - Streams to truncate with optional snapshot state and meta.\n   * @returns Map keyed by stream name, each entry with `deleted` count and `committed` event.\n   */\n  async truncate(\n    targets: Array<{\n      stream: string;\n      snapshot?: Schema;\n      meta?: EventMeta;\n    }>\n  ) {\n    await sleep();\n    // Count per-stream deletions\n    const deletedCounts = new Map<string, number>();\n    const streamSet = new Set(targets.map((t) => t.stream));\n    for (const e of this._events) {\n      if (streamSet.has(e.stream)) {\n        deletedCounts.set(e.stream, (deletedCounts.get(e.stream) ?? 0) + 1);\n      }\n    }\n    this._events = this._events.filter((e) => !streamSet.has(e.stream));\n    for (const stream of streamSet) {\n      this._streams.delete(stream);\n      this._streamVersions.delete(stream);\n      this._maxEventIdByStream.delete(stream);\n    }\n    const result = new Map<\n      string,\n      { deleted: number; committed: Committed<Schemas, keyof Schemas> }\n    >();\n    for (const { stream, snapshot, meta } of targets) {\n      const event: Committed<Schemas, keyof Schemas> = {\n        id: this._events.length,\n        stream,\n        version: 0,\n        created: new Date(),\n        name: snapshot !== undefined ? SNAP_EVENT : TOMBSTONE_EVENT,\n        data: snapshot ?? {},\n        meta: meta ?? { correlation: \"\", causation: {} },\n      };\n      this._events.push(event);\n      this._streamVersions.set(stream, 0);\n      if (event.name !== SNAP_EVENT) {\n        this._maxEventIdByStream.set(stream, event.id);\n      }\n      result.set(stream, {\n        deleted: deletedCounts.get(stream) ?? 0,\n        committed: event,\n      });\n    }\n    // Recompute global max from the per-stream index — deletions may have\n    // dropped the previous max, while new tombstones may have raised it.\n    let max = -1;\n    for (const id of this._maxEventIdByStream.values()) if (id > max) max = id;\n    this._maxNonSnapEventId = max;\n    return result;\n  }\n\n  /**\n   * Atomically wipe-and-rebuild the store under an in-process snapshot.\n   *\n   * Captures every index state up front, clears it, then hands the\n   * orchestrator a per-event insert `callback` via the driver. Any\n   * throw inside the driver restores the snapshot, leaving the store\n   * byte-for-byte unchanged from the operator's perspective.\n   *\n   * `id`s are reassigned `0..N-1` as events arrive (matching the\n   * adapter's commit-id convention — InMemory uses `_events.length`).\n   * `created` is preserved verbatim from the source.\n   */\n  async restore(\n    driver: (\n      callback: (event: Committed<Schemas, keyof Schemas>) => Promise<number>\n    ) => Promise<void>\n  ): Promise<void> {\n    await sleep();\n    // Snapshot every index so we can roll back on throw.\n    const prevEvents = this._events;\n    const prevStreams = this._streams;\n    const prevStreamVersions = this._streamVersions;\n    const prevMaxEventIdByStream = this._maxEventIdByStream;\n    const prevMaxNonSnapEventId = this._maxNonSnapEventId;\n    // Swap in fresh state for the duration of the rebuild.\n    this._events = [];\n    this._streams = new Map();\n    this._streamVersions = new Map();\n    this._maxEventIdByStream = new Map();\n    this._maxNonSnapEventId = -1;\n    try {\n      await driver(async (event) => {\n        const id = this._events.length;\n        const committed: Committed<Schemas, keyof Schemas> = { ...event, id };\n        this._events.push(committed);\n        // Last event per stream wins for the version watermark — the\n        // source is expected to be in commit order, so this is also\n        // the highest version. Out-of-order sources get last-wins,\n        // matching the legacy raw-SQL restore.\n        this._streamVersions.set(event.stream, event.version);\n        if (event.name !== SNAP_EVENT) {\n          this._maxEventIdByStream.set(event.stream, id);\n          this._maxNonSnapEventId = id;\n        }\n        return id;\n      });\n    } catch (err) {\n      // Roll back to the captured snapshot — every index restored\n      // exactly as it was before the call started.\n      this._events = prevEvents;\n      this._streams = prevStreams;\n      this._streamVersions = prevStreamVersions;\n      this._maxEventIdByStream = prevMaxEventIdByStream;\n      this._maxNonSnapEventId = prevMaxNonSnapEventId;\n      throw err;\n    }\n  }\n}\n"],"mappings":"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","names":["log","store","cache"]}