@rotorsoft/act 0.32.2 → 0.32.4

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

@@ -1 +1 @@
-{"version":3,"file":"event-sourcing.d.ts","sourceRoot":"","sources":["../../../src/internal/event-sourcing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;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;CACvB;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;;;;;;;;;;;;;;;;;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,CA6BpC;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,CA+GtC"}
+{"version":3,"file":"event-sourcing.d.ts","sourceRoot":"","sources":["../../../src/internal/event-sourcing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;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;CACvB;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;;;;;;;;;;;;;;;;;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,CAqCpC;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,CA+GtC"}

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

@@ -8,8 +8,15 @@
  * at well-defined moments — entry points for {@link "event-sourcing"} (`load`,
  * `snap`, `action`) and exit points for the {@link "drain"} pipeline (`claim`,
  * `fetch`, `ack`, `block`, `subscribe`). `action` carries both an entry log
- * (🔵) and a post-commit log (🔴) to preserve the diagnostic value of the
- * historical mid-function trace points.
+ * and a post-commit log to preserve the diagnostic value of the historical
+ * mid-function trace points.
+ *
+ * Output styles:
+ * - **Pretty mode** (`config().env !== "production"`) — event-sourcing logs
+ *   show only the colored target body (color carries the operation/phase),
+ *   drain logs keep a colored caption.
+ * - **Plain mode** (production / log aggregators) — every log gets a textual
+ *   prefix; event-sourcing uses `caption: body`, drain uses `caption body`.
  *
  * The two factories — {@link buildEs} and {@link buildDrain} — let the
  * orchestrator choose bare or traced variants once at `.build()` time based

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

@@ -1 +1 @@
-{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../../src/internal/tracing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAwBjD;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CA+B7C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,SAAS,OAAO,EAChD,MAAM,EAAE,MAAM,GACb,QAAQ,CAAC,OAAO,CAAC,CAyDnB"}
+{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../../src/internal/tracing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAqDjD;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CA0C7C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,SAAS,OAAO,EAChD,MAAM,EAAE,MAAM,GACb,QAAQ,CAAC,OAAO,CAAC,CAyDnB"}

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

@@ -1 +1 @@
-{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/ports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAI5D,OAAO,KAAK,EACV,KAAK,EACL,UAAU,EACV,QAAQ,EACR,MAAM,EACN,KAAK,EACN,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS,4BAA6B,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAMlD;;;GAGG;AACH,KAAK,QAAQ,CAAC,IAAI,SAAS,UAAU,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,KAAK,IAAI,CAAC;AAKlE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,IAAI,SAAS,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,IACnD,UAAU,IAAI,KAAG,IAAI,CAQvC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,GAAG,0EASd,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AASH;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAAC,IAAI,GAAE,QAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAY3E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CACrB,QAAQ,CAAC,EAAE,QAAQ,GAClB,CAAC,IAAI,CAAC,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAGpC;AAMD;;;;GAIG;AACH,eAAO,MAAM,UAAU,iBAAiB,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/ports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAI5D,OAAO,KAAK,EACV,KAAK,EACL,UAAU,EACV,QAAQ,EACR,MAAM,EACN,KAAK,EACN,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS,4BAA6B,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAMlD;;;GAGG;AACH,KAAK,QAAQ,CAAC,IAAI,SAAS,UAAU,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,KAAK,IAAI,CAAC;AAKlE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,IAAI,SAAS,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,IACnD,UAAU,IAAI,KAAG,IAAI,CAWvC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,GAAG,0EASd,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AASH;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAAC,IAAI,GAAE,QAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAe3E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CACrB,QAAQ,CAAC,EAAE,QAAQ,GAClB,CAAC,IAAI,CAAC,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAGpC;AAMD;;;;GAIG;AACH,eAAO,MAAM,UAAU,iBAAiB,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,kBAAkB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,OAAO,EAAiB,MAAM,KAAK,CAAC;AAIjE;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,QAAQ,MAAM,EACd,SAAS,QAAQ,CAAC,CAAC,CAAC,EACpB,SAAS,OAAO,CAAC,CAAC,CAAC,KAClB,QAAQ,CAAC,CAAC,CAaZ,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwHG;AACH,eAAO,MAAM,MAAM,GACjB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAEjC,QAAQ,QAAQ,CAAC,CAAC,CAAC,EACnB,QAAQ,OAAO,CAAC,CAAC,CAAC,EAClB,SAAS,QAAQ,CAAC,CAAC,CAAC,KACnB,QAAQ,CAAC,CAAC,GAAG,CAAC,CAGhB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,wBAAsB,KAAK,CAAC,EAAE,CAAC,EAAE,MAAM,oBAEtC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,OAAO,EAAiB,MAAM,KAAK,CAAC;AAI5D;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,QAAQ,MAAM,EACd,SAAS,QAAQ,CAAC,CAAC,CAAC,EACpB,SAAS,OAAO,CAAC,CAAC,CAAC,KAClB,QAAQ,CAAC,CAAC,CASZ,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwHG;AACH,eAAO,MAAM,MAAM,GACjB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAEjC,QAAQ,QAAQ,CAAC,CAAC,CAAC,EACnB,QAAQ,OAAO,CAAC,CAAC,CAAC,EAClB,SAAS,QAAQ,CAAC,CAAC,CAAC,KACnB,QAAQ,CAAC,CAAC,GAAG,CAAC,CAGhB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,wBAAsB,KAAK,CAAC,EAAE,CAAC,EAAE,MAAM,oBAEtC"}

package/dist/index.cjs

@@ -345,12 +345,19 @@ var BaseSchema = PackageSchema.extend({
 });
 var { NODE_ENV, LOG_LEVEL, LOG_SINGLE_LINE, SLEEP_MS } = process.env;
 var env = NODE_ENV || "development";
-var logLevel = LOG_LEVEL || (NODE_ENV === "test" ? "error" : NODE_ENV === "production" ? "info" : "trace");
+var logLevel = LOG_LEVEL || (NODE_ENV === "test" ? "fatal" : NODE_ENV === "production" ? "info" : "trace");
 var logSingleLine = (LOG_SINGLE_LINE || "true") === "true";
-var sleepMs = parseInt(NODE_ENV === "test" ? "0" : SLEEP_MS ?? "100");
+var sleepMs = parseInt(NODE_ENV === "test" ? "0" : SLEEP_MS ?? "100", 10);
 var pkg = getPackage();
+var _validated;
 var config = () => {
-  return extend({ ...pkg, env, logLevel, logSingleLine, sleepMs }, BaseSchema);
+  if (!_validated) {
+    _validated = extend(
+      { ...pkg, env, logLevel, logSingleLine, sleepMs },
+      BaseSchema
+    );
+  }
+  return _validated;
 };
 
 // src/utils.ts
@@ -358,19 +365,15 @@ var validate = (target, payload, schema) => {
   try {
     return schema ? schema.parse(payload) : payload;
   } catch (error) {
-    if (error instanceof Error && error.name === "ZodError") {
-      throw new ValidationError(
-        target,
-        payload,
-        (0, import_zod3.prettifyError)(error)
-      );
+    if (error instanceof import_zod3.ZodError) {
+      throw new ValidationError(target, payload, (0, import_zod3.prettifyError)(error));
     }
     throw new ValidationError(target, payload, error);
   }
 };
 var extend = (source, schema, target) => {
   const value = validate("config", source, schema);
-  return Object.assign(target || {}, value);
+  return { ...target, ...value };
 };
 async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms ?? config().sleepMs));
@@ -777,7 +780,7 @@ function port(injector) {
     if (!adapters.has(injector.name)) {
       const injected = injector(adapter);
       adapters.set(injector.name, injected);
-      console.log(`[act] + ${injector.name}:${injected.constructor.name}`);
+      log().info(`[act] + ${injector.name}:${injected.constructor.name}`);
     }
     return adapters.get(injector.name);
   };
@@ -798,13 +801,13 @@ var cache = port(function cache2(adapter) {
 var disposers = [];
 async function disposeAndExit(code = "EXIT") {
   if (code === "ERROR" && config().env === "production") return;
-  await Promise.all(disposers.map((disposer) => disposer()));
-  await Promise.all(
-    [...adapters.values()].reverse().map(async (adapter) => {
-      await adapter.dispose();
-      console.log(`[act] - ${adapter.constructor.name}`);
-    })
-  );
+  for (const disposer of [...disposers].reverse()) {
+    await disposer();
+  }
+  for (const adapter of [...adapters.values()].reverse()) {
+    await adapter.dispose();
+    log().info(`[act] - ${adapter.constructor.name}`);
+  }
   adapters.clear();
   config().env !== "test" && process.exit(code === "ERROR" ? 1 : 0);
 }
@@ -816,21 +819,20 @@ var SNAP_EVENT = "__snapshot__";
 var TOMBSTONE_EVENT = "__tombstone__";
 
 // src/signals.ts
-var logger = log();
 process.once("SIGINT", async (arg) => {
-  logger.info(arg, "SIGINT");
+  log().info(arg, "SIGINT");
   await disposeAndExit("EXIT");
 });
 process.once("SIGTERM", async (arg) => {
-  logger.info(arg, "SIGTERM");
+  log().info(arg, "SIGTERM");
   await disposeAndExit("EXIT");
 });
 process.once("uncaughtException", async (arg) => {
-  logger.error(arg, "Uncaught Exception");
+  log().error(arg, "Uncaught Exception");
   await disposeAndExit("ERROR");
 });
 process.once("unhandledRejection", async (arg) => {
-  logger.error(arg, "Unhandled Rejection");
+  log().error(arg, "Unhandled Rejection");
   await disposeAndExit("ERROR");
 });
 
@@ -1024,6 +1026,10 @@ async function load(me, stream, callback, asOf) {
       } else if (me.patch[e.name]) {
         state2 = (0, import_act_patch.patch)(state2, me.patch[e.name](event, state2));
         patches++;
+      } else if (e.name !== TOMBSTONE_EVENT) {
+        log().warn(
+          `Skipping unknown event "${String(e.name)}" on stream "${stream}" (id=${e.id}) \u2014 no reducer in state "${me.name}"`
+        );
       }
       callback && callback({ event, state: state2, patches, snaps });
     },
@@ -1118,44 +1124,69 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
 }
 
 // src/internal/tracing.ts
+var PRETTY = config().env !== "production";
+var C_BLUE = "\x1B[38;5;39m";
+var C_ORANGE = "\x1B[38;5;208m";
+var C_GREEN = "\x1B[38;5;42m";
+var C_MAGENTA = "\x1B[38;5;165m";
+var C_DRAIN = "\x1B[38;5;244m";
+var C_RESET = "\x1B[0m";
+var es_caption = (caption, color, body) => PRETTY ? `${color}${body}${C_RESET}` : `${caption}: ${body}`;
+var drain_caption = (caption) => {
+  const tag = `>> ${caption}`;
+  return PRETTY ? `${C_DRAIN}${tag}${C_RESET}` : tag;
+};
 var traced = (inner, exit, entry) => (async (...args) => {
   entry?.(...args);
   const result = await inner(...args);
   exit?.(result, ...args);
   return result;
 });
-function buildEs(logger2) {
-  if (logger2.level !== "trace") {
+function buildEs(logger) {
+  if (logger.level !== "trace") {
     return { snap, load, action };
   }
   return {
     snap: traced(snap, void 0, (snapshot) => {
-      logger2.trace(
-        `\u{1F7E0} snap ${snapshot.event.stream}@${snapshot.event.version}`
+      logger.trace(
+        es_caption(
+          "snap",
+          C_MAGENTA,
+          `${snapshot.event.stream}@${snapshot.event.version}`
+        )
       );
     }),
     load: traced(load, void 0, (_me, stream, _cb, asOf) => {
-      logger2.trace(`\u{1F7E2} load ${stream}${asOf ? " (as-of)" : ""}`);
+      logger.trace(
+        es_caption("load", C_GREEN, `${stream}${asOf ? " (as-of)" : ""}`)
+      );
     }),
     action: traced(
       action,
       (snapshots, _me, _action, target) => {
         const committed = snapshots.filter((s) => s.event);
         if (committed.length) {
-          logger2.trace(
+          logger.trace(
             committed.map((s) => s.event.data),
-            `\u{1F534} commit ${target.stream}.${committed.map((s) => s.event.name).join(", ")}`
+            es_caption(
+              "committed",
+              C_ORANGE,
+              `${target.stream}.${committed.map((s) => s.event.name).join(", ")}`
+            )
           );
         }
       },
       (_me, action2, target, payload) => {
-        logger2.trace(payload, `\u{1F535} ${target.stream}.${action2}`);
+        logger.trace(
+          payload,
+          es_caption("action", C_BLUE, `${target.stream}.${action2}`)
+        );
       }
     )
   };
 }
-function buildDrain(logger2) {
-  if (logger2.level !== "trace") {
+function buildDrain(logger) {
+  if (logger.level !== "trace") {
     return {
       claim,
       fetch,
@@ -1170,7 +1201,7 @@ function buildDrain(logger2) {
         const data = Object.fromEntries(
           leased.map(({ stream, at, retry }) => [stream, { at, retry }])
         );
-        logger2.trace(data, ">> lease");
+        logger.trace(data, drain_caption("claimed"));
       }
     }),
     fetch: traced(fetch, (fetched) => {
@@ -1183,14 +1214,14 @@ function buildDrain(logger2) {
           return [key, value];
         })
       );
-      logger2.trace(data, ">> fetch");
+      logger.trace(data, drain_caption("fetched"));
     }),
     ack: traced(ack, (acked) => {
       if (acked.length) {
         const data = Object.fromEntries(
           acked.map(({ stream, at, retry }) => [stream, { at, retry }])
         );
-        logger2.trace(data, ">> ack");
+        logger.trace(data, drain_caption("acked"));
       }
     }),
     block: traced(block, (blocked) => {
@@ -1201,13 +1232,13 @@ function buildDrain(logger2) {
             { at, retry, error }
           ])
         );
-        logger2.trace(data, ">> block");
+        logger.trace(data, drain_caption("blocked"));
       }
     }),
     subscribe: traced(subscribe, (result, streams) => {
       if (result.subscribed) {
         const data = streams.map(({ stream }) => stream).join(" ");
-        logger2.trace(`>> correlate ${data}`);
+        logger.trace(`${drain_caption("correlated")} ${data}`);
       }
     })
   };
@@ -1221,7 +1252,7 @@ var Act = class {
     this._batch_handlers = batchHandlers;
     this._es = buildEs(this._logger);
     this._cd = buildDrain(this._logger);
-    const statics = [];
+    const statics = /* @__PURE__ */ new Map();
     for (const [name, register] of Object.entries(this.registry.events)) {
       if (register.reactions.size > 0) {
         this._reactive_events.add(name);
@@ -1230,14 +1261,18 @@ var Act = class {
         if (typeof reaction.resolver === "function") {
           this._has_dynamic_resolvers = true;
         } else {
-          statics.push({
-            stream: reaction.resolver.target,
-            source: reaction.resolver.source
-          });
+          const { target, source } = reaction.resolver;
+          const key = `${target}|${source ?? ""}`;
+          if (!statics.has(key)) statics.set(key, { stream: target, source });
         }
       }
     }
-    this._static_targets = statics;
+    this._static_targets = [...statics.values()];
+    for (const merged of this._states.values()) {
+      for (const eventName of Object.keys(merged.events)) {
+        this._event_to_state.set(eventName, merged);
+      }
+    }
     dispose(() => {
       this._emitter.removeAllListeners();
       this.stop_correlations();
@@ -1284,8 +1319,21 @@ var Act = class {
   _es;
   /** Correlate/drain pipeline ops, optionally wrapped with trace decorators */
   _cd;
+  /**
+   * Event-name → owning state, computed at build time. The duplicate-event
+   * guard in merge.ts ensures one event name maps to at most one state, so
+   * this lookup is unambiguous. Used by `close()` to pick the right reducer
+   * set when seeding a `restart` snapshot in multi-state apps.
+   */
+  _event_to_state = /* @__PURE__ */ new Map();
   /** Logger resolved at construction time (after user port configuration) */
   _logger = log();
+  /** Pre-bound IAct methods reused across drain cycles. Only `do` varies per
+   * payload (it captures the triggering event for reactingTo auto-inject). */
+  _bound_do = this.do.bind(this);
+  _bound_load = this.load.bind(this);
+  _bound_query = this.query.bind(this);
+  _bound_query_array = this.query_array.bind(this);
   /**
    * Executes an action on a state instance, committing resulting events.
    *
@@ -1508,12 +1556,12 @@ var Act = class {
     const stream = lease.stream;
     let at = payloads.at(0).event.id, handled = 0;
     lease.retry > 0 && this._logger.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
-    const doAction = this.do.bind(this);
+    const doAction = this._bound_do;
     const scopedApp = {
       do: doAction,
-      load: this.load.bind(this),
-      query: this.query.bind(this),
-      query_array: this.query_array.bind(this)
+      load: this._bound_load,
+      query: this._bound_query,
+      query_array: this._bound_query_array
     };
     for (const payload of payloads) {
       const { event, handler, options } = payload;
@@ -1646,12 +1694,13 @@ var Act = class {
           return { fetched: [], leased: [], acked: [], blocked: [] };
         }
         const fetched = await this._cd.fetch(leased, eventLimit);
-        const payloadsMap = /* @__PURE__ */ new Map();
+        const fetchMap = /* @__PURE__ */ new Map();
         const fetch_window_at = fetched.reduce(
           (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
           0
         );
-        fetched.forEach(({ stream, events }) => {
+        for (const f of fetched) {
+          const { stream, events } = f;
           const payloads = events.flatMap((event) => {
             const register = this.registry.events[event.name];
             if (!register) return [];
@@ -1660,13 +1709,13 @@ var Act = class {
               return resolved && resolved.target === stream;
             }).map((reaction) => ({ ...reaction, event }));
           });
-          payloadsMap.set(stream, payloads);
-        });
+          fetchMap.set(stream, { fetch: f, payloads });
+        }
         const handled = await Promise.all(
           leased.map((lease) => {
-            const streamFetch = fetched.find((f) => f.stream === lease.stream);
-            const at = streamFetch?.events.at(-1)?.id || fetch_window_at;
-            const payloads = payloadsMap.get(lease.stream);
+            const entry = fetchMap.get(lease.stream);
+            const at = entry?.fetch.events.at(-1)?.id || fetch_window_at;
+            const payloads = entry?.payloads ?? [];
             const batchHandler = this._batch_handlers.get(lease.stream);
             if (batchHandler && payloads.length > 0) {
               return this.handleBatch({ ...lease, at }, payloads, batchHandler);
@@ -2000,16 +2049,24 @@ var Act = class {
       streams.map(async (s) => {
         let maxId = -1;
         let version = -1;
+        let lastEventName;
         await store().query(
           (e) => {
-            if (e.name !== TOMBSTONE_EVENT) {
+            if (e.name === TOMBSTONE_EVENT) return;
+            if (maxId === -1) {
               maxId = e.id;
               version = e.version;
             }
+            if (e.name !== SNAP_EVENT && lastEventName === void 0) {
+              lastEventName = e.name;
+            }
           },
-          { stream: s, stream_exact: true, backward: true, limit: 1 }
+          // limit: 2 covers the typical snapshot-at-head case (snapshot is
+          // always preceded by the domain event it captured). Streams with
+          // unusual layouts fall back to no-seed via the lookup miss path.
+          { stream: s, stream_exact: true, backward: true, limit: 2 }
         );
-        if (maxId >= 0) streamInfo.set(s, { maxId, version });
+        if (maxId >= 0) streamInfo.set(s, { maxId, version, lastEventName });
       })
     );
     const skipped = [];
@@ -2018,16 +2075,14 @@ var Act = class {
       safe = [...streamInfo.keys()];
     } else {
       const pendingSet = /* @__PURE__ */ new Set();
-      const leases = await store().claim(1e3, 1e3, (0, import_crypto2.randomUUID)(), 1);
-      if (leases.length) await store().ack(leases);
-      for (const lease of leases) {
-        const sourceRe = lease.source ? RegExp(lease.source) : void 0;
+      await store().query_streams((position) => {
+        const sourceRe = position.source ? RegExp(position.source) : void 0;
         for (const [stream, info] of streamInfo) {
-          if ((!sourceRe || sourceRe.test(stream)) && lease.at < info.maxId) {
+          if ((!sourceRe || sourceRe.test(stream)) && position.at < info.maxId) {
             pendingSet.add(stream);
           }
         }
-      }
+      });
       safe = [];
       for (const [stream] of streamInfo) {
         if (pendingSet.has(stream)) {
@@ -2067,16 +2122,21 @@ var Act = class {
       this.emit("closed", result2);
       return result2;
     }
-    const mergedState = [...this._states.values()][0];
     const seedStates = /* @__PURE__ */ new Map();
-    if (mergedState) {
-      await Promise.all(
-        guarded.filter((s) => targetMap.get(s)?.restart).map(async (stream) => {
-          const snap2 = await this._es.load(mergedState, stream);
-          seedStates.set(stream, snap2.state);
-        })
-      );
-    }
+    await Promise.all(
+      guarded.filter((s) => targetMap.get(s)?.restart).map(async (stream) => {
+        const lastEventName = streamInfo.get(stream)?.lastEventName;
+        const ownerState = lastEventName ? this._event_to_state.get(lastEventName) : void 0;
+        if (!ownerState) {
+          this._logger.error(
+            `Cannot seed restart for "${stream}": no registered state owns event "${lastEventName ?? "<none>"}". Stream will be tombstoned instead.`
+          );
+          return;
+        }
+        const snap2 = await this._es.load(ownerState, stream);
+        seedStates.set(stream, snap2.state);
+      })
+    );
     for (const stream of guarded) {
       const archiveFn = targetMap.get(stream)?.archive;
       if (archiveFn) await archiveFn();
@@ -2187,6 +2247,14 @@ var Act = class {
 };
 
 // src/act-builder.ts
+function registerBatchHandler(proj, batchHandlers) {
+  if (!proj.batchHandler || !proj.target) return;
+  const existing = batchHandlers.get(proj.target);
+  if (existing && existing !== proj.batchHandler) {
+    throw new Error(`Duplicate batch handler for target "${proj.target}"`);
+  }
+  batchHandlers.set(proj.target, proj.batchHandler);
+}
 function act(states = /* @__PURE__ */ new Map(), registry = {
   actions: {},
   events: {}
@@ -2221,9 +2289,7 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
     },
     withProjection: (proj) => {
       mergeProjection(proj, registry.events);
-      if (proj.batchHandler && proj.target) {
-        batchHandlers.set(proj.target, proj.batchHandler);
-      }
+      registerBatchHandler(proj, batchHandlers);
       return act(
         states,
         registry,
@@ -2269,9 +2335,7 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
     build: () => {
       for (const proj of pendingProjections) {
         mergeProjection(proj, registry.events);
-        if (proj.batchHandler && proj.target) {
-          batchHandlers.set(proj.target, proj.batchHandler);
-        }
+        registerBatchHandler(proj, batchHandlers);
       }
       return new Act(
         registry,