@rotorsoft/act 0.43.0 → 0.45.0

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(index_exports, {
   CommittedMetaSchema: () => CommittedMetaSchema,
   ConcurrencyError: () => ConcurrencyError,
   ConsoleLogger: () => ConsoleLogger,
+  DEFAULT_LANE: () => DEFAULT_LANE,
   DEFAULT_MAX_SUBSCRIBED_STREAMS: () => DEFAULT_MAX_SUBSCRIBED_STREAMS,
   DEFAULT_SETTLE_DEBOUNCE_MS: () => DEFAULT_SETTLE_DEBOUNCE_MS,
   Environments: () => Environments,
@@ -145,6 +146,12 @@ var ConsoleLogger = class _ConsoleLogger {
     if (typeof objOrMsg === "string") {
       message = objOrMsg;
       obj = {};
+    } else if (objOrMsg instanceof Error) {
+      message = msg ?? objOrMsg.message;
+      obj = {
+        error: { message: objOrMsg.message, name: objOrMsg.name },
+        stack: objOrMsg.stack
+      };
     } else if (objOrMsg !== null && typeof objOrMsg === "object") {
       message = msg;
       obj = { ...objOrMsg };
@@ -175,6 +182,9 @@ var ConsoleLogger = class _ConsoleLogger {
     let data;
     if (typeof objOrMsg === "string") {
       message = objOrMsg;
+    } else if (objOrMsg instanceof Error) {
+      message = msg ?? objOrMsg.message;
+      data = objOrMsg.stack;
     } else {
       message = msg ?? "";
       if (objOrMsg !== void 0 && objOrMsg !== null) {
@@ -484,10 +494,11 @@ async function sleep(ms) {
 
 // src/adapters/in-memory-store.ts
 var InMemoryStream = class {
-  constructor(stream, source, priority = 0) {
+  constructor(stream, source, priority = 0, lane = DEFAULT_LANE) {
     this.stream = stream;
     this.source = source;
     this._priority = priority;
+    this._lane = lane;
   }
   _at = -1;
   _retry = -1;
@@ -496,9 +507,17 @@ var InMemoryStream = class {
   _leased_by = void 0;
   _leased_until = void 0;
   _priority = 0;
+  _lane = DEFAULT_LANE;
   get priority() {
     return this._priority;
   }
+  get lane() {
+    return this._lane;
+  }
+  /** Replace on every subscribe — current builder config wins on restart. */
+  set lane(value) {
+    this._lane = value;
+  }
   /**
    * Bump the priority via {@link subscribe}: keeps the maximum across
    * reactions so the highest-priority registrant wins.
@@ -552,7 +571,8 @@ var InMemoryStream = class {
       at: lease.at,
       by: lease.by,
       retry: this._retry,
-      lagging: lease.lagging
+      lagging: lease.lagging,
+      lane: this._lane
     };
   }
   /**
@@ -571,7 +591,8 @@ var InMemoryStream = class {
         at: this._at,
         by: lease.by,
         retry: this._retry,
-        lagging: lease.lagging
+        lagging: lease.lagging,
+        lane: this._lane
       };
     }
   }
@@ -591,7 +612,8 @@ var InMemoryStream = class {
         by: this._leased_by,
         retry: this._retry,
         error: this._error,
-        lagging: lease.lagging
+        lagging: lease.lagging,
+        lane: this._lane
       };
     }
   }
@@ -767,7 +789,7 @@ var InMemoryStore = class {
    * @param millis - Lease duration in milliseconds.
    * @returns Granted leases.
    */
-  async claim(lagging, leading, by, millis) {
+  async claim(lagging, leading, by, millis, lane) {
     await sleep();
     const sourceRegex = /* @__PURE__ */ new Map();
     const getRegex = (source) => {
@@ -788,7 +810,7 @@ var InMemoryStore = class {
       return false;
     };
     const available = [...this._streams.values()].filter(
-      (s) => s.is_available && hasWork(s)
+      (s) => s.is_available && hasWork(s) && (lane === void 0 || s.lane === lane)
     );
     const lag = available.sort((a, b) => b.priority - a.priority || a.at - b.at).slice(0, lagging).map((s) => ({
       stream: s.stream,
@@ -824,12 +846,21 @@ var InMemoryStore = class {
   async subscribe(streams) {
     await sleep();
     let subscribed = 0;
-    for (const { stream, source, priority = 0 } of streams) {
+    for (const {
+      stream,
+      source,
+      priority = 0,
+      lane = DEFAULT_LANE
+    } of streams) {
       const existing = this._streams.get(stream);
       if (existing) {
         existing.bumpPriority(priority);
+        existing.lane = lane;
       } else {
-        this._streams.set(stream, new InMemoryStream(stream, source, priority));
+        this._streams.set(
+          stream,
+          new InMemoryStream(stream, source, priority, lane)
+        );
         subscribed++;
       }
     }
@@ -876,6 +907,7 @@ var InMemoryStore = class {
       }
       if (filter.blocked !== void 0 && s.blocked !== filter.blocked)
         return false;
+      if (filter.lane !== void 0 && s.lane !== filter.lane) return false;
       return true;
     };
   }
@@ -986,6 +1018,7 @@ var InMemoryStore = class {
           continue;
       }
       if (blocked !== void 0 && s.blocked !== blocked) continue;
+      if (query?.lane !== void 0 && s.lane !== query.lane) continue;
       callback({
         stream: s.stream,
         source: s.source,
@@ -995,13 +1028,85 @@ var InMemoryStore = class {
         error: s.error,
         priority: s.priority,
         leased_by: s.leased_by,
-        leased_until: s.leased_until
+        leased_until: s.leased_until,
+        lane: s.lane
       });
       count++;
       if (count >= limit) break;
     }
     return { maxEventId: this._events.length - 1, count };
   }
+  /**
+   * Per-stream aggregated stats — see {@link Store.query_stats}.
+   *
+   * Single forward scan over the in-memory event list, accumulating per
+   * stream. The "cheap heads" cost tier from durable adapters doesn't
+   * apply here (InMemory has no indexes); correctness is the goal, perf
+   * is a non-issue.
+   *
+   * Scope rules:
+   * - Array `input` — explicit stream names, regardless of subscription.
+   * - Filter `input` — `stream`/`stream_exact` match against event-bearing
+   *   stream names; `source`/`source_exact`/`blocked` require a
+   *   corresponding subscription in `_streams` (those are subscription
+   *   concepts, not event concepts). Empty filter `{}` matches every
+   *   event-bearing stream.
+   */
+  async query_stats(input, options) {
+    await sleep();
+    const exclude = new Set(options?.exclude ?? []);
+    const wantTail = options?.tail ?? false;
+    const wantCount = options?.count ?? false;
+    const wantNames = options?.names ?? false;
+    const before = options?.before;
+    const arrayTargets = Array.isArray(input) ? new Set(input) : null;
+    const filter = Array.isArray(input) ? null : input;
+    const streamRe = filter?.stream && !filter.stream_exact ? new RegExp(filter.stream) : void 0;
+    const scopeCache = /* @__PURE__ */ new Map();
+    const inScope = (stream) => {
+      const cached = scopeCache.get(stream);
+      if (cached !== void 0) return cached;
+      let ok = true;
+      if (arrayTargets) {
+        ok = arrayTargets.has(stream);
+      } else if (filter?.stream !== void 0) {
+        ok = filter.stream_exact ? stream === filter.stream : (
+          // biome-ignore lint/style/noNonNullAssertion: streamRe set when stream is regex
+          streamRe.test(stream)
+        );
+      }
+      scopeCache.set(stream, ok);
+      return ok;
+    };
+    const acc = /* @__PURE__ */ new Map();
+    for (const e of this._events) {
+      if (before !== void 0 && e.id >= before) continue;
+      if (!inScope(e.stream)) continue;
+      if (exclude.has(e.name)) continue;
+      let a = acc.get(e.stream);
+      if (!a) {
+        a = { head: e, count: 0 };
+        if (wantTail) a.tail = e;
+        if (wantNames) a.names = {};
+        acc.set(e.stream, a);
+      }
+      a.head = e;
+      a.count++;
+      if (wantNames) {
+        const n = String(e.name);
+        a.names[n] = (a.names[n] ?? 0) + 1;
+      }
+    }
+    const out = /* @__PURE__ */ new Map();
+    for (const [stream, a] of acc) {
+      const stats = { head: a.head };
+      if (wantTail) stats.tail = a.tail;
+      if (wantCount) stats.count = a.count;
+      if (wantNames) stats.names = a.names;
+      out.set(stream, stats);
+    }
+    return out;
+  }
   /**
    * Atomically truncates streams and seeds each with a snapshot or tombstone.
    * @param targets - Streams to truncate with optional snapshot state and meta.
@@ -1107,6 +1212,7 @@ function dispose(disposer) {
 }
 var SNAP_EVENT = "__snapshot__";
 var TOMBSTONE_EVENT = "__tombstone__";
+var DEFAULT_LANE = "default";
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
@@ -1130,23 +1236,39 @@ process.once("unhandledRejection", async (arg) => {
 var import_node_events = __toESM(require("events"), 1);
 
 // 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 });
+          }
         }
       }
     }
@@ -1161,7 +1283,8 @@ function classifyRegistry(registry, states) {
     staticTargets: [...statics.values()],
     hasDynamicResolvers,
     reactiveEvents,
-    eventToState
+    eventToState,
+    eventToLanes
   };
 }
 
@@ -1203,24 +1326,18 @@ async function runCloseCycle(targets, deps) {
   return { truncated, skipped };
 }
 async function scanStreamHeads(streams) {
+  const stats = await store2().query_stats(streams, {
+    exclude: [SNAP_EVENT]
+  });
   const out = /* @__PURE__ */ new Map();
-  await Promise.all(
-    streams.map(async (s) => {
-      let maxId = -1;
-      let version = -1;
-      let lastEventName = "";
-      await store2().query(
-        (e) => {
-          if (e.name === TOMBSTONE_EVENT || maxId !== -1) return;
-          maxId = e.id;
-          version = e.version;
-          lastEventName = e.name;
-        },
-        { stream: s, stream_exact: true, backward: true, limit: 1 }
-      );
-      if (maxId >= 0) out.set(s, { maxId, version, lastEventName });
-    })
-  );
+  for (const [stream, { head }] of stats) {
+    if (head.name === TOMBSTONE_EVENT) continue;
+    out.set(stream, {
+      maxId: head.id,
+      version: head.version,
+      lastEventName: head.name
+    });
+  }
   return out;
 }
 async function partitionBySafety(streamInfo, reactiveEventsSize, skipped) {
@@ -1378,6 +1495,7 @@ var CorrelateCycle = class {
               const entry = correlated.get(resolved.target) || {
                 source: resolved.source,
                 priority: incomingPriority,
+                lane: resolved.lane,
                 payloads: []
               };
               if (incomingPriority > entry.priority)
@@ -1396,10 +1514,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);
@@ -1484,904 +1603,955 @@ 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, (0, import_node_crypto2.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) => store2().claim(lagging, leading, by, millis, lane);
+async function fetch(leased, eventLimit) {
+  return Promise.all(
+    leased.map(async ({ stream, source, at, lagging }) => {
+      const events = [];
+      await store2().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;
-  }
-  _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;
-  }
-  /** 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);
-        }
-      }
-      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;
-    }
-  }
-};
+var ack = (leases) => store2().ack(leases);
+var block = (leases) => store2().block(leases);
+var subscribe = (streams) => store2().subscribe(streams);
 
-// 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 };
+// src/internal/event-sourcing.ts
+var import_act_patch = require("@rotorsoft/act-patch");
+async function snap(snapshot) {
+  try {
+    const { id, stream, name, meta, version } = snapshot.event;
+    await store2().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);
   }
-  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);
+async function tombstone(stream, expectedVersion, correlation) {
+  try {
+    const [committed] = await store2().commit(
+      stream,
+      [{ name: TOMBSTONE_EVENT, data: {} }],
+      { correlation, causation: {} },
+      expectedVersion
+    );
+    return committed;
+  } catch (error) {
+    if (error instanceof ConcurrencyError) return void 0;
+    throw error;
   }
-  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/merge.ts
-var import_zod4 = require("zod");
-function baseTypeName(zodType) {
-  let t = zodType;
-  while (typeof t.unwrap === "function") {
-    t = t.unwrap();
-  }
-  return t.constructor.name;
-}
-function mergeSchemas(existing, incoming, stateName) {
-  if (existing instanceof import_zod4.ZodObject && incoming instanceof import_zod4.ZodObject) {
-    const existingShape = existing.shape;
-    const incomingShape = incoming.shape;
-    for (const key of Object.keys(incomingShape)) {
-      if (key in existingShape) {
-        const existingBase = baseTypeName(existingShape[key]);
-        const incomingBase = baseTypeName(incomingShape[key]);
-        if (existingBase !== incomingBase) {
-          throw new Error(
-            `Schema conflict in "${stateName}": key "${key}" has type "${existingBase}" but incoming partial declares "${incomingBase}"`
-          );
-        }
+async function load(me, stream, callback, asOf) {
+  const timeTravel = !!asOf && Object.values(asOf).some((v) => v !== void 0);
+  const cached = timeTravel ? void 0 : await cache2().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 store2().query(
+    (e) => {
+      event = e;
+      version = e.version;
+      if (e.name === SNAP_EVENT) {
+        state2 = e.data;
+        snaps++;
+        patches = 0;
+        replayed++;
+      } else if (me.patch[e.name]) {
+        state2 = (0, import_act_patch.patch)(state2, me.patch[e.name](event, state2));
+        patches++;
+        replayed++;
+      } else if (e.name !== TOMBSTONE_EVENT) {
+        log().warn(
+          `Skipping unknown event "${String(e.name)}" on stream "${stream}" (id=${e.id}) \u2014 no reducer in state "${me.name}"`
+        );
       }
+      callback?.({
+        event,
+        state: state2,
+        version,
+        patches,
+        snaps,
+        cache_hit,
+        replayed
+      });
+    },
+    {
+      stream,
+      stream_exact: true,
+      ...cached ? { after: cached.event_id } : { with_snaps: true, ...asOf }
     }
-    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);
+  );
+  if (replayed > 0 && !timeTravel && event) {
+    await cache2().set(stream, {
+      state: state2,
+      version,
+      event_id: event.id,
+      patches,
+      snaps
+    });
   }
+  return { event, state: state2, version, patches, snaps, cache_hit, replayed };
 }
-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() };
+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
+        );
+    });
   }
-}
-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}"`);
+  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 (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 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)`
+        );
+      }
     }
-    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}"`
-      );
+  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 (existingIsDefault && !incomingIsDefault) {
-      merged[name] = incomingP;
+  };
+  let committed;
+  try {
+    committed = await store2().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 cache2().invalidate(stream);
     }
+    throw error;
   }
-  return merged;
+  let { state: state2, patches } = snapshot;
+  const snapshots = committed.map((event) => {
+    const p = me.patch[event.name](event, state2);
+    state2 = (0, import_act_patch.patch)(state2, p);
+    patches++;
+    return {
+      event,
+      state: state2,
+      version: event.version,
+      patches,
+      snaps: snapshot.snaps,
+      patch: p,
+      cache_hit: snapshot.cache_hit,
+      replayed: snapshot.replayed
+    };
+  });
+  const last = snapshots.at(-1);
+  const snapped = me.snap?.(last);
+  cache2().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;
 }
-function mergeEventRegister(target, source) {
-  for (const [eventName, sourceReg] of Object.entries(source)) {
-    const targetReg = target[eventName];
-    if (!targetReg) continue;
-    for (const [name, reaction] of sourceReg.reactions) {
-      targetReg.reactions.set(name, reaction);
-    }
-  }
-}
-function mergeProjection(proj, events) {
-  for (const eventName of Object.keys(proj.events)) {
-    const projRegister = proj.events[eventName];
-    const existing = events[eventName];
-    if (!existing) {
-      events[eventName] = {
-        schema: projRegister.schema,
-        reactions: new Map(projRegister.reactions)
-      };
-    } else {
-      for (const [name, reaction] of projRegister.reactions) {
-        let key = name;
-        while (existing.reactions.has(key)) key = `${key}_p`;
-        existing.reactions.set(key, reaction);
-      }
-    }
-  }
-}
-var _this_ = ({ stream }) => ({
-  source: stream,
-  target: stream
-});
 
-// src/internal/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;
+// 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;
+});
+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) {
-    this.deps = deps;
-    this.defaultDebounceMs = 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,
+    (0, import_node_crypto2.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: []
+    };
   }
-  _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}.
+  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;
+  }
+  _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).
    */
-  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);
+  _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;
   }
-  /** Cancel any pending or active settle cycle. Idempotent. */
+  /** 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;
+  }
+  /**
+   * 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.
+   */
+  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();
+  }
+  /** 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) => store2().claim(lagging, leading, by, millis);
-async function fetch(leased, eventLimit) {
-  return Promise.all(
-    leased.map(async ({ stream, source, at, lagging }) => {
-      const events = [];
-      await store2().query((e) => events.push(e), {
-        stream: source,
-        after: at,
-        limit: eventLimit
-      });
-      return { stream, source, at, lagging, 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 };
 }
-var ack = (leases) => store2().ack(leases);
-var block = (leases) => store2().block(leases);
-var subscribe = (streams) => store2().subscribe(streams);
-
-// src/internal/event-sourcing.ts
-var import_act_patch = require("@rotorsoft/act-patch");
-async function snap(snapshot) {
-  try {
-    const { id, stream, name, meta, version } = snapshot.event;
-    await store2().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 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;
 }
-async function tombstone(stream, expectedVersion, correlation) {
-  try {
-    const [committed] = await store2().commit(
-      stream,
-      [{ name: TOMBSTONE_EVENT, data: {} }],
-      { correlation, causation: {} },
-      expectedVersion
-    );
-    return committed;
-  } catch (error) {
-    if (error instanceof ConcurrencyError) return void 0;
-    throw error;
+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;
 }
-async function load(me, stream, callback, asOf) {
-  const timeTravel = !!asOf && Object.values(asOf).some((v) => v !== void 0);
-  const cached = timeTravel ? void 0 : await cache2().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 store2().query(
-    (e) => {
-      event = e;
-      version = e.version;
-      if (e.name === SNAP_EVENT) {
-        state2 = e.data;
-        snaps++;
-        patches = 0;
-        replayed++;
-      } else if (me.patch[e.name]) {
-        state2 = (0, import_act_patch.patch)(state2, me.patch[e.name](event, state2));
-        patches++;
-        replayed++;
-      } else if (e.name !== TOMBSTONE_EVENT) {
-        log().warn(
-          `Skipping unknown event "${String(e.name)}" on stream "${stream}" (id=${e.id}) \u2014 no reducer in state "${me.name}"`
-        );
+
+// src/internal/merge.ts
+var import_zod4 = require("zod");
+function baseTypeName(zodType) {
+  let t = zodType;
+  while (typeof t.unwrap === "function") {
+    t = t.unwrap();
+  }
+  return t.constructor.name;
+}
+function mergeSchemas(existing, incoming, stateName) {
+  if (existing instanceof import_zod4.ZodObject && incoming instanceof import_zod4.ZodObject) {
+    const existingShape = existing.shape;
+    const incomingShape = incoming.shape;
+    for (const key of Object.keys(incomingShape)) {
+      if (key in existingShape) {
+        const existingBase = baseTypeName(existingShape[key]);
+        const incomingBase = baseTypeName(incomingShape[key]);
+        if (existingBase !== incomingBase) {
+          throw new Error(
+            `Schema conflict in "${stateName}": key "${key}" has type "${existingBase}" but incoming partial declares "${incomingBase}"`
+          );
+        }
       }
-      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 cache2().set(stream, {
-      state: state2,
-      version,
-      event_id: event.id,
-      patches,
-      snaps
-    });
+    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() };
   }
-  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
-        );
-    });
+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}"`);
   }
-  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 (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}"`);
   }
-  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)`
-        );
-      }
+  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;
     }
   }
-  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 store2().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 cache2().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 = (0, import_act_patch.patch)(state2, p);
-    patches++;
-    return {
-      event,
-      state: state2,
-      version: event.version,
-      patches,
-      snaps: snapshot.snaps,
-      patch: p,
-      cache_hit: snapshot.cache_hit,
-      replayed: snapshot.replayed
-    };
-  });
-  const last = snapshots.at(-1);
-  const snapped = me.snap?.(last);
-  cache2().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;
@@ -2396,11 +2566,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);
@@ -2413,19 +2598,44 @@ 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({
-      logger: this._logger,
-      ops: this._cd,
-      registry: this.registry,
-      batchHandlers: this._batch_handlers,
-      handle: this._handle,
-      handleBatch: this._handle_batch,
-      onAcked: (acked) => this.emit("acked", acked),
-      onBlocked: (blocked) => this.emit("blocked", blocked)
-    });
+    this._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._correlate = new CorrelateCycle(
       this.registry,
       staticTargets,
@@ -2434,7 +2644,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(
@@ -2454,8 +2664,8 @@ var Act = class {
   _emitter = new import_node_events.default();
   /** Event names with at least one registered reaction (computed at build time) */
   _reactive_events;
-  /** Drain pipeline driver: armed flag, concurrency lock, adaptive ratio. */
-  _drain;
+  /** 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. */
@@ -2509,6 +2719,14 @@ 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;
   /** Logger resolved at construction time (after user port configuration) */
   _logger = log();
   /** Wraps a public-method body so internal `store()`/`cache()` resolve to the
@@ -2532,6 +2750,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;
   /**
@@ -2550,6 +2774,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();
       })();
@@ -2569,13 +2794,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");
         }
@@ -2676,14 +2898,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;
     });
@@ -2830,7 +3048,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.
@@ -3001,7 +3271,7 @@ var Act = class {
   async reset(input) {
     return this._scoped(async () => {
       const count = await store2().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;
     });
   }
@@ -3035,7 +3305,7 @@ var Act = class {
   async unblock(input) {
     return this._scoped(async () => {
       const count = await store2().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;
     });
   }
@@ -3208,6 +3478,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 = {
@@ -3216,6 +3502,7 @@ function act() {
   };
   const pendingProjections = [];
   const batchHandlers = /* @__PURE__ */ new Map();
+  const lanes = [];
   let _built = false;
   const finalizeDeprecations = () => {
     const deprecationSummary = [];
@@ -3262,6 +3549,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) => {
@@ -3270,6 +3569,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 = {
@@ -3301,13 +3608,15 @@ function act() {
           registerBatchHandler(proj, batchHandlers);
         }
         finalizeDeprecations();
+        validateLaneReferences(registry, lanes);
         _built = true;
       }
       return new Act(
         registry,
         states,
         batchHandlers,
-        options
+        options,
+        lanes
       );
     },
     events: registry.events
@@ -3388,6 +3697,7 @@ function slice() {
   const actions = {};
   const events = {};
   const projections = [];
+  const lanes = [];
   const builder = {
     withState: (state2) => {
       registerState(state2, states, actions, events);
@@ -3397,6 +3707,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 = {
@@ -3425,7 +3743,8 @@ function slice() {
       _tag: "Slice",
       states,
       events,
-      projections
+      projections,
+      lanes
     }),
     events
   };
@@ -3519,6 +3838,7 @@ function action_builder(state2) {
   CommittedMetaSchema,
   ConcurrencyError,
   ConsoleLogger,
+  DEFAULT_LANE,
   DEFAULT_MAX_SUBSCRIBED_STREAMS,
   DEFAULT_SETTLE_DEBOUNCE_MS,
   Environments,