@rotorsoft/act 1.10.0 → 1.10.1

package/dist/test/index.cjs

@@ -3998,7 +3998,7 @@ var ConsoleLogger = class _ConsoleLogger {
     this._pretty = pretty;
     this.level = level;
     const threshold = LEVEL_VALUES[level] ?? 30;
-    const write = pretty ? this._prettyWrite.bind(this, bindings) : this._jsonWrite.bind(this, bindings);
+    const write = pretty ? this._pretty_write.bind(this, bindings) : this._json_write.bind(this, bindings);
     this.fatal = write.bind(this, "fatal", 60);
     this.error = threshold <= 50 ? write.bind(this, "error", 50) : noop;
     this.warn = threshold <= 40 ? write.bind(this, "warn", 40) : noop;
@@ -4017,24 +4017,24 @@ var ConsoleLogger = class _ConsoleLogger {
       bindings
     });
   }
-  _jsonWrite(bindings, level, _num, objOrMsg, msg) {
+  _json_write(bindings, level, _num, obj_or_msg, msg) {
     let obj;
     let message;
-    if (typeof objOrMsg === "string") {
-      message = objOrMsg;
+    if (typeof obj_or_msg === "string") {
+      message = obj_or_msg;
       obj = {};
-    } else if (objOrMsg instanceof Error) {
-      message = msg ?? objOrMsg.message;
+    } else if (obj_or_msg instanceof Error) {
+      message = msg ?? obj_or_msg.message;
       obj = {
-        error: { message: objOrMsg.message, name: objOrMsg.name },
-        stack: objOrMsg.stack
+        error: { message: obj_or_msg.message, name: obj_or_msg.name },
+        stack: obj_or_msg.stack
       };
-    } else if (objOrMsg !== null && typeof objOrMsg === "object") {
+    } else if (obj_or_msg !== null && typeof obj_or_msg === "object") {
       message = msg;
-      obj = { ...objOrMsg };
+      obj = { ...obj_or_msg };
     } else {
       message = msg;
-      obj = { value: objOrMsg };
+      obj = { value: obj_or_msg };
     }
     const entry = Object.assign({ level, time: Date.now() }, bindings, obj);
     if (message) entry.msg = message;
@@ -4051,29 +4051,29 @@ var ConsoleLogger = class _ConsoleLogger {
     }
     process.stdout.write(line + "\n");
   }
-  _prettyWrite(bindings, level, _num, objOrMsg, msg) {
+  _pretty_write(bindings, level, _num, obj_or_msg, msg) {
     const color = LEVEL_COLORS[level];
     const tag = `${color}${level.toUpperCase().padEnd(5)}${RESET}`;
     const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
     let message;
     let data;
-    if (typeof objOrMsg === "string") {
-      message = objOrMsg;
-    } else if (objOrMsg instanceof Error) {
-      message = msg ?? objOrMsg.message;
-      data = objOrMsg.stack;
+    if (typeof obj_or_msg === "string") {
+      message = obj_or_msg;
+    } else if (obj_or_msg instanceof Error) {
+      message = msg ?? obj_or_msg.message;
+      data = obj_or_msg.stack;
     } else {
       message = msg ?? "";
-      if (objOrMsg !== void 0 && objOrMsg !== null) {
+      if (obj_or_msg !== void 0 && obj_or_msg !== null) {
         try {
-          data = JSON.stringify(objOrMsg);
+          data = JSON.stringify(obj_or_msg);
         } catch {
           data = "[unserializable]";
         }
       }
     }
-    const bindStr = bindings && Object.keys(bindings).length ? ` ${JSON.stringify(bindings)}` : "";
-    const parts = [ts, tag, message, data, bindStr].filter(Boolean);
+    const bind_str = bindings && Object.keys(bindings).length ? ` ${JSON.stringify(bindings)}` : "";
+    const parts = [ts, tag, message, data, bind_str].filter(Boolean);
     process.stdout.write(parts.join(" ") + "\n");
   }
 };
@@ -4229,16 +4229,16 @@ var FALLBACK_PACKAGE = {
   version: "0.0.0-fallback",
   description: "Synthetic fallback \u2014 package.json could not be loaded"
 };
-var getPackage = () => {
+var get_package = () => {
   try {
     const raw = fs.readFileSync("package.json");
     return JSON.parse(raw.toString());
   } catch (err) {
-    pkgLoadError = err;
+    pkg_load_error = err;
     return FALLBACK_PACKAGE;
   }
 };
-var pkgLoadError;
+var pkg_load_error;
 var BaseSchema = PackageSchema.extend({
   env: import_zod4.z.enum(Environments),
   logLevel: import_zod4.z.enum(LogLevels),
@@ -4250,7 +4250,7 @@ var env = NODE_ENV || "development";
 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", 10);
-var pkg = getPackage();
+var pkg = get_package();
 var _validated;
 var config = () => {
   if (!_validated) {
@@ -4258,12 +4258,12 @@ var config = () => {
       { ...pkg, env, logLevel, logSingleLine, sleepMs },
       BaseSchema
     );
-    if (pkgLoadError) {
-      const msg = pkgLoadError instanceof Error ? pkgLoadError.message : typeof pkgLoadError === "string" ? pkgLoadError : "unknown error";
+    if (pkg_load_error) {
+      const msg = pkg_load_error instanceof Error ? pkg_load_error.message : typeof pkg_load_error === "string" ? pkg_load_error : "unknown error";
       log().warn(
         `[act] Could not read package.json (${msg}); using synthetic name="${FALLBACK_PACKAGE.name}" version="${FALLBACK_PACKAGE.version}".`
       );
-      pkgLoadError = void 0;
+      pkg_load_error = void 0;
     }
   }
   return _validated;
@@ -4331,14 +4331,14 @@ var InMemoryStream = class {
    * Bump the priority via {@link subscribe}: keeps the maximum across
    * reactions so the highest-priority registrant wins.
    */
-  bumpPriority(priority) {
+  bump_priority(priority) {
     if (priority > this._priority) this._priority = priority;
   }
   /**
    * Set the priority outright via {@link prioritize}: operator
    * runtime override that ignores the build-time `max()` invariant.
    */
-  setPriority(priority) {
+  set_priority(priority) {
     this._priority = priority;
   }
   get is_available() {
@@ -4460,28 +4460,28 @@ var InMemoryStore = class {
   // 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();
+  _stream_versions = /* @__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();
+  _max_event_id_by_stream = /* @__PURE__ */ new Map();
   // global max non-snapshot event id — fast pre-check for source-less streams in claim()
-  _maxNonSnapEventId = -1;
+  _max_non_snap_event_id = -1;
   // stream → (event_id → cloned sensitive payload). Two-level so `forget_pii`
   // is O(1) — drop the inner Map for the stream and the wipe is done — mirroring
   // the `DELETE WHERE stream = ?` scope that durable adapters get from their
   // stream index. Entries exist only for events committed with a non-null
   // `pii` field; absence means "no PII" (returned as `null` on load).
   _pii = /* @__PURE__ */ new Map();
-  _resetIndexes() {
+  _reset_indexes() {
     this._events.length = 0;
-    this._streamVersions.clear();
-    this._maxEventIdByStream.clear();
-    this._maxNonSnapEventId = -1;
+    this._stream_versions.clear();
+    this._max_event_id_by_stream.clear();
+    this._max_non_snap_event_id = -1;
     this._pii.clear();
   }
   // Attach the isolated PII payload (or null) to an event before handing it to
   // a caller. Allocation-free for events without PII — by far the common case.
-  _withPii(e) {
+  _with_pii(e) {
     const pii = this._pii.get(e.stream)?.get(e.id);
     return pii ? { ...e, pii } : e;
   }
@@ -4491,7 +4491,7 @@ var InMemoryStore = class {
    */
   async dispose() {
     await sleep();
-    this._resetIndexes();
+    this._reset_indexes();
   }
   /**
    * Seed the store with initial data (no-op for in-memory).
@@ -4506,7 +4506,7 @@ var InMemoryStore = class {
    */
   async drop() {
     await sleep();
-    this._resetIndexes();
+    this._reset_indexes();
     this._streams = /* @__PURE__ */ new Map();
   }
   in_query(query, e) {
@@ -4540,7 +4540,7 @@ var InMemoryStore = class {
         if (query.after && e.id <= query.after) break;
         if (query.created_after && e.created <= query.created_after) break;
         await Promise.resolve(
-          callback(this._withPii(e))
+          callback(this._with_pii(e))
         );
         count++;
         if (query?.limit && count >= query.limit) break;
@@ -4554,7 +4554,7 @@ var InMemoryStore = class {
         if (query?.before && e.id >= query.before) break;
         if (query?.created_before && e.created >= query.created_before) break;
         await Promise.resolve(
-          callback(this._withPii(e))
+          callback(this._with_pii(e))
         );
         count++;
         if (query?.limit && count >= query.limit) break;
@@ -4573,17 +4573,17 @@ var InMemoryStore = class {
    */
   async commit(stream, msgs, meta, expectedVersion) {
     await sleep();
-    const currentVersion = this._streamVersions.get(stream) ?? -1;
-    if (typeof expectedVersion === "number" && currentVersion !== expectedVersion) {
+    const current_version = this._stream_versions.get(stream) ?? -1;
+    if (typeof expectedVersion === "number" && current_version !== expectedVersion) {
       throw new ConcurrencyError(
         stream,
-        currentVersion,
+        current_version,
         msgs,
         expectedVersion
       );
     }
-    let version = currentVersion + 1;
-    let lastNonSnapId = -1;
+    let version = current_version + 1;
+    let last_non_snap_id = -1;
     const committed = msgs.map(({ name, data, pii }) => {
       const c = {
         id: this._events.length,
@@ -4596,21 +4596,21 @@ var InMemoryStore = class {
       };
       this._events.push(c);
       if (pii != null) {
-        let perStream = this._pii.get(stream);
-        if (!perStream) {
-          perStream = /* @__PURE__ */ new Map();
-          this._pii.set(stream, perStream);
+        let per_stream = this._pii.get(stream);
+        if (!per_stream) {
+          per_stream = /* @__PURE__ */ new Map();
+          this._pii.set(stream, per_stream);
         }
-        perStream.set(c.id, structuredClone(pii));
+        per_stream.set(c.id, structuredClone(pii));
       }
-      if (name !== SNAP_EVENT) lastNonSnapId = c.id;
+      if (name !== SNAP_EVENT) last_non_snap_id = c.id;
       version++;
-      return this._withPii(c);
+      return this._with_pii(c);
     });
-    this._streamVersions.set(stream, version - 1);
-    if (lastNonSnapId >= 0) {
-      this._maxEventIdByStream.set(stream, lastNonSnapId);
-      this._maxNonSnapEventId = lastNonSnapId;
+    this._stream_versions.set(stream, version - 1);
+    if (last_non_snap_id >= 0) {
+      this._max_event_id_by_stream.set(stream, last_non_snap_id);
+      this._max_non_snap_event_id = last_non_snap_id;
     }
     return committed;
   }
@@ -4625,26 +4625,26 @@ var InMemoryStore = class {
    */
   async claim(lagging, leading, by, millis, lane) {
     await sleep();
-    const sourceRegex = /* @__PURE__ */ new Map();
-    const getRegex = (source) => {
-      let re = sourceRegex.get(source);
+    const source_regex = /* @__PURE__ */ new Map();
+    const get_regex = (source) => {
+      let re = source_regex.get(source);
       if (!re) {
         re = new RegExp(source);
-        sourceRegex.set(source, re);
+        source_regex.set(source, re);
       }
       return re;
     };
-    const hasWork = (s) => {
+    const has_work = (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;
+      if (!s.source) return s.at < this._max_non_snap_event_id;
+      const re = get_regex(s.source);
+      for (const [stream_name, maxId] of this._max_event_id_by_stream) {
+        if (maxId > s.at && re.test(stream_name)) return true;
       }
       return false;
     };
     const available = [...this._streams.values()].filter(
-      (s) => s.is_available && hasWork(s) && (lane === void 0 || s.lane === lane)
+      (s) => s.is_available && has_work(s) && (lane === void 0 || s.lane === lane)
     );
     const lag = available.sort((a, b2) => b2.priority - a.priority || a.at - b2.at).slice(0, lagging).map((s) => ({
       stream: s.stream,
@@ -4688,7 +4688,7 @@ var InMemoryStore = class {
     } of streams) {
       const existing = this._streams.get(stream);
       if (existing) {
-        existing.bumpPriority(priority);
+        existing.bump_priority(priority);
         existing.lane = lane;
       } else {
         this._streams.set(
@@ -4726,17 +4726,17 @@ var InMemoryStore = class {
    * cached in the closure so callers can apply it across the streams
    * map without re-compiling per iteration.
    */
-  _filterPredicate(filter) {
-    const streamRe = filter.stream && !filter.stream_exact ? new RegExp(filter.stream) : void 0;
-    const sourceRe = filter.source && !filter.source_exact ? new RegExp(filter.source) : void 0;
+  _filter_predicate(filter) {
+    const stream_re = filter.stream && !filter.stream_exact ? new RegExp(filter.stream) : void 0;
+    const source_re = filter.source && !filter.source_exact ? new RegExp(filter.source) : void 0;
     return (s) => {
       if (filter.stream !== void 0) {
-        if (filter.stream_exact ? s.stream !== filter.stream : !streamRe.test(s.stream))
+        if (filter.stream_exact ? s.stream !== filter.stream : !stream_re.test(s.stream))
           return false;
       }
       if (filter.source !== void 0) {
         if (s.source === void 0) return false;
-        if (filter.source_exact ? s.source !== filter.source : !sourceRe.test(s.source))
+        if (filter.source_exact ? s.source !== filter.source : !source_re.test(s.source))
           return false;
       }
       if (filter.blocked !== void 0 && s.blocked !== filter.blocked)
@@ -4765,7 +4765,7 @@ var InMemoryStore = class {
         }
       }
     } else {
-      const matches = this._filterPredicate(input);
+      const matches = this._filter_predicate(input);
       for (const s of this._streams.values()) {
         if (matches(s)) {
           s.reset();
@@ -4810,7 +4810,7 @@ var InMemoryStore = class {
         if (s?.unblock()) count++;
       }
     } else {
-      const matches = this._filterPredicate({ ...input, blocked: true });
+      const matches = this._filter_predicate({ ...input, blocked: true });
       for (const s of this._streams.values()) {
         if (matches(s) && s.unblock()) count++;
       }
@@ -4828,12 +4828,12 @@ var InMemoryStore = class {
    */
   async prioritize(filter, priority) {
     await sleep();
-    const matches = this._filterPredicate(filter);
+    const matches = this._filter_predicate(filter);
     let count = 0;
     for (const s of this._streams.values()) {
       if (!matches(s)) continue;
       if (s.priority !== priority) {
-        s.setPriority(priority);
+        s.set_priority(priority);
         count++;
       }
     }
@@ -4849,8 +4849,8 @@ var InMemoryStore = class {
     const limit = query?.limit ?? 100;
     const after = query?.after;
     const blocked = query?.blocked;
-    const streamRe = query?.stream && !query.stream_exact ? new RegExp(query.stream) : void 0;
-    const sourceRe = query?.source && !query.source_exact ? new RegExp(query.source) : void 0;
+    const stream_re = query?.stream && !query.stream_exact ? new RegExp(query.stream) : void 0;
+    const source_re = query?.source && !query.source_exact ? new RegExp(query.source) : void 0;
     const sorted = [...this._streams.values()].sort(
       (a, b2) => a.stream.localeCompare(b2.stream)
     );
@@ -4858,12 +4858,12 @@ var InMemoryStore = class {
     for (const s of sorted) {
       if (after !== void 0 && s.stream <= after) continue;
       if (query?.stream !== void 0) {
-        if (query.stream_exact ? s.stream !== query.stream : !streamRe.test(s.stream))
+        if (query.stream_exact ? s.stream !== query.stream : !stream_re.test(s.stream))
           continue;
       }
       if (query?.source !== void 0) {
         if (s.source === void 0) continue;
-        if (query.source_exact ? s.source !== query.source : !sourceRe.test(s.source))
+        if (query.source_exact ? s.source !== query.source : !source_re.test(s.source))
           continue;
       }
       if (blocked !== void 0 && s.blocked !== blocked) continue;
@@ -4904,44 +4904,44 @@ var InMemoryStore = class {
   async query_stats(input, options) {
     await sleep();
     const exclude = new Set(options?.exclude ?? []);
-    const wantTail = options?.tail ?? false;
-    const wantCount = options?.count ?? false;
-    const wantNames = options?.names ?? false;
+    const want_tail = options?.tail ?? false;
+    const want_count = options?.count ?? false;
+    const want_names = options?.names ?? false;
     const before = options?.before;
-    const arrayTargets = Array.isArray(input) ? new Set(input) : null;
+    const array_targets = Array.isArray(input) ? new Set(input) : null;
     const filter = Array.isArray(input) ? null : input;
-    const streamRe = filter?.stream && !filter.stream_exact ? new RegExp(filter.stream) : void 0;
-    const scopeCache = /* @__PURE__ */ new Map();
-    const inScope = (stream) => {
-      const cached = scopeCache.get(stream);
+    const stream_re = filter?.stream && !filter.stream_exact ? new RegExp(filter.stream) : void 0;
+    const scope_cache = /* @__PURE__ */ new Map();
+    const in_scope = (stream) => {
+      const cached = scope_cache.get(stream);
       if (cached !== void 0) return cached;
       let ok = true;
-      if (arrayTargets) {
-        ok = arrayTargets.has(stream);
+      if (array_targets) {
+        ok = array_targets.has(stream);
       } else if (filter?.stream !== void 0) {
         ok = filter.stream_exact ? stream === filter.stream : (
-          // biome-ignore lint/style/noNonNullAssertion: streamRe set when stream is regex
-          streamRe.test(stream)
+          // biome-ignore lint/style/noNonNullAssertion: stream_re set when stream is regex
+          stream_re.test(stream)
         );
       }
-      scopeCache.set(stream, ok);
+      scope_cache.set(stream, ok);
       return ok;
     };
     const acc = /* @__PURE__ */ new Map();
     for (const e of this._events) {
       if (before !== void 0 && e.id >= before) continue;
-      if (!inScope(e.stream)) continue;
+      if (!in_scope(e.stream)) continue;
       if (exclude.has(e.name)) continue;
       let a = acc.get(e.stream);
       if (!a) {
         a = { head: e, count: 0 };
-        if (wantTail) a.tail = e;
-        if (wantNames) a.names = {};
+        if (want_tail) a.tail = e;
+        if (want_names) a.names = {};
         acc.set(e.stream, a);
       }
       a.head = e;
       a.count++;
-      if (wantNames) {
+      if (want_names) {
         const n = String(e.name);
         a.names[n] = (a.names[n] ?? 0) + 1;
       }
@@ -4949,9 +4949,9 @@ var InMemoryStore = class {
     const out = /* @__PURE__ */ new Map();
     for (const [stream, a] of acc) {
       const stats = { head: a.head };
-      if (wantTail) stats.tail = a.tail;
-      if (wantCount) stats.count = a.count;
-      if (wantNames) stats.names = a.names;
+      if (want_tail) stats.tail = a.tail;
+      if (want_count) stats.count = a.count;
+      if (want_names) stats.names = a.names;
       out.set(stream, stats);
     }
     return out;
@@ -4963,18 +4963,18 @@ var InMemoryStore = class {
    */
   async truncate(targets) {
     await sleep();
-    const deletedCounts = /* @__PURE__ */ new Map();
-    const streamSet = new Set(targets.map((t) => t.stream));
+    const deleted_counts = /* @__PURE__ */ new Map();
+    const stream_set = new Set(targets.map((t) => t.stream));
     for (const e of this._events) {
-      if (streamSet.has(e.stream)) {
-        deletedCounts.set(e.stream, (deletedCounts.get(e.stream) ?? 0) + 1);
+      if (stream_set.has(e.stream)) {
+        deleted_counts.set(e.stream, (deleted_counts.get(e.stream) ?? 0) + 1);
       }
     }
-    this._events = this._events.filter((e) => !streamSet.has(e.stream));
-    for (const stream of streamSet) {
+    this._events = this._events.filter((e) => !stream_set.has(e.stream));
+    for (const stream of stream_set) {
       this._streams.delete(stream);
-      this._streamVersions.delete(stream);
-      this._maxEventIdByStream.delete(stream);
+      this._stream_versions.delete(stream);
+      this._max_event_id_by_stream.delete(stream);
     }
     const result = /* @__PURE__ */ new Map();
     for (const { stream, snapshot, meta } of targets) {
@@ -4988,18 +4988,19 @@ var InMemoryStore = class {
         meta: meta ?? { correlation: "", causation: {} }
       };
       this._events.push(event);
-      this._streamVersions.set(stream, 0);
+      this._stream_versions.set(stream, 0);
       if (event.name !== SNAP_EVENT) {
-        this._maxEventIdByStream.set(stream, event.id);
+        this._max_event_id_by_stream.set(stream, event.id);
       }
       result.set(stream, {
-        deleted: deletedCounts.get(stream) ?? 0,
+        deleted: deleted_counts.get(stream) ?? 0,
         committed: event
       });
     }
     let max = -1;
-    for (const id of this._maxEventIdByStream.values()) if (id > max) max = id;
-    this._maxNonSnapEventId = max;
+    for (const id of this._max_event_id_by_stream.values())
+      if (id > max) max = id;
+    this._max_non_snap_event_id = max;
     return result;
   }
   /**
@@ -5016,34 +5017,34 @@ var InMemoryStore = class {
    */
   async restore(driver) {
     await sleep();
-    const prevEvents = this._events;
-    const prevStreams = this._streams;
-    const prevStreamVersions = this._streamVersions;
-    const prevMaxEventIdByStream = this._maxEventIdByStream;
-    const prevMaxNonSnapEventId = this._maxNonSnapEventId;
+    const prev_events = this._events;
+    const prev_streams = this._streams;
+    const prev_stream_versions = this._stream_versions;
+    const prev_max_event_id_by_stream = this._max_event_id_by_stream;
+    const prev_max_non_snap_event_id = this._max_non_snap_event_id;
     this._events = [];
     this._streams = /* @__PURE__ */ new Map();
-    this._streamVersions = /* @__PURE__ */ new Map();
-    this._maxEventIdByStream = /* @__PURE__ */ new Map();
-    this._maxNonSnapEventId = -1;
+    this._stream_versions = /* @__PURE__ */ new Map();
+    this._max_event_id_by_stream = /* @__PURE__ */ new Map();
+    this._max_non_snap_event_id = -1;
     try {
       await driver(async (event) => {
         const id = this._events.length;
         const committed = { ...event, id };
         this._events.push(committed);
-        this._streamVersions.set(event.stream, event.version);
+        this._stream_versions.set(event.stream, event.version);
         if (event.name !== SNAP_EVENT) {
-          this._maxEventIdByStream.set(event.stream, id);
-          this._maxNonSnapEventId = id;
+          this._max_event_id_by_stream.set(event.stream, id);
+          this._max_non_snap_event_id = id;
         }
         return id;
       });
     } catch (err) {
-      this._events = prevEvents;
-      this._streams = prevStreams;
-      this._streamVersions = prevStreamVersions;
-      this._maxEventIdByStream = prevMaxEventIdByStream;
-      this._maxNonSnapEventId = prevMaxNonSnapEventId;
+      this._events = prev_events;
+      this._streams = prev_streams;
+      this._stream_versions = prev_stream_versions;
+      this._max_event_id_by_stream = prev_max_event_id_by_stream;
+      this._max_non_snap_event_id = prev_max_non_snap_event_id;
       throw err;
     }
   }