@rotorsoft/act 0.32.5 → 0.32.6

package/dist/index.cjs

@@ -70,7 +70,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/adapters/ConsoleLogger.ts
+// src/adapters/console-logger.ts
 var LEVEL_VALUES = {
   fatal: 60,
   error: 50,
@@ -139,14 +139,25 @@ var ConsoleLogger = class _ConsoleLogger {
       obj = {};
     } else if (objOrMsg !== null && typeof objOrMsg === "object") {
       message = msg;
-      obj = Object.fromEntries(Object.entries(objOrMsg));
+      obj = { ...objOrMsg };
     } else {
       message = msg;
       obj = { value: objOrMsg };
     }
     const entry = Object.assign({ level, time: Date.now() }, bindings, obj);
     if (message) entry.msg = message;
-    process.stdout.write(JSON.stringify(entry) + "\n");
+    let line;
+    try {
+      line = JSON.stringify(entry);
+    } catch {
+      line = JSON.stringify({
+        level,
+        time: entry.time,
+        msg: message ?? "[unserializable]",
+        unserializable: true
+      });
+    }
+    process.stdout.write(line + "\n");
   }
   _prettyWrite(bindings, level, _num, objOrMsg, msg) {
     const color = LEVEL_COLORS[level];
@@ -192,7 +203,7 @@ var LruMap = class {
     this._entries.delete(key);
     if (this._entries.size >= this._maxSize) {
       const oldest = this._entries.keys().next().value;
-      if (oldest !== void 0) this._entries.delete(oldest);
+      this._entries.delete(oldest);
     }
     this._entries.set(key, value);
   }
@@ -228,7 +239,7 @@ var LruSet = class {
   }
 };
 
-// src/adapters/InMemoryCache.ts
+// src/adapters/in-memory-cache.ts
 var InMemoryCache = class {
   // CacheEntry<any> lets `get<TState>` and `set<TState>` flow without casts:
   // any is bidirectionally compatible with the per-call TState binding, while
@@ -294,7 +305,7 @@ var StreamClosedError = class extends Error {
 var ConcurrencyError = class extends Error {
   constructor(stream, lastVersion, events, expectedVersion) {
     super(
-      `Concurrency error committing "${events.map((e) => `${stream}.${e.name}.${JSON.stringify(e.data)}`).join(
+      `Concurrency error committing "${events.map((e) => `${stream}.${e.name}`).join(
         ", "
       )}". Expected version ${expectedVersion} but found version ${lastVersion}.`
     );
@@ -383,10 +394,21 @@ var PackageSchema = import_zod2.z.object({
   license: import_zod2.z.string().min(1).optional(),
   dependencies: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional()
 });
+var FALLBACK_PACKAGE = {
+  name: "act-fallback",
+  version: "0.0.0-fallback",
+  description: "Synthetic fallback \u2014 package.json could not be loaded"
+};
 var getPackage = () => {
-  const pkg2 = fs.readFileSync("package.json");
-  return JSON.parse(pkg2.toString());
+  try {
+    const raw = fs.readFileSync("package.json");
+    return JSON.parse(raw.toString());
+  } catch (err) {
+    pkgLoadError = err;
+    return FALLBACK_PACKAGE;
+  }
 };
+var pkgLoadError;
 var BaseSchema = PackageSchema.extend({
   env: import_zod2.z.enum(Environments),
   logLevel: import_zod2.z.enum(LogLevels),
@@ -406,6 +428,13 @@ var config = () => {
       { ...pkg, env, logLevel, logSingleLine, sleepMs },
       BaseSchema
     );
+    if (pkgLoadError) {
+      const msg = pkgLoadError instanceof Error ? pkgLoadError.message : typeof pkgLoadError === "string" ? pkgLoadError : "unknown error";
+      log().warn(
+        `[act] Could not read package.json (${msg}); using synthetic name="${FALLBACK_PACKAGE.name}" version="${FALLBACK_PACKAGE.version}".`
+      );
+      pkgLoadError = void 0;
+    }
   }
   return _validated;
 };
@@ -429,7 +458,7 @@ async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms ?? config().sleepMs));
 }
 
