@rotorsoft/act 0.44.0 → 0.46.0

package/dist/index.js

@@ -1,5 +1,6 @@
 import {
   ConsoleLogger,
+  DEFAULT_LANE,
   ExitCodes,
   InMemoryCache,
   InMemoryStore,
@@ -18,7 +19,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-LKRNWD7C.js";
+} from "./chunk-VC6MSVC3.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -35,7 +36,7 @@ import {
   TargetSchema,
   ValidationError,
   ZodEmpty
-} from "./chunk-VMX7RPTC.js";
+} from "./chunk-TZWDSNSN.js";
 import "./chunk-5WRI5ZAA.js";
 
 // src/signals.ts
@@ -59,24 +60,459 @@ process.once("unhandledRejection", async (arg) => {
 // src/act.ts
 import EventEmitter from "events";
 
+// src/internal/event-versions.ts
+var VERSION_SUFFIX = /^(.+?)_v(\d+)$/;
+function parse(name) {
+  const m = name.match(VERSION_SUFFIX);
+  if (m) {
+    const v = Number.parseInt(m[2], 10);
+    if (v >= 2) return { base: m[1], version: v };
+  }
+  return { base: name, version: 1 };
+}
+function deprecatedEventNames(names) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const { base, version } = parse(name);
+    const list = groups.get(base);
+    if (list) list.push({ version, name });
+    else groups.set(base, [{ version, name }]);
+  }
+  const deprecated = /* @__PURE__ */ new Set();
+  for (const list of groups.values()) {
+    if (list.length < 2) continue;
+    list.sort((a, b) => b.version - a.version);
+    for (let i = 1; i < list.length; i++) deprecated.add(list[i].name);
+  }
+  return deprecated;
+}
+function currentVersionOf(deprecatedName, allNames) {
+  const target = parse(deprecatedName);
+  let highest;
+  for (const name of allNames) {
+    const { base, version } = parse(name);
+    if (base !== target.base) continue;
+    if (!highest || version > highest.version) highest = { version, name };
+  }
+  return highest && highest.version > target.version ? highest.name : void 0;
+}
+
+// src/internal/audit.ts
+var DEFAULTS = {
+  idle_days: 90,
+  restart_min: 1e4,
+  stuck_minutes: 30,
+  deprecated_min: 0.1,
+  drift_min: 500,
+  near_block: 3
+};
+var ALL_CATEGORIES = [
+  "schema",
+  "close-candidate",
+  "restart-candidate",
+  "deprecated-load",
+  "reaction-health",
+  "snapshot-drift",
+  "routing-health",
+  "correlation-gaps",
+  "clock-anomalies"
+];
+async function* audit(deps, categories, options = {}) {
+  const requested = new Set(categories ?? [...ALL_CATEGORIES]);
+  const orderedCategories = ALL_CATEGORIES.filter((c) => requested.has(c));
+  const passes = orderedCategories.map(
+    (c) => PASS_FACTORIES[c](deps, options)
+  );
+  const needStats = passes.some((p) => p.onStat !== void 0);
+  const needStreams = passes.some((p) => p.onStream !== void 0);
+  const needEvents = passes.some((p) => p.onEvent !== void 0);
+  if (needStats) {
+    const stats = await deps.store().query_stats({}, { count: true, names: true });
+    for (const [stream, s] of stats) {
+      for (const p of passes) p.onStat?.(stream, s);
+    }
+  }
+  if (needStreams) {
+    await deps.store().query_streams((pos) => {
+      for (const p of passes) p.onStream?.(pos);
+    });
+  }
+  if (needEvents) {
+    await deps.store().query((event) => {
+      for (const p of passes) p.onEvent?.(event);
+    }, options.query);
+  }
+  for (const p of passes) await p.finalize?.(deps);
+  for (const p of passes) {
+    for (const f of p.drain()) yield f;
+  }
+}
+var makeSchemaPass = (deps) => {
+  const findings = [];
+  return {
+    category: "schema",
+    onEvent(event) {
+      const name = String(event.name);
+      const state2 = deps.event_to_state.get(name);
+      if (!state2) {
+        if (name.startsWith("__")) return;
+        findings.push({
+          category: "schema",
+          stream: event.stream,
+          event_id: event.id,
+          name,
+          reason: "unknown_event_name"
+        });
+        return;
+      }
+      const schema = state2.events[name];
+      const parsed = schema.safeParse(event.data);
+      if (!parsed.success) {
+        findings.push({
+          category: "schema",
+          stream: event.stream,
+          event_id: event.id,
+          name,
+          reason: "schema_validation_failed",
+          zod_error: parsed.error
+        });
+      }
+    },
+    drain: () => findings
+  };
+};
+var makeDeprecatedLoadPass = (deps, options) => {
+  const share_min = options.thresholds?.deprecated_min ?? DEFAULTS.deprecated_min;
+  const totals = /* @__PURE__ */ new Map();
+  const perStream = /* @__PURE__ */ new Map();
+  return {
+    category: "deprecated-load",
+    onStat(stream, { names }) {
+      for (const [name, count] of Object.entries(names)) {
+        totals.set(name, (totals.get(name) ?? 0) + count);
+        let m = perStream.get(name);
+        if (!m) {
+          m = /* @__PURE__ */ new Map();
+          perStream.set(name, m);
+        }
+        m.set(stream, count);
+      }
+    },
+    drain() {
+      const findings = [];
+      const grand = [...totals.values()].reduce((s, n) => s + n, 0);
+      if (grand === 0) return findings;
+      const deprecated = deprecatedEventNames(deps.known_events);
+      const sorted = [...deprecated].map((name) => ({ name, count: totals.get(name) ?? 0 })).sort((a, b) => b.count - a.count);
+      for (const { name, count } of sorted) {
+        if (count === 0) continue;
+        if (count / grand < share_min) continue;
+        const currentVersion = currentVersionOf(name, deps.known_events);
+        const topStreams = [...perStream.get(name).entries()].map(([stream, c]) => ({ stream, count: c })).sort((a, b) => b.count - a.count).slice(0, 10);
+        findings.push({
+          category: "deprecated-load",
+          name,
+          current_version: currentVersion,
+          total: count,
+          top_streams: topStreams
+        });
+      }
+      return findings;
+    }
+  };
+};
+var makeCloseCandidatePass = (deps, options) => {
+  const idle_days = options.thresholds?.idle_days ?? DEFAULTS.idle_days;
+  const terminal_events = new Set(options.thresholds?.terminal_events ?? []);
+  const idle_cutoff = Date.now() - idle_days * 24 * 60 * 60 * 1e3;
+  const findings = [];
+  return {
+    category: "close-candidate",
+    onStat(stream, { head }) {
+      const head_name = String(head.name);
+      if (head_name.startsWith("__")) return;
+      const head_time = head.created.getTime();
+      const is_idle = head_time < idle_cutoff;
+      const is_terminal = terminal_events.has(head_name);
+      if (!is_idle && !is_terminal) return;
+      findings.push({
+        category: "close-candidate",
+        stream,
+        last_event_at: head.created.toISOString(),
+        reason: is_terminal ? "terminal" : "idle",
+        idle_days: is_idle ? Math.floor((Date.now() - head_time) / (24 * 60 * 60 * 1e3)) : void 0,
+        restart_supported: restartIsSupported(deps, head_name)
+      });
+    },
+    drain: () => findings
+  };
+};
+var makeRestartCandidatePass = (deps, options) => {
+  const threshold = options.thresholds?.restart_min ?? DEFAULTS.restart_min;
+  const findings = [];
+  return {
+    category: "restart-candidate",
+    onStat(stream, { head, count, names }) {
+      if (count < threshold) return;
+      const head_name = String(head.name);
+      if (head_name.startsWith("__")) return;
+      if (!restartIsSupported(deps, head_name)) return;
+      findings.push({
+        category: "restart-candidate",
+        stream,
+        count,
+        // names map is sparse — `__snapshot__` key absent when the
+        // stream has never been snapshotted (a common case for the
+        // restart-candidate signal).
+        snaps: names["__snapshot__"] ?? 0
+      });
+    },
+    drain: () => findings
+  };
+};
+var makeReactionHealthPass = (_deps, options) => {
+  const near_block = options.thresholds?.near_block ?? DEFAULTS.near_block;
+  const stuck_minutes = options.thresholds?.stuck_minutes ?? DEFAULTS.stuck_minutes;
+  const stuck_cutoff = Date.now() - stuck_minutes * 60 * 1e3;
+  const findings = [];
+  return {
+    category: "reaction-health",
+    onStream(p) {
+      if (p.blocked) {
+        findings.push({
+          category: "reaction-health",
+          stream: p.stream,
+          status: "blocked",
+          retry: p.retry,
+          reason: p.error || "blocked without recorded error"
+        });
+        return;
+      }
+      if (p.retry >= near_block) {
+        findings.push({
+          category: "reaction-health",
+          stream: p.stream,
+          status: "near-block",
+          retry: p.retry,
+          reason: `retry ${p.retry} \u2265 near-block threshold ${near_block}`
+        });
+        return;
+      }
+      if (p.leased_by && p.leased_until && p.leased_until.getTime() < stuck_cutoff) {
+        const minutes = Math.floor(
+          (Date.now() - p.leased_until.getTime()) / (60 * 1e3)
+        );
+        findings.push({
+          category: "reaction-health",
+          stream: p.stream,
+          status: "stuck-backoff",
+          retry: p.retry,
+          reason: `lease expired ${minutes}m ago without release`
+        });
+      }
+    },
+    drain: () => findings
+  };
+};
+var makeSnapshotDriftPass = (deps, options) => {
+  const drift_min = options.thresholds?.drift_min ?? DEFAULTS.drift_min;
+  const candidates = [];
+  const findings = [];
+  return {
+    category: "snapshot-drift",
+    onStat(stream, { head, count, names }) {
+      if (!restartIsSupported(deps, String(head.name))) return;
+      if (count < drift_min) return;
+      candidates.push({
+        stream,
+        total: count,
+        snaps: names["__snapshot__"] ?? 0
+      });
+    },
+    async finalize(deps2) {
+      for (const { stream, total, snaps } of candidates) {
+        let events_since_snap = total;
+        let snap_at;
+        if (snaps > 0) {
+          const collected = [];
+          await deps2.store().query(
+            (e) => {
+              collected.push({ id: e.id });
+            },
+            {
+              stream,
+              stream_exact: true,
+              names: ["__snapshot__"],
+              backward: true,
+              limit: 1,
+              with_snaps: true
+            }
+          );
+          snap_at = collected[0].id;
+          let after = 0;
+          await deps2.store().query(
+            () => {
+              after++;
+            },
+            { stream, stream_exact: true, after: snap_at }
+          );
+          events_since_snap = after;
+        }
+        if (events_since_snap < drift_min) continue;
+        findings.push({
+          category: "snapshot-drift",
+          stream,
+          events_since_snap,
+          snap_at
+        });
+      }
+    },
+    drain: () => findings
+  };
+};
+var makeRoutingHealthPass = (deps) => {
+  const findings = [];
+  const seenEventNames = /* @__PURE__ */ new Set();
+  return {
+    category: "routing-health",
+    onStream(p) {
+      if (!p.lane) return;
+      if (deps.declared_lanes.has(p.lane)) return;
+      findings.push({
+        category: "routing-health",
+        stream: p.stream,
+        reason: "unknown-lane",
+        lane: p.lane
+      });
+    },
+    onStat(_stream, { names }) {
+      for (const name of Object.keys(names)) {
+        seenEventNames.add(name);
+      }
+    },
+    finalize() {
+      for (const name of seenEventNames) {
+        if (name.startsWith("__")) continue;
+        if (deps.routed_events.has(name)) continue;
+        findings.push({
+          category: "routing-health",
+          stream: "*",
+          reason: "unrouted"
+        });
+      }
+      return Promise.resolve();
+    },
+    drain: () => findings
+  };
+};
+var makeCorrelationGapsPass = () => {
+  const seenIds = /* @__PURE__ */ new Set();
+  const checks = [];
+  return {
+    category: "correlation-gaps",
+    onEvent(e) {
+      seenIds.add(e.id);
+      const causation = e.meta?.causation;
+      const parentId = causation?.event?.id;
+      if (parentId !== void 0) {
+        checks.push({ stream: e.stream, id: e.id, parentId });
+      }
+    },
+    drain() {
+      const findings = [];
+      for (const { stream, id, parentId } of checks) {
+        if (!seenIds.has(parentId)) {
+          findings.push({
+            category: "correlation-gaps",
+            stream,
+            event_id: id,
+            reason: "orphan-parent"
+          });
+        }
+      }
+      return findings;
+    }
+  };
+};
+var makeClockAnomaliesPass = () => {
+  const findings = [];
+  const lastPerStream = /* @__PURE__ */ new Map();
+  return {
+    category: "clock-anomalies",
+    onEvent(e) {
+      const created = e.created.getTime();
+      if (created > Date.now()) {
+        findings.push({
+          category: "clock-anomalies",
+          stream: e.stream,
+          event_id: e.id,
+          reason: "future-created"
+        });
+      }
+      const prev = lastPerStream.get(e.stream);
+      if (prev !== void 0 && created < prev) {
+        findings.push({
+          category: "clock-anomalies",
+          stream: e.stream,
+          event_id: e.id,
+          reason: "out-of-order"
+        });
+      }
+      lastPerStream.set(e.stream, created);
+    },
+    drain: () => findings
+  };
+};
+function restartIsSupported(deps, headEventName) {
+  const state2 = deps.event_to_state.get(headEventName);
+  return state2?.snap !== void 0;
+}
+var PASS_FACTORIES = {
+  schema: makeSchemaPass,
+  "deprecated-load": makeDeprecatedLoadPass,
+  "close-candidate": makeCloseCandidatePass,
+  "restart-candidate": makeRestartCandidatePass,
+  "reaction-health": makeReactionHealthPass,
+  "snapshot-drift": makeSnapshotDriftPass,
+  "routing-health": makeRoutingHealthPass,
+  "correlation-gaps": makeCorrelationGapsPass,
+  "clock-anomalies": makeClockAnomaliesPass
+};
+
 // src/internal/build-classify.ts
