@rotorsoft/act 0.33.2 → 0.34.0

package/dist/index.cjs

@@ -1,2985 +0,0 @@
-"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);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Act: () => Act,
-  ActorSchema: () => ActorSchema,
-  CausationEventSchema: () => CausationEventSchema,
-  CommittedMetaSchema: () => CommittedMetaSchema,
-  ConcurrencyError: () => ConcurrencyError,
-  ConsoleLogger: () => ConsoleLogger,
-  DEFAULT_MAX_SUBSCRIBED_STREAMS: () => DEFAULT_MAX_SUBSCRIBED_STREAMS,
-  DEFAULT_SETTLE_DEBOUNCE_MS: () => DEFAULT_SETTLE_DEBOUNCE_MS,
-  Environments: () => Environments,
-  Errors: () => Errors,
-  EventMetaSchema: () => EventMetaSchema,
-  ExitCodes: () => ExitCodes,
-  InMemoryCache: () => InMemoryCache,
-  InMemoryStore: () => InMemoryStore,
-  InvariantError: () => InvariantError,
-  LogLevels: () => LogLevels,
-  PackageSchema: () => PackageSchema,
-  QuerySchema: () => QuerySchema,
-  SNAP_EVENT: () => SNAP_EVENT,
-  StreamClosedError: () => StreamClosedError,
-  TOMBSTONE_EVENT: () => TOMBSTONE_EVENT,
-  TargetSchema: () => TargetSchema,
-  ValidationError: () => ValidationError,
-  ZodEmpty: () => ZodEmpty,
-  act: () => act,
-  cache: () => cache,
-  config: () => config,
-  dispose: () => dispose,
-  disposeAndExit: () => disposeAndExit,
-  extend: () => extend,
-  log: () => log,
-  port: () => port,
-  projection: () => projection,
-  sleep: () => sleep,
-  slice: () => slice,
-  state: () => state,
-  store: () => store,
-  validate: () => validate
-});
-module.exports = __toCommonJS(index_exports);
-
-// 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._prettyWrite.bind(this, bindings) : this._jsonWrite.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
-    });
-  }
-  _jsonWrite(bindings, level, _num, objOrMsg, msg) {
-    let obj;
-    let message;
-    if (typeof objOrMsg === "string") {
-      message = objOrMsg;
-      obj = {};
-    } else if (objOrMsg !== null && typeof objOrMsg === "object") {
-      message = msg;
-      obj = { ...objOrMsg };
-    } else {
-      message = msg;
-      obj = { value: objOrMsg };
-    }
-    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");
-  }
-  _prettyWrite(bindings, level, _num, objOrMsg, 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 {
-      message = msg ?? "";
-      if (objOrMsg !== void 0 && objOrMsg !== null) {
-        try {
-          data = JSON.stringify(objOrMsg);
-        } catch {
-          data = "[unserializable]";
-        }
-      }
-    }
-    const bindStr = bindings && Object.keys(bindings).length ? ` ${JSON.stringify(bindings)}` : "";
-    const parts = [ts, tag, message, data, bindStr].filter(Boolean);
-    process.stdout.write(parts.join(" ") + "\n");
-  }
-};
-
-// src/lru-map.ts
-var LruMap = class {
-  constructor(_maxSize) {
-    this._maxSize = _maxSize;
-  }
-  _entries = /* @__PURE__ */ new Map();
-  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._maxSize) {
-      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;
-  }
-};
-var LruSet = class {
-  _map;
-  constructor(maxSize) {
-    this._map = new LruMap(maxSize);
-  }
-  has(value) {
-    return this._map.has(value);
-  }
-  add(value) {
-    this._map.set(value, true);
-  }
-  delete(value) {
-    return this._map.delete(value);
-  }
-  clear() {
-    this._map.clear();
-  }
-  get size() {
-    return this._map.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/types/errors.ts
-var Errors = {
-  ValidationError: "ERR_VALIDATION",
-  InvariantError: "ERR_INVARIANT",
-  ConcurrencyError: "ERR_CONCURRENCY",
-  StreamClosedError: "ERR_STREAM_CLOSED"
-};
-var ValidationError = class extends Error {
-  constructor(target, payload, details) {
-    super(`Invalid ${target} payload`);
-    this.target = target;
-    this.payload = payload;
-    this.details = details;
-    this.name = Errors.ValidationError;
-  }
-};
-var InvariantError = class extends Error {
-  constructor(action2, payload, target, snapshot, description) {
-    super(`${action2} failed invariant: ${description}`);
-    this.action = action2;
-    this.payload = payload;
-    this.target = target;
-    this.snapshot = snapshot;
-    this.description = description;
-    this.name = Errors.InvariantError;
-  }
-};
-var ConcurrencyError = class extends Error {
-  constructor(stream, lastVersion, events, expectedVersion) {
-    super(
-      `Concurrency error committing "${events.map((e) => `${stream}.${e.name}`).join(
-        ", "
-      )}". Expected version ${expectedVersion} but found version ${lastVersion}.`
-    );
-    this.stream = stream;
-    this.lastVersion = lastVersion;
-    this.events = events;
-    this.expectedVersion = expectedVersion;
-    this.name = Errors.ConcurrencyError;
-  }
-};
-var StreamClosedError = class extends Error {
-  constructor(stream) {
-    super(`Stream "${stream}" is closed (tombstoned)`);
-    this.stream = stream;
-    this.name = Errors.StreamClosedError;
-  }
-};
-
-// src/utils.ts
-var import_zod3 = require("zod");
-
-// src/config.ts
-var fs = __toESM(require("fs"), 1);
-var import_zod2 = require("zod");
-
-// src/types/schemas.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()
-}).loose().readonly();
-var TargetSchema = import_zod.z.object({
-  stream: import_zod.z.string(),
-  actor: ActorSchema,
-  expectedVersion: import_zod.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 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(),
-    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(),
-  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()
-}).readonly();
-
-// src/types/index.ts
-var Environments = [
-  "development",
-  "test",
-  "staging",
-  "production"
-];
-var LogLevels = [
-  "fatal",
-  "error",
-  "warn",
-  "info",
-  "debug",
-  "trace"
-];
-
-// src/config.ts
-var PackageSchema = import_zod2.z.object({
-  name: import_zod2.z.string().min(1),
-  version: import_zod2.z.string().min(1),
-  description: import_zod2.z.string().min(1).optional(),
-  author: import_zod2.z.object({ name: import_zod2.z.string().min(1), email: import_zod2.z.string().optional() }).optional().or(import_zod2.z.string().min(1)).optional(),
-  license: import_zod2.z.string().min(1).optional(),
-  dependencies: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional()
-});
-var FALLBACK_PACKAGE = {
-  name: "act-fallback",
-  version: "0.0.0-fallback",
-  description: "Synthetic fallback \u2014 package.json could not be loaded"
-};
-var getPackage = () => {
-  try {
-    const raw = fs.readFileSync("package.json");
-    return JSON.parse(raw.toString());
-  } catch (err) {
-    pkgLoadError = err;
-    return FALLBACK_PACKAGE;
-  }
-};
-var pkgLoadError;
-var BaseSchema = PackageSchema.extend({
-  env: import_zod2.z.enum(Environments),
-  logLevel: import_zod2.z.enum(LogLevels),
-  logSingleLine: import_zod2.z.boolean(),
-  sleepMs: import_zod2.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 _validated;
-var config = () => {
-  if (!_validated) {
-    _validated = extend(
-      { ...pkg, env, logLevel, logSingleLine, sleepMs },
-      BaseSchema
-    );
-    if (pkgLoadError) {
-      const msg = pkgLoadError instanceof Error ? pkgLoadError.message : typeof pkgLoadError === "string" ? pkgLoadError : "unknown error";
-      log().warn(
-        `[act] Could not read package.json (${msg}); using synthetic name="${FALLBACK_PACKAGE.name}" version="${FALLBACK_PACKAGE.version}".`
-      );
-      pkgLoadError = void 0;
-    }
-  }
-  return _validated;
-};
-
-// src/utils.ts
-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/adapters/in-memory-store.ts
-var InMemoryStream = class {
-  constructor(stream, source) {
-    this.stream = stream;
-    this.source = source;
-  }
-  _at = -1;
-  _retry = -1;
-  _blocked = false;
-  _error = "";
-  _leased_by = void 0;
-  _leased_until = void 0;
-  get is_available() {
-    return !this._blocked && (!this._leased_until || this._leased_until <= /* @__PURE__ */ new Date());
-  }
-  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;
-  }
-  /**
-   * Attempt to lease this stream for processing.
-   * @param lease - The lease request.
-   * @param millis - Lease duration in milliseconds.
-   * @returns The granted lease or undefined if blocked.
-   */
-  lease(lease, millis) {
-    if (millis > 0) {
-      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
-    };
-  }
-  /**
-   * Acknowledge completion of processing for this stream.
-   * @param lease - The lease request.
-   */
-  ack(lease) {
-    if (this._leased_by === lease.by) {
-      this._leased_by = void 0;
-      this._leased_until = void 0;
-      this._at = lease.at;
-      this._retry = -1;
-      return {
-        stream: this.stream,
-        source: this.source,
-        at: this._at,
-        by: lease.by,
-        retry: this._retry,
-        lagging: lease.lagging
-      };
-    }
-  }
-  /**
-   * Block a stream for processing after failing to process and reaching max retries with blocking enabled.
-   * @param lease - The lease request.
-   * @param error Blocked error message.
-   */
-  block(lease, error) {
-    if (this._leased_by === lease.by) {
-      this._blocked = true;
-      this._error = error;
-      return {
-        stream: this.stream,
-        source: this.source,
-        at: this._at,
-        by: this._leased_by,
-        retry: this._retry,
-        error: this._error,
-        lagging: lease.lagging
-      };
-    }
-  }
-  /**
-   * Reset this stream's watermark and state for replay. The retry counter
-   * resets to -1 to match the constructor + ack() invariant ("released
-   * stream"); the next claim() bumps it to 0 (first attempt).
-   */
-  reset() {
-    this._at = -1;
-    this._retry = -1;
-    this._blocked = false;
-    this._error = "";
-    this._leased_by = void 0;
-    this._leased_until = void 0;
-  }
-};
-var InMemoryStore = class {
-  // stored events
-  _events = [];
-  // stored stream positions and other metadata
-  _streams = /* @__PURE__ */ new Map();
-  // last committed version per stream — O(1) replacement for filter-on-commit
-  _streamVersions = /* @__PURE__ */ new Map();
-  // max non-snapshot event id per stream — drives the source-pattern probe in claim()
-  // without scanning the full event log.
-  _maxEventIdByStream = /* @__PURE__ */ new Map();
-  // global max non-snapshot event id — fast pre-check for source-less streams in claim()
-  _maxNonSnapEventId = -1;
-  _resetIndexes() {
-    this._events.length = 0;
-    this._streamVersions.clear();
-    this._maxEventIdByStream.clear();
-    this._maxNonSnapEventId = -1;
-  }
-  /**
-   * Dispose of the store and clear all events.
-   * @returns Promise that resolves when disposal is complete.
-   */
-  async dispose() {
-    await sleep();
-    this._resetIndexes();
-  }
-  /**
-   * Seed the store with initial data (no-op for in-memory).
-   * @returns Promise that resolves when seeding is complete.
-   */
-  async seed() {
-    await sleep();
-  }
-  /**
-   * Drop all data from the store.
-   * @returns Promise that resolves when the store is cleared.
-   */
-  async drop() {
-    await sleep();
-    this._resetIndexes();
-    this._streams = /* @__PURE__ */ new Map();
-  }
-  in_query(query, e) {
-    if (query.stream) {
-      if (query.stream_exact) {
-        if (e.stream !== query.stream) return false;
-      } else if (!RegExp(`^${query.stream}$`).test(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;
-    return true;
-  }
-  /**
-   * Query events in the store, optionally filtered by query options.
-   * @param callback - Function to call for each event.
-   * @param query - Optional query options.
-   * @returns The number of events processed.
-   */
-  async query(callback, query) {
-    await sleep();
-    let count = 0;
-    if (query?.backward) {
-      let i = (query?.before || this._events.length) - 1;
-      while (i >= 0) {
-        const e = this._events[i--];
-        if (query && !this.in_query(query, e)) continue;
-        if (query?.created_before && e.created >= query.created_before)
-          continue;
-        if (query.after && e.id <= query.after) break;
-        if (query.created_after && e.created <= query.created_after) break;
-        callback(e);
-        count++;
-        if (query?.limit && count >= query.limit) break;
-      }
-    } else {
-      let i = (query?.after ?? -1) + 1;
-      while (i < this._events.length) {
-        const e = this._events[i++];
-        if (query && !this.in_query(query, e)) continue;
-        if (query?.created_after && e.created <= query.created_after) continue;
-        if (query?.before && e.id >= query.before) break;
-        if (query?.created_before && e.created >= query.created_before) break;
-        callback(e);
-        count++;
-        if (query?.limit && count >= query.limit) break;
-      }
-    }
-    return count;
-  }
-  /**
-   * Commit one or more events to a stream.
-   * @param stream - The stream name.
-   * @param msgs - The events/messages to commit.
-   * @param meta - Event metadata.
-   * @param expectedVersion - Optional optimistic concurrency check.
-   * @returns The committed events with metadata.
-   * @throws ConcurrencyError if expectedVersion does not match.
-   */
-  async commit(stream, msgs, meta, expectedVersion) {
-    await sleep();
-    const currentVersion = this._streamVersions.get(stream) ?? -1;
-    if (typeof expectedVersion === "number" && currentVersion !== expectedVersion) {
-      throw new ConcurrencyError(
-        stream,
-        currentVersion,
-        msgs,
-        expectedVersion
-      );
-    }
-    let version = currentVersion + 1;
-    let lastNonSnapId = -1;
-    const committed = msgs.map(({ name, data }) => {
-      const c = {
-        id: this._events.length,
-        stream,
-        version,
-        created: /* @__PURE__ */ new Date(),
-        name,
-        data,
-        meta
-      };
-      this._events.push(c);
-      if (name !== SNAP_EVENT) lastNonSnapId = c.id;
-      version++;
-      return c;
-    });
-    this._streamVersions.set(stream, version - 1);
-    if (lastNonSnapId >= 0) {
-      this._maxEventIdByStream.set(stream, lastNonSnapId);
-      this._maxNonSnapEventId = lastNonSnapId;
-    }
-    return committed;
-  }
-  /**
-   * Atomically discovers and leases streams for processing.
-   * Fuses poll + lease into a single operation.
-   * @param lagging - Max streams from lagging frontier.
-   * @param leading - Max streams from leading frontier.
-   * @param by - Lease holder identifier.
-   * @param millis - Lease duration in milliseconds.
-   * @returns Granted leases.
-   */
-  async claim(lagging, leading, by, millis) {
-    await sleep();
-    const sourceRegex = /* @__PURE__ */ new Map();
-    const getRegex = (source) => {
-      let re = sourceRegex.get(source);
-      if (!re) {
-        re = new RegExp(source);
-        sourceRegex.set(source, re);
-      }
-      return re;
-    };
-    const hasWork = (s) => {
-      if (s.at < 0) return true;
-      if (!s.source) return s.at < this._maxNonSnapEventId;
-      const re = getRegex(s.source);
-      for (const [streamName, maxId] of this._maxEventIdByStream) {
-        if (maxId > s.at && re.test(streamName)) return true;
-      }
-      return false;
-    };
-    const available = [...this._streams.values()].filter(
-      (s) => s.is_available && hasWork(s)
-    );
-    const lag = available.sort((a, b) => a.at - b.at).slice(0, lagging).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);
-  }
-  /**
-   * Registers streams for event processing.
-   * @param streams - Streams to register with optional source.
-   * @returns subscribed count and current max watermark.
-   */
-  async subscribe(streams) {
-    await sleep();
-    let subscribed = 0;
-    for (const { stream, source } of streams) {
-      if (!this._streams.has(stream)) {
-        this._streams.set(stream, new InMemoryStream(stream, source));
-        subscribed++;
-      }
-    }
-    let watermark = -1;
-    for (const s of this._streams.values()) {
-      if (s.at > watermark) watermark = s.at;
-    }
-    return { subscribed, watermark };
-  }
-  /**
-   * Acknowledge completion of processing for leased streams.
-   * @param leases - Leases to acknowledge, including last processed watermark and lease holder.
-   */
-  async ack(leases) {
-    await sleep();
-    return leases.map((l) => this._streams.get(l.stream)?.ack(l)).filter((l) => !!l);
-  }
-  /**
-   * Block a stream for processing after failing to process and reaching max retries with blocking enabled.
-   * @param leases - Leases to block, including lease holder and last error message.
-   * @returns Blocked leases.
-   */
-  async block(leases) {
-    await sleep();
-    return leases.map((l) => this._streams.get(l.stream)?.block(l, l.error)).filter((l) => !!l);
-  }
-  /**
-   * Reset watermarks for the given streams to -1, clearing retry, blocked,
-   * error, and lease state so they can be replayed from the beginning.
-   * @param streams - Stream names to reset.
-   * @returns Count of streams that were actually reset.
-   */
-  async reset(streams) {
-    await sleep();
-    let count = 0;
-    for (const name of streams) {
-      const s = this._streams.get(name);
-      if (s) {
-        s.reset();
-        count++;
-      }
-    }
-    return count;
-  }
-  /**
-   * Streams registered subscription positions to the callback, ordered by
-   * stream name. Returns the highest event id in the store and the count
-   * of positions emitted.
-   */
-  async query_streams(callback, query) {
-    await sleep();
-    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 sorted = [...this._streams.values()].sort(
-      (a, b) => a.stream.localeCompare(b.stream)
-    );
-    let count = 0;
-    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))
-          continue;
-      }
-      if (query?.source !== void 0) {
-        if (s.source === void 0) continue;
-        if (query.source_exact ? s.source !== query.source : !sourceRe.test(s.source))
-          continue;
-      }
-      if (blocked !== void 0 && s.blocked !== blocked) continue;
-      callback({
-        stream: s.stream,
-        source: s.source,
-        at: s.at,
-        retry: s.retry,
-        blocked: s.blocked,
-        error: s.error,
-        leased_by: s.leased_by,
-        leased_until: s.leased_until
-      });
-      count++;
-      if (count >= limit) break;
-    }
-    return { maxEventId: this._events.length - 1, count };
-  }
-  /**
-   * Atomically truncates streams and seeds each with a snapshot or tombstone.
-   * @param targets - Streams to truncate with optional snapshot state and meta.
-   * @returns Map keyed by stream name, each entry with `deleted` count and `committed` event.
-   */
-  async truncate(targets) {
-    await sleep();
-    const deletedCounts = /* @__PURE__ */ new Map();
-    const streamSet = 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);
-      }
-    }
-    this._events = this._events.filter((e) => !streamSet.has(e.stream));
-    for (const stream of streamSet) {
-      this._streams.delete(stream);
-      this._streamVersions.delete(stream);
-      this._maxEventIdByStream.delete(stream);
-    }
-    const result = /* @__PURE__ */ new Map();
-    for (const { stream, snapshot, meta } of targets) {
-      const event = {
-        id: this._events.length,
-        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._streamVersions.set(stream, 0);
-      if (event.name !== SNAP_EVENT) {
-        this._maxEventIdByStream.set(stream, event.id);
-      }
-      result.set(stream, {
-        deleted: deletedCounts.get(stream) ?? 0,
-        committed: event
-      });
-    }
-    let max = -1;
-    for (const id of this._maxEventIdByStream.values()) if (id > max) max = id;
-    this._maxNonSnapEventId = max;
-    return result;
-  }
-};
-
-// src/ports.ts
-var ExitCodes = ["ERROR", "EXIT"];
-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 store2(adapter) {
-  return adapter || new InMemoryStore();
-});
-var cache = port(function cache2(adapter) {
-  return adapter || new InMemoryCache();
-});
-var disposers = [];
-async function disposeAndExit(code = "EXIT") {
-  if (code === "ERROR" && config().env === "production") {
-    log().warn(
-      "disposeAndExit('ERROR') ignored in production \u2014 process kept alive"
-    );
-    return;
-  }
-  for (const disposer of [...disposers].reverse()) {
-    await disposer();
-  }
-  for (const adapter of [...adapters.values()].reverse()) {
-    await adapter.dispose();
-    log().info(`[act] - ${adapter.constructor.name}`);
-  }
-  adapters.clear();
-  config().env !== "test" && process.exit(code === "ERROR" ? 1 : 0);
-}
-function dispose(disposer) {
-  disposer && disposers.push(disposer);
-  return disposeAndExit;
-}
-var SNAP_EVENT = "__snapshot__";
-var TOMBSTONE_EVENT = "__tombstone__";
-
-// src/signals.ts
-process.once("SIGINT", async (arg) => {
-  log().info(arg, "SIGINT");
-  await disposeAndExit("EXIT");
-});
-process.once("SIGTERM", async (arg) => {
-  log().info(arg, "SIGTERM");
-  await disposeAndExit("EXIT");
-});
-process.once("uncaughtException", async (arg) => {
-  log().error(arg, "Uncaught Exception");
-  await disposeAndExit("ERROR");
-});
-process.once("unhandledRejection", async (arg) => {
-  log().error(arg, "Unhandled Rejection");
-  await disposeAndExit("ERROR");
-});
-
-// src/act.ts
-var import_node_events = __toESM(require("events"), 1);
-
-// src/internal/build-classify.ts
-function classifyRegistry(registry, states) {
-  const statics = /* @__PURE__ */ new Map();
-  const reactiveEvents = /* @__PURE__ */ new Set();
-  let hasDynamicResolvers = false;
-  for (const [name, register] of Object.entries(registry.events)) {
-    if (register.reactions.size > 0) reactiveEvents.add(name);
-    for (const reaction of register.reactions.values()) {
-      if (typeof reaction.resolver === "function") {
-        hasDynamicResolvers = true;
-      } else {
-        const { target, source } = reaction.resolver;
-        const key = `${target}|${source ?? ""}`;
-        if (!statics.has(key)) statics.set(key, { stream: target, source });
-      }
-    }
-  }
-  const eventToState = /* @__PURE__ */ new Map();
-  for (const merged of states.values()) {
-    for (const eventName of Object.keys(merged.events)) {
-      eventToState.set(eventName, merged);
-    }
-  }
-  return {
-    staticTargets: [...statics.values()],
-    hasDynamicResolvers,
-    reactiveEvents,
-    eventToState
-  };
-}
-
-// src/internal/close-cycle.ts
-var import_node_crypto = require("crypto");
-async function runCloseCycle(targets, deps) {
-  const targetMap = new Map(targets.map((t) => [t.stream, t]));
-  const streams = [...targetMap.keys()];
-  const skipped = [];
-  const streamInfo = await scanStreamHeads(streams);
-  const safe = await partitionBySafety(
-    streamInfo,
-    deps.reactiveEventsSize,
-    skipped
-  );
-  if (!safe.length) return { truncated: /* @__PURE__ */ new Map(), skipped };
-  const correlation = (0, import_node_crypto.randomUUID)();
-  const { guarded, guardEvents } = await guardWithTombstones(
-    safe,
-    streamInfo,
-    correlation,
-    deps.tombstone,
-    skipped
-  );
-  if (!guarded.length) return { truncated: /* @__PURE__ */ new Map(), skipped };
-  const seedStates = await loadRestartSeeds(
-    guarded,
-    targetMap,
-    streamInfo,
-    deps.eventToState,
-    deps.load,
-    deps.logger
-  );
-  await runArchiveCallbacks(guarded, targetMap);
-  const truncated = await truncateAndWarmCache(
-    guarded,
-    seedStates,
-    guardEvents,
-    correlation
-  );
-  return { truncated, skipped };
-}
-async function scanStreamHeads(streams) {
-  const out = /* @__PURE__ */ new Map();
-  await Promise.all(
-    streams.map(async (s) => {
-      let maxId = -1;
-      let version = -1;
-      let lastEventName = "";
-      await store().query(
-        (e) => {
-          if (e.name === TOMBSTONE_EVENT || maxId !== -1) return;
-          maxId = e.id;
-          version = e.version;
-          lastEventName = e.name;
-        },
-        { stream: s, stream_exact: true, backward: true, limit: 1 }
-      );
-      if (maxId >= 0) out.set(s, { maxId, version, lastEventName });
-    })
-  );
-  return out;
-}
-async function partitionBySafety(streamInfo, reactiveEventsSize, skipped) {
-  if (reactiveEventsSize === 0) return [...streamInfo.keys()];
-  const pendingSet = /* @__PURE__ */ new Set();
-  await store().query_streams((position) => {
-    const sourceRe = position.source ? RegExp(position.source) : void 0;
-    for (const [stream, info] of streamInfo) {
-      if ((!sourceRe || sourceRe.test(stream)) && position.at < info.maxId) {
-        pendingSet.add(stream);
-      }
-    }
-  });
-  const safe = [];
-  for (const [stream] of streamInfo) {
-    if (pendingSet.has(stream)) skipped.push(stream);
-    else safe.push(stream);
-  }
-  return safe;
-}
-async function guardWithTombstones(safe, streamInfo, correlation, tombstone2, skipped) {
-  const guarded = [];
-  const guardEvents = /* @__PURE__ */ new Map();
-  await Promise.all(
-    safe.map(async (stream) => {
-      const info = streamInfo.get(stream);
-      const committed = await tombstone2(stream, info.version, correlation);
-      if (committed) {
-        guarded.push(stream);
-        guardEvents.set(stream, { id: committed.id, stream });
-      } else {
-        skipped.push(stream);
-      }
-    })
-  );
-  return { guarded, guardEvents };
-}
-async function loadRestartSeeds(guarded, targetMap, streamInfo, eventToState, load2, logger) {
-  const seedStates = /* @__PURE__ */ new Map();
-  await Promise.all(
-    guarded.filter((s) => targetMap.get(s)?.restart).map(async (stream) => {
-      const lastEventName = streamInfo.get(stream).lastEventName;
-      const ownerState = eventToState.get(lastEventName);
-      if (!ownerState) {
-        logger.error(
-          `Cannot seed restart for "${stream}": no registered state owns event "${lastEventName}". Stream will be tombstoned instead.`
-        );
-        return;
-      }
-      const snap2 = await load2(ownerState, stream);
-      seedStates.set(stream, snap2.state);
-    })
-  );
-  return seedStates;
-}
-async function runArchiveCallbacks(guarded, targetMap) {
-  for (const stream of guarded) {
-    const archiveFn = targetMap.get(stream)?.archive;
-    if (archiveFn) await archiveFn();
-  }
-}
-async function truncateAndWarmCache(guarded, seedStates, guardEvents, correlation) {
-  const truncTargets = guarded.map((stream) => {
-    const snapshot = seedStates.get(stream);
-    const guard = guardEvents.get(stream);
-    return {
-      stream,
-      snapshot,
-      meta: {
-        correlation,
-        causation: {
-          event: { id: guard.id, name: TOMBSTONE_EVENT, stream: guard.stream }
-        }
-      }
-    };
-  });
-  const truncated = await store().truncate(truncTargets);
-  await Promise.all(
-    guarded.map(async (stream) => {
-      const entry = truncated.get(stream);
-      const state2 = seedStates.get(stream);
-      if (state2 && entry) {
-        await cache().set(stream, {
-          state: state2,
-          version: entry.committed.version,
-          event_id: entry.committed.id,
-          patches: 0,
-          snaps: 1
-        });
-      } else {
-        await cache().invalidate(stream);
-      }
-    })
-  );
-  return truncated;
-}
-
-// src/internal/correlate-cycle.ts
-var CorrelateCycle = class {
-  constructor(registry, staticTargets, hasDynamicResolvers, cd, maxSubscribedStreams, onInit) {
-    this.registry = registry;
-    this.staticTargets = staticTargets;
-    this.hasDynamicResolvers = hasDynamicResolvers;
-    this.cd = cd;
-    this.onInit = onInit;
-    this._subscribed = new LruSet(maxSubscribedStreams);
-  }
-  _checkpoint = -1;
-  _initialized = false;
-  _timer = void 0;
-  _subscribed;
-  /** Last correlated event id. */
-  get checkpoint() {
-    return this._checkpoint;
-  }
-  /**
-   * Initialize correlation state on first call.
-   * - Reads max(at) from store as cold-start checkpoint
-   * - Subscribes static resolver targets (idempotent upsert)
-   * - Populates the subscribed-streams LRU
-   * - Fires `onInit` once (Act uses this to flag a cold-start drain)
-   */
-  async init() {
-    if (this._initialized) return;
-    this._initialized = true;
-    const { watermark } = await store().subscribe([...this.staticTargets]);
-    this._checkpoint = watermark;
-    this.onInit?.();
-    for (const { stream } of this.staticTargets) {
-      this._subscribed.add(stream);
-    }
-  }
-  /**
-   * Discover dynamic-resolver targets in the events past the checkpoint
-   * and register any new streams via `cd.subscribe`. Static targets are
-   * subscribed at init time, so this only walks dynamic resolvers.
-   */
-  async correlate(query = { after: -1, limit: 10 }) {
-    await this.init();
-    if (!this.hasDynamicResolvers)
-      return { subscribed: 0, last_id: this._checkpoint };
-    const after = Math.max(this._checkpoint, query.after || -1);
-    const correlated = /* @__PURE__ */ new Map();
-    let last_id = after;
-    await store().query(
-      (event) => {
-        last_id = event.id;
-        const register = this.registry.events[event.name];
-        if (register) {
-          for (const reaction of register.reactions.values()) {
-            if (typeof reaction.resolver !== "function") continue;
-            const resolved = reaction.resolver(event);
-            if (resolved && !this._subscribed.has(resolved.target)) {
-              const entry = correlated.get(resolved.target) || {
-                source: resolved.source,
-                payloads: []
-              };
-              entry.payloads.push({
-                ...reaction,
-                source: resolved.source,
-                event
-              });
-              correlated.set(resolved.target, entry);
-            }
-          }
-        }
-      },
-      { ...query, after }
-    );
-    if (correlated.size) {
-      const streams = [...correlated.entries()].map(([stream, { source }]) => ({
-        stream,
-        source
-      }));
-      const { subscribed } = await this.cd.subscribe(streams);
-      this._checkpoint = last_id;
-      if (subscribed) {
-        for (const { stream } of streams) {
-          this._subscribed.add(stream);
-        }
-      }
-      return { subscribed, last_id };
-    }
-    this._checkpoint = last_id;
-    return { subscribed: 0, last_id };
-  }
-  /**
-   * Start a periodic correlation worker. Returns false if one is already
-   * running. Errors from `correlate()` are sent to `console.error` (matches
-   * pre-extraction behavior; the timer keeps running on failure).
-   */
-  startPolling(query = {}, frequency = 1e4, callback) {
-    if (this._timer) return false;
-    const limit = query.limit || 100;
-    this._timer = setInterval(
-      () => this.correlate({ ...query, after: this._checkpoint, limit }).then((result) => {
-        if (callback && result.subscribed) callback(result.subscribed);
-      }).catch(console.error),
-      frequency
-    );
-    return true;
-  }
-  /** Stop the periodic correlation worker. Idempotent. */
-  stopPolling() {
-    if (this._timer) {
-      clearInterval(this._timer);
-      this._timer = void 0;
-    }
-  }
-};
-
-// src/internal/drain-cycle.ts
-var import_node_crypto2 = require("crypto");
-
-// src/internal/drain-ratio.ts
-var RATIO_MIN = 0.2;
-var RATIO_MAX = 0.8;
-var RATIO_DEFAULT = 0.5;
-function computeLagLeadRatio(handled, lagging, leading) {
-  let lagging_handled = 0;
-  let leading_handled = 0;
-  for (const { lease, handled: count } of handled) {
-    if (lease.lagging) lagging_handled += count;
-    else leading_handled += count;
-  }
-  const lagging_avg = lagging > 0 ? lagging_handled / lagging : 0;
-  const leading_avg = leading > 0 ? leading_handled / leading : 0;
-  const total = lagging_avg + leading_avg;
-  if (total === 0) return RATIO_DEFAULT;
-  return Math.max(RATIO_MIN, Math.min(RATIO_MAX, lagging_avg / total));
-}
-
-// src/internal/drain-cycle.ts
-async function runDrainCycle(ops, registry, batchHandlers, handle, handleBatch, lagging, leading, eventLimit, leaseMillis) {
-  const leased = await ops.claim(lagging, leading, (0, import_node_crypto2.randomUUID)(), leaseMillis);
-  if (!leased.length) return void 0;
-  const fetched = await ops.fetch(leased, eventLimit);
-  const fetchMap = /* @__PURE__ */ new Map();
-  const fetch_window_at = fetched.reduce(
-    (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
-    0
-  );
-  for (const f of fetched) {
-    const { stream, events } = f;
-    const payloads = events.flatMap((event) => {
-      const register = registry.events[event.name];
-      if (!register) return [];
-      return [...register.reactions.values()].filter((reaction) => {
-        const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
-        return resolved && resolved.target === stream;
-      }).map((reaction) => ({ ...reaction, event }));
-    });
-    fetchMap.set(stream, { fetch: f, payloads });
-  }
-  const handled = await Promise.all(
-    leased.map((lease) => {
-      const entry = fetchMap.get(lease.stream);
-      const at = entry.fetch.events.at(-1)?.id || fetch_window_at;
-      const { payloads } = entry;
-      const batchHandler = batchHandlers.get(lease.stream);
-      if (batchHandler && payloads.length > 0) {
-        return handleBatch({ ...lease, at }, payloads, batchHandler);
-      }
-      return handle({ ...lease, at }, payloads);
-    })
-  );
-  const acked = await ops.ack(
-    handled.filter(({ error }) => !error).map(({ at, lease }) => ({ ...lease, at }))
-  );
-  const blocked = await ops.block(
-    handled.filter(({ block: block2 }) => block2).map(({ lease, error }) => ({ ...lease, error }))
-  );
-  return { leased, fetched, handled, acked, blocked };
-}
-var EMPTY_DRAIN = {
-  fetched: [],
-  leased: [],
-  acked: [],
-  blocked: []
-};
-var DrainController = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  _armed = false;
-  _locked = false;
-  _ratio = 0.5;
-  /**
-   * Signal that a commit (or reset / cold-start) may have produced work.
-   * Subsequent `drain()` calls will run the pipeline; once the pipeline
-   * settles to no-progress, the controller disarms itself.
-   */
-  arm() {
-    this._armed = true;
-  }
-  /** Read-only flag — true while a commit / reset is unprocessed. */
-  get armed() {
-    return this._armed;
-  }
-  /** Run one drain pass. Short-circuits when not armed or already running. */
-  async drain({
-    streamLimit = 10,
-    eventLimit = 10,
-    leaseMillis = 1e4
-  } = {}) {
-    if (!this._armed) return EMPTY_DRAIN;
-    if (this._locked) return EMPTY_DRAIN;
-    try {
-      this._locked = true;
-      const lagging = Math.ceil(streamLimit * this._ratio);
-      const leading = streamLimit - lagging;
-      const cycle = await runDrainCycle(
-        this.deps.ops,
-        this.deps.registry,
-        this.deps.batchHandlers,
-        this.deps.handle,
-        this.deps.handleBatch,
-        lagging,
-        leading,
-        eventLimit,
-        leaseMillis
-      );
-      if (!cycle) {
-        this._armed = false;
-        return EMPTY_DRAIN;
-      }
-      const { leased, fetched, handled, acked, blocked } = cycle;
-      this._ratio = computeLagLeadRatio(handled, lagging, leading);
-      if (acked.length) this.deps.onAcked(acked);
-      if (blocked.length) this.deps.onBlocked(blocked);
-      const hasErrors = handled.some(({ error }) => error);
-      if (!acked.length && !blocked.length && !hasErrors) this._armed = false;
-      return { fetched, leased, acked, blocked };
-    } catch (error) {
-      this.deps.logger.error(error);
-      return EMPTY_DRAIN;
-    } finally {
-      this._locked = false;
-    }
-  }
-};
-
-// src/internal/merge.ts
-var import_zod4 = require("zod");
-function baseTypeName(zodType) {
-  let t = zodType;
-  while (typeof t.unwrap === "function") {
-    t = t.unwrap();
-  }
-  return t.constructor.name;
-}
-function mergeSchemas(existing, incoming, stateName) {
-  if (existing instanceof import_zod4.ZodObject && incoming instanceof import_zod4.ZodObject) {
-    const existingShape = existing.shape;
-    const incomingShape = incoming.shape;
-    for (const key of Object.keys(incomingShape)) {
-      if (key in existingShape) {
-        const existingBase = baseTypeName(existingShape[key]);
-        const incomingBase = baseTypeName(incomingShape[key]);
-        if (existingBase !== incomingBase) {
-          throw new Error(
-            `Schema conflict in "${stateName}": key "${key}" has type "${existingBase}" but incoming partial declares "${incomingBase}"`
-          );
-        }
-      }
-    }
-    return existing.extend(incomingShape);
-  }
-  return existing;
-}
-function mergeInits(existing, incoming) {
-  return () => ({ ...existing(), ...incoming() });
-}
-function registerState(state2, states, actions, events) {
-  const existing = states.get(state2.name);
-  if (existing) {
-    mergeIntoExisting(state2, existing, states, actions, events);
-  } else {
-    registerNewState(state2, states, actions, events);
-  }
-}
-function registerNewState(state2, states, actions, events) {
-  states.set(state2.name, state2);
-  for (const name of Object.keys(state2.actions)) {
-    if (actions[name]) throw new Error(`Duplicate action "${name}"`);
-    actions[name] = state2;
-  }
-  for (const name of Object.keys(state2.events)) {
-    if (events[name]) throw new Error(`Duplicate event "${name}"`);
-    events[name] = { schema: state2.events[name], reactions: /* @__PURE__ */ new Map() };
-  }
-}
-function mergeIntoExisting(state2, existing, states, actions, events) {
-  for (const name of Object.keys(state2.actions)) {
-    if (existing.actions[name] === state2.actions[name]) continue;
-    if (actions[name]) throw new Error(`Duplicate action "${name}"`);
-  }
-  for (const name of Object.keys(state2.events)) {
-    if (existing.events[name] === state2.events[name]) continue;
-    if (existing.events[name]) continue;
-    if (events[name]) throw new Error(`Duplicate event "${name}"`);
-  }
-  const mergedPatch = mergePatches(existing.patch, state2.patch, state2.name);
-  const merged = {
-    ...existing,
-    state: mergeSchemas(existing.state, state2.state, state2.name),
-    init: mergeInits(existing.init, state2.init),
-    events: { ...existing.events, ...state2.events },
-    actions: { ...existing.actions, ...state2.actions },
-    patch: mergedPatch,
-    on: { ...existing.on, ...state2.on },
-    given: { ...existing.given, ...state2.given },
-    snap: state2.snap && existing.snap && state2.snap !== existing.snap ? (() => {
-      throw new Error(
-        `Duplicate snap strategy for state "${state2.name}"`
-      );
-    })() : state2.snap || existing.snap
-  };
-  states.set(state2.name, merged);
-  for (const name of Object.keys(merged.actions)) {
-    actions[name] = merged;
-  }
-  for (const name of Object.keys(state2.events)) {
-    if (events[name]) continue;
-    events[name] = { schema: state2.events[name], reactions: /* @__PURE__ */ new Map() };
-  }
-}
-function mergePatches(existing, incoming, stateName) {
-  const merged = { ...existing };
-  for (const name of Object.keys(incoming)) {
-    const existingP = existing[name];
-    const incomingP = incoming[name];
-    if (!existingP) {
-      merged[name] = incomingP;
-      continue;
-    }
-    const existingIsDefault = existingP._passthrough;
-    const incomingIsDefault = incomingP._passthrough;
-    if (!existingIsDefault && !incomingIsDefault && existingP !== incomingP) {
-      throw new Error(
-        `Duplicate custom patch for event "${name}" in state "${stateName}"`
-      );
-    }
-    if (existingIsDefault && !incomingIsDefault) {
-      merged[name] = incomingP;
-    }
-  }
-  return merged;
-}
-function mergeEventRegister(target, source) {
-  for (const [eventName, sourceReg] of Object.entries(source)) {
-    const targetReg = target[eventName];
-    if (!targetReg) continue;
-    for (const [name, reaction] of sourceReg.reactions) {
-      targetReg.reactions.set(name, reaction);
-    }
-  }
-}
-function mergeProjection(proj, events) {
-  for (const eventName of Object.keys(proj.events)) {
-    const projRegister = proj.events[eventName];
-    const existing = events[eventName];
-    if (!existing) {
-      events[eventName] = {
-        schema: projRegister.schema,
-        reactions: new Map(projRegister.reactions)
-      };
-    } else {
-      for (const [name, reaction] of projRegister.reactions) {
-        let key = name;
-        while (existing.reactions.has(key)) key = `${key}_p`;
-        existing.reactions.set(key, reaction);
-      }
-    }
-  }
-}
-var _this_ = ({ stream }) => ({
-  source: stream,
-  target: stream
-});
-
-// src/internal/reactions.ts
-function finalize(lease, handled, at, error, options, logger) {
-  if (!error) return { lease, handled, at };
-  logger.error(error);
-  const block2 = lease.retry >= options.maxRetries && options.blockOnError;
-  if (block2)
-    logger.error(`Blocking ${lease.stream} after ${lease.retry} retries.`);
-  return {
-    lease,
-    handled,
-    at,
-    error: handled === 0 ? error.message : void 0,
-    block: block2
-  };
-}
-function buildHandle(deps) {
-  const { logger, boundDo, boundLoad, boundQuery, boundQueryArray } = deps;
-  return async (lease, payloads) => {
-    if (payloads.length === 0) return { lease, handled: 0, at: lease.at };
-    const stream = lease.stream;
-    let at = payloads.at(0).event.id;
-    let handled = 0;
-    if (lease.retry > 0)
-      logger.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
-    const scopedApp = {
-      do: boundDo,
-      load: boundLoad,
-      query: boundQuery,
-      query_array: boundQueryArray
-    };
-    for (const payload of payloads) {
-      const { event, handler } = payload;
-      scopedApp.do = (action2, target, actionPayload, reactingTo, skipValidation) => boundDo(
-        action2,
-        target,
-        actionPayload,
-        reactingTo ?? event,
-        skipValidation
-      );
-      try {
-        await handler(event, stream, scopedApp);
-        at = event.id;
-        handled++;
-      } catch (error) {
-        return finalize(
-          lease,
-          handled,
-          at,
-          error,
-          payload.options,
-          logger
-        );
-      }
-    }
-    return finalize(lease, handled, at, void 0, payloads[0].options, logger);
-  };
-}
-function buildHandleBatch(logger) {
-  return async (lease, payloads, batchHandler) => {
-    const stream = lease.stream;
-    const events = payloads.map((p) => p.event);
-    const options = payloads[0].options;
-    if (lease.retry > 0)
-      logger.warn(`Retrying batch ${stream}@${events[0].id} (${lease.retry}).`);
-    try {
-      await batchHandler(events, stream);
-      return finalize(
-        lease,
-        events.length,
-        events.at(-1).id,
-        void 0,
-        options,
-        logger
-      );
-    } catch (error) {
-      return finalize(lease, 0, lease.at, error, options, logger);
-    }
-  };
-}
-
-// src/internal/settle.ts
-var SettleLoop = class {
-  constructor(deps, defaultDebounceMs) {
-    this.deps = deps;
-    this.defaultDebounceMs = defaultDebounceMs;
-  }
-  _timer = void 0;
-  _running = false;
-  /**
-   * Schedule a settle pass. Multiple calls inside the debounce window
-   * coalesce into one cycle. The cycle runs correlate→drain in a loop
-   * until no progress is made (no new subscriptions, no acks, no blocks)
-   * or `maxPasses` is reached, then emits the `"settled"` lifecycle event
-   * via {@link SettleDeps.onSettled}.
-   */
-  schedule(options = {}) {
-    const {
-      debounceMs = this.defaultDebounceMs,
-      correlate: correlateQuery = { after: -1, limit: 100 },
-      maxPasses = Infinity,
-      ...drainOptions
-    } = options;
-    if (this._timer) clearTimeout(this._timer);
-    this._timer = setTimeout(() => {
-      this._timer = void 0;
-      if (this._running) return;
-      this._running = true;
-      (async () => {
-        await this.deps.init();
-        let lastDrain;
-        for (let i = 0; i < maxPasses; i++) {
-          const { subscribed } = await this.deps.correlate({
-            ...correlateQuery,
-            after: this.deps.checkpoint()
-          });
-          lastDrain = await this.deps.drain(drainOptions);
-          const made_progress = subscribed > 0 || lastDrain.acked.length > 0 || lastDrain.blocked.length > 0;
-          if (!made_progress) break;
-        }
-        if (lastDrain) this.deps.onSettled(lastDrain);
-      })().catch((err) => this.deps.logger.error(err)).finally(() => {
-        this._running = false;
-      });
-    }, debounceMs);
-  }
-  /** Cancel any pending or active settle cycle. Idempotent. */
-  stop() {
-    if (this._timer) {
-      clearTimeout(this._timer);
-      this._timer = void 0;
-    }
-  }
-};
-
-// src/internal/drain.ts
-var claim = (lagging, leading, by, millis) => store().claim(lagging, leading, by, millis);
-async function fetch(leased, eventLimit) {
-  return Promise.all(
-    leased.map(async ({ stream, source, at, lagging }) => {
-      const events = [];
-      await store().query((e) => events.push(e), {
-        stream: source,
-        after: at,
-        limit: eventLimit
-      });
-      return { stream, source, at, lagging, events };
-    })
-  );
-}
-var ack = (leases) => store().ack(leases);
-var block = (leases) => store().block(leases);
-var subscribe = (streams) => store().subscribe(streams);
-
-// src/internal/event-sourcing.ts
-var import_node_crypto3 = require("crypto");
-var import_act_patch = require("@rotorsoft/act-patch");
-async function snap(snapshot) {
-  try {
-    const { id, stream, name, meta, version } = snapshot.event;
-    await store().commit(
-      stream,
-      [{ name: SNAP_EVENT, data: snapshot.state }],
-      {
-        correlation: meta.correlation,
-        causation: { event: { id, name, stream } }
-      },
-      version
-      // IMPORTANT! - state events are committed right after the snapshot event
-    );
-  } catch (error) {
-    log().error(error);
-  }
-}
-async function tombstone(stream, expectedVersion, correlation) {
-  try {
-    const [committed] = await store().commit(
-      stream,
-      [{ name: TOMBSTONE_EVENT, data: {} }],
-      { correlation, causation: {} },
-      expectedVersion
-    );
-    return committed;
-  } catch (error) {
-    if (error instanceof ConcurrencyError) return void 0;
-    throw error;
-  }
-}
-async function load(me, stream, callback, asOf) {
-  const timeTravel = !!asOf && Object.values(asOf).some((v) => v !== void 0);
-  const cached = timeTravel ? void 0 : await cache().get(stream);
-  const cache_hit = !!cached;
-  let state2 = cached?.state ?? (me.init ? me.init() : {});
-  let patches = cached?.patches ?? 0;
-  let snaps = cached?.snaps ?? 0;
-  let version = cached?.version ?? -1;
-  let replayed = 0;
-  let event;
-  await store().query(
-    (e) => {
-      event = e;
-      version = e.version;
-      if (e.name === SNAP_EVENT) {
-        state2 = e.data;
-        snaps++;
-        patches = 0;
-        replayed++;
-      } else if (me.patch[e.name]) {
-        state2 = (0, import_act_patch.patch)(state2, me.patch[e.name](event, state2));
-        patches++;
-        replayed++;
-      } else if (e.name !== TOMBSTONE_EVENT) {
-        log().warn(
-          `Skipping unknown event "${String(e.name)}" on stream "${stream}" (id=${e.id}) \u2014 no reducer in state "${me.name}"`
-        );
-      }
-      callback?.({
-        event,
-        state: state2,
-        version,
-        patches,
-        snaps,
-        cache_hit,
-        replayed
-      });
-    },
-    {
-      stream,
-      stream_exact: true,
-      ...cached ? { after: cached.event_id } : { with_snaps: true, ...asOf }
-    }
-  );
-  if (replayed > 0 && !timeTravel && event) {
-    await cache().set(stream, {
-      state: state2,
-      version,
-      event_id: event.id,
-      patches,
-      snaps
-    });
-  }
-  return { event, state: state2, version, patches, snaps, cache_hit, replayed };
-}
-async function action(me, action2, target, payload, reactingTo, skipValidation = false) {
-  const { stream, expectedVersion, actor } = target;
-  if (!stream) throw new Error("Missing target stream");
-  payload = skipValidation ? payload : validate(action2, payload, me.actions[action2]);
-  const snapshot = await load(me, stream);
-  if (snapshot.event?.name === TOMBSTONE_EVENT)
-    throw new StreamClosedError(stream);
-  const expected = expectedVersion ?? snapshot.event?.version;
-  if (me.given) {
-    const invariants = me.given[action2] || [];
-    invariants.forEach(({ valid, description }) => {
-      if (!valid(snapshot.state, actor))
-        throw new InvariantError(
-          action2,
-          payload,
-          target,
-          snapshot,
-          description
-        );
-    });
-  }
-  const result = me.on[action2](payload, snapshot, target);
-  if (!result) return [snapshot];
-  if (Array.isArray(result) && result.length === 0) {
-    return [snapshot];
-  }
-  const tuples = Array.isArray(result[0]) ? result : [result];
-  const emitted = tuples.map(([name, data]) => ({
-    name,
-    data: skipValidation ? data : validate(name, data, me.events[name])
-  }));
-  const meta = {
-    correlation: reactingTo?.meta.correlation || (0, import_node_crypto3.randomUUID)(),
-    causation: {
-      action: {
-        name: action2,
-        ...target
-        // payload intentionally omitted: it can be large or contain PII,
-        // and callers correlate via the correlation id when they need it.
-      },
-      event: reactingTo ? {
-        id: reactingTo.id,
-        name: reactingTo.name,
-        stream: reactingTo.stream
-      } : void 0
-    }
-  };
-  let committed;
-  try {
-    committed = await store().commit(
-      stream,
-      emitted,
-      meta,
-      // Reactions skip optimistic concurrency: they always append against the
-      // current head. Stream leasing already serializes concurrent reactions,
-      // and forcing version checks here would turn ordinary catch-up into
-      // spurious retries.
-      reactingTo ? void 0 : expected
-    );
-  } catch (error) {
-    if (error instanceof ConcurrencyError) {
-      await cache().invalidate(stream);
-    }
-    throw error;
-  }
-  let { state: state2, patches } = snapshot;
-  const snapshots = committed.map((event) => {
-    const p = me.patch[event.name](event, state2);
-    state2 = (0, import_act_patch.patch)(state2, p);
-    patches++;
-    return {
-      event,
-      state: state2,
-      version: event.version,
-      patches,
-      snaps: snapshot.snaps,
-      patch: p,
-      cache_hit: snapshot.cache_hit,
-      replayed: snapshot.replayed
-    };
-  });
-  const last = snapshots.at(-1);
-  const snapped = me.snap?.(last);
-  cache().set(stream, {
-    state: last.state,
-    version: last.event.version,
-    event_id: last.event.id,
-    patches: snapped ? 0 : last.patches,
-    snaps: snapped ? last.snaps + 1 : last.snaps
-  }).catch((err) => log().error(err));
-  if (snapped) void snap(last);
-  return snapshots;
-}
-
-// src/internal/tracing.ts
-var PRETTY = config().env !== "production";
-var C_BLUE = "\x1B[38;5;39m";
-var C_ORANGE = "\x1B[38;5;208m";
-var C_GREEN = "\x1B[38;5;42m";
-var C_MAGENTA = "\x1B[38;5;165m";
-var C_DRAIN = "\x1B[38;5;244m";
-var C_HIT = "\x1B[38;5;82m";
-var C_MISS = "\x1B[38;5;220m";
-var C_RESET = "\x1B[0m";
-var es_caption = (caption, color, body) => PRETTY ? `${color}${body}${C_RESET}` : `${caption}: ${body}`;
-var drain_caption = (caption) => {
-  const tag = `>> ${caption}`;
-  return PRETTY ? `${C_DRAIN}${tag}${C_RESET}` : tag;
-};
-var cache_marker = (hit) => {
-  const word = hit ? "hit" : "miss";
-  if (!PRETTY) return word;
-  return `${hit ? C_HIT : C_MISS}${word}${C_RESET}${C_GREEN}`;
-};
-var stats_marker = (version, replayed, snaps, patches) => {
-  const text = `v=${version} replayed=${replayed} snaps=${snaps} patches=${patches}`;
-  if (!PRETTY) return text;
-  return `${C_DRAIN}${text}${C_RESET}${C_GREEN}`;
-};
-var as_of_marker = (asOf) => {
-  if (!asOf) return "";
-  const parts = [];
-  if (asOf.before !== void 0) parts.push(`before=${asOf.before}`);
-  if (asOf.created_before !== void 0)
-    parts.push(`created_before=${asOf.created_before.toISOString()}`);
-  if (asOf.created_after !== void 0)
-    parts.push(`created_after=${asOf.created_after.toISOString()}`);
-  if (asOf.limit !== void 0) parts.push(`limit=${asOf.limit}`);
-  return parts.length ? ` (as-of ${parts.join(" ")})` : " (as-of)";
-};
-var traced = (inner, exit, entry) => (async (...args) => {
-  entry?.(...args);
-  const result = await inner(...args);
-  exit?.(result, ...args);
-  return result;
-});
-function buildEs(logger) {
-  if (logger.level !== "trace") {
-    return {
-      snap,
-      load,
-      action,
-      tombstone
-    };
-  }
-  return {
-    snap: traced(snap, void 0, (snapshot) => {
-      logger.trace(
-        es_caption(
-          "snap",
-          C_MAGENTA,
-          `${snapshot.event.stream}@${snapshot.event.version}`
-        )
-      );
-    }),
-    load: traced(load, (result, _me, stream, _cb, asOf) => {
-      const stats = stats_marker(
-        result.version,
-        result.replayed,
-        result.snaps,
-        result.patches
-      );
-      logger.trace(
-        es_caption(
-          "load",
-          C_GREEN,
-          `${stream}${as_of_marker(asOf)} ${cache_marker(result.cache_hit)} ${stats}`
-        )
-      );
-    }),
-    action: traced(
-      action,
-      (snapshots, _me, _action, target) => {
-        const committed = snapshots.filter((s) => s.event);
-        if (committed.length) {
-          logger.trace(
-            committed.map((s) => s.event.data),
-            es_caption(
-              "committed",
-              C_ORANGE,
-              `${target.stream}.${committed.map((s) => s.event.name).join(", ")}`
-            )
-          );
-        }
-      },
-      (_me, action2, target, payload) => {
-        logger.trace(
-          payload,
-          es_caption("action", C_BLUE, `${target.stream}.${action2}`)
-        );
-      }
-    ),
-    tombstone: traced(tombstone, (committed, stream) => {
-      if (committed)
-        logger.trace(
-          es_caption("tombstoned", C_ORANGE, `${stream}@${committed.version}`)
-        );
-    })
-  };
-}
-function buildDrain(logger) {
-  if (logger.level !== "trace") {
-    return {
-      claim,
-      fetch,
-      ack,
-      block,
-      subscribe
-    };
-  }
-  return {
-    claim: traced(claim, (leased) => {
-      if (leased.length) {
-        const data = Object.fromEntries(
-          leased.map(({ stream, at, retry }) => [stream, { at, retry }])
-        );
-        logger.trace(data, drain_caption("claimed"));
-      }
-    }),
-    fetch: traced(fetch, (fetched) => {
-      const data = Object.fromEntries(
-        fetched.map(({ stream, source, events }) => {
-          const key = source ? `${stream}<-${source}` : stream;
-          const value = Object.fromEntries(
-            events.map(({ id, stream: stream2, name }) => [id, { [stream2]: name }])
-          );
-          return [key, value];
-        })
-      );
-      logger.trace(data, drain_caption("fetched"));
-    }),
-    ack: traced(ack, (acked) => {
-      if (acked.length) {
-        const data = Object.fromEntries(
-          acked.map(({ stream, at, retry }) => [stream, { at, retry }])
-        );
-        logger.trace(data, drain_caption("acked"));
-      }
-    }),
-    block: traced(block, (blocked) => {
-      if (blocked.length) {
-        const data = Object.fromEntries(
-          blocked.map(({ stream, at, retry, error }) => [
-            stream,
-            { at, retry, error }
-          ])
-        );
-        logger.trace(data, drain_caption("blocked"));
-      }
-    }),
-    subscribe: traced(subscribe, (result, streams) => {
-      if (result.subscribed) {
-        const data = streams.map(({ stream }) => stream).join(" ");
-        logger.trace(`${drain_caption("correlated")} ${data}`);
-      }
-    })
-  };
-}
-
-// src/act.ts
-var DEFAULT_MAX_SUBSCRIBED_STREAMS = 1e3;
-var DEFAULT_SETTLE_DEBOUNCE_MS = 10;
-var Act = class {
-  /**
-   * Create a new Act orchestrator. Prefer the {@link act} builder over
-   * direct construction — `act()...build()` wires the registry, merges
-   * partial states, and collects batch handlers from registered slices
-   * and projections in one pass.
-   *
-   * @param registry  Schemas for every event and action across registered states
-   * @param _states   Merged map of state name → state definition
-   * @param batchHandlers Static-target projection batch handlers (target → handler)
-   * @param options   Tuning knobs — see {@link ActOptions}
-   */
-  constructor(registry, _states = /* @__PURE__ */ new Map(), batchHandlers = /* @__PURE__ */ new Map(), options = {}) {
-    this.registry = registry;
-    this._states = _states;
-    this._batch_handlers = batchHandlers;
-    this._es = buildEs(this._logger);
-    this._cd = buildDrain(this._logger);
-    this._handle = buildHandle({
-      logger: this._logger,
-      boundDo: this._bound_do,
-      boundLoad: this._bound_load,
-      boundQuery: this._bound_query,
-      boundQueryArray: this._bound_query_array
-    });
-    this._handle_batch = buildHandleBatch(this._logger);
-    const { staticTargets, hasDynamicResolvers, reactiveEvents, eventToState } = classifyRegistry(this.registry, this._states);
-    this._reactive_events = reactiveEvents;
-    this._event_to_state = eventToState;
-    this._drain = new DrainController({
-      logger: this._logger,
-      ops: this._cd,
-      registry: this.registry,
-      batchHandlers: this._batch_handlers,
-      handle: this._handle,
-      handleBatch: this._handle_batch,
-      onAcked: (acked) => this.emit("acked", acked),
-      onBlocked: (blocked) => this.emit("blocked", blocked)
-    });
-    this._correlate = new CorrelateCycle(
-      this.registry,
-      staticTargets,
-      hasDynamicResolvers,
-      this._cd,
-      options.maxSubscribedStreams ?? DEFAULT_MAX_SUBSCRIBED_STREAMS,
-      // Cold start: assume drain is needed (historical events may need processing)
-      () => {
-        if (this._reactive_events.size > 0) this._drain.arm();
-      }
-    );
-    this._settle = new SettleLoop(
-      {
-        logger: this._logger,
-        init: () => this._correlate.init(),
-        checkpoint: () => this._correlate.checkpoint,
-        correlate: (q) => this.correlate(q),
-        drain: (o) => this.drain(o),
-        onSettled: (drain) => this.emit("settled", drain)
-      },
-      options.settleDebounceMs ?? DEFAULT_SETTLE_DEBOUNCE_MS
-    );
-    dispose(() => {
-      this._emitter.removeAllListeners();
-      this.stop_correlations();
-      this.stop_settling();
-      return Promise.resolve();
-    });
-  }
-  _emitter = new import_node_events.default();
-  /** Event names with at least one registered reaction (computed at build time) */
-  _reactive_events;
-  /** Drain pipeline driver: armed flag, concurrency lock, adaptive ratio. */
-  _drain;
-  /** Correlation state machine: lazy init, dynamic-resolver scan, periodic worker. */
-  _correlate;
-  /** Debounced correlate→drain catch-up loop. */
-  _settle;
-  /**
-   * Emit a lifecycle event. The payload type is inferred from the event name
-   * via {@link ActLifecycleEvents}.
-   */
-  emit(event, args) {
-    return this._emitter.emit(event, args);
-  }
-  /**
-   * Register a listener for a lifecycle event. The listener receives the
-   * event-specific payload.
-   */
-  on(event, listener) {
-    this._emitter.on(event, listener);
-    return this;
-  }
-  /**
-   * Remove a previously registered lifecycle listener.
-   */
-  off(event, listener) {
-    this._emitter.off(event, listener);
-    return this;
-  }
-  /** Batch handlers for static-target projections (target → handler) */
-  _batch_handlers;
-  /** Event-sourcing handlers, optionally wrapped with trace decorators */
-  _es;
-  /** Correlate/drain pipeline ops, optionally wrapped with trace decorators */
-  _cd;
-  /**
-   * Event-name → owning state, computed at build time. The duplicate-event
-   * guard in merge.ts ensures one event name maps to at most one state, so
-   * this lookup is unambiguous. Used by `close()` to pick the right reducer
-   * set when seeding a `restart` snapshot in multi-state apps.
-   */
-  _event_to_state;
-  /** Logger resolved at construction time (after user port configuration) */
-  _logger = log();
-  /** Pre-bound IAct methods reused across drain cycles. Only `do` varies per
-   * payload (it captures the triggering event for reactingTo auto-inject). */
-  _bound_do = this.do.bind(this);
-  _bound_load = this.load.bind(this);
-  _bound_query = this.query.bind(this);
-  _bound_query_array = this.query_array.bind(this);
-  /** Reaction dispatchers built once and handed to runDrainCycle each cycle. */
-  _handle;
-  _handle_batch;
-  /**
-   * Executes an action on a state instance, committing resulting events.
-   *
-   * This is the primary method for modifying state. It:
-   * 1. Validates the action payload against the schema
-   * 2. Loads the current state snapshot
-   * 3. Checks invariants (business rules)
-   * 4. Executes the action handler to generate events
-   * 5. Applies events to create new state
-   * 6. Commits events to the store with optimistic concurrency control
-   *
-   * @template TKey - Action name from registered actions
-   * @param action - The name of the action to execute
-   * @param target - Target specification with stream ID and actor context
-   * @param payload - Action payload matching the action's schema
-   * @param reactingTo - Optional event that triggered this action (for correlation)
-   * @param skipValidation - Skip schema validation (use carefully, for performance)
-   * @returns Array of snapshots for all affected states (usually one)
-   *
-   * @throws {ValidationError} If payload doesn't match action schema
-   * @throws {InvariantError} If business rules are violated
-   * @throws {ConcurrencyError} If another process modified the stream
-   *
-   * @example Basic action execution
-   * ```typescript
-   * const snapshots = await app.do(
-   *   "increment",
-   *   {
-   *     stream: "counter-1",
-   *     actor: { id: "user1", name: "Alice" }
-   *   },
-   *   { by: 5 }
-   * );
-   *
-   * console.log(snapshots[0].state.count); // Current count after increment
-   * ```
-   *
-   * @example With error handling
-   * ```typescript
-   * try {
-   *   await app.do(
-   *     "withdraw",
-   *     { stream: "account-123", actor: { id: "user1", name: "Alice" } },
-   *     { amount: 1000 }
-   *   );
-   * } catch (error) {
-   *   if (error instanceof InvariantError) {
-   *     console.error("Business rule violated:", error.description);
-   *   } else if (error instanceof ConcurrencyError) {
-   *     console.error("Concurrent modification detected, retry...");
-   *   } else if (error instanceof ValidationError) {
-   *     console.error("Invalid payload:", error.details);
-   *   }
-   * }
-   * ```
-   *
-   * @example Reaction triggering another action (reactingTo auto-injected)
-   * ```typescript
-   * const app = act()
-   *   .withState(Order)
-   *   .withState(Inventory)
-   *   .on("OrderPlaced")
-   *     .do(async function reduceInventory(event, _stream, app) {
-   *       // Inside reaction handlers, reactingTo is auto-injected when omitted.
-   *       // The triggering event is used by default, maintaining the correlation chain.
-   *       await app.do(
-   *         "reduceStock",
-   *         { stream: "inventory-1", actor: { id: "sys", name: "system" } },
-   *         { amount: event.data.items.length }
-   *       );
-   *       // To use a different correlation, pass reactingTo explicitly:
-   *       // await app.do("reduceStock", target, payload, customEvent);
-   *     })
-   *     .to("inventory-1")
-   *   .build();
-   * ```
-   *
-   * @see {@link Target} for target structure
-   * @see {@link Snapshot} for return value structure
-   * @see {@link ValidationError}, {@link InvariantError}, {@link ConcurrencyError}
-   */
-  async do(action2, target, payload, reactingTo, skipValidation = false) {
-    const snapshots = await this._es.action(
-      this.registry.actions[action2],
-      action2,
-      target,
-      payload,
-      reactingTo,
-      skipValidation
-    );
-    if (this._reactive_events.size > 0) {
-      for (const snap2 of snapshots) {
-        if (snap2.event?.name && this._reactive_events.has(snap2.event.name)) {
-          this._drain.arm();
-          break;
-        }
-      }
-    }
-    this.emit("committed", snapshots);
-    return snapshots;
-  }
-  async load(stateOrName, stream, callback, asOf) {
-    let merged;
-    if (typeof stateOrName === "string") {
-      const found = this._states.get(stateOrName);
-      if (!found) throw new Error(`State "${stateOrName}" not found`);
-      merged = found;
-    } else {
-      merged = this._states.get(stateOrName.name) || stateOrName;
-    }
-    return await this._es.load(merged, stream, callback, asOf);
-  }
-  /**
-   * Queries the event store for events matching a filter.
-   *
-   * Use this for analyzing event streams, generating reports, or debugging.
-   * The callback is invoked for each matching event, and the method returns
-   * summary information (first event, last event, total count).
-   *
-   * For small result sets, consider using {@link query_array} instead.
-   *
-   * @param query - Filter criteria — see {@link Query} for available fields
-   *   (`stream`, `name`, `after`, `before`, `created_after`, `created_before`,
-   *   `limit`, `with_snaps`, `stream_exact`)
-   * @param callback - Optional callback invoked for each matching event
-   * @returns Object with first event, last event, and total count
-   *
-   * @example Query all events for a stream
-   * ```typescript
-   * const { first, last, count } = await app.query(
-   *   { stream: "counter-1" },
-   *   (event) => console.log(event.name, event.data)
-   * );
-   * console.log(`Found ${count} events from ${first?.id} to ${last?.id}`);
-   * ```
-   *
-   * @example Query specific event types
-   * ```typescript
-   * const { count } = await app.query(
-   *   { name: "UserCreated", limit: 100 },
-   *   (event) => {
-   *     console.log("User created:", event.data.email);
-   *   }
-   * );
-   * ```
-   *
-   * @example Query events in time range
-   * ```typescript
-   * const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
-   * const { count } = await app.query({
-   *   created_after: yesterday,
-   *   stream: "user-123"
-   * });
-   * console.log(`User had ${count} events in last 24 hours`);
-   * ```
-   *
-   * @see {@link query_array} for loading events into memory
-   */
-  async query(query, callback) {
-    let first;
-    let last;
-    const count = await store().query((e) => {
-      if (!first) first = e;
-      last = e;
-      callback?.(e);
-    }, query);
-    return { first, last, count };
-  }
-  /**
-   * Queries the event store and returns all matching events in memory.
-   *
-   * **Use with caution** - this loads all results into memory. For large result sets,
-   * use {@link query} with a callback instead to process events incrementally.
-   *
-   * @param query - The query filter (same as {@link query})
-   * @returns Array of all matching events
-   *
-   * @example Load all events for a stream
-   * ```typescript
-   * const events = await app.query_array({ stream: "counter-1" });
-   * console.log(`Loaded ${events.length} events`);
-   * events.forEach(event => console.log(event.name, event.data));
-   * ```
-   *
-   * @example Get recent events
-   * ```typescript
-   * const recent = await app.query_array({
-   *   stream: "user-123",
-   *   limit: 10
-   * });
-   * ```
-   *
-   * @see {@link query} for large result sets
-   */
-  async query_array(query) {
-    const events = [];
-    await store().query((e) => events.push(e), query);
-    return events;
-  }
-  /**
-   * Processes pending reactions by draining uncommitted events from the event store.
-   *
-   * Runs a single drain cycle:
-   * 1. Polls the store for streams with uncommitted events
-   * 2. Leases streams to prevent concurrent processing
-   * 3. Fetches events for each leased stream
-   * 4. Executes matching reaction handlers
-   * 5. Acknowledges successful reactions or blocks failing ones
-   *
-   * Drain uses a dual-frontier strategy to balance processing of new streams (lagging)
-   * vs active streams (leading). The ratio adapts based on event pressure.
-   *
-   * Call `correlate()` before `drain()` to discover target streams. For a higher-level
-   * API that handles debouncing, correlation, and signaling automatically, use {@link settle}.
-   *
-   * @param options - Drain configuration — see {@link DrainOptions} for fields
-   *   (`streamLimit`, `eventLimit`, `leaseMillis`).
-   * @returns Drain statistics with fetched, leased, acked, and blocked counts
-   *
-   * @example In tests and scripts
-   * ```typescript
-   * await app.do("createUser", target, payload);
-   * await app.correlate();
-   * await app.drain();
-   * ```
-   *
-   * @example In production, prefer settle()
-   * ```typescript
-   * await app.do("CreateItem", target, input);
-   * app.settle(); // debounced correlate→drain, emits "settled"
-   * ```
-   *
-   * @see {@link settle} for debounced correlate→drain with lifecycle events
-   * @see {@link correlate} for dynamic stream discovery
-   * @see {@link start_correlations} for automatic correlation
-   */
-  async drain(options = {}) {
-    return this._drain.drain(options);
-  }
-  /**
-   * Discovers and registers new streams dynamically based on reaction resolvers.
-   *
-   * Correlation enables "dynamic reactions" where target streams are determined at runtime
-   * based on event content. For example, you might create a stats stream for each user
-   * when they perform certain actions.
-   *
-   * This method scans events matching the query and identifies new target streams based
-   * on reaction resolvers. It then registers these streams so they'll be picked up by
-   * the next drain cycle.
-   *
-   * @param query - Query filter to scan for new correlations
-   * @param query - Scan filter — see {@link Query} for fields (typically
-   *   `{ after: <event-id>, limit: <count> }`)
-   * @returns Object with newly leased streams and last scanned event ID
-   *
-   * @example Manual correlation
-   * ```typescript
-   * // Scan for new streams
-   * const { leased, last_id } = await app.correlate({ after: 0, limit: 100 });
-   * console.log(`Found ${leased.length} new streams`);
-   *
-   * // Save last_id for next scan
-   * await saveCheckpoint(last_id);
-   * ```
-   *
-   * @example Dynamic stream creation
-   * ```typescript
-   * const app = act()
-   *   .withState(User)
-   *   .withState(UserStats)
-   *   .on("UserLoggedIn")
-   *     .do(async (event) => ["incrementLoginCount", {}])
-   *     .to((event) => ({
-   *       target: `stats-${event.stream}` // Dynamic target per user
-   *     }))
-   *   .build();
-   *
-   * // Discover stats streams as users log in
-   * await app.correlate();
-   * ```
-   *
-   * @see {@link start_correlations} for automatic periodic correlation
-   * @see {@link stop_correlations} to stop automatic correlation
-   */
-  async correlate(query = { after: -1, limit: 10 }) {
-    return this._correlate.correlate(query);
-  }
-  /**
-   * Starts automatic periodic correlation worker for discovering new streams.
-   *
-   * The correlation worker runs in the background, scanning for new events and identifying
-   * new target streams based on reaction resolvers. It maintains a sliding window that
-   * advances with each scan, ensuring all events are eventually correlated.
-   *
-   * This is useful for dynamic stream creation patterns where you don't know all streams
-   * upfront - they're discovered as events arrive.
-   *
-   * **Note:** Only one correlation worker can run at a time per Act instance.
-   *
-   * @param query - Query filter for correlation scans — see {@link Query}
-   *   (typically `{ after: -1, limit: 100 }`)
-   * @param frequency - Correlation frequency in milliseconds (default: 10000)
-   * @param callback - Optional callback invoked with newly discovered streams
-   * @returns `true` if worker started, `false` if already running
-   *
-   * @example Start automatic correlation
-   * ```typescript
-   * // Start correlation worker scanning every 5 seconds
-   * app.start_correlations(
-   *   { after: 0, limit: 100 },
-   *   5000,
-   *   (leased) => {
-   *     console.log(`Discovered ${leased.length} new streams`);
-   *   }
-   * );
-   *
-   * // Later, stop it
-   * app.stop_correlations();
-   * ```
-   *
-   * @example With checkpoint persistence
-   * ```typescript
-   * // Load last checkpoint
-   * const lastId = await loadCheckpoint();
-   *
-   * app.start_correlations(
-   *   { after: lastId, limit: 100 },
-   *   10000,
-   *   async (leased) => {
-   *     // Save checkpoint for next restart
-   *     if (leased.length) {
-   *       const maxId = Math.max(...leased.map(l => l.at));
-   *       await saveCheckpoint(maxId);
-   *     }
-   *   }
-   * );
-   * ```
-   *
-   * @see {@link correlate} for manual one-time correlation
-   * @see {@link stop_correlations} to stop the worker
-   */
-  start_correlations(query = {}, frequency = 1e4, callback) {
-    return this._correlate.startPolling(query, frequency, callback);
-  }
-  /**
-   * Stops the automatic correlation worker.
-   *
-   * Call this to stop the background correlation worker started by {@link start_correlations}.
-   * This is automatically called when the Act instance is disposed.
-   *
-   * @example
-   * ```typescript
-   * // Start correlation
-   * app.start_correlations();
-   *
-   * // Later, stop it
-   * app.stop_correlations();
-   * ```
-   *
-   * @see {@link start_correlations}
-   */
-  stop_correlations() {
-    this._correlate.stopPolling();
-  }
-  /**
-   * Cancels any pending or active settle cycle.
-   *
-   * @see {@link settle}
-   */
-  stop_settling() {
-    this._settle.stop();
-  }
-  /**
-   * Reset reaction stream watermarks and request a drain on the next
-   * `drain()` / `settle()` cycle.
-   *
-   * Use this to replay events through projections (or other reaction targets)
-   * after changing handler logic. Equivalent to calling `store().reset(streams)`
-   * directly, but also raises the orchestrator's internal "needs drain" flag —
-   * `store().reset(...)` alone leaves the flag untouched, so a settled app
-   * would short-circuit and skip the replay.
-   *
-   * Pair with `app.settle()` (or a single `app.drain()` for small streams).
-   * `settle()` loops correlate→drain until no progress is made, so one call
-   * fully catches up paginated streams without forcing callers to roll
-   * their own loop.
-   *
-   * @param streams - Reaction target streams (e.g., projection names) to reset
-   * @returns Count of streams that were actually reset
-   *
-   * @example Rebuild a projection (production)
-   * ```typescript
-   * await app.reset(["my-projection"]);
-   * app.settle({ eventLimit: 1000 });   // emits "settled" when fully replayed
-   * ```
-   *
-   * @example Rebuild a projection (tests / scripts)
-   * ```typescript
-   * await app.reset(["my-projection"]);
-   * await app.drain({ eventLimit: 1000 });   // small streams: one pass is enough
-   * ```
-   *
-   * @see {@link Store.reset} for the underlying store primitive
-   * @see {@link settle} for the debounced full-catch-up loop
-   */
-  async reset(streams) {
-    const count = await store().reset(streams);
-    if (count > 0 && this._reactive_events.size > 0) this._drain.arm();
-    return count;
-  }
-  /**
-   * Close the books — guard, archive, truncate, and optionally restart streams.
-   *
-   * Safely removes historical events from the operational store:
-   *
-   * 1. **Correlate** — discover pending reaction targets
-   * 2. **Safety check** — skip streams with pending reactions (skipped when no reactive events)
-   * 3. **Guard** — commit `__tombstone__` with `expectedVersion` to block concurrent writes
-   * 4. **Load state** — for streams in `snapshots`, load final state while guarded (no races)
-   * 5. **Archive** — user callback per stream (abort-all on failure, streams are guarded)
-   * 6. **Truncate + seed** — atomic: delete all events, insert `__snapshot__` or `__tombstone__`
-   * 7. **Cache** — invalidate (tombstoned) or warm (restarted)
-   * 8. **Emit "closed"** — lifecycle event with results
-   *
-   * @param targets - Per-stream close options (stream, restart?, archive?)
-   * @returns `{ truncated: TruncateResult, skipped: string[] }`
-   *
-   * @example Archive and close
-   * ```typescript
-   * await app.close([
-   *   { stream: "order-123", archive: async () => { await archiveToS3("order-123"); } },
-   *   { stream: "order-456" },
-   * ]);
-   * ```
-   *
-   * @example Close with restart (state loaded automatically after guard)
-   * ```typescript
-   * await app.close([
-   *   { stream: "counter-1", restart: true },
-   *   { stream: "counter-2" },  // tombstoned
-   * ]);
-   * ```
-   */
-  async close(targets) {
-    if (!targets.length) return { truncated: /* @__PURE__ */ new Map(), skipped: [] };
-    await this.correlate({ limit: 1e3 });
-    const result = await runCloseCycle(targets, {
-      reactiveEventsSize: this._reactive_events.size,
-      eventToState: this._event_to_state,
-      load: this._es.load,
-      tombstone: this._es.tombstone,
-      logger: this._logger
-    });
-    this.emit("closed", result);
-    return result;
-  }
-  /**
-   * Debounced, non-blocking correlate→drain cycle.
-   *
-   * Call this after `app.do()` (or `app.reset()`) to schedule a background
-   * drain. Multiple rapid calls within the debounce window are coalesced
-   * into a single cycle. Runs correlate→drain in a loop until a pass makes
-   * no progress — no new subscriptions, no acks, no blocks — then emits
-   * the `"settled"` lifecycle event. This means a single `settle()` call
-   * fully catches up paginated streams (e.g. after `reset()` on a long
-   * projection) without forcing callers to loop.
-   *
-   * @param options - Settle configuration — see {@link SettleOptions} for fields:
-   *   `debounceMs` (default 10), `correlate` (default `{ after: -1, limit: 100 }`),
-   *   `maxPasses` (default `Infinity` — kill-switch for runaway loops),
-   *   `streamLimit` (default 10), `eventLimit` (default 10),
-   *   `leaseMillis` (default 10000).
-   *
-   * @example API mutations
-   * ```typescript
-   * await app.do("CreateItem", target, input);
-   * app.settle(); // non-blocking, returns immediately
-   *
-   * app.on("settled", (drain) => {
-   *   // notify SSE clients, invalidate caches, etc.
-   * });
-   * ```
-   *
-   * @see {@link drain} for single synchronous drain cycles
-   * @see {@link correlate} for manual correlation
-   */
-  settle(options = {}) {
-    this._settle.schedule(options);
-  }
-};
-
-// src/builders/act-builder.ts
-function registerBatchHandler(proj, batchHandlers) {
-  if (!proj.batchHandler || !proj.target) return;
-  const existing = batchHandlers.get(proj.target);
-  if (existing && existing !== proj.batchHandler) {
-    throw new Error(`Duplicate batch handler for target "${proj.target}"`);
-  }
-  batchHandlers.set(proj.target, proj.batchHandler);
-}
-function act() {
-  const states = /* @__PURE__ */ new Map();
-  const registry = {
-    actions: {},
-    events: {}
-  };
-  const pendingProjections = [];
-  const batchHandlers = /* @__PURE__ */ new Map();
-  const builder = {
-    withState: (state2) => {
-      registerState(state2, states, registry.actions, registry.events);
-      return builder;
-    },
-    withSlice: (input) => {
-      for (const s of input.states.values()) {
-        registerState(s, states, registry.actions, registry.events);
-      }
-      mergeEventRegister(registry.events, input.events);
-      pendingProjections.push(...input.projections);
-      return builder;
-    },
-    withProjection: (proj) => {
-      mergeProjection(proj, registry.events);
-      registerBatchHandler(proj, batchHandlers);
-      return builder;
-    },
-    withActor: () => builder,
-    on: (event) => ({
-      do: (handler, options) => {
-        const reaction = {
-          handler,
-          resolver: _this_,
-          options: {
-            blockOnError: options?.blockOnError ?? true,
-            maxRetries: options?.maxRetries ?? 3
-          }
-        };
-        if (!handler.name)
-          throw new Error(
-            `Reaction handler for "${String(event)}" must be a named function`
-          );
-        registry.events[event].reactions.set(handler.name, reaction);
-        return Object.assign(builder, {
-          to(resolver) {
-            reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
-            return builder;
-          }
-        });
-      }
-    }),
-    build: (options) => {
-      for (const proj of pendingProjections) {
-        mergeProjection(proj, registry.events);
-        registerBatchHandler(proj, batchHandlers);
-      }
-      return new Act(
-        registry,
-        states,
-        batchHandlers,
-        options
-      );
-    },
-    events: registry.events
-  };
-  return builder;
-}
-
-// src/builders/projection-builder.ts
-function _projection(target) {
-  const events = {};
-  const defaultResolver = typeof target === "string" ? { target } : void 0;
-  const base = {
-    on: (entry) => {
-      const keys = Object.keys(entry);
-      if (keys.length !== 1) throw new Error(".on() requires exactly one key");
-      const event = keys[0];
-      const schema = entry[event];
-      if (!(event in events)) {
-        events[event] = {
-          schema,
-          reactions: /* @__PURE__ */ new Map()
-        };
-      }
-      return {
-        do: (handler) => {
-          const reaction = {
-            handler,
-            resolver: defaultResolver ?? _this_,
-            options: {
-              blockOnError: true,
-              maxRetries: 3
-            }
-          };
-          const register = events[event];
-          if (!handler.name)
-            throw new Error(
-              `Projection handler for "${event}" must be a named function`
-            );
-          register.reactions.set(handler.name, reaction);
-          const widened = base;
-          return Object.assign(widened, {
-            to(resolver) {
-              reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
-              return widened;
-            }
-          });
-        }
-      };
-    },
-    build: () => ({
-      _tag: "Projection",
-      events,
-      ...target !== void 0 && { target }
-    }),
-    events
-  };
-  if (typeof target === "string") {
-    return Object.assign(base, {
-      batch: (handler) => ({
-        build: () => ({
-          _tag: "Projection",
-          events,
-          target,
-          batchHandler: handler
-        })
-      })
-    });
-  }
-  return base;
-}
-function projection(target) {
-  return _projection(target);
-}
-
-// src/builders/slice-builder.ts
-function slice() {
-  const states = /* @__PURE__ */ new Map();
-  const actions = {};
-  const events = {};
-  const projections = [];
-  const builder = {
-    withState: (state2) => {
-      registerState(state2, states, actions, events);
-      return builder;
-    },
-    withProjection: (proj) => {
-      projections.push(proj);
-      return builder;
-    },
-    on: (event) => ({
-      do: (handler, options) => {
-        const reaction = {
-          handler,
-          resolver: _this_,
-          options: {
-            blockOnError: options?.blockOnError ?? true,
-            maxRetries: options?.maxRetries ?? 3
-          }
-        };
-        if (!handler.name)
-          throw new Error(
-            `Reaction handler for "${String(event)}" must be a named function`
-          );
-        events[event].reactions.set(handler.name, reaction);
-        return Object.assign(builder, {
-          to(resolver) {
-            reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
-            return builder;
-          }
-        });
-      }
-    }),
-    build: () => ({
-      _tag: "Slice",
-      states,
-      events,
-      projections
-    }),
-    events
-  };
-  return builder;
-}
-
-// src/builders/state-builder.ts
-function state(entry) {
-  const keys = Object.keys(entry);
-  if (keys.length !== 1) throw new Error("state() requires exactly one key");
-  const name = keys[0];
-  const stateSchema = entry[name];
-  return {
-    init(init) {
-      return {
-        emits(events) {
-          const defaultPatch = Object.fromEntries(
-            Object.keys(events).map((k) => {
-              const fn = Object.assign(({ data }) => data, {
-                _passthrough: true
-              });
-              return [k, fn];
-            })
-          );
-          const internal = {
-            events,
-            actions: {},
-            state: stateSchema,
-            name,
-            init,
-            patch: defaultPatch,
-            on: {}
-          };
-          const builder = action_builder(internal);
-          return Object.assign(builder, {
-            patch(customPatch) {
-              Object.assign(internal.patch, customPatch);
-              return builder;
-            }
-          });
-        }
-      };
-    }
-  };
-}
-function action_builder(state2) {
-  const internal = state2;
-  const builder = {
-    on(entry) {
-      const keys = Object.keys(entry);
-      if (keys.length !== 1) throw new Error(".on() requires exactly one key");
-      const action2 = keys[0];
-      const schema = entry[action2];
-      if (action2 in internal.actions)
-        throw new Error(`Duplicate action "${action2}"`);
-      internal.actions[action2] = schema;
-      function given(rules) {
-        internal.given ??= {};
-        internal.given[action2] = rules;
-        return { emit };
-      }
-      function emit(handler) {
-        if (typeof handler === "string") {
-          const eventName = handler;
-          internal.on[action2] = (payload) => [
-            eventName,
-            payload
-          ];
-        } else {
-          internal.on[action2] = handler;
-        }
-        return builder;
-      }
-      return { given, emit };
-    },
-    snap(snap2) {
-      internal.snap = snap2;
-      return builder;
-    },
-    build() {
-      return internal;
-    }
-  };
-  return builder;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Act,
-  ActorSchema,
-  CausationEventSchema,
-  CommittedMetaSchema,
-  ConcurrencyError,
-  ConsoleLogger,
-  DEFAULT_MAX_SUBSCRIBED_STREAMS,
-  DEFAULT_SETTLE_DEBOUNCE_MS,
-  Environments,
-  Errors,
-  EventMetaSchema,
-  ExitCodes,
-  InMemoryCache,
-  InMemoryStore,
-  InvariantError,
-  LogLevels,
-  PackageSchema,
-  QuerySchema,
-  SNAP_EVENT,
-  StreamClosedError,
-  TOMBSTONE_EVENT,
-  TargetSchema,
-  ValidationError,
-  ZodEmpty,
-  act,
-  cache,
-  config,
-  dispose,
-  disposeAndExit,
-  extend,
-  log,
-  port,
-  projection,
-  sleep,
-  slice,
-  state,
-  store,
-  validate
-});
-//# sourceMappingURL=index.cjs.map