-// src/adapters/InMemoryStore.ts
+// src/adapters/in-memory-store.ts
 var InMemoryStream = class {
   constructor(stream, source) {
     this.stream = stream;
@@ -524,11 +553,13 @@ var InMemoryStream = class {
     }
   }
   /**
-   * Reset this stream's watermark and state for replay.
+   * Reset this stream's watermark and state for replay. The retry counter
+   * resets to -1 to match the constructor + ack() invariant ("released
+   * stream"); the next claim() bumps it to 0 (first attempt).
    */
   reset() {
     this._at = -1;
-    this._retry = 0;
+    this._retry = -1;
     this._blocked = false;
     this._error = "";
     this._leased_by = void 0;
@@ -540,13 +571,26 @@ var InMemoryStore = class {
   _events = [];
   // stored stream positions and other metadata
   _streams = /* @__PURE__ */ new Map();
+  // last committed version per stream — O(1) replacement for filter-on-commit
+  _streamVersions = /* @__PURE__ */ new Map();
+  // max non-snapshot event id per stream — drives the source-pattern probe in claim()
+  // without scanning the full event log.
+  _maxEventIdByStream = /* @__PURE__ */ new Map();
+  // global max non-snapshot event id — fast pre-check for source-less streams in claim()
+  _maxNonSnapEventId = -1;
+  _resetIndexes() {
+    this._events.length = 0;
+    this._streamVersions.clear();
+    this._maxEventIdByStream.clear();
+    this._maxNonSnapEventId = -1;
+  }
   /**
    * Dispose of the store and clear all events.
    * @returns Promise that resolves when disposal is complete.
    */
   async dispose() {
     await sleep();
-    this._events.length = 0;
+    this._resetIndexes();
   }
   /**
    * Seed the store with initial data (no-op for in-memory).
@@ -561,7 +605,7 @@ var InMemoryStore = class {
    */
   async drop() {
     await sleep();
-    this._events.length = 0;
+    this._resetIndexes();
     this._streams = /* @__PURE__ */ new Map();
   }
   in_query(query, e) {
@@ -624,18 +668,19 @@ var InMemoryStore = class {
    */
   async commit(stream, msgs, meta, expectedVersion) {
     await sleep();
-    const instance = this._events.filter((e) => e.stream === stream);
-    if (typeof expectedVersion === "number" && instance.length - 1 !== expectedVersion) {
+    const currentVersion = this._streamVersions.get(stream) ?? -1;
+    if (typeof expectedVersion === "number" && currentVersion !== expectedVersion) {
       throw new ConcurrencyError(
         stream,
-        instance.length - 1,
+        currentVersion,
         msgs,
         expectedVersion
       );
     }
-    let version = instance.length;
-    return msgs.map(({ name, data }) => {
-      const committed = {
+    let version = currentVersion + 1;
+    let lastNonSnapId = -1;
+    const committed = msgs.map(({ name, data }) => {
+      const c = {
         id: this._events.length,
         stream,
         version,
@@ -644,10 +689,17 @@ var InMemoryStore = class {
         data,
         meta
       };
-      this._events.push(committed);
+      this._events.push(c);
+      if (name !== SNAP_EVENT) lastNonSnapId = c.id;
       version++;
-      return committed;
+      return c;
     });
+    this._streamVersions.set(stream, version - 1);
+    if (lastNonSnapId >= 0) {
+      this._maxEventIdByStream.set(stream, lastNonSnapId);
+      this._maxNonSnapEventId = lastNonSnapId;
+    }
+    return committed;
   }
   /**
    * Atomically discovers and leases streams for processing.
@@ -660,10 +712,26 @@ var InMemoryStore = class {
    */
   async claim(lagging, leading, by, millis) {
     await sleep();
+    const sourceRegex = /* @__PURE__ */ new Map();
+    const getRegex = (source) => {
+      let re = sourceRegex.get(source);
+      if (!re) {
+        re = new RegExp(source);
+        sourceRegex.set(source, re);
+      }
+      return re;
+    };
+    const hasWork = (s) => {
+      if (s.at < 0) return true;
+      if (!s.source) return s.at < this._maxNonSnapEventId;
+      const re = getRegex(s.source);
+      for (const [streamName, maxId] of this._maxEventIdByStream) {
+        if (maxId > s.at && re.test(streamName)) return true;
+      }
+      return false;
+    };
     const available = [...this._streams.values()].filter(
-      (s) => s.is_available && (s.at < 0 || this._events.some(
-        (e) => e.id > s.at && e.name !== SNAP_EVENT && (!s.source || RegExp(s.source).test(e.stream))
-      ))
+      (s) => s.is_available && hasWork(s)
     );
     const lag = available.sort((a, b) => a.at - b.at).slice(0, lagging).map((s) => ({
       stream: s.stream,
@@ -800,9 +868,13 @@ var InMemoryStore = class {
       }
     }
     this._events = this._events.filter((e) => !streamSet.has(e.stream));
+    for (const stream of streamSet) {
+      this._streams.delete(stream);
+      this._streamVersions.delete(stream);
+      this._maxEventIdByStream.delete(stream);
+    }
     const result = /* @__PURE__ */ new Map();
     for (const { stream, snapshot, meta } of targets) {
-      this._streams.delete(stream);
       const event = {
         id: this._events.length,
         stream,
@@ -813,11 +885,18 @@ var InMemoryStore = class {
         meta: meta ?? { correlation: "", causation: {} }
       };
       this._events.push(event);
+      this._streamVersions.set(stream, 0);
+      if (event.name !== SNAP_EVENT) {
+        this._maxEventIdByStream.set(stream, event.id);
+      }
       result.set(stream, {
         deleted: deletedCounts.get(stream) ?? 0,
         committed: event
       });
     }
+    let max = -1;
+    for (const id of this._maxEventIdByStream.values()) if (id > max) max = id;
+    this._maxNonSnapEventId = max;
     return result;
   }
 };
@@ -850,7 +929,12 @@ var cache = port(function cache2(adapter) {
 });
 var disposers = [];
 async function disposeAndExit(code = "EXIT") {
-  if (code === "ERROR" && config().env === "production") return;
+  if (code === "ERROR" && config().env === "production") {
+    log().warn(
+      "disposeAndExit('ERROR') ignored in production \u2014 process kept alive"
+    );
+    return;
+  }
   for (const disposer of [...disposers].reverse()) {
     await disposer();
   }
@@ -892,7 +976,6 @@ var import_events = __toESM(require("events"), 1);
 // src/internal/close-cycle.ts
 var import_crypto = require("crypto");
 async function runCloseCycle(targets, deps) {
-  if (!targets.length) return { truncated: /* @__PURE__ */ new Map(), skipped: [] };
   const targetMap = new Map(targets.map((t) => [t.stream, t]));
   const streams = [...targetMap.keys()];
   const skipped = [];
@@ -935,22 +1018,15 @@ async function scanStreamHeads(streams) {
     streams.map(async (s) => {
       let maxId = -1;
       let version = -1;
-      let lastEventName;
+      let lastEventName = "";
       await store().query(
         (e) => {
-          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;
-          }
+          if (e.name === TOMBSTONE_EVENT || maxId !== -1) return;
+          maxId = e.id;
+          version = e.version;
+          lastEventName = e.name;
         },
-        // 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 }
+        { stream: s, stream_exact: true, backward: true, limit: 1 }
       );
       if (maxId >= 0) out.set(s, { maxId, version, lastEventName });
     })
@@ -996,11 +1072,11 @@ async function loadRestartSeeds(guarded, targetMap, streamInfo, eventToState, lo
   const seedStates = /* @__PURE__ */ new Map();
   await Promise.all(
     guarded.filter((s) => targetMap.get(s)?.restart).map(async (stream) => {
-      const lastEventName = streamInfo.get(stream)?.lastEventName;
-      const ownerState = lastEventName ? eventToState.get(lastEventName) : void 0;
+      const lastEventName = streamInfo.get(stream).lastEventName;
+      const ownerState = eventToState.get(lastEventName);
       if (!ownerState) {
         logger.error(
-          `Cannot seed restart for "${stream}": no registered state owns event "${lastEventName ?? "<none>"}". Stream will be tombstoned instead.`
+          `Cannot seed restart for "${stream}": no registered state owns event "${lastEventName}". Stream will be tombstoned instead.`
         );
         return;
       }
@@ -1078,8 +1154,8 @@ async function runDrainCycle(ops, registry, batchHandlers, handle, handleBatch,
   const handled = await Promise.all(
     leased.map((lease) => {
       const entry = fetchMap.get(lease.stream);
-      const at = entry?.fetch.events.at(-1)?.id || fetch_window_at;
-      const payloads = entry?.payloads ?? [];
+      const at = entry.fetch.events.at(-1)?.id || fetch_window_at;
+      const { payloads } = entry;
       const batchHandler = batchHandlers.get(lease.stream);
       if (batchHandler && payloads.length > 0) {
         return handleBatch({ ...lease, at }, payloads, batchHandler);
@@ -1375,8 +1451,8 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
       action: {
         name: action2,
         ...target
-        // payload: TODO: flag to include action payload in metadata
-        // not included by default to avoid large payloads
+        // payload intentionally omitted: it can be large or contain PII,
+        // and callers correlate via the correlation id when they need it.
       },
       event: reactingTo ? {
         id: reactingTo.id,
@@ -1391,7 +1467,10 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
       stream,
       emitted,
       meta,
-      // TODO: review reactions not enforcing expected version
+      // Reactions skip optimistic concurrency: they always append against the
+      // current head. Stream leasing already serializes concurrent reactions,
+      // and forcing version checks here would turn ordinary catch-up into
+      // spurious retries.
       reactingTo ? void 0 : expected
     );
   } catch (error) {