@rotorsoft/act 1.32.30 → 1.33.0

package/dist/test/index.cjs

@@ -1,1130 +1,34 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/test/index.ts
-var test_exports = {};
-__export(test_exports, {
-  fixture: () => fixture,
-  sandbox: () => sandbox
-});
-module.exports = __toCommonJS(test_exports);
 
-// src/test/sandbox.ts
-var import_vitest = require("vitest");
-
-// src/internal/lru-map.ts
-var LruMap = class {
-  _entries = /* @__PURE__ */ new Map();
-  _max_size;
-  constructor(maxSize) {
-    this._max_size = maxSize;
-  }
-  get(key) {
-    const v = this._entries.get(key);
-    if (v === void 0) return void 0;
-    this._entries.delete(key);
-    this._entries.set(key, v);
-    return v;
-  }
-  has(key) {
-    return this._entries.has(key);
-  }
-  set(key, value) {
-    this._entries.delete(key);
-    if (this._entries.size >= this._max_size) {
-      const oldest = this._entries.keys().next().value;
-      this._entries.delete(oldest);
-    }
-    this._entries.set(key, value);
-  }
-  delete(key) {
-    return this._entries.delete(key);
-  }
-  clear() {
-    this._entries.clear();
-  }
-  get size() {
-    return this._entries.size;
-  }
-};
-
-// 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
-  // the public Cache interface still presents a typed surface to callers.
-  _entries;
-  constructor(options) {
-    this._entries = new LruMap(options?.maxSize ?? 1e3);
-  }
-  /** @inheritDoc */
-  async get(stream) {
-    return this._entries.get(stream);
-  }
-  /** @inheritDoc */
-  async set(stream, entry) {
-    this._entries.set(stream, entry);
-  }
-  /** @inheritDoc */
-  async invalidate(stream) {
-    this._entries.delete(stream);
-  }
-  /** @inheritDoc */
-  async clear() {
-    this._entries.clear();
-  }
-  /** @inheritDoc */
-  async dispose() {
-    this._entries.clear();
-  }
-  /** Current number of entries held by the LRU. */
-  get size() {
-    return this._entries.size;
-  }
-};
-
-// src/adapters/console-logger.ts
-var LEVEL_VALUES = {
-  fatal: 60,
-  error: 50,
-  warn: 40,
-  info: 30,
-  debug: 20,
-  trace: 10
-};
-var LEVEL_COLORS = {
-  fatal: "\x1B[41m\x1B[37m",
-  // white on red bg
-  error: "\x1B[31m",
-  // red
-  warn: "\x1B[33m",
-  // yellow
-  info: "\x1B[32m",
-  // green
-  debug: "\x1B[36m",
-  // cyan
-  trace: "\x1B[90m"
-  // gray
-};
-var RESET = "\x1B[0m";
-var noop = () => {
-};
-var ConsoleLogger = class _ConsoleLogger {
-  level;
-  _pretty;
-  fatal;
-  error;
-  warn;
-  info;
-  debug;
-  trace;
-  constructor(options = {}) {
-    const {
-      level = "info",
-      pretty = process.env.NODE_ENV !== "production",
-      bindings
-    } = options;
-    this._pretty = pretty;
-    this.level = level;
-    const threshold = LEVEL_VALUES[level] ?? 30;
-    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;
-    this.info = threshold <= 30 ? write.bind(this, "info", 30) : noop;
-    this.debug = threshold <= 20 ? write.bind(this, "debug", 20) : noop;
-    this.trace = threshold <= 10 ? write.bind(this, "trace", 10) : noop;
-  }
-  /** No-op — `console.log` has no resources to release. */
-  async dispose() {
-  }
-  /** @inheritDoc */
-  child(bindings) {
-    return new _ConsoleLogger({
-      level: this.level,
-      pretty: this._pretty,
-      bindings
-    });
-  }
-  _json_write(bindings, level, _num, obj_or_msg, msg) {
-    let obj;
-    let message;
-    if (typeof obj_or_msg === "string") {
-      message = obj_or_msg;
-      obj = {};
-    } else if (obj_or_msg instanceof Error) {
-      message = msg ?? obj_or_msg.message;
-      obj = {
-        error: { message: obj_or_msg.message, name: obj_or_msg.name },
-        stack: obj_or_msg.stack
-      };
-    } else if (obj_or_msg !== null && typeof obj_or_msg === "object") {
-      message = msg;
-      obj = { ...obj_or_msg };
-    } else {
-      message = msg;
-      obj = { value: obj_or_msg };
-    }
-    const entry = Object.assign({ level, time: Date.now() }, bindings, obj);
-    if (message) entry.msg = message;
-    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");
-  }
-  _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 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 (obj_or_msg !== void 0 && obj_or_msg !== null) {
-        try {
-          data = JSON.stringify(obj_or_msg);
-        } catch {
-          data = "[unserializable]";
-        }
-      }
-    }
-    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_zod4 = require("zod");
-
-// src/types/errors.ts
-var Errors = {
-  ValidationError: "ERR_VALIDATION",
-  InvariantError: "ERR_INVARIANT",
-  ConcurrencyError: "ERR_CONCURRENCY",
-  StreamClosedError: "ERR_STREAM_CLOSED",
-  NonRetryableError: "ERR_NON_RETRYABLE",
-  StoreError: "ERR_STORE"
-};
-var ValidationError = class extends Error {
-  /** The type of target being validated (e.g., "action", "event") */
-  target;
-  /** The invalid payload that failed validation */
-  payload;
-  /** Zod validation error details */
-  details;
-  constructor(target, payload, details) {
-    super(`Invalid ${target} payload`);
-    this.name = Errors.ValidationError;
-    this.target = target;
-    this.payload = payload;
-    this.details = details;
-  }
-};
-var ConcurrencyError = class extends Error {
-  /** The stream that had the concurrent modification */
-  stream;
-  /** The actual current version in the store */
-  lastVersion;
-  /** The events that were being committed */
-  events;
-  /** The version number that was expected */
-  expectedVersion;
-  constructor(stream, lastVersion, events, expectedVersion) {
-    super(
-      `Concurrency error committing "${events.map((e) => `${stream}.${e.name}`).join(
-        ", "
-      )}". Expected version ${expectedVersion} but found version ${lastVersion}.`
-    );
-    this.name = Errors.ConcurrencyError;
-    this.stream = stream;
-    this.lastVersion = lastVersion;
-    this.events = events;
-    this.expectedVersion = expectedVersion;
-  }
-};
-
-// src/types/schemas.ts
-var import_zod2 = require("zod");
-
-// src/internal/sensitive.ts
-var import_zod = require("zod");
-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_zod2.z.object({
-  stream: import_zod2.z.string(),
-  actor: ActorSchema,
-  expectedVersion: import_zod2.z.number().optional()
-}).loose().readonly();
-var CausationEventSchema = import_zod2.z.object({
-  id: import_zod2.z.number(),
-  name: import_zod2.z.string(),
-  stream: import_zod2.z.string()
-});
-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_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_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(),
-  with_pii: import_zod2.z.boolean().optional(),
-  stream_exact: import_zod2.z.boolean().optional()
-}).readonly();
-
-// src/types/index.ts
-var Environments = [
-  "development",
-  "test",
-  "staging",
-  "production"
-];
-var LogLevels = [
-  "fatal",
-  "error",
-  "warn",
-  "info",
-  "debug",
-  "trace"
-];
-
-// src/utils.ts
-var import_zod3 = require("zod");
-var validate = (target, payload, schema) => {
-  try {
-    return schema ? schema.parse(payload) : payload;
-  } catch (error) {
-    if (error instanceof import_zod3.ZodError) {
-      throw new ValidationError(target, payload, (0, import_zod3.prettifyError)(error));
-    }
-    throw new ValidationError(target, payload, error);
-  }
-};
-var extend = (source, schema, target) => {
-  const value = validate("config", source, schema);
-  return { ...target, ...value };
-};
-async function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms ?? config().sleepMs));
-}
-
-// src/config.ts
-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 get_package = () => {
-  try {
-    const raw = JSON.parse(fs.readFileSync("package.json").toString());
-    const pkg2 = {
-      name: FALLBACK_PACKAGE.name,
-      version: FALLBACK_PACKAGE.version
-    };
-    for (const [key, schema] of Object.entries(PackageSchema.shape)) {
-      const field = schema.safeParse(raw?.[key]);
-      if (field.success && field.data !== void 0) pkg2[key] = field.data;
-    }
-    return pkg2;
-  } catch (err) {
-    pkg_load_error = err;
-    return FALLBACK_PACKAGE;
-  }
-};
-var pkg_load_error;
-var BaseSchema = PackageSchema.extend({
-  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 = get_package();
-var _validated;
-var config = () => {
-  if (!_validated) {
-    _validated = extend(
-      { ...pkg, env, logLevel, logSingleLine, sleepMs },
-      BaseSchema
-    );
-    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}".`
-      );
-      pkg_load_error = void 0;
-    }
-  }
-  return _validated;
-};
-
-// src/scoped.ts
-var import_node_async_hooks = require("async_hooks");
-var scoped = new import_node_async_hooks.AsyncLocalStorage();
-var reacting = new import_node_async_hooks.AsyncLocalStorage();
-
-// src/ports.ts
-var adapters = /* @__PURE__ */ new Map();
-function port(injector) {
-  return (adapter) => {
-    if (!adapters.has(injector.name)) {
-      const injected = injector(adapter);
-      adapters.set(injector.name, injected);
-      log().info(`[act] + ${injector.name}:${injected.constructor.name}`);
-    }
-    return adapters.get(injector.name);
-  };
-}
-var log = port(function log2(adapter) {
-  const cfg = config();
-  return adapter || new ConsoleLogger({
-    level: cfg.logLevel,
-    pretty: cfg.env !== "production"
-  });
-});
-var _store = port(function store(adapter) {
-  return adapter ?? new InMemoryStore();
-});
-var _cache = port(function cache(adapter) {
-  return adapter ?? new InMemoryCache();
-});
-var SNAP_EVENT = "__snapshot__";
-var TOMBSTONE_EVENT = "__tombstone__";
-var DEFAULT_LANE = "default";
-
-// src/adapters/in-memory-store.ts
-var InMemoryStream = class {
-  stream;
-  source;
-  _at = -1;
-  _retry = -1;
-  _blocked = false;
-  _error = "";
-  _leased_by = void 0;
-  _leased_until = void 0;
-  _priority = 0;
-  _lane = DEFAULT_LANE;
-  // While in the future, the stream is held out of `claim`.
-  _deferred_at = void 0;
-  // Work mark; `undefined` = never correlated, so `claim` skips it.
-  _correlated_at = void 0;
-  constructor(stream, source, priority = 0, lane = DEFAULT_LANE) {
-    this.stream = stream;
-    this.source = source;
-    this._priority = priority;
-    this._lane = lane;
-  }
-  get priority() {
-    return this._priority;
-  }
-  get lane() {
-    return this._lane;
-  }
-  /** Replaced on every subscribe, so the current config wins on restart. */
-  set lane(value) {
-    this._lane = value;
-  }
-  bump_priority(priority) {
-    if (priority > this._priority) this._priority = priority;
-  }
-  get correlated_at() {
-    return this._correlated_at;
-  }
-  /** A mark never regresses, including at zero and negatives. */
-  mark(correlated_at) {
-    if (this._correlated_at === void 0 || correlated_at > this._correlated_at)
-      this._correlated_at = correlated_at;
-  }
-  /** Operator override; ignores the subscribe-time `max()`. */
-  set_priority(priority) {
-    this._priority = priority;
-  }
-  get is_available() {
-    return !this._blocked && (!this._leased_until || this._leased_until <= /* @__PURE__ */ new Date()) && (!this._deferred_at || this._deferred_at <= Date.now());
-  }
-  defer(deferred_at) {
-    this._deferred_at = deferred_at;
-    this._retry = -1;
-  }
-  get at() {
-    return this._at;
-  }
-  get retry() {
-    return this._retry;
-  }
-  get blocked() {
-    return this._blocked;
-  }
-  get error() {
-    return this._error;
-  }
-  get leased_by() {
-    return this._leased_by;
-  }
-  get leased_until() {
-    return this._leased_until;
-  }
-  get deferred_at() {
-    return this._deferred_at;
-  }
-  lease(lease, millis) {
-    this._leased_by = lease.by;
-    this._leased_until = new Date(Date.now() + millis);
-    this._retry = this._retry + 1;
-    return {
-      stream: this.stream,
-      source: this.source,
-      at: lease.at,
-      by: lease.by,
-      retry: this._retry,
-      lagging: lease.lagging,
-      lane: this._lane
-    };
-  }
-  /** Ack, or with `due`, also persist the schedule. See {@link Store.ack}. */
-  ack(lease) {
-    if (this._leased_by === lease.by) {
-      this._leased_by = void 0;
-      this._leased_until = void 0;
-      if (lease.due !== void 0) {
-        this._at = lease.at;
-        this._retry = lease.retry;
-        this._deferred_at = lease.due;
-        return void 0;
-      }
-      this._retry = -1;
-      this._at = lease.at;
-      this._deferred_at = void 0;
-      return {
-        stream: this.stream,
-        source: this.source,
-        at: this._at,
-        by: lease.by,
-        retry: this._retry,
-        lagging: lease.lagging,
-        lane: this._lane
-      };
-    }
-  }
-  block(lease, error) {
-    if (this._leased_by === lease.by && !this._blocked) {
-      this._blocked = true;
-      this._error = error;
-      this._deferred_at = void 0;
-      return {
-        stream: this.stream,
-        source: this.source,
-        at: this._at,
-        by: this._leased_by,
-        retry: this._retry,
-        error: this._error,
-        lagging: lease.lagging,
-        lane: this._lane
-      };
-    }
-  }
-  /** Retry resets to -1 (released); the next claim makes it 0. */
-  reset() {
-    this._at = -1;
-    this._retry = -1;
-    this._blocked = false;
-    this._error = "";
-    this._leased_by = void 0;
-    this._leased_until = void 0;
-    this._deferred_at = void 0;
-  }
-  /** True only when the stream was blocked. */
-  unblock() {
-    if (!this._blocked) return false;
-    this._blocked = false;
-    this._retry = -1;
-    this._error = "";
-    this._leased_by = void 0;
-    this._leased_until = void 0;
-    this._deferred_at = void 0;
-    return true;
-  }
-};
-var InMemoryStore = class {
-  _events = [];
-  // Never reused. Deletions punch holes, so ids are not array indexes.
-  _next_id = 0;
-  _streams = /* @__PURE__ */ new Map();
-  /** Correlate checkpoint: how far the log has been READ. */
-  _correlated_at = -1;
-  /** Per-correlator checkpoint and lease; keyless callers use `_correlated_at`. */
-  _correlators = /* @__PURE__ */ new Map();
-  _stream_versions = /* @__PURE__ */ new Map();
-  // stream → (event_id → cloned pii). Two levels so `forget_pii` drops one
-  // inner Map. Absence means no PII.
-  _pii = /* @__PURE__ */ new Map();
-  _reset_indexes() {
-    this._events.length = 0;
-    this._next_id = 0;
-    this._correlated_at = -1;
-    this._stream_versions.clear();
-    this._pii.clear();
-  }
-  // Stores a cloned copy, so caller-side mutation can't reach it.
-  _put_pii(stream, id, pii) {
-    let per_stream = this._pii.get(stream);
-    if (!per_stream) {
-      per_stream = /* @__PURE__ */ new Map();
-      this._pii.set(stream, per_stream);
-    }
-    per_stream.set(id, structuredClone(pii));
-  }
-  // First index whose id is greater than `after` (ids are sorted, not dense).
-  _first_index_after(after) {
-    let lo = 0;
-    let hi = this._events.length;
-    while (lo < hi) {
-      const mid = lo + hi >>> 1;
-      if (this._events[mid].id > after) hi = mid;
-      else lo = mid + 1;
-    }
-    return lo;
-  }
-  // Allocation-free for events without PII, the common case.
-  _with_pii(e, wanted = true) {
-    if (!wanted) return e;
-    const pii = this._pii.get(e.stream)?.get(e.id);
-    return pii ? { ...e, pii } : e;
-  }
-  async dispose() {
-    await sleep();
-    this._reset_indexes();
-  }
-  async seed() {
-    await sleep();
-  }
-  async drop() {
-    await sleep();
-    this._reset_indexes();
-    this._streams = /* @__PURE__ */ new Map();
-  }
-  in_query(query, e) {
-    if (query.stream && !this._stream_matches(query.stream, query, e.stream))
-      return false;
-    if (query.names && !query.names.includes(e.name)) return false;
-    if (query.correlation && e.meta?.correlation !== query.correlation)
-      return false;
-    if (e.name === SNAP_EVENT && !query.with_snaps) return false;
-    if (query.created_after && e.created <= query.created_after) return false;
-    if (query.created_before && e.created >= query.created_before) return false;
-    return true;
-  }
-  _stream_matches(pattern, query, stream) {
-    return query.stream_exact ? stream === pattern : RegExp(pattern).test(stream);
-  }
-  /** Index of the stream's latest snapshot, or -1; an explicit `after` wins. */
-  _snap_floor(query) {
-    if (!query?.with_snaps || !query.stream_exact || query.stream === void 0 || query.after !== void 0)
-      return -1;
-    for (let j = this._events.length - 1; j >= 0; j--) {
-      const e = this._events[j];
-      if (e.stream === query.stream && e.name === SNAP_EVENT) return j;
-    }
-    return -1;
-  }
-  async query(callback, query) {
-    await sleep();
-    const floor = this._snap_floor(query);
-    const lo = floor >= 0 ? floor : this._first_index_after(query?.after ?? -1);
-    const hi = query?.before !== void 0 ? this._first_index_after(query.before - 1) : this._events.length;
-    const with_pii = query?.with_pii !== false;
-    let count = 0;
-    for (let k = 0; k < hi - lo; k++) {
-      const e = this._events[query?.backward ? hi - 1 - k : lo + k];
-      if (query && !this.in_query(query, e)) continue;
-      await Promise.resolve(
-        callback(this._with_pii(e, with_pii))
-      );
-      count++;
-      if (query?.limit && count >= query.limit) break;
-    }
-    return count;
-  }
-  async commit(stream, msgs, meta, expectedVersion) {
-    await sleep();
-    const current_version = this._stream_versions.get(stream) ?? -1;
-    if (typeof expectedVersion === "number" && current_version !== expectedVersion) {
-      throw new ConcurrencyError(
-        stream,
-        current_version,
-        msgs,
-        expectedVersion
-      );
-    }
-    let version = current_version + 1;
-    const committed = msgs.map(({ name, data, pii }) => {
-      const c = {
-        id: this._next_id++,
-        stream,
-        version,
-        created: /* @__PURE__ */ new Date(),
-        name,
-        data,
-        meta
-      };
-      this._events.push(c);
-      if (pii != null) this._put_pii(stream, c.id, pii);
-      version++;
-      return this._with_pii(c);
-    });
-    this._stream_versions.set(stream, version - 1);
-    return committed;
-  }
-  async claim(lagging, leading, by, millis, lane) {
-    await sleep();
-    const has_work = (s) => s.correlated_at !== void 0 && s.at < s.correlated_at;
-    const available = [...this._streams.values()].filter(
-      (s) => s.is_available && has_work(s) && (lane === void 0 || s.lane === lane)
-    );
-    const fair = lagging >= 2 ? Math.max(1, Math.floor(lagging / 4)) : 0;
-    const by_priority = [...available].sort(
-      (a, b) => b.priority - a.priority || a.at - b.at
-    );
-    const priority_slice = by_priority.slice(0, lagging - fair);
-    const picked = new Set(priority_slice.map((s) => s.stream));
-    const fair_slice = [...available].sort((a, b) => a.at - b.at).filter((s) => !picked.has(s.stream)).slice(0, fair);
-    const lag = [...priority_slice, ...fair_slice].map((s) => ({
-      stream: s.stream,
-      source: s.source,
-      at: s.at,
-      lagging: true
-    }));
-    const lead = available.sort((a, b) => b.at - a.at).slice(0, leading).map((s) => ({
-      stream: s.stream,
-      source: s.source,
-      at: s.at,
-      lagging: false
-    }));
-    const seen = /* @__PURE__ */ new Set();
-    const combined = [...lag, ...lead].filter((p) => {
-      if (seen.has(p.stream)) return false;
-      seen.add(p.stream);
-      return true;
-    });
-    return combined.map(
-      (p) => this._streams.get(p.stream)?.lease({ ...p, by, retry: 0 }, millis)
-    ).filter((l) => !!l);
-  }
-  async subscribe(streams, correlated_at, correlator) {
-    await sleep();
-    let correlating;
-    let keyed_at;
-    if (correlator) {
-      const now = Date.now();
-      const held = this._correlators.get(correlator.key);
-      const at = Math.max(held?.at ?? this._correlated_at, correlated_at ?? -1);
-      keyed_at = at;
-      if (!held || held.until < now || held.by === correlator.by) {
-        correlating = true;
-        this._correlators.set(correlator.key, {
-          at,
-          by: correlator.by,
-          // Release outright, or a successor in the same ms is still refused.
-          until: correlator.millis > 0 ? now + correlator.millis : 0
-        });
-      } else {
-        correlating = false;
-        held.at = at;
-      }
-      if (correlated_at !== void 0 && correlated_at > this._correlated_at)
-        this._correlated_at = correlated_at;
-    } else if (correlated_at !== void 0 && correlated_at > this._correlated_at)
-      this._correlated_at = correlated_at;
-    let subscribed = 0;
-    for (const {
-      stream,
-      source,
-      priority = 0,
-      lane = DEFAULT_LANE,
-      correlated_at: correlated_at2
-    } of streams) {
-      const existing = this._streams.get(stream);
-      if (existing) {
-        if (priority >= existing.priority) existing.lane = lane;
-        existing.bump_priority(priority);
-        if (correlated_at2 !== void 0) existing.mark(correlated_at2);
-      } else {
-        const created = new InMemoryStream(stream, source, priority, lane);
-        if (correlated_at2 !== void 0) created.mark(correlated_at2);
-        this._streams.set(stream, created);
-        subscribed++;
-      }
-    }
-    let watermark = -1;
-    for (const s of this._streams.values()) {
-      if (s.at > watermark) watermark = s.at;
-    }
-    return {
-      subscribed,
-      watermark,
-      correlated_at: keyed_at ?? this._correlated_at,
-      ...correlating === void 0 ? {} : { correlating }
-    };
-  }
-  async ack(leases) {
-    await sleep();
-    return leases.map((l) => this._streams.get(l.stream)?.ack(l)).filter((l) => !!l);
-  }
-  async block(leases) {
-    await sleep();
-    return leases.map((l) => this._streams.get(l.stream)?.block(l, l.error)).filter((l) => !!l);
-  }
-  async defer(input, deferred_at) {
-    await sleep();
-    const selected = this._select(input);
-    for (const s of selected) s.defer(deferred_at);
-    return selected.length;
-  }
-  /** De-duplicated like the SQL `stream = ANY(...)`; unknown names skipped. */
-  _select(input) {
-    if (Array.isArray(input))
-      return [...new Set(input)].map((name) => this._streams.get(name)).filter((s) => s !== void 0);
-    return [...this._streams.values()].filter(this._filter_predicate(input));
-  }
-  _filter_predicate(filter) {
-    const stream_re = filter.stream !== void 0 && !filter.stream_exact ? new RegExp(filter.stream) : void 0;
-    const source_re = filter.source !== void 0 && !filter.source_exact ? new RegExp(filter.source) : void 0;
-    return (s) => {
-      if (filter.stream !== void 0) {
-        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 : !source_re.test(s.source))
-          return false;
-      }
-      if (filter.blocked !== void 0 && s.blocked !== filter.blocked)
-        return false;
-      if (filter.lane !== void 0 && s.lane !== filter.lane) return false;
-      return true;
-    };
-  }
-  async reset(input) {
-    await sleep();
-    const selected = this._select(input);
-    for (const s of selected) s.reset();
-    return selected.length;
-  }
-  async forget_pii(stream) {
-    await sleep();
-    const count = this._pii.get(stream)?.size ?? 0;
-    this._pii.delete(stream);
-    return count;
-  }
-  async unblock(input) {
-    await sleep();
-    const selected = this._select(
-      Array.isArray(input) ? input : { ...input, blocked: true }
-    );
-    return selected.filter((s) => s.unblock()).length;
-  }
-  async prioritize(filter, priority) {
-    await sleep();
-    const changed = this._select(filter).filter((s) => s.priority !== priority);
-    for (const s of changed) s.set_priority(priority);
-    return changed.length;
-  }
-  async query_streams(callback, query) {
-    await sleep();
-    const limit = query?.limit ?? 100;
-    const after = query?.after;
-    const source_matches = query?.source_matches;
-    const matches = this._filter_predicate(query ?? {});
-    const reverse_cache = /* @__PURE__ */ new Map();
-    const reverse_match = (source) => {
-      let re = reverse_cache.get(source);
-      if (!re) {
-        re = new RegExp(source);
-        reverse_cache.set(source, re);
-      }
-      return source_matches.some((name) => re.test(name));
-    };
-    const sorted = [...this._streams.keys()].sort().map((stream) => this._streams.get(stream));
-    let count = 0;
-    for (const s of sorted) {
-      if (after !== void 0 && s.stream <= after) continue;
-      if (!matches(s)) continue;
-      if (source_matches !== void 0) {
-        if (s.source && !reverse_match(s.source)) continue;
-      }
-      if (count >= limit) break;
-      callback({
-        stream: s.stream,
-        source: s.source,
-        at: s.at,
-        retry: s.retry,
-        blocked: s.blocked,
-        error: s.error,
-        priority: s.priority,
-        leased_by: s.leased_by,
-        leased_until: s.leased_until,
-        lane: s.lane,
-        deferred_at: s.deferred_at,
-        correlated_at: s.correlated_at
-      });
-      count++;
-    }
-    return { maxEventId: this._events.at(-1)?.id ?? -1, count };
-  }
-  async query_stats(input, options) {
-    await sleep();
-    const exclude = new Set(options?.exclude ?? []);
-    const want_tail = options?.tail ?? false;
-    const want_count = options?.count ?? false;
-    const want_names = options?.names ?? false;
-    const before = options?.before;
-    const after = options?.after;
-    const limit = options?.limit;
-    const array_targets = Array.isArray(input) ? new Set(input) : null;
-    const filter = Array.isArray(input) ? null : input;
-    const stream_re = filter?.stream !== void 0 && !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 (array_targets) {
-        ok = array_targets.has(stream);
-      } else if (filter?.stream !== void 0) {
-        ok = filter.stream_exact ? stream === filter.stream : (
-          // stream_re set when stream is regex
-          stream_re.test(stream)
-        );
-      }
-      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 (!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 (want_tail) a.tail = e;
-        if (want_names) a.names = {};
-        acc.set(e.stream, a);
-      }
-      a.head = e;
-      a.count++;
-      if (want_names) {
-        const n = String(e.name);
-        a.names[n] = (a.names[n] ?? 0) + 1;
-      }
-    }
-    const ordered = [...acc.keys()].sort();
-    const out = /* @__PURE__ */ new Map();
-    for (const stream of ordered) {
-      if (limit !== void 0 && out.size >= limit) break;
-      if (after !== void 0 && stream <= after) continue;
-      const a = acc.get(stream);
-      const stats = { head: a.head };
-      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;
-  }
-  async truncate(targets) {
-    await sleep();
-    const result = /* @__PURE__ */ new Map();
-    const windowed = targets.filter((t) => t.before !== void 0);
-    if (windowed.length) {
-      const drop = /* @__PURE__ */ new Set();
-      for (const { stream, before, max_id } of windowed) {
-        let boundary;
-        for (const e of this._events) {
-          if (e.stream === stream && e.name === SNAP_EVENT && e.created < before && (max_id === void 0 || e.id <= max_id) && (!boundary || e.id > boundary.id))
-            boundary = e;
-        }
-        if (!boundary) continue;
-        let deleted = 0;
-        for (const e of this._events) {
-          if (e.stream === stream && e.id < boundary.id) {
-            drop.add(e.id);
-            this._pii.get(stream)?.delete(e.id);
-            deleted++;
-          }
-        }
-        result.set(stream, { deleted, committed: boundary, before });
-      }
-      if (drop.size) this._events = this._events.filter((e) => !drop.has(e.id));
-    }
-    const full = targets.filter((t) => t.before === void 0);
-    for (const { stream, snapshot, meta } of full) {
-      let deleted = 0;
-      this._events = this._events.filter((e) => {
-        if (e.stream !== stream) return true;
-        deleted++;
-        return false;
-      });
-      this._stream_versions.delete(stream);
-      this._pii.delete(stream);
-      const event = {
-        id: this._next_id++,
-        stream,
-        version: 0,
-        created: /* @__PURE__ */ new Date(),
-        name: snapshot !== void 0 ? SNAP_EVENT : TOMBSTONE_EVENT,
-        data: snapshot ?? {},
-        meta: meta ?? { correlation: "", causation: {} }
-      };
-      this._events.push(event);
-      this._stream_versions.set(stream, 0);
-      result.set(stream, { deleted, committed: event });
-    }
-    return result;
-  }
-  /** A throw inside the driver restores the captured state. Ids restart at 0. */
-  async restore(driver) {
-    await sleep();
-    const prev_events = this._events;
-    const prev_next_id = this._next_id;
-    const prev_streams = this._streams;
-    const prev_stream_versions = this._stream_versions;
-    const prev_pii = this._pii;
-    const prev_correlated_at = this._correlated_at;
-    const prev_correlators = new Map(
-      [...this._correlators].map(([k, v]) => [k, { ...v }])
-    );
-    this._correlated_at = -1;
-    for (const c of this._correlators.values()) c.at = -1;
-    this._events = [];
-    this._next_id = 0;
-    this._streams = /* @__PURE__ */ new Map();
-    this._stream_versions = /* @__PURE__ */ new Map();
-    this._pii = /* @__PURE__ */ new Map();
-    try {
-      await driver(async (event) => {
-        const id = this._next_id++;
-        const { pii, ...rest } = event;
-        const committed = { ...rest, id };
-        this._events.push(committed);
-        if (pii != null) this._put_pii(event.stream, id, pii);
-        this._stream_versions.set(event.stream, event.version);
-        return id;
-      });
-    } catch (err) {
-      this._events = prev_events;
-      this._next_id = prev_next_id;
-      this._streams = prev_streams;
-      this._stream_versions = prev_stream_versions;
-      this._pii = prev_pii;
-      this._correlated_at = prev_correlated_at;
-      this._correlators = prev_correlators;
-      throw err;
-    }
-  }
-};
+var _chunkVE3MTY4Acjs = require('../chunk-VE3MTY4A.cjs');
+require('../chunk-HF433MAF.cjs');
 
 // src/test/sandbox.ts