+var ALL_LANES = /* @__PURE__ */ Symbol("act-1103/all-lanes");
 function classifyRegistry(registry, states) {
   const statics = /* @__PURE__ */ new Map();
   const reactiveEvents = /* @__PURE__ */ new Set();
+  const eventToLanes = /* @__PURE__ */ new Map();
   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;
+        eventToLanes.set(name, ALL_LANES);
       } else {
-        const { target, source, priority = 0 } = reaction.resolver;
+        const { target, source, priority = 0, lane } = reaction.resolver;
+        const lane_name = lane ?? "default";
+        const existing_lanes = eventToLanes.get(name);
+        if (existing_lanes !== ALL_LANES) {
+          const set = existing_lanes ?? /* @__PURE__ */ new Set();
+          set.add(lane_name);
+          eventToLanes.set(name, set);
+        }
         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 });
+          statics.set(key, { stream: target, source, priority, lane });
+        } else {
+          if ((existing.lane ?? void 0) !== (lane ?? void 0))
+            throw new Error(
+              `Stream "${target}" has conflicting lane assignments ("${existing.lane ?? "default"}" vs "${lane ?? "default"}")`
+            );
+          if (priority > existing.priority) {
+            statics.set(key, { ...existing, priority });
+          }
         }
       }
     }
