@rotorsoft/act 1.9.0 → 1.10.1

package/dist/test/index.cjs

@@ -232,7 +232,7 @@ function C({ force: e } = {}) {
 var d = C();
 var y = d;
 
-// ../../node_modules/.pnpm/@vitest+pretty-format@4.1.7/node_modules/@vitest/pretty-format/dist/index.js
+// ../../node_modules/.pnpm/@vitest+pretty-format@4.1.8/node_modules/@vitest/pretty-format/dist/index.js
 function _mergeNamespaces(n, m) {
   m.forEach(function(e) {
     e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
@@ -1228,7 +1228,7 @@ var plugins = {
   Error: ErrorPlugin
 };
 
-// ../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/display.js
+// ../../node_modules/.pnpm/@vitest+utils@4.1.8/node_modules/@vitest/utils/dist/display.js
 var ansiColors = {
   bold: ["1", "22"],
   dim: ["2", "22"],
@@ -1942,7 +1942,7 @@ function objDisplay(obj, options = {}) {
   return str;
 }
 
-// ../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/helpers.js
+// ../../node_modules/.pnpm/@vitest+utils@4.1.8/node_modules/@vitest/utils/dist/helpers.js
 function assertTypes(value, name, types) {
   const receivedType = typeof value;
   const pass = types.includes(receivedType);
@@ -2037,7 +2037,7 @@ function unique(array) {
   return Array.from(new Set(array));
 }
 
-// ../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/timers.js
+// ../../node_modules/.pnpm/@vitest+utils@4.1.8/node_modules/@vitest/utils/dist/timers.js
 var SAFE_TIMERS_SYMBOL = /* @__PURE__ */ Symbol("vitest:SAFE_TIMERS");
 function getSafeTimers() {
   const { setTimeout: safeSetTimeout, setInterval: safeSetInterval, clearInterval: safeClearInterval, clearTimeout: safeClearTimeout, setImmediate: safeSetImmediate, clearImmediate: safeClearImmediate, queueMicrotask: safeQueueMicrotask } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
@@ -2054,7 +2054,7 @@ function getSafeTimers() {
   };
 }
 
-// ../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js
+// ../../node_modules/.pnpm/@vitest+utils@4.1.8/node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js
 var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
   if (!input) {
@@ -2151,7 +2151,7 @@ var isAbsolute = function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 };
 
-// ../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/source-map.js
+// ../../node_modules/.pnpm/@vitest+utils@4.1.8/node_modules/@vitest/utils/dist/source-map.js
 var comma = ",".charCodeAt(0);
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var intToChar = new Uint8Array(64);
@@ -2278,7 +2278,7 @@ function parseSingleV8Stack(raw) {
   };
 }
 
-// ../../node_modules/.pnpm/@vitest+runner@4.1.7/node_modules/@vitest/runner/dist/chunk-artifact.js
+// ../../node_modules/.pnpm/@vitest+runner@4.1.8/node_modules/@vitest/runner/dist/chunk-artifact.js
 var PendingError = class extends Error {
   code = "VITEST_PENDING";
   taskId;
@@ -3831,7 +3831,7 @@ function manageArtifactAttachment(attachment) {
   }
 }
 
-// ../../node_modules/.pnpm/vite@8.0.14_@types+node@25.9.1_esbuild@0.27.2_jiti@2.6.1_terser@5.46.1_tsx@4.22.3_yaml@2.9.0/node_modules/vite/dist/node/module-runner.js
+// ../../node_modules/.pnpm/vite@8.0.16_@types+node@25.9.1_esbuild@0.27.2_jiti@2.6.1_terser@5.46.1_tsx@4.22.4_yaml@2.9.0/node_modules/vite/dist/node/module-runner.js
 var SOURCEMAPPING_URL = "sourceMa";
 SOURCEMAPPING_URL += "ppingURL";
 var isWindows = typeof process < "u" && process.platform === "win32";
@@ -3877,7 +3877,7 @@ var envProxy = new Proxy({}, { get(_, p) {
   throw Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
 } });
 
-// ../../node_modules/.pnpm/vitest@4.1.7_@types+node@25.9.1_@vitest+coverage-v8@4.1.7_vite@8.0.14_@types+node@25.9._80d5839fc632fdcd9de039dffc6761e7/node_modules/vitest/dist/index.js
+// ../../node_modules/.pnpm/vitest@4.1.8_@types+node@25.9.1_@vitest+coverage-v8@4.1.8_vite@8.0.16_@types+node@25.9._87965f5280639f5a2754f2fd84ad1804/node_modules/vitest/dist/index.js
 var import_expect_type = __toESM(require_dist(), 1);
 
 // src/internal/lru-map.ts
@@ -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,36 +4051,36 @@ 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");
   }
 };
 
 // src/config.ts
 var fs = __toESM(require("fs"), 1);
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/types/errors.ts
 var Errors = {
@@ -4129,48 +4129,54 @@ var ConcurrencyError = class extends Error {
 };
 
 // src/types/schemas.ts
+var import_zod2 = require("zod");
+
+// src/internal/sensitive.ts
 var import_zod = require("zod");
-var ZodEmpty = import_zod.z.record(import_zod.z.string(), import_zod.z.never());
-var ActorSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  name: import_zod.z.string()
+var _registry = import_zod.z.registry();
+
+// src/types/schemas.ts
+var ZodEmpty = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.never());
+var ActorSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string()
 }).loose().readonly();
-var TargetSchema = import_zod.z.object({
-  stream: import_zod.z.string(),
+var TargetSchema = import_zod2.z.object({
+  stream: import_zod2.z.string(),
   actor: ActorSchema,
-  expectedVersion: import_zod.z.number().optional()
+  expectedVersion: import_zod2.z.number().optional()
 }).loose().readonly();
-var CausationEventSchema = import_zod.z.object({
-  id: import_zod.z.number(),
-  name: import_zod.z.string(),
-  stream: import_zod.z.string()
+var CausationEventSchema = import_zod2.z.object({
+  id: import_zod2.z.number(),
+  name: import_zod2.z.string(),
+  stream: import_zod2.z.string()
 });
-var EventMetaSchema = import_zod.z.object({
-  correlation: import_zod.z.string(),
-  causation: import_zod.z.object({
-    action: TargetSchema.and(import_zod.z.object({ name: import_zod.z.string() })).optional(),
+var EventMetaSchema = import_zod2.z.object({
+  correlation: import_zod2.z.string(),
+  causation: import_zod2.z.object({
+    action: TargetSchema.and(import_zod2.z.object({ name: import_zod2.z.string() })).optional(),
     event: CausationEventSchema.optional()
   })
 }).readonly();
-var CommittedMetaSchema = import_zod.z.object({
-  id: import_zod.z.number(),
-  stream: import_zod.z.string(),
-  version: import_zod.z.number(),
-  created: import_zod.z.date(),
+var CommittedMetaSchema = import_zod2.z.object({
+  id: import_zod2.z.number(),
+  stream: import_zod2.z.string(),
+  version: import_zod2.z.number(),
+  created: import_zod2.z.date(),
   meta: EventMetaSchema
 }).readonly();
-var QuerySchema = import_zod.z.object({
-  stream: import_zod.z.string().optional(),
-  names: import_zod.z.string().array().optional(),
-  before: import_zod.z.number().optional(),
-  after: import_zod.z.number().optional(),
-  limit: import_zod.z.number().optional(),
-  created_before: import_zod.z.date().optional(),
-  created_after: import_zod.z.date().optional(),
-  backward: import_zod.z.boolean().optional(),
-  correlation: import_zod.z.string().optional(),
-  with_snaps: import_zod.z.boolean().optional(),
-  stream_exact: import_zod.z.boolean().optional()
+var QuerySchema = import_zod2.z.object({
+  stream: import_zod2.z.string().optional(),
+  names: import_zod2.z.string().array().optional(),
+  before: import_zod2.z.number().optional(),
+  after: import_zod2.z.number().optional(),
+  limit: import_zod2.z.number().optional(),
+  created_before: import_zod2.z.date().optional(),
+  created_after: import_zod2.z.date().optional(),
+  backward: import_zod2.z.boolean().optional(),
+  correlation: import_zod2.z.string().optional(),
+  with_snaps: import_zod2.z.boolean().optional(),
+  stream_exact: import_zod2.z.boolean().optional()
 }).readonly();
 
 // src/types/index.ts
@@ -4190,13 +4196,13 @@ var LogLevels = [
 ];
 
 // src/utils.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var validate = (target, payload, schema) => {
   try {
     return schema ? schema.parse(payload) : payload;
   } catch (error) {
-    if (error instanceof import_zod2.ZodError) {
-      throw new ValidationError(target, payload, (0, import_zod2.prettifyError)(error));
+    if (error instanceof import_zod3.ZodError) {
+      throw new ValidationError(target, payload, (0, import_zod3.prettifyError)(error));
     }
     throw new ValidationError(target, payload, error);
   }
@@ -4210,41 +4216,41 @@ async function sleep(ms) {
 }
 
 // src/config.ts
-var PackageSchema = import_zod3.z.object({
-  name: import_zod3.z.string().min(1),
-  version: import_zod3.z.string().min(1),
-  description: import_zod3.z.string().min(1).optional(),
-  author: import_zod3.z.object({ name: import_zod3.z.string().min(1), email: import_zod3.z.string().optional() }).optional().or(import_zod3.z.string().min(1)).optional(),
-  license: import_zod3.z.string().min(1).optional(),
-  dependencies: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional()
+var PackageSchema = import_zod4.z.object({
+  name: import_zod4.z.string().min(1),
+  version: import_zod4.z.string().min(1),
+  description: import_zod4.z.string().min(1).optional(),
+  author: import_zod4.z.object({ name: import_zod4.z.string().min(1), email: import_zod4.z.string().optional() }).optional().or(import_zod4.z.string().min(1)).optional(),
+  license: import_zod4.z.string().min(1).optional(),
+  dependencies: import_zod4.z.record(import_zod4.z.string(), import_zod4.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 = () => {
+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_zod3.z.enum(Environments),
-  logLevel: import_zod3.z.enum(LogLevels),
-  logSingleLine: import_zod3.z.boolean(),
-  sleepMs: import_zod3.z.number().int().min(0).max(5e3)
+  env: import_zod4.z.enum(Environments),
+  logLevel: import_zod4.z.enum(LogLevels),
+  logSingleLine: import_zod4.z.boolean(),
+  sleepMs: import_zod4.z.number().int().min(0).max(5e3)
 });
 var { NODE_ENV, LOG_LEVEL, LOG_SINGLE_LINE, SLEEP_MS } = process.env;
 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) {
@@ -4252,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;
@@ -4325,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() {
@@ -4454,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;
   }
@@ -4485,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).
@@ -4500,7 +4506,7 @@ var InMemoryStore = class {
    */
   async drop() {
     await sleep();
-    this._resetIndexes();
+    this._reset_indexes();
     this._streams = /* @__PURE__ */ new Map();
   }
   in_query(query, e) {
@@ -4534,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;
@@ -4548,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;
@@ -4567,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,
@@ -4590,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;
   }
@@ -4619,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,
@@ -4682,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(
@@ -4720,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)
@@ -4759,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();
@@ -4804,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++;
       }
@@ -4822,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++;
       }
     }
@@ -4843,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)
     );
@@ -4852,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;
@@ -4898,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;
       }
@@ -4943,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;
@@ -4957,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) {
@@ -4982,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;
   }
   /**
@@ -5010,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;
     }
   }