+var _vitest = require('vitest');
 async function sandbox(builder, options = {}) {
-  const store2 = options.store ? await options.store() : new InMemoryStore();
-  const cache2 = options.cache ? await options.cache() : new InMemoryCache();
-  await store2.seed();
+  const store = options.store ? await options.store() : new (0, _chunkVE3MTY4Acjs.InMemoryStore)();
+  const cache = options.cache ? await options.cache() : new (0, _chunkVE3MTY4Acjs.InMemoryCache)();
+  await store.seed();
   const app = builder.build({
     ...options.actOptions,
-    scoped: { store: store2, cache: cache2 }
+    scoped: { store, cache }
   });
   let _disposed;
   const dispose = () => {
     if (!_disposed) {
       _disposed = (async () => {
         await app.shutdown();
-        await store2.dispose();
-        await cache2.dispose();
+        await store.dispose();
+        await cache.dispose();
       })();
     }
     return _disposed;
   };
-  return { app, store: store2, cache: cache2, dispose };
+  return { app, store, cache, dispose };
 }
 function fixture(builder, defaults = {}) {
-  return import_vitest.test.extend({
+  return _vitest.test.extend({
     app: async ({}, use) => {
       const ctx = await sandbox(builder, defaults);
       try {
@@ -1135,9 +39,8 @@ function fixture(builder, defaults = {}) {
     }
   });
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  fixture,
-  sandbox
-});
+
+
+
+exports.fixture = fixture; exports.sandbox = sandbox;
 //# sourceMappingURL=index.cjs.map