@@ -91,7 +527,8 @@ function classifyRegistry(registry, states) {
     staticTargets: [...statics.values()],
     hasDynamicResolvers,
     reactiveEvents,
-    eventToState
+    eventToState,
+    eventToLanes
   };
 }
 
@@ -302,6 +739,7 @@ var CorrelateCycle = class {
               const entry = correlated.get(resolved.target) || {
                 source: resolved.source,
                 priority: incomingPriority,
+                lane: resolved.lane,
                 payloads: []
               };
               if (incomingPriority > entry.priority)
@@ -320,10 +758,11 @@ var CorrelateCycle = class {
     );
     if (correlated.size) {
       const streams = [...correlated.entries()].map(
-        ([stream, { source, priority }]) => ({
+        ([stream, { source, priority, lane }]) => ({
           stream,
           source,
-          priority
+          priority,
+          lane
         })
       );
       const { subscribed } = await this.cd.subscribe(streams);
@@ -408,904 +847,918 @@ function computeLagLeadRatio(handled, lagging, leading) {
   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, isDeferred) {
-  const leased = await ops.claim(lagging, leading, randomUUID(), leaseMillis);
-  if (!leased.length) return void 0;
-  const active = isDeferred ? leased.filter((l) => !isDeferred(l.stream)) : leased;
-  if (!active.length) {
-    return {
-      leased,
-      fetched: [],
-      handled: [],
-      acked: [],
-      blocked: []
-    };
-  }
-  const fetched = await ops.fetch(active, 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(
-    active.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);
+// src/internal/drain.ts
+var claim = (lagging, leading, by, millis, lane) => store().claim(lagging, leading, by, millis, lane);
+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 };
     })
   );
-  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;
+var ack = (leases) => store().ack(leases);
+var block = (leases) => store().block(leases);
+var subscribe = (streams) => store().subscribe(streams);
+
+// src/internal/event-sourcing.ts
+import { patch } from "@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);
   }
-  _armed = false;
-  _locked = false;
-  _ratio = 0.5;
-  /**
-   * Per-stream backoff: `stream → nextAttemptAt` (ms since epoch). Set by
-   * `_finalize` via `HandleResult.nextAttemptAt`; cleared on successful
-   * ack or terminal block. Lives in process memory — per-worker pacing
-   * by design (see {@link BackoffOptions} for the multi-worker trade-off).
-   */
-  _backoff = /* @__PURE__ */ new Map();
-  /** Timer re-arming drain at the earliest pending `nextAttemptAt`. */
-  _backoffTimer;
-  /**
-   * 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;
+}
+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;
   }
-  /** Read-only flag — true while a commit / reset is unprocessed. */
-  get armed() {
-    return this._armed;
-  }
-  /** Returns true when `stream` is currently within a backoff window. */
-  isDeferred = (stream) => {
-    const next = this._backoff.get(stream);
-    return next !== void 0 && next > Date.now();
-  };
-  /**
-   * Schedule the next drain re-arm at the earliest pending backoff
-   * expiry. Called only when the backoff map is non-empty (caller guard).
-   * Idempotent — collapses many simultaneously deferred streams into a
-   * single timer.
-   */
-  scheduleBackoffWake() {
-    if (this._backoffTimer) clearTimeout(this._backoffTimer);
-    let earliest = Number.POSITIVE_INFINITY;
-    for (const t of this._backoff.values()) if (t < earliest) earliest = t;
-    const delay = Math.max(0, earliest - Date.now());
-    this._backoffTimer = setTimeout(() => {
-      this._backoffTimer = void 0;
-      const now = Date.now();
-      for (const [stream, at] of this._backoff) {
-        if (at <= now) this._backoff.delete(stream);
-      }
-      this._armed = true;
-    }, delay);
-    this._backoffTimer.unref();
-  }
-  /** 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,
-        this._backoff.size > 0 ? this.isDeferred : void 0
-      );
-      if (!cycle) {
-        this._armed = false;
-        return EMPTY_DRAIN;
-      }
-      const { leased, fetched, handled, acked, blocked } = cycle;
-      this._ratio = computeLagLeadRatio(handled, lagging, leading);
-      for (const lease of acked) this._backoff.delete(lease.stream);
-      for (const lease of blocked) this._backoff.delete(lease.stream);
-      for (const h of handled) {
-        if (h.nextAttemptAt !== void 0 && !h.block) {
-          this._backoff.set(h.lease.stream, h.nextAttemptAt);
-        }
+}
+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 = 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}"`
+        );
       }
-      if (this._backoff.size > 0) this.scheduleBackoffWake();
-      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;
+      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
+    });
   }
-};
-
-// src/internal/event-versions.ts
-var VERSION_SUFFIX = /^(.+?)_v(\d+)$/;
-function parse(name) {
-  const m = name.match(VERSION_SUFFIX);
-  if (m) {
-    const v = Number.parseInt(m[2], 10);
-    if (v >= 2) return { base: m[1], version: v };
-  }
-  return { base: name, version: 1 };
-}
-function deprecatedEventNames(names) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const name of names) {
-    const { base, version } = parse(name);
-    const list = groups.get(base);
-    if (list) list.push({ version, name });
-    else groups.set(base, [{ version, name }]);
-  }
-  const deprecated = /* @__PURE__ */ new Set();
-  for (const list of groups.values()) {
-    if (list.length < 2) continue;
-    list.sort((a, b) => b.version - a.version);
-    for (let i = 1; i < list.length; i++) deprecated.add(list[i].name);
-  }
-  return deprecated;
+  return { event, state: state2, version, patches, snaps, cache_hit, replayed };
 }
-function currentVersionOf(deprecatedName, allNames) {
-  const target = parse(deprecatedName);
-  let highest;
-  for (const name of allNames) {
-    const { base, version } = parse(name);
-    if (base !== target.base) continue;
-    if (!highest || version > highest.version) highest = { version, name };
+async function action(me, action2, target, payload, reactingTo, skipValidation = false, correlator = defaultCorrelator) {
+  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
+        );
+    });
   }
