@rotorsoft/act 0.32.2 → 0.32.3

package/dist/index.js

@@ -154,7 +154,7 @@ var InMemoryCache = class {
 };
 
 // src/utils.ts
-import { prettifyError } from "zod";
+import { ZodError, prettifyError } from "zod";
 
 // src/config.ts
 import * as fs from "fs";
@@ -181,7 +181,7 @@ 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 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 config = () => {
   return extend({ ...pkg, env, logLevel, logSingleLine, sleepMs }, BaseSchema);
@@ -192,19 +192,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,
-        prettifyError(error)
-      );
+    if (error instanceof ZodError) {
+      throw new ValidationError(target, payload, 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));
@@ -632,13 +628,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();
+    console.log(`[act] - ${adapter.constructor.name}`);
+  }
   adapters.clear();
   config().env !== "test" && process.exit(code === "ERROR" ? 1 : 0);
 }
@@ -650,21 +646,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");
 });
 
@@ -858,6 +853,10 @@ async function load(me, stream, callback, asOf) {
       } else if (me.patch[e.name]) {
         state2 = 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 });
     },
@@ -958,38 +957,38 @@ var traced = (inner, exit, entry) => (async (...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(
+      logger.trace(
         `\u{1F7E0} snap ${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(`\u{1F7E2} load ${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(", ")}`
           );
         }
       },
       (_me, action2, target, payload) => {
-        logger2.trace(payload, `\u{1F535} ${target.stream}.${action2}`);
+        logger.trace(payload, `\u{1F535} ${target.stream}.${action2}`);
       }
     )
   };
 }
-function buildDrain(logger2) {
-  if (logger2.level !== "trace") {
+function buildDrain(logger) {
+  if (logger.level !== "trace") {
     return {
       claim,
       fetch,
@@ -1004,7 +1003,7 @@ function buildDrain(logger2) {
         const data = Object.fromEntries(
           leased.map(({ stream, at, retry }) => [stream, { at, retry }])
         );
-        logger2.trace(data, ">> lease");
+        logger.trace(data, ">> lease");
       }
     }),
     fetch: traced(fetch, (fetched) => {
@@ -1017,14 +1016,14 @@ function buildDrain(logger2) {
           return [key, value];
         })
       );
-      logger2.trace(data, ">> fetch");
+      logger.trace(data, ">> fetch");
     }),
     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, ">> ack");
       }
     }),
     block: traced(block, (blocked) => {
@@ -1035,13 +1034,13 @@ function buildDrain(logger2) {
             { at, retry, error }
           ])
         );
-        logger2.trace(data, ">> block");
+        logger.trace(data, ">> block");
       }
     }),
     subscribe: traced(subscribe, (result, streams) => {
       if (result.subscribed) {
         const data = streams.map(({ stream }) => stream).join(" ");
-        logger2.trace(`>> correlate ${data}`);
+        logger.trace(`>> correlate ${data}`);
       }
     })
   };
@@ -1072,6 +1071,11 @@ var Act = class {
       }
     }
     this._static_targets = statics;
+    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();
@@ -1118,6 +1122,13 @@ 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();
   /**
@@ -1834,16 +1845,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 = [];
@@ -1852,16 +1871,14 @@ var Act = class {
       safe = [...streamInfo.keys()];
     } else {
       const pendingSet = /* @__PURE__ */ new Set();
-      const leases = await store().claim(1e3, 1e3, randomUUID2(), 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)) {
@@ -1901,16 +1918,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();
@@ -2021,6 +2043,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: {}
@@ -2055,9 +2085,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,
@@ -2103,9 +2131,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,