@rotorsoft/act 0.32.2 → 0.32.4

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";
@@ -179,12 +179,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
@@ -192,19 +199,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));
@@ -611,7 +614,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);
   };
@@ -632,13 +635,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);
 }
@@ -650,21 +653,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 +860,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 });
     },
@@ -952,44 +958,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,
@@ -1004,7 +1035,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) => {
@@ -1017,14 +1048,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) => {
@@ -1035,13 +1066,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}`);
       }
     })
   };
@@ -1055,7 +1086,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);
@@ -1064,14 +1095,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();
@@ -1118,8 +1153,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.
    *
@@ -1342,12 +1390,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;
@@ -1480,12 +1528,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 [];
@@ -1494,13 +1543,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);
@@ -1834,16 +1883,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 +1909,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 +1956,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 +2081,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 +2123,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 +2169,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,