-  return highest && highest.version > target.version ? highest.name : void 0;
-}
-
-// src/internal/merge.ts
-import { ZodObject } from "zod";
-function baseTypeName(zodType) {
-  let t = zodType;
-  while (typeof t.unwrap === "function") {
-    t = t.unwrap();
+  const result = me.on[action2](validated, snapshot, target);
+  if (!result) return [snapshot];
+  if (Array.isArray(result) && result.length === 0) {
+    return [snapshot];
   }
-  return t.constructor.name;
-}
-function mergeSchemas(existing, incoming, stateName) {
-  if (existing instanceof ZodObject && incoming instanceof 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}"`
-          );
-        }
+  const tuples = Array.isArray(result[0]) ? result : [result];
+  const deprecated = me._deprecated;
+  if (deprecated && deprecated.size > 0) {
+    const me_ = me;
+    const warned = me_._warned ?? (me_._warned = /* @__PURE__ */ new Set());
+    for (const [name] of tuples) {
+      const evt = name;
+      if (deprecated.has(evt) && !warned.has(evt)) {
+        warned.add(evt);
+        log().warn(
+          `Action "${String(action2)}" emitted deprecated event "${evt}". A newer version exists in the registry \u2014 update the action's .emit() to target the current version. (warned once per process)`
+        );
       }
     }
-    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]) {
-      throw new Error(
-        `Event "${name}" in state "${state2.name}" is declared with different Zod schemas across slices. Cross-slice event schemas must reference the same instance \u2014 extract a shared schema (e.g. \`export const ${name} = z.object({ ... })\` in a shared module) and import it in every slice that declares it.`
-      );
+  const emitted = tuples.map(([name, data]) => ({
+    name,
+    data: skipValidation ? data : validate(name, data, me.events[name])
+  }));
+  const meta = {
+    correlation: reactingTo?.meta.correlation || correlator({
+      action: action2,
+      state: me.name,
+      stream,
+      actor: target.actor
+    }),
+    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
     }
-    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);
-      }
+  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 = 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;
 }
-var _this_ = ({ stream }) => ({
-  source: stream,
-  target: stream
+
+// 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 C_LANE = "\x1B[38;5;183m";
+var C_DIM = "\x1B[38;5;240m";
+var C_ERR = "\x1B[38;5;196m";
+var C_STREAM = "\x1B[38;5;226m";
+var dim = (text) => PRETTY ? `${C_DIM}${text}${C_RESET}` : text;
+var hue = (color, text) => PRETTY ? `${color}${text}${C_RESET}` : text;
+var drain_caption = (caption, lane) => {
+  const showLane = lane && lane !== "default";
+  if (PRETTY) {
+    const tag = `${C_DRAIN}>> ${caption}${C_RESET}`;
+    return showLane ? `${tag} ${C_LANE}${lane}${C_RESET}` : tag;
+  }
+  return showLane ? `>> ${caption} ${lane}` : `>> ${caption}`;
+};
+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;
 });
