@rotorsoft/act 0.35.1 → 0.35.2

package/dist/index.cjs

@@ -0,0 +1,3144 @@
+"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, priority = 0) {
+    this.stream = stream;
+    this.source = source;
+    this._priority = priority;
+  }
+  _at = -1;
+  _retry = -1;
+  _blocked = false;
+  _error = "";
+  _leased_by = void 0;
+  _leased_until = void 0;
+  _priority = 0;
+  get priority() {
+    return this._priority;
+  }
+  /**
+   * Bump the priority via {@link subscribe}: keeps the maximum across
+   * reactions so the highest-priority registrant wins.
+   */
+  bumpPriority(priority) {
+    if (priority > this._priority) this._priority = priority;
+  }
+  /**
+   * Set the priority outright via {@link prioritize}: operator
+   * runtime override that ignores the build-time `max()` invariant.
+   */
+  setPriority(priority) {
+    this._priority = priority;
+  }
+  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) => b.priority - a.priority || 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. When the same stream is
+   * resubscribed with a different priority, the **maximum** wins — so
+   * the highest-priority registered reaction sets the scheduling lane.
+   * Use {@link prioritize} for operator runtime overrides.
+   *
+   * @param streams - Streams to register with optional source + priority.
+   * @returns subscribed count and current max watermark.
+   */
+  async subscribe(streams) {
+    await sleep();
+    let subscribed = 0;
+    for (const { stream, source, priority = 0 } of streams) {
+      const existing = this._streams.get(stream);
+      if (existing) {
+        existing.bumpPriority(priority);
+      } else {
+        this._streams.set(stream, new InMemoryStream(stream, source, priority));
+        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;
+  }
+  /**
+   * Bulk-update priority of streams matching `filter`. Mirrors
+   * {@link query_streams}'s filter semantics — see {@link Store.prioritize}.
+   * Unlike {@link subscribe} (which keeps `max()` of registered
+   * priorities), this sets the priority outright — operator override
+   * for the build-time scheduling policy.
+   *
+   * @returns Count of streams whose priority changed.
+   */
+  async prioritize(filter, priority) {
+    await sleep();
+    const streamRe = filter.stream && !filter.stream_exact ? new RegExp(`^${filter.stream}$`) : void 0;
+    const sourceRe = filter.source && !filter.source_exact ? new RegExp(`^${filter.source}$`) : void 0;
+    let count = 0;
+    for (const s of this._streams.values()) {
+      if (filter.stream !== void 0) {
+        if (filter.stream_exact ? s.stream !== filter.stream : !streamRe.test(s.stream))
+          continue;
+      }
+      if (filter.source !== void 0) {
+        if (s.source === void 0) continue;
+        if (filter.source_exact ? s.source !== filter.source : !sourceRe.test(s.source))
+          continue;
+      }
+      if (filter.blocked !== void 0 && s.blocked !== filter.blocked)
+        continue;
+      if (s.priority !== priority) {
+        s.setPriority(priority);
+        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,
+        priority: s.priority,
+        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, priority = 0 } = reaction.resolver;
+        const key = `${target}|${source ?? ""}`;
+        const existing = statics.get(key);
+        if (!existing) {
+          statics.set(key, { stream: target, source, priority });
+        } else if (priority > existing.priority) {
+          statics.set(key, { ...existing, priority });
+        }
+      }
+    }
+  }
+  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 incomingPriority = resolved.priority ?? 0;
+              const entry = correlated.get(resolved.target) || {
+                source: resolved.source,
+                priority: incomingPriority,
+                payloads: []
+              };
+              if (incomingPriority > entry.priority)
+                entry.priority = incomingPriority;
+              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, priority }]) => ({
+          stream,
+          source,
+          priority
+        })
+      );
+      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 routed through `log()` so they
+   * land in the configured logger (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((err) => log().error(err)),
+      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");
+  const validated = 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,
+          validated,
+          target,
+          snapshot,
+          description
+        );
+    });
+  }
+  const result = me.on[action2](validated, 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
+    );
+    this._notify_disposer = this._wireNotify();
+    dispose(async () => {
+      this._emitter.removeAllListeners();
+      this.stop_correlations();
+      this.stop_settling();
+      const disposer = await this._notify_disposer;
+      if (disposer) await disposer();
+    });
+  }
+  _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;
+  /**
+   * Disposer for the cross-process notify subscription, set up eagerly
+   * during construction. Held as a promise because the subscription
+   * itself may be async (the PG adapter checks out a dedicated client
+   * and runs `LISTEN` before resolving). Resolves to `undefined` when
+   * the store doesn't implement `notify` or there are no registered
+   * reactions.
+   *
+   * **Contract:** the configured store must be injected via
+   * {@link store}`(adapter)` *before* calling `act()...build()`. The
+   * orchestrator wires notify against whatever store is current at
+   * construction time — late injection after build is unsupported.
+   */
+  _notify_disposer;
+  /**
+   * 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;
+  /**
+   * Subscribe to {@link Store.notify} when both the store and the
+   * registry support it. Returns the disposer (or `undefined` when no
+   * subscription was made). Errors during subscription are logged but
+   * never thrown — `notify` is a hint, not a contract.
+   */
+  async _wireNotify() {
+    if (this._reactive_events.size === 0) return void 0;
+    const s = store();
+    if (!s.notify) return void 0;
+    try {
+      return await s.notify((notification) => {
+        try {
+          this.emit("notified", notification);
+          const hasReactive = notification.events.some(
+            (e) => this._reactive_events.has(e.name)
+          );
+          if (hasReactive) {
+            this._drain.arm();
+            this._settle.schedule({ debounceMs: 0 });
+          }
+        } catch (err) {
+          this._logger.error(err, "notified handler threw");
+        }
+      });
+    } catch (err) {
+      this._logger.error(err, "Store.notify subscription failed");
+      return void 0;
+    }
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Bulk-update scheduling priority for streams matching `filter`.
+   *
+   * Operator-grade override of the `claim()` lagging-frontier
+   * ordering (ACT-102). Useful when a long-running replay needs to
+   * jump ahead of other lagging streams, or when a no-longer-urgent
+   * job should yield slots back to the rest. Build-time priorities
+   * (set via the resolver's `priority` field) are subject to a
+   * `max()` invariant across reactions; this API ignores that and
+   * sets the priority outright on every matching row.
+   *
+   * Filter shape mirrors {@link query} / {@link Store.query_streams}:
+   * `stream` / `source` are regex by default, exact with the
+   * `*_exact` flags; `blocked` restricts to blocked or unblocked
+   * rows. **An empty filter (`{}`) updates every registered stream.**
+   *
+   * @param filter - Selection criteria (regex by default).
+   * @param priority - New priority value. Set as-is — no clamp.
+   * @returns Count of streams whose priority changed.
+   *
+   * @example Boost a specific projection mid-replay
+   * ```typescript
+   * await app.prioritize({ stream: "^proj-orders$", stream_exact: false }, 10);
+   * ```
+   *
+   * @example Drop all audit projections to background
+   * ```typescript
+   * await app.prioritize({ source: "^audit-" }, -5);
+   * ```
+   *
+   * @example Reset everyone to default
+   * ```typescript
+   * await app.prioritize({}, 0);
+   * ```
+   *
+   * @see {@link Store.prioritize} for the underlying primitive
+   * @see {@link claim} for how priority biases scheduling
+   */
+  async prioritize(filter, priority) {
+    return store().prioritize(filter, priority);
+  }
+  /**
+   * 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