-
-// src/internal/backoff.ts
-function computeBackoffDelay(retry, opts) {
-  if (!opts || opts.baseMs <= 0) return 0;
-  const r = Math.max(0, retry);
-  let delay;
-  switch (opts.strategy) {
-    case "fixed":
-      delay = opts.baseMs;
-      break;
-    case "linear":
-      delay = opts.baseMs * (r + 1);
-      break;
-    case "exponential":
-      delay = opts.baseMs * 2 ** r;
-      if (opts.maxMs !== void 0) delay = Math.min(delay, opts.maxMs);
-      break;
+function buildEs(logger, correlator = defaultCorrelator) {
+  const boundAction = (me, actionName, target, payload, reactingTo, skipValidation = false) => action(
+    me,
+    actionName,
+    target,
+    payload,
+    reactingTo,
+    skipValidation,
+    correlator
+  );
+  if (logger.level !== "trace") {
+    return {
+      snap,
+      load,
+      action: boundAction,
+      tombstone
+    };
   }
-  if (opts.jitter) delay = delay * (0.5 + Math.random());
-  return Math.max(0, Math.floor(delay));
-}
-
-// src/internal/reactions.ts
-function finalize(lease, handled, at, error, options, logger) {
-  if (!error) return { lease, handled, at };
-  logger.error(error);
-  const nonRetryable = error instanceof NonRetryableError;
-  const block2 = options.blockOnError && (nonRetryable || lease.retry >= options.maxRetries);
-  if (block2)
-    logger.error(
-      nonRetryable ? `Blocking ${lease.stream} on non-retryable error.` : `Blocking ${lease.stream} after ${lease.retry} retries.`
-    );
-  const nextAttemptAt = !block2 && options.backoff ? Date.now() + computeBackoffDelay(lease.retry, options.backoff) : void 0;
   return {
-    lease,
-    handled,
-    at,
-    error: handled === 0 ? error.message : void 0,
-    block: block2,
-    nextAttemptAt
-  };
-}
-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
+    snap: traced(snap, void 0, (snapshot) => {
+      logger.trace(
+        es_caption(
+          "snap",
+          C_MAGENTA,
+          `${snapshot.event.stream}@${snapshot.event.version}`
+        )
       );
-      try {
-        await handler(event, stream, scopedApp);
-        at = event.id;
-        handled++;
-      } catch (error) {
-        return finalize(
-          lease,
-          handled,
-          at,
-          error,
-          payload.options,
-          logger
+    }),
+    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(
+      boundAction,
+      (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}`)
         );
       }
-    }
-    return finalize(lease, handled, at, void 0, payloads[0].options, logger);
+    ),
+    tombstone: traced(tombstone, (committed, stream) => {
+      if (committed)
+        logger.trace(
+          es_caption("tombstoned", C_ORANGE, `${stream}@${committed.version}`)
+        );
+    })
   };
 }
-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);
-    }
+function buildDrain(logger) {
+  return {
+    claim,
+    fetch,
+    ack,
+    block,
+    subscribe: logger.level !== "trace" ? subscribe : traced(subscribe, (result, streams) => {
+      if (!result.subscribed) return;
+      const lanes = new Set(streams.map((s) => s.lane ?? "default"));
+      const uniformLane = lanes.size === 1 ? streams[0]?.lane : void 0;
+      const data = streams.map(
+        ({ stream, lane }) => uniformLane || !lane || lane === "default" ? hue(C_STREAM, stream) : `${hue(C_STREAM, stream)}${dim(`[${lane}]`)}`
+      ).join(" ");
+      logger.trace(`${drain_caption("correlated", uniformLane)} ${data}`);
+    })
   };
 }
+function traceCycle(logger, leased, fetched, handled, acked, blocked) {
+  if (logger.level !== "trace" || !leased.length) return;
+  const lane = leased[0]?.lane;
+  const fetchByStream = new Map(fetched.map((f) => [f.stream, f]));
+  const ackedByStream = new Map(acked.map((a) => [a.stream, a.at]));
+  const blockedByStream = new Map(blocked.map((b) => [b.stream, b.error]));
+  const failedByStream = new Map(
+    handled.filter((h) => h.error).map((h) => [h.lease.stream, h])
+  );
+  const detail = leased.map(({ stream, at, retry }) => {
+    const f = fetchByStream.get(stream);
+    const key = f?.source ? `${hue(C_STREAM, stream)}${dim(`<-${f.source}`)}` : hue(C_STREAM, stream);
+    const events = f && f.events.length ? ` ${dim(
+      `[${f.events.map(({ id, name }) => `#${id} ${String(name)}`).join(", ")}]`
+    )}` : "";
+    const ackedAt = ackedByStream.get(stream);
+    const ackPart = ackedAt !== void 0 ? hue(C_HIT, `\u2713 @${ackedAt}`) : "";
+    const failure = failedByStream.get(stream);
+    let failPart = "";
+    if (failure) {
+      const failedAt = failure.failed_at ?? at;
+      const blockedError = blockedByStream.get(stream);
+      if (blockedError !== void 0) {
+        failPart = `${hue(C_ERR, `\u2717 @${failedAt}/${retry}`)} ${dim(`(${blockedError})`)}`;
+      } else {
+        failPart = `${hue(C_MISS, `\u26A0 @${failedAt}/${retry}`)} ${dim(`(${failure.error})`)}`;
+      }
+    }
+    let tail;
+    if (ackPart && failPart) tail = ` ${ackPart} ${failPart}`;
+    else if (ackPart) tail = ` ${ackPart}`;
+    else if (failPart) tail = ` ${failPart}`;
+    else tail = ` ${dim(`\u2298 @${at}/${retry}`)}`;
+    return `${key}${events}${tail}`;
+  }).join(", ");
+  logger.trace(`${drain_caption("drained", lane)} ${detail}`);
+}
 
-// src/internal/settle.ts
-var SettleLoop = class {
-  constructor(deps, defaultDebounceMs) {
+// src/internal/drain-cycle.ts
+async function runDrainCycle(ops, registry, batchHandlers, handle, handleBatch, lagging, leading, eventLimit, leaseMillis, isDeferred, lane) {
+  const leased = await ops.claim(
+    lagging,
+    leading,
+    randomUUID(),
+    leaseMillis,
+    lane
+  );
+  if (!leased.length) return void 0;
+  const active = isDeferred ? leased.filter((l) => !isDeferred(l.stream)) : leased;
+  if (!active.length) {
+    return {
+      leased,
+      fetched: [],
+      handled: [],
+      acked: [],
+      blocked: []
+    };
+  }
+  const fetched = await ops.fetch(active, 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(
+    active.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((h) => h.handled > 0 || !h.error).map((h) => ({ ...h.lease, at: h.acked_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;
-    this.defaultDebounceMs = defaultDebounceMs;
   }
-  _timer = void 0;
-  _running = false;
+  _armed = false;
+  _locked = false;
+  _ratio = 0.5;
+  /**
+   * Per-stream backoff: `stream → nextAttemptAt` (ms since epoch). Set by
+   * `_finalize` via `HandleResult.nextAttemptAt`; cleared on successful
+   * ack or terminal block. Lives in process memory — per-worker pacing
+   * by design (see {@link BackoffOptions} for the multi-worker trade-off).
+   */
+  _backoff = /* @__PURE__ */ new Map();
+  /** Timer re-arming drain at the earliest pending `nextAttemptAt`. */
+  _backoffTimer;
+  /** Worker timer (ACT-1103). Set when `start()` is active, undefined otherwise. */
+  _worker;
+  _stopped = false;
+  /**
+   * 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;
+  }
+  /** Returns true when `stream` is currently within a backoff window. */
+  isDeferred = (stream) => {
+    const next = this._backoff.get(stream);
+    return next !== void 0 && next > Date.now();
+  };
+  /**
+   * Schedule the next drain re-arm at the earliest pending backoff
+   * expiry. Called only when the backoff map is non-empty (caller guard).
+   * Idempotent — collapses many simultaneously deferred streams into a
+   * single timer.
+   */
+  scheduleBackoffWake() {
+    if (this._backoffTimer) clearTimeout(this._backoffTimer);
+    let earliest = Number.POSITIVE_INFINITY;
+    for (const t of this._backoff.values()) if (t < earliest) earliest = t;
+    const delay = Math.max(0, earliest - Date.now());
+    this._backoffTimer = setTimeout(() => {
+      this._backoffTimer = void 0;
+      const now = Date.now();
+      for (const [stream, at] of this._backoff) {
+        if (at <= now) this._backoff.delete(stream);
+      }
+      this._armed = true;
+    }, delay);
+    this._backoffTimer.unref();
+  }
+  /** Lane this controller drains (undefined = legacy single-lane span). */
+  get lane() {
+    return this.deps.lane;
+  }
   /**
-   * 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}.
+   * Start a per-lane worker that drains at the lane's `cycleMs`
+   * cadence (ACT-1103). When armed, the worker calls `drain()` on every
+   * tick and re-schedules; when not armed, it still re-schedules at
+   * `cycleMs` so a future `arm()` is picked up on the next tick.
+   *
+   * The setTimeout chain uses `unref()` so it doesn't keep the process
+   * alive on its own.
    */
-  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);
+  start(cycleMs) {
+    if (this._worker || this._stopped) return;
+    const tick = async () => {
+      if (this._armed) await this.drain();
+      if (this._stopped) return;
+      this._worker = setTimeout(tick, cycleMs);
+      this._worker.unref();
+    };
+    this._worker = setTimeout(tick, cycleMs);
+    this._worker.unref();
   }
-  /** Cancel any pending or active settle cycle. Idempotent. */
+  /** Stop the per-lane worker. Idempotent. */
   stop() {
-    if (this._timer) {
-      clearTimeout(this._timer);
-      this._timer = void 0;
+    this._stopped = true;
+    if (this._worker) {
+      clearTimeout(this._worker);
+      this._worker = void 0;
+    }
+  }
+  /** Run one drain pass. Short-circuits when not armed or already running. */
+  async drain(options = {}) {
+    if (!this._armed) return EMPTY_DRAIN;
+    if (this._locked) return EMPTY_DRAIN;
+    const d = this.deps.defaults ?? {};
+    const streamLimit = d.streamLimit ?? options.streamLimit ?? 10;
+    const eventLimit = d.eventLimit ?? options.eventLimit ?? 10;
+    const leaseMillis = d.leaseMillis ?? options.leaseMillis ?? 1e4;
+    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,
+        this._backoff.size > 0 ? this.isDeferred : void 0,
+        this.deps.lane
+      );
+      if (!cycle) {
+        this._armed = false;
+        return EMPTY_DRAIN;
+      }
+      const { leased, fetched, handled, acked, blocked } = cycle;
+      traceCycle(this.deps.logger, leased, fetched, handled, acked, blocked);
+      this._ratio = computeLagLeadRatio(handled, lagging, leading);
+      for (const lease of acked) this._backoff.delete(lease.stream);
+      for (const lease of blocked) this._backoff.delete(lease.stream);
+      for (const h of handled) {
+        if (h.nextAttemptAt !== void 0 && !h.block) {
+          this._backoff.set(h.lease.stream, h.nextAttemptAt);
+        }
+      }
+      if (this._backoff.size > 0) this.scheduleBackoffWake();
+      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/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 };
-    })
-  );
+// src/internal/merge.ts
+import { ZodObject } from "zod";
+function baseTypeName(zodType) {
+  let t = zodType;
+  while (typeof t.unwrap === "function") {
+    t = t.unwrap();
+  }
+  return t.constructor.name;
 }
-var ack = (leases) => store().ack(leases);
-var block = (leases) => store().block(leases);
-var subscribe = (streams) => store().subscribe(streams);
-
-// src/internal/event-sourcing.ts
-import { patch } from "@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);
+function mergeSchemas(existing, incoming, stateName) {
+  if (existing instanceof ZodObject && incoming instanceof 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;
 }
-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;
+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);
   }
 }
-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 = 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
-    });
+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]) {
+      throw new Error(
+        `Event "${name}" in state "${state2.name}" is declared with different Zod schemas across slices. Cross-slice event schemas must reference the same instance \u2014 extract a shared schema (e.g. \`export const ${name} = z.object({ ... })\` in a shared module) and import it in every slice that declares it.`
+      );
+    }
+    if (events[name]) throw new Error(`Duplicate event "${name}"`);
   }
-  return { event, state: state2, version, patches, snaps, cache_hit, replayed };
-}
-async function action(me, action2, target, payload, reactingTo, skipValidation = false, correlator = defaultCorrelator) {
-  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 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;
   }
-  const result = me.on[action2](validated, snapshot, target);
-  if (!result) return [snapshot];
-  if (Array.isArray(result) && result.length === 0) {
-    return [snapshot];
+  for (const name of Object.keys(state2.events)) {
+    if (events[name]) continue;
+    events[name] = { schema: state2.events[name], reactions: /* @__PURE__ */ new Map() };
   }
-  const tuples = Array.isArray(result[0]) ? result : [result];
-  const deprecated = me._deprecated;
-  if (deprecated && deprecated.size > 0) {
-    const me_ = me;
-    const warned = me_._warned ?? (me_._warned = /* @__PURE__ */ new Set());
-    for (const [name] of tuples) {
-      const evt = name;
-      if (deprecated.has(evt) && !warned.has(evt)) {
-        warned.add(evt);
-        log().warn(
-          `Action "${String(action2)}" emitted deprecated event "${evt}". A newer version exists in the registry \u2014 update the action's .emit() to target the current version. (warned once per process)`
-        );
-      }
+}
+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;
     }
   }
-  const emitted = tuples.map(([name, data]) => ({
-    name,
-    data: skipValidation ? data : validate(name, data, me.events[name])
-  }));
-  const meta = {
-    correlation: reactingTo?.meta.correlation || correlator({
-      action: action2,
-      state: me.name,
-      stream,
-      actor: target.actor
-    }),
-    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
+  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);
     }
-  };
-  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);
+  }
+}
+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);
+      }
     }
-    throw error;
   }
-  let { state: state2, patches } = snapshot;
-  const snapshots = committed.map((event) => {
-    const p = me.patch[event.name](event, state2);
-    state2 = 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;
+var _this_ = ({ stream }) => ({
+  source: stream,
+  target: stream
 });
-function buildEs(logger, correlator = defaultCorrelator) {
-  const boundAction = (me, actionName, target, payload, reactingTo, skipValidation = false) => action(
-    me,
-    actionName,
-    target,
-    payload,
-    reactingTo,
-    skipValidation,
-    correlator
-  );
-  if (logger.level !== "trace") {
-    return {
-      snap,
-      load,
-      action: boundAction,
-      tombstone
-    };
+
+// src/internal/backoff.ts
+function computeBackoffDelay(retry, opts) {
+  if (!opts || opts.baseMs <= 0) return 0;
+  const r = Math.max(0, retry);
+  let delay;
+  switch (opts.strategy) {
+    case "fixed":
+      delay = opts.baseMs;
+      break;
+    case "linear":
+      delay = opts.baseMs * (r + 1);
+      break;
+    case "exponential":
+      delay = opts.baseMs * 2 ** r;
+      if (opts.maxMs !== void 0) delay = Math.min(delay, opts.maxMs);
+      break;
   }
+  if (opts.jitter) delay = delay * (0.5 + Math.random());
+  return Math.max(0, Math.floor(delay));
+}
+
+// src/internal/reactions.ts
+function finalize(lease, handled, at, error, options, logger, failed_at) {
+  if (!error) return { lease, handled, acked_at: at };
+  logger.error(error);
+  const nonRetryable = error instanceof NonRetryableError;
+  const block2 = options.blockOnError && (nonRetryable || lease.retry >= options.maxRetries);
+  if (block2)
+    logger.error(
+      nonRetryable ? `Blocking ${lease.stream} on non-retryable error.` : `Blocking ${lease.stream} after ${lease.retry} retries.`
+    );
+  const nextAttemptAt = !block2 && options.backoff ? Date.now() + computeBackoffDelay(lease.retry, options.backoff) : void 0;
   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(
-      boundAction,
-      (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}`)
-        );
-    })
+    lease,
+    handled,
+    acked_at: at,
+    error: error.message,
+    block: block2,
+    nextAttemptAt,
+    failed_at
   };
 }
-function buildDrain(logger) {
-  if (logger.level !== "trace") {
-    return {
-      claim,
-      fetch,
-      ack,
-      block,
-      subscribe
+function buildHandle(deps) {
+  const { logger, boundDo, boundLoad, boundQuery, boundQueryArray } = deps;
+  return async (lease, payloads) => {
+    if (payloads.length === 0) return { lease, handled: 0, acked_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
     };
-  }
-  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];
-        })
+    for (const payload of payloads) {
+      const { event, handler } = payload;
+      scopedApp.do = (action2, target, actionPayload, reactingTo, skipValidation) => boundDo(
+        action2,
+        target,
+        actionPayload,
+        reactingTo ?? event,
+        skipValidation
       );
-      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 }
-          ])
+      try {
+        await handler(event, stream, scopedApp);
+        at = event.id;
+        handled++;
+      } catch (error) {
+        return finalize(
+          lease,
+          handled,
+          at,
+          error,
+          payload.options,
+          logger,
+          event.id
         );
-        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}`);
       }
-    })
+    }
+    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/act.ts
 var DEFAULT_MAX_SUBSCRIBED_STREAMS = 1e3;
 var DEFAULT_SETTLE_DEBOUNCE_MS = 10;
@@ -1320,11 +1773,26 @@ var Act = class {
    * @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}
+   * @param lanes     Declared drain lanes (ACT-1103). The builder collects
+   *   these from `.withLane(...)` calls. Slice 1 records them on the
+   *   instance; later slices fan out one `DrainController` per lane.
    */
-  constructor(registry, _states = /* @__PURE__ */ new Map(), batchHandlers = /* @__PURE__ */ new Map(), options = {}) {
+  constructor(registry, _states = /* @__PURE__ */ new Map(), batchHandlers = /* @__PURE__ */ new Map(), options = {}, lanes = []) {
     this.registry = registry;
     this._states = _states;
     this._batch_handlers = batchHandlers;
+    this._lanes = lanes;
+    if (options.onlyLanes && options.onlyLanes.length > 0) {
+      const declared = /* @__PURE__ */ new Set([
+        "default",
+        ...lanes.map((l) => l.name)
+      ]);
+      const unknown = options.onlyLanes.filter((l) => !declared.has(l));
+      if (unknown.length > 0)
+        throw new Error(
+          `ActOptions.onlyLanes references undeclared lane(s): ${unknown.map((l) => `"${l}"`).join(", ")}`
+        );
+    }
     this._scoped = options.scoped ? (fn) => scoped.run(options.scoped, fn) : (fn) => fn();
     this._correlator = options.correlator ?? defaultCorrelator;
     this._es = buildEs(this._logger, this._correlator);
@@ -1337,19 +1805,53 @@ var Act = class {
       boundQueryArray: this._bound_query_array
     });
     this._handle_batch = buildHandleBatch(this._logger);
-    const { staticTargets, hasDynamicResolvers, reactiveEvents, eventToState } = classifyRegistry(this.registry, this._states);
+    const {
+      staticTargets,
+      hasDynamicResolvers,
+      reactiveEvents,
+      eventToState,
+      eventToLanes
+    } = classifyRegistry(this.registry, this._states);
     this._reactive_events = reactiveEvents;
     this._event_to_state = eventToState;
-    this._drain = new DrainController({
+    this._event_to_lanes = eventToLanes;
+    const allLanes = ["default", ...lanes.map((l) => l.name)];
+    const onlySet = options.onlyLanes && options.onlyLanes.length > 0 ? new Set(options.onlyLanes) : void 0;
+    const activeLanes = onlySet ? allLanes.filter((n) => onlySet.has(n)) : allLanes;
+    const singleDefaultLane = activeLanes.length === 1 && activeLanes[0] === "default";
+    this._drain_controllers = /* @__PURE__ */ new Map();
+    for (const name of activeLanes) {
+      const cfg = lanes.find((l) => l.name === name);
+      const controller = 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),
+        // Pass lane only when a true per-lane controller is active.
+        // The all-lanes (single default) case keeps lane=undefined so
+        // adapter SQL collapses to the pre-1103 shape.
+        lane: singleDefaultLane ? void 0 : name,
+        defaults: cfg && {
+          streamLimit: cfg.streamLimit,
+          leaseMillis: cfg.leaseMillis
+        }
+      });
+      if (cfg?.cycleMs !== void 0) controller.start(cfg.cycleMs);
+      this._drain_controllers.set(name, controller);
+    }
+    this._audit_deps = {
+      store,
       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)
-    });
+      event_to_state: eventToState,
+      states: this._states,
+      known_events: new Set(eventToState.keys()),
+      declared_lanes: new Set(this._drain_controllers.keys()),
+      routed_events: new Set(eventToLanes.keys())
+    };
     this._correlate = new CorrelateCycle(
       this.registry,
       staticTargets,
@@ -1358,7 +1860,7 @@ var Act = class {
       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();
+        if (this._reactive_events.size > 0) this._armAll();
       }
     );
     this._settle = new SettleLoop(
@@ -1378,8 +1880,8 @@ var Act = class {
   _emitter = new EventEmitter();
   /** Event names with at least one registered reaction (computed at build time) */
   _reactive_events;
-  /** Drain pipeline driver: armed flag, concurrency lock, adaptive ratio. */
-  _drain;
+  /** One DrainController per active lane, keyed by lane name. */
+  _drain_controllers;
   /** Correlation state machine: lazy init, dynamic-resolver scan, periodic worker. */
   _correlate;
   /** Debounced correlate→drain catch-up loop. */
@@ -1433,6 +1935,22 @@ var Act = class {
    * set when seeding a `restart` snapshot in multi-state apps.
    */
   _event_to_state;
+  /**
+   * Event-name → lane fan-in for selective arming (ACT-1103). Built by
+   * `classifyRegistry` once per build. `"all"` means at least one of
+   * the event's reactions is a dynamic resolver (lane opaque until
+   * runtime); a `Set<string>` lists the static lanes only that event's
+   * reactions target.
+   */
+  _event_to_lanes;
+  /**
+   * Audit dependency bag (#723). Built once at construction; held as
+   * an immutable snapshot of the registry state the audit module
+   * needs. Lives in `internal/audit.ts` — this orchestrator never
+   * carries audit logic, only the deps + a one-liner that hands them
+   * over.
+   */
+  _audit_deps;
   /** Logger resolved at construction time (after user port configuration) */
   _logger = log();
   /** Wraps a public-method body so internal `store()`/`cache()` resolve to the
@@ -1456,6 +1974,12 @@ var Act = class {
   /** Reaction dispatchers built once and handed to runDrainCycle each cycle. */
   _handle;
   _handle_batch;
+  /** Declared drain lanes (ACT-1103). */
+  _lanes;
+  /** Drain lanes declared via `.withLane(...)`. Implicit default not included. */
+  get lanes() {
+    return this._lanes;
+  }
   /** True after the first `shutdown()` call. Guards idempotency. */
   _shutdown_promise;
   /**
@@ -1474,6 +1998,7 @@ var Act = class {
         this._emitter.removeAllListeners();
         this.stop_correlations();
         this.stop_settling();
+        for (const c of this._drain_controllers.values()) c.stop();
         const disposer = await this._notify_disposer;
         if (disposer) await disposer();
       })();
@@ -1493,13 +2018,10 @@ var Act = class {
       return await s.notify((notification) => {
         try {
           this.emit("notified", notification);
-          const hasReactive = notification.events.some(
-            (e) => this._reactive_events.has(e.name)
+          const armed = this._armForEventNames(
+            notification.events.map((e) => e.name)
           );
-          if (hasReactive) {
-            this._drain.arm();
-            this._settle.schedule({ debounceMs: 0 });
-          }
+          if (armed) this._settle.schedule({ debounceMs: 0 });
         } catch (err) {
           this._logger.error(err, "notified handler threw");
         }
@@ -1600,14 +2122,10 @@ var Act = class {
         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;
-          }
-        }
-      }
+      if (this._reactive_events.size > 0)
+        this._armForEventNames(
+          snapshots.map((s) => s.event.name)
+        );
       this.emit("committed", snapshots);
       return snapshots;
     });
@@ -1754,7 +2272,59 @@ var Act = class {
    * @see {@link start_correlations} for automatic correlation
    */
   async drain(options = {}) {
-    return this._scoped(() => this._drain.drain(options));
+    return this._scoped(() => this._drainAll(options));
+  }
+  /** Arm every active lane controller (ACT-1103). */
+  _armAll() {
+    for (const c of this._drain_controllers.values()) c.arm();
+  }
+  /**
+   * Arm only the lane controllers whose reactions match the supplied
+   * event names (ACT-1103 selective arming). Events with any dynamic
+   * resolver fall back to `_armAll()` via the `"all"` sentinel — the
+   * resolver's lane isn't known until correlate runs the function.
+   * Events with no reactions are skipped; `_event_to_lanes` doesn't
+   * carry them. Returns true when any controller was armed (used by
+   * the notify handler to decide whether to schedule a settle).
+   */
+  _armForEventNames(names) {
+    const to_arm = /* @__PURE__ */ new Set();
+    for (const name of names) {
+      const set = this._event_to_lanes.get(name);
+      if (set === void 0) continue;
+      if (set === ALL_LANES) {
+        this._armAll();
+        return true;
+      }
+      for (const lane of set) to_arm.add(lane);
+    }
+    if (to_arm.size === 0) return false;
+    for (const lane of to_arm) this._drain_controllers.get(lane)?.arm();
+    return true;
+  }
+  /** Drain every active lane controller in parallel and aggregate.
+   *
+   * Parallel — not sequential — so a slow lane's in-flight handler does
+   * not block a fast lane's claim/dispatch/ack cycle. Each controller's
+   * `claim()` is independent (filtered by lane); the store's
+   * `SKIP LOCKED` keeps cross-controller races safe. Lifecycle events
+   * (`acked`, `blocked`) may interleave by lane — listeners filter via
+   * `lease.lane`. */
+  async _drainAll(options) {
+    const results = await Promise.all(
+      [...this._drain_controllers.values()].map((c) => c.drain(options))
+    );
+    const fetched = [];
+    const leased = [];
+    const acked = [];
+    const blocked = [];
+    for (const r of results) {
+      fetched.push(...r.fetched);
+      leased.push(...r.leased);
+      acked.push(...r.acked);
+      blocked.push(...r.blocked);
+    }
+    return { fetched, leased, acked, blocked };
   }
   /**
    * Discovers and registers new streams dynamically based on reaction resolvers.
@@ -1925,7 +2495,7 @@ var Act = class {
   async reset(input) {
     return this._scoped(async () => {
       const count = await store().reset(input);
-      if (count > 0 && this._reactive_events.size > 0) this._drain.arm();
+      if (count > 0 && this._reactive_events.size > 0) this._armAll();
       return count;
     });
   }
@@ -1959,7 +2529,7 @@ var Act = class {
   async unblock(input) {
     return this._scoped(async () => {
       const count = await store().unblock(input);
-      if (count > 0 && this._reactive_events.size > 0) this._drain.arm();
+      if (count > 0 && this._reactive_events.size > 0) this._armAll();
       return count;
     });
   }
@@ -1997,6 +2567,50 @@ var Act = class {
       return positions;
     });
   }
+  /**
+   * Operator-driven store audit (#723).
+   *
+   * Walks the connected store and yields per-category findings —
+   * each tagged with the remediation it suggests. Same operator-
+   * driven category as `app.close()` / `app.reset()` /
+   * `app.unblock()` / `app.blocked_streams()`: never auto-invoked by
+   * the framework; the operator decides when to run it (CI gate,
+   * scheduled job, ad-hoc forensics) and what to do with the
+   * findings.
+   *
+   * Categories are independent — pass a subset to scope the work,
+   * or omit to run everything:
+   *
+   * ```typescript
+   * // Targeted: schema drift + deprecated-event load only
+   * for await (const f of app.audit(["schema", "deprecated-load"], {
+   *   query: { created_after: lastScan },
+   *   thresholds: { deprecatedLoadShareMin: 0.10 },
+   * })) {
+   *   await escalate(f);
+   * }
+   *
+   * // Full audit, default thresholds
+   * for await (const f of app.audit()) console.log(f);
+   * ```
+   *
+   * Returns an `AsyncIterable` so callers can `break` early — the
+   * underlying store paginations respect the iterator protocol and
+   * stop cleanly. Each finding is emitted independently, so
+   * pipelining into Slack / persistence / further analysis works
+   * without buffering the full report in memory.
+   *
+   * Findings shape — see {@link AuditFinding}. The discriminated
+   * union carries enough context for the operator to act on each
+   * finding directly: stream id, event id, recommendation hints.
+   *
+   * @param categories - Subset of categories to run (default: all).
+   * @param options - Query window + per-category thresholds.
+   * @returns Async iterable of {@link AuditFinding}.
+   */
+  audit(categories, options) {
+    return audit(this._audit_deps, categories, options);
+  }
   /**
    * Bulk-update scheduling priority for streams matching `filter`.
    *
@@ -2132,6 +2746,22 @@ function registerBatchHandler(proj, batchHandlers) {
   }
   batchHandlers.set(proj.target, proj.batchHandler);
 }
+function validateLaneReferences(registry, lanes) {
+  const declared = /* @__PURE__ */ new Set([DEFAULT_LANE, ...lanes.map((l) => l.name)]);
+  for (const [eventName, def] of Object.entries(registry.events)) {
+    const entry = def;
+    for (const [handlerName, reaction] of entry.reactions) {
+      const resolver = reaction.resolver;
+      if (typeof resolver === "function") continue;
+      const lane = resolver.lane;
+      if (lane && !declared.has(lane)) {
+        throw new Error(
+          `Reaction "${handlerName}" on "${eventName}" targets undeclared lane "${lane}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. Add \`.withLane({ name: "${lane}", ... })\` to act() or correct the .to() declaration.`
+        );
+      }
+    }
+  }
+}
 function act() {
   const states = /* @__PURE__ */ new Map();
   const registry = {
@@ -2140,6 +2770,7 @@ function act() {
   };
   const pendingProjections = [];
   const batchHandlers = /* @__PURE__ */ new Map();
+  const lanes = [];
   let _built = false;
   const finalizeDeprecations = () => {
     const deprecationSummary = [];
@@ -2186,6 +2817,18 @@ function act() {
       }
       mergeEventRegister(registry.events, input.events);
       pendingProjections.push(...input.projections);
+      for (const sliceLane of input.lanes) {
+        const existing = lanes.find((l) => l.name === sliceLane.name);
+        if (!existing) {
+          lanes.push(sliceLane);
+          continue;
+        }
+        if (existing.leaseMillis !== sliceLane.leaseMillis || existing.streamLimit !== sliceLane.streamLimit || existing.cycleMs !== sliceLane.cycleMs) {
+          throw new Error(
+            `Lane "${sliceLane.name}" was already declared with a different config`
+          );
+        }
+      }
       return builder;
     },
     withProjection: (proj) => {
@@ -2194,6 +2837,14 @@ function act() {
       return builder;
     },
     withActor: () => builder,
+    withLane: (config2) => {
+      if (config2.name === DEFAULT_LANE)
+        throw new Error(`Lane "${DEFAULT_LANE}" is reserved`);
+      if (lanes.some((l) => l.name === config2.name))
+        throw new Error(`Lane "${config2.name}" was already declared`);
+      lanes.push(config2);
+      return builder;
+    },
     on: (event) => ({
       do: (handler, options) => {
         const reaction = {
@@ -2225,13 +2876,15 @@ function act() {
           registerBatchHandler(proj, batchHandlers);
         }
         finalizeDeprecations();
+        validateLaneReferences(registry, lanes);
         _built = true;
       }
       return new Act(
         registry,
         states,
         batchHandlers,
-        options
+        options,
+        lanes
       );
     },
     events: registry.events
@@ -2312,6 +2965,7 @@ function slice() {
   const actions = {};
   const events = {};
   const projections = [];
+  const lanes = [];
   const builder = {
     withState: (state2) => {
       registerState(state2, states, actions, events);
@@ -2321,6 +2975,14 @@ function slice() {
       projections.push(proj);
       return builder;
     },
+    withLane: (config2) => {
+      if (config2.name === DEFAULT_LANE)
+        throw new Error(`Lane "${DEFAULT_LANE}" is reserved`);
+      if (lanes.some((l) => l.name === config2.name))
+        throw new Error(`Lane "${config2.name}" was already declared`);
+      lanes.push(config2);
+      return builder;
+    },
     on: (event) => ({
       do: (handler, options) => {
         const reaction = {
@@ -2349,7 +3011,8 @@ function slice() {
       _tag: "Slice",
       states,
       events,
-      projections
+      projections,
+      lanes
     }),
     events
   };
@@ -2442,6 +3105,7 @@ export {
   CommittedMetaSchema,
   ConcurrencyError,
   ConsoleLogger,
+  DEFAULT_LANE,
   DEFAULT_MAX_SUBSCRIBED_STREAMS,
   DEFAULT_SETTLE_DEBOUNCE_MS,
   Environments,