@rotorsoft/act 1.37.7 → 2.0.0

package/dist/index.cjs

@@ -40,11 +40,11 @@
 
 
 
-var _chunkPRDX3HP6cjs = require('./chunk-PRDX3HP6.cjs');
 
 
 
 
+var _chunkLUHPSF3Ccjs = require('./chunk-LUHPSF3C.cjs');
 
 
 
@@ -74,24 +74,27 @@ var _chunkPRDX3HP6cjs = require('./chunk-PRDX3HP6.cjs');
 
 
 
-var _chunkH6KVPVP4cjs = require('./chunk-H6KVPVP4.cjs');
+
+
+
+var _chunkYFFWCVXWcjs = require('./chunk-YFFWCVXW.cjs');
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
-  _chunkPRDX3HP6cjs.log.call(void 0, ).info(arg, "SIGINT");
-  await _chunkPRDX3HP6cjs.disposeAndExit.call(void 0, "EXIT");
+  _chunkLUHPSF3Ccjs.log.call(void 0, ).info(arg, "SIGINT");
+  await _chunkLUHPSF3Ccjs.disposeAndExit.call(void 0, "EXIT");
 });
 process.once("SIGTERM", async (arg) => {
-  _chunkPRDX3HP6cjs.log.call(void 0, ).info(arg, "SIGTERM");
-  await _chunkPRDX3HP6cjs.disposeAndExit.call(void 0, "EXIT");
+  _chunkLUHPSF3Ccjs.log.call(void 0, ).info(arg, "SIGTERM");
+  await _chunkLUHPSF3Ccjs.disposeAndExit.call(void 0, "EXIT");
 });
 process.once("uncaughtException", async (arg) => {
-  _chunkPRDX3HP6cjs.log.call(void 0, ).error(arg, "Uncaught Exception");
-  await _chunkPRDX3HP6cjs.disposeAndExit.call(void 0, "ERROR");
+  _chunkLUHPSF3Ccjs.log.call(void 0, ).error(arg, "Uncaught Exception");
+  await _chunkLUHPSF3Ccjs.disposeAndExit.call(void 0, "ERROR");
 });
 process.once("unhandledRejection", async (arg) => {
-  _chunkPRDX3HP6cjs.log.call(void 0, ).error(arg, "Unhandled Rejection");
-  await _chunkPRDX3HP6cjs.disposeAndExit.call(void 0, "ERROR");
+  _chunkLUHPSF3Ccjs.log.call(void 0, ).error(arg, "Unhandled Rejection");
+  await _chunkLUHPSF3Ccjs.disposeAndExit.call(void 0, "ERROR");
 });
 
 // src/act.ts
@@ -199,7 +202,7 @@ async function* audit(deps, categories, options = {}) {
   if (need_stats) {
     const stats = await deps.store().query_stats(
       {},
-      { count: true, names: true, exclude: [_chunkH6KVPVP4cjs.SNAP_EVENT] }
+      { count: true, names: true, exclude: [_chunkYFFWCVXWcjs.SNAP_EVENT] }
     );
     for (const [stream, s] of stats) {
       for (const p of passes) _optionalChain([p, 'access', _4 => _4.on_stat, 'optionalCall', _5 => _5(stream, s)]);
@@ -281,7 +284,7 @@ var make_schema_pass = (deps) => {
         return;
       }
       const schema = state2.events[name];
-      const sensitive2 = _chunkH6KVPVP4cjs.pii_fields.call(void 0, schema);
+      const sensitive2 = _chunkYFFWCVXWcjs.pii_fields.call(void 0, schema);
       let parse_schema = schema;
       if (sensitive2.length > 0) {
         const omitter = schema.omit;
@@ -415,7 +418,7 @@ var make_restart_candidate_pass = (deps, options) => {
           {
             stream,
             stream_exact: true,
-            names: [_chunkH6KVPVP4cjs.SNAP_EVENT],
+            names: [_chunkYFFWCVXWcjs.SNAP_EVENT],
             with_snaps: true,
             // From the start: on its own, `with_snaps` resumes at the latest.
             after: -1
@@ -575,7 +578,7 @@ var make_correlation_gaps_pass = () => {
       seen_ids.add(e.id);
       const causation = _optionalChain([e, 'access', _31 => _31.meta, 'optionalAccess', _32 => _32.causation]);
       const parent_id = _optionalChain([causation, 'optionalAccess', _33 => _33.event, 'optionalAccess', _34 => _34.id]);
-      if (parent_id !== void 0 && e.name !== _chunkH6KVPVP4cjs.TOMBSTONE_EVENT) {
+      if (parent_id !== void 0 && e.name !== _chunkYFFWCVXWcjs.TOMBSTONE_EVENT) {
         checks.push({ stream: e.stream, id: e.id, parent_id });
       }
     },
@@ -750,6 +753,7 @@ var CircuitBreaker = (_class = class {
 
 // src/internal/classify.ts
 var ALL_LANES = /* @__PURE__ */ Symbol("act/all-lanes");
+var describe_source = (source) => source === void 0 ? "no source (every stream)" : `"${source}"`;
 function classify_registry(registry, states) {
   const statics = /* @__PURE__ */ new Map();
   const target_lanes = /* @__PURE__ */ new Map();
@@ -776,6 +780,10 @@ function classify_registry(registry, states) {
           );
         }
         const existing = statics.get(target);
+        if (existing && existing.source !== source)
+          throw new Error(
+            `Target "${target}" has reactions on two sources, ${describe_source(existing.source)} and ${describe_source(source)}. A target reads one source, so the second would miss events or read too many. Give it its own target.`
+          );
         if (!existing) {
           statics.set(target, { stream: target, source, priority, lane });
         } else if (priority > existing.priority) {
@@ -797,674 +805,303 @@ function classify_registry(registry, states) {
   };
 }
 
-// src/internal/close-cycle.ts
-var CLOSE_CATCH_UP_LIMIT = 1e3;
-var CLOSE_CATCH_UP_PASSES = 20;
-async function catch_up_correlation(cursor, correlate, until) {
-  for (let pass = 0; pass < CLOSE_CATCH_UP_PASSES && cursor.checkpoint < until; pass++) {
-    const before = cursor.checkpoint;
-    cursor.arm();
-    await correlate(CLOSE_CATCH_UP_LIMIT);
-    if (cursor.checkpoint <= before) break;
-  }
-  return cursor.checkpoint;
+// src/internal/autoclose-policy.ts
+var _zod = require('zod');
+var DAY_MS = 864e5;
+var MIN_AFTER_DAYS = 1 / 1440;
+var MIN_KEEP_DAYS = 1;
+function days_after(date, days) {
+  return new Date(date.getTime() + days * DAY_MS);
 }
-var CloseLock = (_class2 = class {constructor() { _class2.prototype.__init2.call(this); }
-  __init2() {this._tails = /* @__PURE__ */ new Map()}
-  /** Run `work` after every earlier close of `stream` has settled. */
-  run(stream, work) {
-    const prev = _nullishCoalesce(this._tails.get(stream), () => ( Promise.resolve()));
-    const next = prev.then(work, work);
-    this._tails.set(stream, next);
-    const cleanup = () => {
-      if (this._tails.get(stream) === next) this._tails.delete(stream);
-    };
-    next.then(cleanup, cleanup);
-    return next;
+function days_before_now(days) {
+  return new Date(Date.now() - days * DAY_MS);
+}
+var window_schema = (field, min_days, floor) => _zod.z.object({
+  days: _zod.z.number({ message: `autocloses: ${field}.days must be a number` }).positive(`autocloses: ${field}.days must be > 0`)
+}).refine((o) => o.days >= min_days, {
+  message: `autocloses: ${field} resolves to < ${floor}, which is too short to be a meaningful retention window`
+});
+var AfterSchema = window_schema("after", MIN_AFTER_DAYS, "one minute");
+var KeepSchema = window_schema("keep", MIN_KEEP_DAYS, "one day");
+var IsSchema = _zod.z.union([
+  _zod.z.string().min(1, "autocloses: is must be a non-empty event name"),
+  _zod.z.array(
+    _zod.z.string().min(1, "autocloses: is entries must be non-empty event names")
+  ).min(1, "autocloses: is must include at least one event name").readonly()
+]);
+var ReachesSchema = _zod.z.number({ message: "autocloses: reaches must be a number" }).int("autocloses: reaches must be an integer").min(1, "autocloses: reaches must be >= 1");
+var OrBlockSchema = _zod.z.object({
+  after: AfterSchema.optional(),
+  is: IsSchema.optional(),
+  reaches: ReachesSchema.optional()
+}).strict().refine(
+  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0,
+  {
+    message: "autocloses: `or` block must include at least one of after / is / reaches"
   }
-}, _class2);
-var SAFETY_PROBE_PAGE_SIZE = 1e3;
-async function run_close_cycle(targets, deps) {
-  const target_map = new Map(targets.map((t) => [t.stream, t]));
-  for (const t of target_map.values()) {
-    if (t.before !== void 0 && t.restart)
-      throw new Error(
-        `close: \`before\` and \`restart\` are mutually exclusive (stream "${t.stream}") \u2014 a windowed close keeps the stream live behind a real snapshot; restart reseeds it`
-      );
+);
+var AutoclosePolicySchema = _zod.z.object({
+  after: AfterSchema.optional(),
+  is: IsSchema.optional(),
+  reaches: ReachesSchema.optional(),
+  or: OrBlockSchema.optional(),
+  keep: KeepSchema.optional()
+}).strict().refine(
+  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0 || o.or !== void 0 || o.keep !== void 0,
+  {
+    message: "autocloses: at least one of after / is / reaches / or / keep must be specified \u2014 empty `{}` is a misconfiguration"
   }
-  const windowed = [...target_map.values()].filter(
-    (t) => t.before !== void 0
-  );
-  const full = [...target_map.values()].filter((t) => t.before === void 0);
-  const skipped = [];
-  const windowed_result = windowed.length ? await run_windowed_closes(windowed, deps, skipped) : /* @__PURE__ */ new Map();
-  if (!full.length) return { truncated: windowed_result, skipped };
-  const truncated = await with_stream_locks(
-    full.map((t) => t.stream),
-    deps,
-    () => run_full_closes(full, target_map, deps, skipped)
-  );
-  const retired = [...truncated.entries()].filter(([, r]) => r.committed.name === _chunkH6KVPVP4cjs.TOMBSTONE_EVENT).map(([stream]) => stream);
-  if (retired.length) _optionalChain([deps, 'access', _42 => _42.forget_subscribed, 'optionalCall', _43 => _43(retired)]);
-  for (const [stream, entry] of windowed_result) truncated.set(stream, entry);
-  return { truncated, skipped };
+);
+function compile_after(after) {
+  return (_stream, head) => days_after(head.created, after.days) <= /* @__PURE__ */ new Date();
 }
-function with_stream_locks(streams, deps, work) {
-  const with_lock = _nullishCoalesce(deps.with_stream_lock, () => ( ((_stream, w) => w())));
-  return [...streams].sort().reduceRight(
-    (inner, stream) => () => with_lock(stream, inner),
-    work
-  )();
+function compile_is(is) {
+  const set = new Set(typeof is === "string" ? [is] : is);
+  return (_stream, head) => set.has(head.name);
 }
-async function run_full_closes(full, target_map, deps, skipped) {
-  const none = /* @__PURE__ */ new Map();
-  const streams = full.map((t) => t.stream);
-  const stream_info = await scan_stream_heads(streams);
-  for (const target of full) {
-    if (!target.restart) continue;
-    const info = stream_info.get(target.stream);
-    if (!info) continue;
-    const owner = deps.event_to_state.get(info.last_event_name);
-    if (_optionalChain([owner, 'optionalAccess', _44 => _44.pii_aware])) {
-      deps.logger.error(
-        `Refusing to close "${target.stream}" with restart: state "${owner.name}" carries sensitive fields, so a restart seed would persist redacted values while deleting the originals. Close it without restart to retire the stream, or leave it open.`
-      );
-      skipped.push(target.stream);
-      stream_info.delete(target.stream);
-    }
-  }
-  const safe = await partition_by_safety(
-    stream_info,
-    deps.reactive,
-    skipped,
-    _nullishCoalesce(deps.probe_page_size, () => ( SAFETY_PROBE_PAGE_SIZE)),
-    deps.catch_up_correlation
-  );
-  if (!safe.length) return none;
-  const { guarded, guard_events } = await guard_with_tombstones(
-    safe,
-    stream_info,
-    deps.correlation,
-    deps.tombstone,
-    skipped
-  );
-  if (!guarded.length) return none;
-  const seed_states = await load_restart_seeds(
-    guarded,
-    target_map,
-    stream_info,
-    deps.event_to_state,
-    deps.load,
-    deps.logger
-  );
-  await run_archive_callbacks(guarded, target_map);
-  const still_guarded = await heads_still_guarded(
-    guarded,
-    guard_events,
-    skipped
-  );
-  if (!still_guarded.length) return none;
-  return truncate_and_warm_cache(
-    still_guarded,
-    seed_states,
-    guard_events,
-    deps.correlation
-  );
+function compile_reaches(reaches) {
+  return (_stream, _head, count) => count >= reaches;
 }
-async function run_windowed_closes(windowed, deps, skipped) {
-  const checkpoint = deps.reactive ? await deps.catch_up_correlation(Number.MAX_SAFE_INTEGER) : -1;
-  const min_at = deps.reactive ? await probe_min_watermarks(
-    windowed.map((t) => t.stream),
-    _nullishCoalesce(deps.probe_page_size, () => ( SAFETY_PROBE_PAGE_SIZE)),
-    checkpoint
-  ) : /* @__PURE__ */ new Map();
-  const with_lock = _nullishCoalesce(deps.with_stream_lock, () => ( ((_stream, work) => work())));
-  const truncated = /* @__PURE__ */ new Map();
-  for (const t of windowed) {
-    const entry = await with_lock(t.stream, async () => {
-      const max_id = min_at.get(t.stream);
-      if (!await windowed_prune_pending(t.stream, t.before, max_id))
-        return void 0;
-      if (t.archive) await t.archive();
-      const result = await _chunkPRDX3HP6cjs.store.call(void 0, ).truncate([
-        { stream: t.stream, before: t.before, max_id }
-      ]);
-      return result.get(t.stream);
-    });
-    if (entry) truncated.set(t.stream, entry);
-    else skipped.push(t.stream);
-  }
-  return truncated;
+function policy_min_after_days(options) {
+  const parsed = AutoclosePolicySchema.parse(options);
+  const windows = [];
+  if (parsed.after) windows.push(parsed.after.days);
+  if (_optionalChain([parsed, 'access', _42 => _42.or, 'optionalAccess', _43 => _43.after])) windows.push(parsed.or.after.days);
+  return windows.length ? Math.min(...windows) : void 0;
 }
-async function windowed_prune_pending(stream, before, max_id) {
-  let boundary_id;
-  let min_id;
-  await _chunkPRDX3HP6cjs.store.call(void 0, ).query(
-    (event) => {
-      if (min_id === void 0 || event.id < min_id) min_id = event.id;
-      if (event.name === _chunkH6KVPVP4cjs.SNAP_EVENT && event.created < before && (max_id === void 0 || event.id <= max_id) && (boundary_id === void 0 || event.id > boundary_id))
-        boundary_id = event.id;
-    },
-    { stream, stream_exact: true, with_snaps: true, after: -1 }
-  );
-  return boundary_id !== void 0 && min_id < boundary_id;
+function policy_after_windows(options) {
+  const parsed = AutoclosePolicySchema.parse(options);
+  return [parsed.after, _optionalChain([parsed, 'access', _44 => _44.or, 'optionalAccess', _45 => _45.after])].flatMap((w) => w ? [w.days] : []);
 }
-async function probe_min_watermarks(streams, page_size, checkpoint) {
-  const min_at = /* @__PURE__ */ new Map();
-  const matches = source_matcher();
-  await walk_streams(
-    _chunkPRDX3HP6cjs.store.call(void 0, ),
-    (position) => {
-      const pending = position.correlated_at === void 0 || position.at < position.correlated_at;
-      const cap = pending ? position.at : Math.max(position.at, checkpoint);
-      for (const stream of streams) {
-        if (matches(position.source, stream)) {
-          const prev = min_at.get(stream);
-          if (prev === void 0 || cap < prev) min_at.set(stream, cap);
-        }
-      }
-    },
-    { limit: page_size, source_matches: streams }
-  );
-  return min_at;
+function policy_keep_days(options) {
+  const parsed = AutoclosePolicySchema.parse(options);
+  return _optionalChain([parsed, 'access', _46 => _46.keep, 'optionalAccess', _47 => _47.days]);
 }
-function source_matcher() {
-  const compiled = /* @__PURE__ */ new Map();
-  return (source, stream) => {
-    if (!source) return true;
-    let re = compiled.get(source);
-    if (!re) {
-      re = new RegExp(source);
-      compiled.set(source, re);
+function compile_autoclose_policy(options) {
+  const parsed = AutoclosePolicySchema.parse(options);
+  const and_preds = [];
+  if (parsed.after) and_preds.push(compile_after(parsed.after));
+  if (parsed.is) and_preds.push(compile_is(parsed.is));
+  if (parsed.reaches) and_preds.push(compile_reaches(parsed.reaches));
+  const or_preds = [];
+  if (parsed.or) {
+    if (parsed.or.after) or_preds.push(compile_after(parsed.or.after));
+    if (parsed.or.is) or_preds.push(compile_is(parsed.or.is));
+    if (parsed.or.reaches) or_preds.push(compile_reaches(parsed.or.reaches));
+  }
+  return (stream, head, count) => {
+    if (and_preds.length > 0 && and_preds.every((p) => p(stream, head, count))) {
+      return true;
     }
-    return re.test(stream);
+    if (or_preds.some((p) => p(stream, head, count))) {
+      return true;
+    }
+    return false;
   };
 }
-async function scan_stream_heads(streams) {
-  const stats = await _chunkPRDX3HP6cjs.store.call(void 0, ).query_stats(streams, {
-    exclude: [_chunkH6KVPVP4cjs.SNAP_EVENT]
-  });
-  const domain_heads = await _chunkPRDX3HP6cjs.store.call(void 0, ).query_stats(streams, {
-    exclude: [_chunkH6KVPVP4cjs.SNAP_EVENT, _chunkH6KVPVP4cjs.TOMBSTONE_EVENT]
-  });
-  const true_heads = await _chunkPRDX3HP6cjs.store.call(void 0, ).query_stats(streams, {});
-  const out = /* @__PURE__ */ new Map();
-  for (const [stream, { head }] of domain_heads) {
-    const marker_head = _optionalChain([stats, 'access', _45 => _45.get, 'call', _46 => _46(stream), 'optionalAccess', _47 => _47.head]);
-    const interrupted = _optionalChain([marker_head, 'optionalAccess', _48 => _48.name]) === _chunkH6KVPVP4cjs.TOMBSTONE_EVENT;
-    out.set(stream, {
-      max_id: head.id,
-      version: true_heads.get(stream).head.version,
-      last_event_name: head.name,
-      ...interrupted ? { resumed_guard: { id: marker_head.id } } : {}
-    });
-  }
-  return out;
+
+// src/internal/autoclose-window.ts
+function hour_in_zone(now, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hour: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(now);
+  return Number(_optionalChain([parts, 'access', _48 => _48.find, 'call', _49 => _49((p) => p.type === "hour"), 'optionalAccess', _50 => _50.value]));
 }
-async function partition_by_safety(stream_info, reactive, skipped, page_size, catch_up_correlation2) {
-  if (!reactive) return [...stream_info.keys()];
-  let needed = -1;
-  for (const info of stream_info.values())
-    needed = Math.max(needed, info.max_id);
-  const checkpoint = await catch_up_correlation2(needed);
-  const uncorrelated = /* @__PURE__ */ new Set();
-  for (const [stream, info] of stream_info) {
-    if (checkpoint < info.max_id) uncorrelated.add(stream);
-  }
-  const pending_set = /* @__PURE__ */ new Set();
-  const matches = source_matcher();
-  const targets = [...stream_info.keys()];
-  await walk_streams(
-    _chunkPRDX3HP6cjs.store.call(void 0, ),
-    (position) => {
-      const has_work = position.correlated_at !== void 0 && position.at < position.correlated_at;
-      if (!has_work) return;
-      for (const [stream, info] of stream_info) {
-        if (matches(position.source, stream) && position.at < info.max_id)
-          pending_set.add(stream);
-      }
-    },
-    { limit: page_size, source_matches: targets }
-  );
-  const safe = [];
-  for (const [stream] of stream_info) {
-    if (pending_set.has(stream) || uncorrelated.has(stream))
-      skipped.push(stream);
-    else safe.push(stream);
-  }
-  return safe;
+function hour_in_range(hour, start, end) {
+  return start < end ? hour >= start && hour < end : hour >= start || hour < end;
 }
-async function guard_with_tombstones(safe, stream_info, correlation, tombstone2, skipped) {
-  const guarded = [];
-  const guard_events = /* @__PURE__ */ new Map();
-  await Promise.all(
-    safe.map(async (stream) => {
-      const info = stream_info.get(stream);
-      if (info.resumed_guard) {
-        guarded.push(stream);
-        guard_events.set(stream, { id: info.resumed_guard.id, stream });
-        return;
-      }
-      const committed = await tombstone2(stream, info.version, correlation);
-      if (committed) {
-        guarded.push(stream);
-        guard_events.set(stream, { id: committed.id, stream });
-      } else {
-        skipped.push(stream);
-      }
-    })
-  );
-  return { guarded, guard_events };
+function is_dst_gap_open(now, timeZone, start) {
+  const hour = hour_in_zone(now, timeZone);
+  if (hour <= start) return false;
+  const prev = hour_in_zone(new Date(now.getTime() - 36e5), timeZone);
+  return prev === start - 1 && hour === start + 1;
 }
-async function load_restart_seeds(guarded, target_map, stream_info, event_to_state, load2, logger) {
-  const seed_states = /* @__PURE__ */ new Map();
-  await Promise.all(
-    guarded.filter((s) => _optionalChain([target_map, 'access', _49 => _49.get, 'call', _50 => _50(s), 'optionalAccess', _51 => _51.restart])).map(async (stream) => {
-      const last_event_name = stream_info.get(stream).last_event_name;
-      const owner_state = event_to_state.get(last_event_name);
-      if (!owner_state) {
-        logger.error(
-          `Cannot seed restart for "${stream}": no registered state owns event "${last_event_name}". Stream will be tombstoned instead.`
-        );
-        return;
-      }
-      const snap2 = await load2(owner_state, { stream });
-      seed_states.set(stream, snap2.state);
-    })
-  );
-  return seed_states;
+function in_autoclose_window(window, now) {
+  if (!window) return true;
+  const hour = hour_in_zone(now, window.timeZone);
+  return hour_in_range(hour, window.start, window.end) || is_dst_gap_open(now, window.timeZone, window.start);
 }
-async function run_archive_callbacks(guarded, target_map) {
-  for (const stream of guarded) {
-    const archive_fn = _optionalChain([target_map, 'access', _52 => _52.get, 'call', _53 => _53(stream), 'optionalAccess', _54 => _54.archive]);
-    if (archive_fn) await archive_fn();
+function next_window_open(window, now) {
+  const start_ms = now.getTime();
+  for (let h = 0; h <= 48; h++) {
+    const candidate = new Date(start_ms + h * 36e5);
+    if (hour_in_zone(candidate, window.timeZone) === window.start)
+      return candidate;
+    const boundary = new Date(
+      candidate.getTime() - candidate.getTime() % 36e5
+    );
+    if (boundary.getTime() >= start_ms && is_dst_gap_open(boundary, window.timeZone, window.start))
+      return boundary;
   }
+  return new Date(start_ms + 864e5);
 }
-async function heads_still_guarded(guarded, guard_events, skipped) {
-  const heads = await _chunkPRDX3HP6cjs.store.call(void 0, ).query_stats(guarded, {});
-  return guarded.filter((stream) => {
-    if (_optionalChain([heads, 'access', _55 => _55.get, 'call', _56 => _56(stream), 'optionalAccess', _57 => _57.head, 'access', _58 => _58.id]) === guard_events.get(stream).id)
-      return true;
-    skipped.push(stream);
-    return false;
-  });
+
+// src/internal/defer-config.ts
+
+var DeferDurationSchema = _zod.z.object({
+  days: _zod.z.number().positive().optional(),
+  hours: _zod.z.number().positive().optional(),
+  minutes: _zod.z.number().positive().optional()
+}).strict().refine((d) => d.days != null || d.hours != null || d.minutes != null, {
+  message: "defer: a duration needs at least one of days, hours, or minutes"
+});
+var DeferWhenSchema = _zod.z.object({
+  after: DeferDurationSchema.optional(),
+  at: _zod.z.date().optional()
+}).strict().refine((w) => w.after === void 0 !== (w.at === void 0), {
+  message: "defer: specify exactly one of `after` or `at`"
+});
+function duration_ms(d) {
+  return (_nullishCoalesce(d.days, () => ( 0))) * 864e5 + (_nullishCoalesce(d.hours, () => ( 0))) * 36e5 + (_nullishCoalesce(d.minutes, () => ( 0))) * 6e4;
 }
-async function truncate_and_warm_cache(guarded, seed_states, guard_events, correlation) {
-  const trunc_targets = guarded.map((stream) => {
-    const snapshot = seed_states.get(stream);
-    const guard = guard_events.get(stream);
-    return {
-      stream,
-      snapshot,
-      meta: {
-        correlation,
-        causation: {
-          event: { id: guard.id, name: _chunkH6KVPVP4cjs.TOMBSTONE_EVENT, stream: guard.stream }
-        }
-      }
-    };
-  });
-  const truncated = await _chunkPRDX3HP6cjs.store.call(void 0, ).truncate(trunc_targets);
-  await Promise.all(
-    guarded.map(async (stream) => {
-      const entry = truncated.get(stream);
-      const state2 = seed_states.get(stream);
-      if (state2 && entry) {
-        await _chunkPRDX3HP6cjs.cache.call(void 0, ).set(stream, {
-          stream,
-          state: state2,
-          version: entry.committed.version,
-          event_id: entry.committed.id,
-          patches: 0,
-          snaps: 1
-        });
-      } else {
-        await _chunkPRDX3HP6cjs.cache.call(void 0, ).invalidate(stream);
-      }
-    })
-  );
-  return truncated;
+function resolve_defer_at(when, event) {
+  const parsed = DeferWhenSchema.parse(when);
+  if (parsed.after) return event.created.getTime() + duration_ms(parsed.after);
+  return parsed.at.getTime();
+}
+function assert_defer_when(when) {
+  DeferWhenSchema.parse(when);
+}
+function make_deferred(handler, schedule) {
+  const call = handler;
+  const deferred = async (event, stream, app) => {
+    const when = typeof schedule === "function" ? schedule(event) : schedule;
+    if (Date.now() < resolve_defer_at(when, event)) throw new (0, _chunkYFFWCVXWcjs.DeferSignal)(when);
+    return call(event, stream, app);
+  };
+  Object.defineProperty(deferred, "name", { value: handler.name });
+  return deferred;
 }
 
-// src/internal/correlate-cycle.ts
+// src/internal/drain-cycle.ts
 var _crypto = require('crypto');
 
-// src/internal/report-once.ts
-function report_once(seen, key, message) {
-  if (seen.has(key)) return;
-  seen.add(key);
-  _chunkPRDX3HP6cjs.log.call(void 0, ).error(new Error(message));
+// src/internal/backoff.ts
+function compute_backoff_delay(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;
+    default: {
+      const _never = opts.strategy;
+      throw new Error(`unknown backoff strategy: ${String(_never)}`);
+    }
+  }
+  if (opts.jitter) delay = delay * (0.5 + Math.random());
+  return Math.max(0, Math.floor(delay));
 }
 
-// src/internal/correlate-cycle.ts
-var COLD_START_BACK_SCAN = 1e4;
-var CORRELATION_LEASE_MS = 5e3;
-var registry_key = (events) => {
-  const shape = Object.keys(events).filter((name) => events[name].reactions.size > 0).sort().map((name) => [name, [...events[name].reactions.keys()].sort()]);
-  return _crypto.createHash.call(void 0, "sha256").update(JSON.stringify(shape)).digest("hex").slice(0, 32);
-};
-var PATTERN_CACHE_SIZE = 32;
-function report_undeclared_lane(seen, handler, target, lane, declared) {
-  report_once(
-    seen,
-    `lane|${handler}|${lane}`,
-    `Reaction "${handler}" resolved onto undeclared lane "${lane}" \u2014 for example target "${target}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. No controller claims it, so the stream would never drain \u2014 running it on "default" instead. The equivalent static \`.to({ lane })\` is rejected at build; a dynamic resolver's lane is only knowable here.`
-  );
-}
-function report_lane_conflict(seen, handler, target, kept, dropped) {
-  report_once(
-    seen,
-    `conflict|${handler}|${kept}|${dropped}`,
-    `Reaction "${handler}" resolved lane "${dropped}" for a stream already on "${kept}" \u2014 for example "${target}". These are conflicting lane assignments from two dynamic resolutions at equal priority. Keeping "${kept}", the lane it was first discovered on \u2014 re-laning a live stream would move it out from under a worker holding its lease. The reaction resolving "${dropped}" runs inside the "${kept}" lane's budget, and a process restricted to "${dropped}" via onlyLanes never runs it. The equivalent static declaration is rejected at build; align the resolvers, or split the target.`
-  );
-}
-var CorrelateCycle = (_class3 = class {
-  __init3() {this._checkpoint = -1}
-  // Lease holder id; per instance, so a restart never inherits a stale claim.
-  __init4() {this._by = _crypto.randomUUID.call(void 0, )}
-  
-  // Local expiry of the held lease (0 = none); stale only costs a duplicate scan.
-  __init5() {this._lease_until = 0}
-  // Armed while `_raised` (bumped by a commit or notification) is ahead of
-  // `_lowered` (the raise count the last short page saw). Starts armed.
-  __init6() {this._raised = 1}
-  __init7() {this._lowered = 0}
-  // Bumped by a release (shutdown), so a scan or lease reply that was out
-  // across one writes nothing.
-  __init8() {this._epoch = 0}
-  // Passes in flight: a restore waits for them, and refuses new ones.
-  __init9() {this._passes = /* @__PURE__ */ new Set()}
-  __init10() {this._restoring = false}
-  
-  // Bounded by `maxSubscribedStreams`; static records live apart so eviction
-  // never lets a resolution re-lane them.
-  
-  __init11() {this._static_subscriptions = /* @__PURE__ */ new Map()}
-  __init12() {this._patterns = new (0, _chunkPRDX3HP6cjs.LruMap)(PATTERN_CACHE_SIZE)}
-  
-  
-  
+// src/internal/defer-timer.ts
+var MAX_TIMER_DELAY_MS = 2147483647;
+var DeferTimer = (_class2 = class {
+  __init2() {this._due = /* @__PURE__ */ new Map()}
   
   
-  // Report-once keys; per instance because `internal/` holds no module state.
-  __init13() {this._reported = /* @__PURE__ */ new Set()}
-  constructor({
-    registry,
-    static_targets,
-    cd,
-    max_subscribed_streams,
-    declared_lanes,
-    shard,
-    on_init
-  }) {;_class3.prototype.__init3.call(this);_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);
-    this._key = shard ? `${registry_key(registry.events)}:${[...shard].sort().join(",")}` : registry_key(registry.events);
-    this._dynamic_subscriptions = new (0, _chunkPRDX3HP6cjs.LruMap)(max_subscribed_streams);
-    this._registry = registry;
-    this._declared_lanes = declared_lanes;
-    this._static_targets = static_targets;
-    this._cd = cd;
-    this._on_init = on_init;
-  }
-  get checkpoint() {
-    return this._checkpoint;
+  /**
+   * @param on_wake - invoked once each time the earliest due-time elapses.
+   *   The consumer re-schedules for whatever is still parked.
+   */
+  constructor(on_wake) {;_class2.prototype.__init2.call(this);
+    this._on_wake = on_wake;
   }
-  /** A commit (local or remote) may have produced uncorrelated events. */
-  arm() {
-    this._raised++;
+  /** Number of currently parked streams. */
+  get size() {
+    return this._due.size;
   }
-  async _init() {
-    this._init_promise ??= this._run_init().catch((error) => {
-      this._init_promise = void 0;
-      throw error;
-    });
-    await this._init_promise;
+  /**
+   * Park `stream` for a re-visit at `at` (ms since epoch). A plain
+   * overwrite: the caller computes the authoritative next-visit for the
+   * stream (the drain's `handle` already reconciles a stream's reactions
+   * into one result per cycle), so there is no stale value to merge against.
+   */
+  set(stream, at) {
+    this._due.set(stream, at);
   }
-  async _run_init() {
-    const { watermark, correlated_at } = await this._cd.subscribe([
-      ...this._static_targets
-    ]);
-    this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - COLD_START_BACK_SCAN);
-    for (const { stream, priority = 0, lane } of this._static_targets) {
-      this._static_subscriptions.set(stream, {
-        priority,
-        lane
-      });
-    }
-    await _optionalChain([this, 'access', _59 => _59._on_init, 'optionalCall', _60 => _60()]);
+  /** Drop `stream` from the parked set (e.g. on a successful ack or block). */
+  delete(stream) {
+    this._due.delete(stream);
   }
   /**
-   * Replace the log with no pass in flight, then cold-start: a pass that
-   * read the old log writes before the restore, never into the new one.
+   * Drop every entry due at or before `before`. The drain calls it when a
+   * pass that started at `before` claimed nothing: whatever was due by then
+   * was handled elsewhere (another worker) or has no work left, so waking
+   * for it again would spin.
    */
-  async restart(restore) {
-    this._restoring = true;
-    try {
-      await Promise.allSettled(this._passes);
-      await restore();
-    } finally {
-      this._restoring = false;
-    }
-    this._init_promise = void 0;
-    this._checkpoint = -1;
-    this._dynamic_subscriptions.clear();
-    this._static_subscriptions.clear();
-  }
-  /** Forget dynamic targets whose rows a full close deleted, so they re-subscribe. */
-  forget_subscribed(streams) {
-    for (const stream of streams) this._dynamic_subscriptions.delete(stream);
+  prune(before) {
+    for (const [stream, at] of this._due)
+      if (at <= before) this._due.delete(stream);
   }
-  // Would the target's own `fetch` (filtered by `source`) return this event?
-  _in_fetch_window(source, stream) {
-    if (source === void 0 || source === stream) return true;
-    if (_chunkPRDX3HP6cjs.is_literal_source.call(void 0, source)) return false;
-    let pattern = this._patterns.get(source);
-    if (!pattern) {
-      pattern = new RegExp(source);
-      this._patterns.set(source, pattern);
+  /**
+   * (Re)schedule the wake timer at the earliest pending due-time. Idempotent
+   * — collapses many parked streams into a single timer. A no-op clears any
+   * pending timer when the map is empty.
+   *
+   * The timer is `unref()`-ed so pending re-visits never keep the process
+   * alive on their own.
+   */
+  schedule() {
+    if (this._timer) clearTimeout(this._timer);
+    if (this._due.size === 0) {
+      this._timer = void 0;
+      return;
     }
-    return pattern.test(stream);
+    let earliest = Number.POSITIVE_INFINITY;
+    for (const t of this._due.values()) if (t < earliest) earliest = t;
+    const delay = Math.min(
+      Math.max(0, earliest - Date.now()),
+      MAX_TIMER_DELAY_MS
+    );
+    this._timer = setTimeout(() => {
+      this._timer = void 0;
+      this._on_wake();
+    }, delay);
+    this._timer.unref();
   }
-  /** Scan past the checkpoint, subscribe new targets and raise their work marks. */
-  async correlate(limit, lease = false) {
-    if (this._restoring) return { kind: "idle", last_id: this._checkpoint };
-    const pass = this._scan(limit, lease);
-    this._passes.add(pass);
-    try {
-      return await pass;
-    } finally {
-      this._passes.delete(pass);
+  /** Cancel any pending wake timer. Idempotent. Leaves the parked set intact. */
+  stop() {
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = void 0;
     }
   }
-  async _scan(limit, lease) {
-    await this._init();
-    const epoch = this._epoch;
-    const idle = () => ({
-      kind: "idle",
-      last_id: this._checkpoint
-    });
-    if (this._raised === this._lowered) return idle();
-    const raised = this._raised;
-    const now = Date.now();
-    if (lease && now >= this._lease_until - CORRELATION_LEASE_MS / 2) {
-      const { correlating } = await this._cd.subscribe([], void 0, {
-        key: this._key,
-        by: this._by,
-        millis: CORRELATION_LEASE_MS
-      });
-      if (this._epoch !== epoch) return idle();
-      this._lease_until = correlating ? now + CORRELATION_LEASE_MS : 0;
-      if (correlating === false) return idle();
-    }
-    const after = this._checkpoint;
-    const correlated = /* @__PURE__ */ new Map();
-    let last_id = after;
-    let stopped = false;
-    const found = await _chunkPRDX3HP6cjs.store.call(void 0, ).query(
-      (event) => {
-        if (stopped) return;
-        const register = this._registry.events[event.name];
-        if (register) {
-          for (const reaction of register.reactions.values()) {
-            let resolved;
-            try {
-              resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
-            } catch (error) {
-              stopped = true;
-              report_once(
-                this._reported,
-                `resolver|${reaction.handler.name}|${event.id}`,
-                `Resolver of reaction "${reaction.handler.name}" threw on ${String(event.name)} #${event.id} (stream "${event.stream}"): ${String(error)}. Correlation stops before this event until the resolver stops throwing; work already found keeps draining.`
-              );
-              return;
-            }
-            if (!resolved) continue;
-            let lane = resolved.lane;
-            if (lane !== void 0 && !this._declared_lanes.has(lane)) {
-              report_undeclared_lane(
-                this._reported,
-                reaction.handler.name,
-                resolved.target,
-                lane,
-                this._declared_lanes
-              );
-              lane = void 0;
-            }
-            const fixed = this._static_subscriptions.get(resolved.target);
-            const recorded = _nullishCoalesce(fixed, () => ( this._dynamic_subscriptions.get(resolved.target)));
-            const priority = _nullishCoalesce(resolved.priority, () => ( 0));
-            const upgraded = !recorded || !fixed && priority > recorded.priority;
-            const carried = upgraded ? { priority, lane } : { priority: recorded.priority, lane: recorded.lane };
-            const entry = correlated.get(resolved.target) || {
-              source: resolved.source,
-              priority: carried.priority,
-              lane: carried.lane,
-              upgraded,
-              missed: !recorded,
-              handler: reaction.handler.name,
-              correlated_at: void 0
-            };
-            const seen_in_scan = correlated.has(resolved.target);
-            const held_lane = _nullishCoalesce((seen_in_scan ? entry.lane : _optionalChain([recorded, 'optionalAccess', _61 => _61.lane])), () => ( _chunkH6KVPVP4cjs.DEFAULT_LANE));
-            const held_priority = seen_in_scan ? entry.priority : _optionalChain([recorded, 'optionalAccess', _62 => _62.priority]);
-            const resolved_lane = _nullishCoalesce(lane, () => ( _chunkH6KVPVP4cjs.DEFAULT_LANE));
-            if (held_priority === priority && held_lane !== resolved_lane)
-              report_lane_conflict(
-                this._reported,
-                reaction.handler.name,
-                resolved.target,
-                held_lane,
-                resolved_lane
-              );
-            if (carried.priority > entry.priority) {
-              entry.priority = carried.priority;
-              entry.lane = carried.lane;
-              entry.upgraded = upgraded;
-              entry.handler = reaction.handler.name;
-            }
-            if (this._in_fetch_window(resolved.source, event.stream))
-              entry.correlated_at = event.id;
-            correlated.set(resolved.target, entry);
-          }
-        }
-        last_id = event.id;
-      },
-      // Resolvers see `pii: null`: correlate runs actor-less, and one
-      // undecryptable row would otherwise stop every stream's reactions.
-      { after, limit, with_pii: false }
-    );
-    if (this._declared_lanes.size > 1) await this._recall(correlated);
-    const read = last_id > after;
-    if (this._epoch !== epoch) return idle();
-    const streams = [];
-    for (const [stream, entry] of correlated) {
-      if (entry.upgraded || entry.correlated_at !== void 0)
-        streams.push({
-          stream,
-          source: entry.source,
-          priority: entry.priority,
-          lane: entry.lane,
-          correlated_at: entry.correlated_at
-        });
-    }
-    if (streams.length) {
-      const renewed_at = Date.now();
-      const { subscribed, correlating } = await this._cd.subscribe(
-        streams,
-        last_id,
-        lease ? { key: this._key, by: this._by, millis: CORRELATION_LEASE_MS } : void 0
-      );
-      if (lease && correlating !== false)
-        this._lease_until = renewed_at + CORRELATION_LEASE_MS;
-      const marked = streams.filter(
-        (entry) => entry.correlated_at !== void 0
-      ).length;
-      this._checkpoint = last_id;
-      for (const { stream, priority, lane } of streams) {
-        if (_optionalChain([correlated, 'access', _63 => _63.get, 'call', _64 => _64(stream), 'optionalAccess', _65 => _65.upgraded]))
-          this._dynamic_subscriptions.set(stream, {
-            priority,
-            lane
-          });
-      }
-      return { kind: "scanned", last_id, subscribed, marked, read };
-    }
-    this._checkpoint = last_id;
-    if (!stopped && found !== limit) this._lowered = raised;
-    return { kind: "scanned", last_id, subscribed: 0, marked: 0, read };
+}, _class2);
+
+// src/internal/drain-ratio.ts
+var RATIO_MIN = 0.2;
+var RATIO_MAX = 0.8;
+var RATIO_DEFAULT = 0.5;
+function compute_lag_lead_ratio(handled, lagging, leading) {
+  let lagging_handled = 0;
+  let leading_handled = 0;
+  for (const { lease, handled: count } of handled) {
+    if (lease.lagging) lagging_handled += count;
+    else leading_handled += count;
   }
-  // Read the row of each target this scan had no record of (new or evicted),
-  // so a resolution that doesn't beat its priority keeps the row's lane.
-  // Only called with more than one lane declared.
-  async _recall(correlated) {
-    const missed = [...correlated].filter(([, entry]) => entry.missed);
-    await Promise.all(
-      missed.map(async ([stream, entry]) => {
-        let row;
-        await _chunkPRDX3HP6cjs.store.call(void 0, ).query_streams(
-          (position) => {
-            row = position;
-          },
-          { stream, stream_exact: true, limit: 1 }
-        );
-        if (!row) return;
-        this._dynamic_subscriptions.set(stream, {
-          priority: row.priority,
-          lane: row.lane
-        });
-        if (entry.priority > row.priority) return;
-        const held_lane = _nullishCoalesce(row.lane, () => ( _chunkH6KVPVP4cjs.DEFAULT_LANE));
-        const resolved_lane = _nullishCoalesce(entry.lane, () => ( _chunkH6KVPVP4cjs.DEFAULT_LANE));
-        if (entry.priority === row.priority && held_lane !== resolved_lane)
-          report_lane_conflict(
-            this._reported,
-            entry.handler,
-            stream,
-            held_lane,
-            resolved_lane
-          );
-        entry.priority = row.priority;
-        entry.lane = row.lane;
-        entry.upgraded = false;
-      })
-    );
-  }
-  /** Release the lease early by re-acquiring it for zero ms. Best-effort. */
-  async release_correlation() {
-    try {
-      this._lease_until = 0;
-      this._epoch++;
-      await this._cd.subscribe([], void 0, {
-        key: this._key,
-        by: this._by,
-        millis: 0
-      });
-    } catch (error) {
-      _chunkPRDX3HP6cjs.log.call(void 0, ).warn(
-        `Could not hand back the correlation lease during shutdown; it expires on its own within ${CORRELATION_LEASE_MS}ms and correlation resumes normally after that. On a single-writer store this usually means another connection holds the database. Cause: ${String(_nullishCoalesce(error.cause, () => ( error)))}`
-      );
-    }
-  }
-}, _class3);
+  const lagging_avg = lagging > 0 ? lagging_handled / lagging : 0;
+  const leading_avg = leading > 0 ? leading_handled / leading : 0;
+  const total = lagging_avg + leading_avg;
+  if (total === 0) return RATIO_DEFAULT;
+  return Math.max(RATIO_MIN, Math.min(RATIO_MAX, lagging_avg / total));
+}
+
+// src/internal/report-once.ts
+function report_once(seen, key, message) {
+  if (seen.has(key)) return;
+  seen.add(key);
+  _chunkLUHPSF3Ccjs.log.call(void 0, ).error(new Error(message));
+}
 
 // src/internal/correlation-id.ts
 
@@ -1490,136 +1127,15 @@ function close_correlation(correlator, actor) {
   });
 }
 
-// src/internal/drain-cycle.ts
-
-
-// src/internal/backoff.ts
-function compute_backoff_delay(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;
-    default: {
-      const _never = opts.strategy;
-      throw new Error(`unknown backoff strategy: ${String(_never)}`);
-    }
-  }
-  if (opts.jitter) delay = delay * (0.5 + Math.random());
-  return Math.max(0, Math.floor(delay));
-}
-
-// src/internal/defer-timer.ts
-var MAX_TIMER_DELAY_MS = 2147483647;
-var DeferTimer = (_class4 = class {
-  __init14() {this._due = /* @__PURE__ */ new Map()}
-  
-  
-  /**
-   * @param on_wake - invoked once each time the earliest due-time elapses.
-   *   The consumer re-schedules for whatever is still parked.
-   */
-  constructor(on_wake) {;_class4.prototype.__init14.call(this);
-    this._on_wake = on_wake;
-  }
-  /** Number of currently parked streams. */
-  get size() {
-    return this._due.size;
-  }
-  /**
-   * Park `stream` for a re-visit at `at` (ms since epoch). A plain
-   * overwrite: the caller computes the authoritative next-visit for the
-   * stream (the drain's `handle` already reconciles a stream's reactions
-   * into one result per cycle), so there is no stale value to merge against.
-   */
-  set(stream, at) {
-    this._due.set(stream, at);
-  }
-  /** Drop `stream` from the parked set (e.g. on a successful ack or block). */
-  delete(stream) {
-    this._due.delete(stream);
-  }
-  /**
-   * Drop every entry due at or before `before`. The drain calls it when a
-   * pass that started at `before` claimed nothing: whatever was due by then
-   * was handled elsewhere (another worker) or has no work left, so waking
-   * for it again would spin.
-   */
-  prune(before) {
-    for (const [stream, at] of this._due)
-      if (at <= before) this._due.delete(stream);
-  }
-  /**
-   * (Re)schedule the wake timer at the earliest pending due-time. Idempotent
-   * — collapses many parked streams into a single timer. A no-op clears any
-   * pending timer when the map is empty.
-   *
-   * The timer is `unref()`-ed so pending re-visits never keep the process
-   * alive on their own.
-   */
-  schedule() {
-    if (this._timer) clearTimeout(this._timer);
-    if (this._due.size === 0) {
-      this._timer = void 0;
-      return;
-    }
-    let earliest = Number.POSITIVE_INFINITY;
-    for (const t of this._due.values()) if (t < earliest) earliest = t;
-    const delay = Math.min(
-      Math.max(0, earliest - Date.now()),
-      MAX_TIMER_DELAY_MS
-    );
-    this._timer = setTimeout(() => {
-      this._timer = void 0;
-      this._on_wake();
-    }, delay);
-    this._timer.unref();
-  }
-  /** Cancel any pending wake timer. Idempotent. Leaves the parked set intact. */
-  stop() {
-    if (this._timer) {
-      clearTimeout(this._timer);
-      this._timer = void 0;
-    }
-  }
-}, _class4);
-
-// src/internal/drain-ratio.ts
-var RATIO_MIN = 0.2;
-var RATIO_MAX = 0.8;
-var RATIO_DEFAULT = 0.5;
-function compute_lag_lead_ratio(handled, lagging, leading) {
-  let lagging_handled = 0;
-  let leading_handled = 0;
-  for (const { lease, handled: count } of handled) {
-    if (lease.lagging) lagging_handled += count;
-    else leading_handled += count;
-  }
-  const lagging_avg = lagging > 0 ? lagging_handled / lagging : 0;
-  const leading_avg = leading > 0 ? leading_handled / leading : 0;
-  const total = lagging_avg + leading_avg;
-  if (total === 0) return RATIO_DEFAULT;
-  return Math.max(RATIO_MIN, Math.min(RATIO_MAX, lagging_avg / total));
-}
-
 // src/internal/drain-ops.ts
-var claim = (lagging, leading, by, millis, lane) => _chunkPRDX3HP6cjs.store.call(void 0, ).claim(lagging, leading, by, millis, lane);
+var claim = (lagging, leading, by, millis, lane) => _chunkLUHPSF3Ccjs.store.call(void 0, ).claim(lagging, leading, by, millis, lane);
 async function fetch(leased, eventLimit) {
   return Promise.all(
     leased.map(async ({ stream, source, at, lagging }) => {
       const events = [];
-      const stream_exact = source !== void 0 && _chunkPRDX3HP6cjs.is_literal_source.call(void 0, source) ? true : void 0;
+      const stream_exact = source !== void 0 && _chunkLUHPSF3Ccjs.is_literal_source.call(void 0, source, stream) ? true : void 0;
       try {
-        await _chunkPRDX3HP6cjs.store.call(void 0, ).query((e) => events.push(e), {
+        await _chunkLUHPSF3Ccjs.store.call(void 0, ).query((e) => events.push(e), {
           stream: source,
           stream_exact,
           after: at,
@@ -1632,23 +1148,23 @@ async function fetch(leased, eventLimit) {
           at,
           lagging,
           events: [],
-          error: _nullishCoalesce(_optionalChain([error, 'optionalAccess', _66 => _66.message]), () => ( String(error)))
+          error: _nullishCoalesce(_optionalChain([error, 'optionalAccess', _51 => _51.message]), () => ( String(error)))
         };
       }
       return { stream, source, at, lagging, events };
     })
   );
 }
-var ack = (leases) => _chunkPRDX3HP6cjs.store.call(void 0, ).ack(leases);
-var block = (leases) => _chunkPRDX3HP6cjs.store.call(void 0, ).block(leases);
-var subscribe = (streams, correlated_at, correlator) => _chunkPRDX3HP6cjs.store.call(void 0, ).subscribe(streams, correlated_at, correlator);
+var ack = (leases) => _chunkLUHPSF3Ccjs.store.call(void 0, ).ack(leases);
+var block = (leases) => _chunkLUHPSF3Ccjs.store.call(void 0, ).block(leases);
+var subscribe = (streams, correlated_at, correlator) => _chunkLUHPSF3Ccjs.store.call(void 0, ).subscribe(streams, correlated_at, correlator);
 
 // src/internal/event-sourcing.ts
 var _actpatch = require('@rotorsoft/act-patch');
-var _zod = require('zod');
+
 var bare_patch = (_me, state2, partial) => _actpatch.patch.call(void 0, state2, partial);
 var value_at = (value, path) => path.reduce(
-  (at, key) => _optionalChain([at, 'optionalAccess', _67 => _67[key]]),
+  (at, key) => _optionalChain([at, 'optionalAccess', _52 => _52[key]]),
   value
 );
 var check_invariants = (target, state2, schema, pii_aware) => {
@@ -1656,29 +1172,29 @@ var check_invariants = (target, state2, schema, pii_aware) => {
   try {
     result = schema.safeParse(state2);
   } catch (error) {
-    throw new (0, _chunkH6KVPVP4cjs.ValidationError)(target, state2, error);
+    throw new (0, _chunkYFFWCVXWcjs.ValidationError)(target, state2, error);
   }
   if (result.success) return;
   const issues = pii_aware ? result.error.issues.filter((issue) => {
     const value = value_at(state2, issue.path);
-    return value !== _chunkH6KVPVP4cjs.REDACTED && value !== _chunkH6KVPVP4cjs.SHREDDED;
+    return value !== _chunkYFFWCVXWcjs.REDACTED && value !== _chunkYFFWCVXWcjs.SHREDDED;
   }) : result.error.issues;
   if (issues.length)
-    throw new (0, _chunkH6KVPVP4cjs.ValidationError)(
+    throw new (0, _chunkYFFWCVXWcjs.ValidationError)(
       target,
       state2,
       _zod.prettifyError.call(void 0, new (0, _zod.ZodError)(issues))
     );
 };
 var DEFAULT_BATCH = 500;
-var cache_put = (stream, entry) => _chunkPRDX3HP6cjs.cache.call(void 0, ).set(stream, entry).catch(
-  (err) => _chunkPRDX3HP6cjs.log.call(void 0, ).warn(
+var cache_put = (stream, entry) => _chunkLUHPSF3Ccjs.cache.call(void 0, ).set(stream, entry).catch(
+  (err) => _chunkLUHPSF3Ccjs.log.call(void 0, ).warn(
     err,
     "cache set skipped; the next load re-folds from the store"
   )
 );
-var cache_drop = (stream) => _chunkPRDX3HP6cjs.cache.call(void 0, ).invalidate(stream).catch(
-  (err) => _chunkPRDX3HP6cjs.log.call(void 0, ).warn(
+var cache_drop = (stream) => _chunkLUHPSF3Ccjs.cache.call(void 0, ).invalidate(stream).catch(
+  (err) => _chunkLUHPSF3Ccjs.log.call(void 0, ).warn(
     err,
     "cache invalidate skipped; a stale checkpoint re-folds from its event_id"
   )
@@ -1686,35 +1202,43 @@ var cache_drop = (stream) => _chunkPRDX3HP6cjs.cache.call(void 0, ).invalidate(s
 async function snap(snapshot) {
   const { id, stream, name, meta, version } = snapshot.event;
   try {
-    const [committed] = await _chunkPRDX3HP6cjs.store.call(void 0, ).commit(
-      stream,
-      [{ name: _chunkH6KVPVP4cjs.SNAP_EVENT, data: snapshot.state }],
+    const [committed] = await _chunkLUHPSF3Ccjs.store.call(void 0, ).commit(
+      [
+        {
+          stream,
+          msgs: [{ name: _chunkYFFWCVXWcjs.SNAP_EVENT, data: snapshot.state }],
+          // IMPORTANT! - state events are committed right after the snapshot event
+          expectedVersion: version
+        }
+      ],
       {
         correlation: meta.correlation,
         causation: { event: { id, name, stream } }
-      },
-      version
-      // IMPORTANT! - state events are committed right after the snapshot event
+      }
     );
     return committed;
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
-    _chunkPRDX3HP6cjs.log.call(void 0, ).warn(
+    _chunkLUHPSF3Ccjs.log.call(void 0, ).warn(
       `Snapshot write failed on stream "${stream}": ${reason} \u2014 cold starts will replay full history until snapshots succeed.`
     );
   }
 }
 async function tombstone(stream, expectedVersion, correlation) {
   try {
-    const [committed] = await _chunkPRDX3HP6cjs.store.call(void 0, ).commit(
-      stream,
-      [{ name: _chunkH6KVPVP4cjs.TOMBSTONE_EVENT, data: {} }],
-      { correlation, causation: {} },
-      expectedVersion
+    const [committed] = await _chunkLUHPSF3Ccjs.store.call(void 0, ).commit(
+      [
+        {
+          stream,
+          msgs: [{ name: _chunkYFFWCVXWcjs.TOMBSTONE_EVENT, data: {} }],
+          expectedVersion
+        }
+      ],
+      { correlation, causation: {} }
     );
     return committed;
   } catch (error) {
-    if (error instanceof _chunkH6KVPVP4cjs.ConcurrencyError) return void 0;
+    if (error instanceof _chunkYFFWCVXWcjs.ConcurrencyError) return void 0;
     throw error;
   }
 }
@@ -1744,9 +1268,9 @@ async function scan(source, opts = {}, callback) {
   if (drop_closed_streams) {
     await source.query(
       (e) => {
-        if (e.name === _chunkH6KVPVP4cjs.TOMBSTONE_EVENT) closed_streams.add(e.stream);
+        if (e.name === _chunkYFFWCVXWcjs.TOMBSTONE_EVENT) closed_streams.add(e.stream);
       },
-      { names: [_chunkH6KVPVP4cjs.TOMBSTONE_EVENT] }
+      { names: [_chunkYFFWCVXWcjs.TOMBSTONE_EVENT] }
     );
   }
   let max_id;
@@ -1768,16 +1292,16 @@ async function scan(source, opts = {}, callback) {
         if (!is_valid(event))
           throw new Error(`Invalid event at index ${processed}`);
         if (on_progress) on_progress({ processed, id: event.id, max_id });
-        if (drop_snapshots && event.name === _chunkH6KVPVP4cjs.SNAP_EVENT) {
+        if (drop_snapshots && event.name === _chunkYFFWCVXWcjs.SNAP_EVENT) {
           dropped_snaps++;
           return;
         }
-        if (closed_streams.has(event.stream) && event.name !== _chunkH6KVPVP4cjs.TOMBSTONE_EVENT) {
+        if (closed_streams.has(event.stream) && event.name !== _chunkYFFWCVXWcjs.TOMBSTONE_EVENT) {
           dropped_closed++;
           return;
         }
         let migrated = event;
-        const migration = _optionalChain([event_migrations, 'optionalAccess', _68 => _68[event.name]]);
+        const migration = _optionalChain([event_migrations, 'optionalAccess', _53 => _53[event.name]]);
         if (migration) {
           const old_data = migration.from_schema.parse(event.data);
           const new_data = migration.migrate(old_data);
@@ -1799,7 +1323,7 @@ async function scan(source, opts = {}, callback) {
           return;
         }
         let remapped = migrated;
-        const caused_by = _optionalChain([migrated, 'access', _69 => _69.meta, 'access', _70 => _70.causation, 'access', _71 => _71.event, 'optionalAccess', _72 => _72.id]);
+        const caused_by = _optionalChain([migrated, 'access', _54 => _54.meta, 'access', _55 => _55.causation, 'access', _56 => _56.event, 'optionalAccess', _57 => _57.id]);
         if (caused_by !== void 0) {
           const new_caused_by = id_map.get(caused_by);
           if (new_caused_by !== void 0 && new_caused_by !== caused_by) {
@@ -1840,18 +1364,18 @@ async function load(me, target, callback, patch_fn = bare_patch) {
   const { stream, actor, asOf } = target;
   const time_travel = !!asOf && Object.values(asOf).some((v) => v !== void 0);
   const seeded = time_travel && asOf.limit === void 0 && !asOf.created_after;
-  const cached = time_travel ? void 0 : await _chunkPRDX3HP6cjs.cache.call(void 0, ).get(stream);
+  const cached = time_travel ? void 0 : await _chunkLUHPSF3Ccjs.cache.call(void 0, ).get(stream);
   const cache_hit = !!cached;
-  let state2 = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _73 => _73.state]), () => ( (me.init ? me.init() : {})));
-  let patches = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _74 => _74.patches]), () => ( 0));
-  let snaps = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _75 => _75.snaps]), () => ( 0));
+  let state2 = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _58 => _58.state]), () => ( (me.init ? me.init() : {})));
+  let patches = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _59 => _59.patches]), () => ( 0));
+  let snaps = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _60 => _60.snaps]), () => ( 0));
   let replayed = 0;
   let event;
-  await _chunkPRDX3HP6cjs.store.call(void 0, ).query(
+  await _chunkLUHPSF3Ccjs.store.call(void 0, ).query(
     (raw) => {
-      if (seeded && raw.name === _chunkH6KVPVP4cjs.SNAP_EVENT && replayed > 0) return;
+      if (seeded && raw.name === _chunkYFFWCVXWcjs.SNAP_EVENT && replayed > 0) return;
       event = me.view(raw, actor);
-      if (event.name === _chunkH6KVPVP4cjs.SNAP_EVENT) {
+      if (event.name === _chunkYFFWCVXWcjs.SNAP_EVENT) {
         state2 = event.data;
         snaps++;
         patches = 0;
@@ -1860,12 +1384,12 @@ async function load(me, target, callback, patch_fn = bare_patch) {
         state2 = patch_fn(me, state2, me.patch[event.name](event, state2), event);
         patches++;
         replayed++;
-      } else if (event.name !== _chunkH6KVPVP4cjs.TOMBSTONE_EVENT) {
-        _chunkPRDX3HP6cjs.log.call(void 0, ).warn(
+      } else if (event.name !== _chunkYFFWCVXWcjs.TOMBSTONE_EVENT) {
+        _chunkLUHPSF3Ccjs.log.call(void 0, ).warn(
           `Skipping unknown event "${String(event.name)}" on stream "${stream}" (id=${event.id}) \u2014 no reducer in state "${me.name}"`
         );
       }
-      _optionalChain([callback, 'optionalCall', _76 => _76({
+      _optionalChain([callback, 'optionalCall', _61 => _61({
         event,
         state: state2,
         version: event.version,
@@ -1889,7 +1413,7 @@ async function load(me, target, callback, patch_fn = bare_patch) {
       ) : time_travel ? asOf : { with_snaps: true }
     }
   );
-  const head_is_tombstone = _optionalChain([event, 'optionalAccess', _77 => _77.name]) === _chunkH6KVPVP4cjs.TOMBSTONE_EVENT;
+  const head_is_tombstone = _optionalChain([event, 'optionalAccess', _62 => _62.name]) === _chunkYFFWCVXWcjs.TOMBSTONE_EVENT;
   if (replayed > 0 && !time_travel && event && !me.pii_aware && !head_is_tombstone) {
     await cache_put(stream, {
       stream,
@@ -1903,23 +1427,56 @@ async function load(me, target, callback, patch_fn = bare_patch) {
   return {
     event,
     state: state2,
-    version: _nullishCoalesce(_nullishCoalesce(_optionalChain([event, 'optionalAccess', _78 => _78.version]), () => ( _optionalChain([cached, 'optionalAccess', _79 => _79.version]))), () => ( -1)),
+    version: _nullishCoalesce(_nullishCoalesce(_optionalChain([event, 'optionalAccess', _63 => _63.version]), () => ( _optionalChain([cached, 'optionalAccess', _64 => _64.version]))), () => ( -1)),
     // Captured with `state`, so consumers never race a separate cache lookup.
-    id: _nullishCoalesce(_nullishCoalesce(_optionalChain([event, 'optionalAccess', _80 => _80.id]), () => ( _optionalChain([cached, 'optionalAccess', _81 => _81.event_id]))), () => ( -1)),
+    id: _nullishCoalesce(_nullishCoalesce(_optionalChain([event, 'optionalAccess', _65 => _65.id]), () => ( _optionalChain([cached, 'optionalAccess', _66 => _66.event_id]))), () => ( -1)),
     patches,
     snaps,
     cache_hit,
     replayed
   };
 }
+async function load_others(loads, payload, own, actor, patch_fn, refuse) {
+  const streams = loads.map((l) => l.target(payload, own.state));
+  streams.forEach((stream, i) => {
+    if (stream === void 0) return;
+    if (typeof stream !== "string" || !stream)
+      throw refuse(`loads "${loads[i].name}" from an empty stream name`);
+    if (stream === own.stream) throw refuse(`loads its own stream "${stream}"`);
+    if (streams.indexOf(stream) !== i)
+      throw refuse(`loads stream "${stream}" twice`);
+  });
+  return Promise.all(
+    loads.map(async (l, i) => {
+      const stream = streams[i];
+      if (stream === void 0) return void 0;
+      const snapshot = await load(
+        l.state,
+        { stream, actor },
+        void 0,
+        patch_fn
+      );
+      if (_optionalChain([snapshot, 'access', _67 => _67.event, 'optionalAccess', _68 => _68.name]) === _chunkYFFWCVXWcjs.TOMBSTONE_EVENT)
+        throw new (0, _chunkYFFWCVXWcjs.StreamClosedError)(stream);
+      return {
+        state: l.state,
+        stream,
+        snapshot,
+        expected: snapshot.version,
+        events: []
+      };
+    })
+  );
+}
 async function action(me, action2, target, payload, options, patch_fn = bare_patch) {
   const { stream, expectedVersion, actor } = target;
   if (!stream) throw new Error("Missing target stream");
-  const reactingTo = _optionalChain([options, 'optionalAccess', _82 => _82.reactingTo]);
-  const correlator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _83 => _83.correlator]), () => ( default_correlator));
-  const validated = _chunkPRDX3HP6cjs.validate.call(void 0, action2, payload, me.actions[action2]);
-  const opts = _optionalChain([me, 'access', _84 => _84.options, 'optionalAccess', _85 => _85[action2]]);
-  const max_retries = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _86 => _86.maxRetries]), () => ( 0));
+  const reactingTo = _optionalChain([options, 'optionalAccess', _69 => _69.reactingTo]);
+  const correlator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _70 => _70.correlator]), () => ( default_correlator));
+  const validated = _chunkLUHPSF3Ccjs.validate.call(void 0, action2, payload, me.actions[action2]);
+  const opts = _optionalChain([me, 'access', _71 => _71.options, 'optionalAccess', _72 => _72[action2]]);
+  const max_retries = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _73 => _73.maxRetries]), () => ( 0));
+  const loads = _nullishCoalesce(_optionalChain([me, 'access', _74 => _74.loads, 'optionalAccess', _75 => _75[action2]]), () => ( []));
   for (let attempt = 0; ; attempt++) {
     try {
       const snapshot = await load(
@@ -1928,38 +1485,68 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
         void 0,
         patch_fn
       );
-      if (_optionalChain([snapshot, 'access', _87 => _87.event, 'optionalAccess', _88 => _88.name]) === _chunkH6KVPVP4cjs.TOMBSTONE_EVENT)
-        throw new (0, _chunkH6KVPVP4cjs.StreamClosedError)(stream);
-      const expected = _nullishCoalesce(expectedVersion, () => ( snapshot.version));
-      for (const { valid, description } of _nullishCoalesce(_optionalChain([me, 'access', _89 => _89.given, 'optionalAccess', _90 => _90[action2]]), () => ( [])))
-        if (!valid(snapshot.state, actor))
-          throw new (0, _chunkH6KVPVP4cjs.InvariantError)(
-            action2,
-            validated,
-            target,
-            snapshot,
-            description
-          );
-      for (const { holds, description } of _nullishCoalesce(_optionalChain([me, 'access', _91 => _91.requires, 'optionalAccess', _92 => _92[action2]]), () => ( [])))
-        if (!holds(validated, snapshot.state, actor))
-          throw new (0, _chunkH6KVPVP4cjs.PreconditionError)(
+      if (_optionalChain([snapshot, 'access', _76 => _76.event, 'optionalAccess', _77 => _77.name]) === _chunkYFFWCVXWcjs.TOMBSTONE_EVENT)
+        throw new (0, _chunkYFFWCVXWcjs.StreamClosedError)(stream);
+      const own = {
+        state: me,
+        stream,
+        snapshot,
+        expected: _nullishCoalesce(expectedVersion, () => ( snapshot.version)),
+        events: []
+      };
+      const others = loads.length ? await load_others(
+        loads,
+        validated,
+        { stream, state: snapshot.state },
+        target.actor,
+        patch_fn,
+        (description) => new (0, _chunkYFFWCVXWcjs.PreconditionError)(
+          action2,
+          validated,
+          target,
+          snapshot,
+          description
+        )
+      ) : [];
+      const loaded = Object.fromEntries(
+        others.map((p, i) => [loads[i].name, _optionalChain([p, 'optionalAccess', _78 => _78.snapshot, 'access', _79 => _79.state])])
+      );
+      for (const { holds, description } of _nullishCoalesce(_optionalChain([me, 'access', _80 => _80.requires, 'optionalAccess', _81 => _81[action2]]), () => ( [])))
+        if (!holds(validated, snapshot.state, actor, loaded))
+          throw new (0, _chunkYFFWCVXWcjs.PreconditionError)(
             action2,
             validated,
             target,
             snapshot,
             description
           );
-      const result = me.on[action2](validated, snapshot, target);
+      const result = me.on[action2](validated, snapshot, target, loaded);
       if (!result || Array.isArray(result) && !result.length)
         return [snapshot];
       const tuples = Array.isArray(result[0]) ? result : [result];
-      const events = tuples.map(([name, data]) => ({
-        name,
-        data: _chunkPRDX3HP6cjs.validate.call(void 0, name, data, me.events[name])
-      }));
-      const emitted = events.map((e) => me.message(e));
+      for (const [name, data] of tuples) {
+        const event = name;
+        const i = loads.findIndex((l) => l.events.includes(event));
+        if (i >= 0 && !others[i]) continue;
+        const to = i >= 0 ? others[i] : name in me.events ? own : void 0;
+        if (!to)
+          throw new Error(
+            `Action "${action2}" emitted "${event}", which isn't an event of "${me.name}" and isn't listed on any of its loads`
+          );
+        to.events.push({
+          name: event,
+          data: _chunkLUHPSF3Ccjs.validate.call(void 0, event, data, to.state.events[event])
+        });
+      }
+      if (!own.events.length)
+        throw new Error(
+          `Action "${action2}" appends only to the streams it loads; it must append an event to its own stream too`
+        );
+      const appends = [own, ...others].filter(
+        (p) => !!_optionalChain([p, 'optionalAccess', _82 => _82.events, 'access', _83 => _83.length])
+      );
       const meta = {
-        correlation: _optionalChain([reactingTo, 'optionalAccess', _93 => _93.meta, 'access', _94 => _94.correlation]) || correlator({
+        correlation: _optionalChain([reactingTo, 'optionalAccess', _84 => _84.meta, 'access', _85 => _85.correlation]) || correlator({
           action: action2,
           state: me.name,
           stream,
@@ -1978,72 +1565,97 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
           } : void 0
         }
       };
-      let { state: state2, patches } = snapshot;
       const created = /* @__PURE__ */ new Date();
-      const folded = events.map((e, i) => {
-        const event = {
-          ...e,
-          id: -1,
-          stream,
-          version: snapshot.version + i + 1,
-          created,
-          meta
-        };
-        const patch2 = me.patch[event.name](event, state2);
-        state2 = patch_fn(me, state2, patch2, event);
-        patches++;
-        return { state: state2, patch: patch2, patches };
+      const folds = appends.map((p) => {
+        let { state: state2, patches } = p.snapshot;
+        const folded = p.events.map((e, i) => {
+          const event = {
+            ...e,
+            id: -1,
+            stream: p.stream,
+            version: p.snapshot.version + i + 1,
+            created,
+            meta
+          };
+          const patch2 = p.state.patch[event.name](event, state2);
+          state2 = patch_fn(p.state, state2, patch2, event);
+          patches++;
+          return { state: state2, patch: patch2, patches };
+        });
+        check_invariants(
+          `${p.state.name}.${action2}`,
+          state2,
+          p.state.state,
+          p.state.pii_aware
+        );
+        return folded;
       });
-      check_invariants(
-        `${me.name}.${action2}`,
-        state2,
-        me.state,
-        me.pii_aware
-      );
       let committed;
       try {
-        committed = await _chunkPRDX3HP6cjs.store.call(void 0, ).commit(stream, emitted, meta, expected);
+        committed = await _chunkLUHPSF3Ccjs.store.call(void 0, ).commit(
+          appends.map((p) => ({
+            stream: p.stream,
+            msgs: p.events.map((e) => p.state.message(e)),
+            expectedVersion: p.expected
+          })),
+          meta
+        );
       } catch (error) {
-        if (error instanceof _chunkH6KVPVP4cjs.ConcurrencyError) void cache_drop(stream);
+        if (error instanceof _chunkYFFWCVXWcjs.ConcurrencyError) void cache_drop(error.stream);
         throw error;
       }
-      const snapshots = committed.map((row, i) => ({
-        event: { ...row, data: events[i].data },
-        state: folded[i].state,
-        version: row.version,
-        id: row.id,
-        patches: folded[i].patches,
-        snaps: snapshot.snaps,
-        patch: folded[i].patch,
-        cache_hit: snapshot.cache_hit,
-        replayed: snapshot.replayed
-      }));
-      const last = snapshots.at(-1);
-      const snap_event = _optionalChain([me, 'access', _95 => _95.snap, 'optionalCall', _96 => _96(last)]) ? await snap(last) : void 0;
-      if (!me.pii_aware)
-        void cache_put(stream, {
-          stream,
-          state: last.state,
-          version: _nullishCoalesce(_optionalChain([snap_event, 'optionalAccess', _97 => _97.version]), () => ( last.event.version)),
-          event_id: _nullishCoalesce(_optionalChain([snap_event, 'optionalAccess', _98 => _98.id]), () => ( last.event.id)),
-          patches: snap_event ? 0 : last.patches,
-          snaps: snap_event ? last.snaps + 1 : last.snaps
+      let row = 0;
+      const snapshots = [];
+      for (const [a, append] of appends.entries()) {
+        const { snapshot: base, state: owner } = append;
+        const appended = append.events.map((e, i) => {
+          const stored = committed[row++];
+          const fold = folds[a][i];
+          return {
+            event: { ...stored, data: e.data },
+            state: fold.state,
+            version: stored.version,
+            id: stored.id,
+            patches: fold.patches,
+            snaps: base.snaps,
+            patch: fold.patch,
+            cache_hit: base.cache_hit,
+            replayed: base.replayed
+          };
         });
+        const last = appended.at(-1);
+        const snap_event = _optionalChain([owner, 'access', _86 => _86.snap, 'optionalCall', _87 => _87(last)]) ? await snap(last) : void 0;
+        if (!owner.pii_aware)
+          void cache_put(append.stream, {
+            stream: append.stream,
+            state: last.state,
+            version: _nullishCoalesce(_optionalChain([snap_event, 'optionalAccess', _88 => _88.version]), () => ( last.event.version)),
+            event_id: _nullishCoalesce(_optionalChain([snap_event, 'optionalAccess', _89 => _89.id]), () => ( last.event.id)),
+            patches: snap_event ? 0 : last.patches,
+            snaps: snap_event ? last.snaps + 1 : last.snaps
+          });
+        if (snap_event)
+          appended[appended.length - 1] = {
+            ...last,
+            version: snap_event.version
+          };
+        snapshots.push(...appended);
+      }
       return snapshots;
     } catch (error) {
-      if (!(error instanceof _chunkH6KVPVP4cjs.ConcurrencyError)) throw error;
-      if (expectedVersion !== void 0) throw error;
+      if (!(error instanceof _chunkYFFWCVXWcjs.ConcurrencyError)) throw error;
+      if (expectedVersion !== void 0 && error.stream === stream) throw error;
       if (attempt >= max_retries) throw error;
-      if (_optionalChain([opts, 'optionalAccess', _99 => _99.backoff])) {
+      if (_optionalChain([opts, 'optionalAccess', _90 => _90.backoff])) {
         const delay_ms = compute_backoff_delay(attempt, opts.backoff);
-        if (delay_ms > 0) await _chunkPRDX3HP6cjs.sleep.call(void 0, delay_ms);
+        if (delay_ms > 0) await _chunkLUHPSF3Ccjs.sleep.call(void 0, delay_ms);
       }
     }
   }
 }
 
 // src/internal/tracing.ts
-var PRETTY = _chunkPRDX3HP6cjs.config.call(void 0, ).env !== "production";
+var PRETTY = _chunkLUHPSF3Ccjs.config.call(void 0, ).env !== "production";
 var C_BLUE = "\x1B[38;5;39m";
 var C_ORANGE = "\x1B[38;5;208m";
 var C_GREEN = "\x1B[38;5;42m";
@@ -2089,9 +1701,9 @@ var as_of_marker = (asOf) => {
   return parts.length ? ` (as-of ${parts.join(" ")})` : " (as-of)";
 };
 var traced = (inner, exit, entry) => (async (...args) => {
-  _optionalChain([entry, 'optionalCall', _100 => _100(...args)]);
+  _optionalChain([entry, 'optionalCall', _91 => _91(...args)]);
   const result = await inner(...args);
-  _optionalChain([exit, 'optionalCall', _101 => _101(result, ...args)]);
+  _optionalChain([exit, 'optionalCall', _92 => _92(result, ...args)]);
   return result;
 });
 function build_es(logger, correlator = default_correlator, patch_fn = bare_patch) {
@@ -2100,7 +1712,7 @@ function build_es(logger, correlator = default_correlator, patch_fn = bare_patch
     action_name,
     target,
     payload,
-    { ...options, correlator: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _102 => _102.correlator]), () => ( correlator)) },
+    { ...options, correlator: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _93 => _93.correlator]), () => ( correlator)) },
     patch_fn
   );
   const bound_load = (me, target, callback) => load(me, target, callback, patch_fn);
@@ -2139,14 +1751,14 @@ function build_es(logger, correlator = default_correlator, patch_fn = bare_patch
     }),
     action: traced(
       bound_action,
-      (snapshots, _me, _action, target) => {
+      (snapshots) => {
         if (snapshots[0].patch)
           logger.trace(
             snapshots.map((s) => s.event.data),
             es_caption(
               "committed",
               C_ORANGE,
-              `${target.stream}.${snapshots.map((s) => s.event.name).join(", ")}`
+              snapshots.map((s) => `${s.event.stream}.${s.event.name}`).join(", ")
             )
           );
       },
@@ -2174,7 +1786,7 @@ function build_drain(logger) {
     subscribe: logger.level !== "trace" ? subscribe : traced(subscribe, (result, streams) => {
       if (!result.subscribed) return;
       const lanes = new Set(streams.map((s) => _nullishCoalesce(s.lane, () => ( "default"))));
-      const uniform_lane = lanes.size === 1 ? _optionalChain([streams, 'access', _103 => _103[0], 'optionalAccess', _104 => _104.lane]) : void 0;
+      const uniform_lane = lanes.size === 1 ? _optionalChain([streams, 'access', _94 => _94[0], 'optionalAccess', _95 => _95.lane]) : void 0;
       const data = streams.map(
         ({ stream, lane }) => uniform_lane || !lane || lane === "default" ? hue(C_STREAM, stream) : `${hue(C_STREAM, stream)}${dim(`[${lane}]`)}`
       ).join(" ");
@@ -2186,7 +1798,7 @@ function build_drain(logger) {
 }
 function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
   if (logger.level !== "trace" || !leased.length) return;
-  const lane = _optionalChain([leased, 'access', _105 => _105[0], 'optionalAccess', _106 => _106.lane]);
+  const lane = _optionalChain([leased, 'access', _96 => _96[0], 'optionalAccess', _97 => _97.lane]);
   const fetch_by_stream = new Map(fetched.map((f) => [f.stream, f]));
   const acked_by_stream = new Map(acked.map((a) => [a.stream, a.at]));
   const blocked_by_stream = new Map(blocked.map((b) => [b.stream, b.error]));
@@ -2195,8 +1807,8 @@ function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
   );
   const detail = leased.map(({ stream, at, retry }) => {
     const f = fetch_by_stream.get(stream);
-    const key = _optionalChain([f, 'optionalAccess', _107 => _107.source]) ? `${hue(C_STREAM, stream)}${dim(`<-${f.source}`)}` : hue(C_STREAM, stream);
-    const events = _optionalChain([f, 'optionalAccess', _108 => _108.events, 'access', _109 => _109.length]) ? ` ${dim(
+    const key = _optionalChain([f, 'optionalAccess', _98 => _98.source]) ? `${hue(C_STREAM, stream)}${dim(`<-${f.source}`)}` : hue(C_STREAM, stream);
+    const events = _optionalChain([f, 'optionalAccess', _99 => _99.events, 'access', _100 => _100.length]) ? ` ${dim(
       `[${f.events.map(({ id, name }) => `#${id} ${String(name)}`).join(", ")}]`
     )}` : "";
     const acked_at = acked_by_stream.get(stream);
@@ -2224,10 +1836,10 @@ function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
 
 // src/internal/drain-cycle.ts
 function budget_exhausted(lease, options, store_failing) {
-  if (store_failing || !_optionalChain([options, 'optionalAccess', _110 => _110.blockOnError]) || lease.retry <= options.maxRetries)
+  if (store_failing || !_optionalChain([options, 'optionalAccess', _101 => _101.blockOnError]) || lease.retry <= options.maxRetries)
     return void 0;
   const error = `Blocking ${lease.stream} after ${lease.retry} claims with no acknowledged progress \u2014 the retry budget (${options.maxRetries}) was spent without the handler ever reporting an error. That means every attempt lost its lease before it could ack: move the reaction to a lane whose leaseMillis covers the handler, then unblock the stream.`;
-  _chunkPRDX3HP6cjs.log.call(void 0, ).error(error);
+  _chunkLUHPSF3Ccjs.log.call(void 0, ).error(error);
   return { lease, handled: 0, acked_at: lease.at, error, block: true };
 }
 function fetch_failure_policy(registry) {
@@ -2243,13 +1855,13 @@ function fetch_failure_policy(registry) {
 function finalize(lease, handled, at, error, options, logger, failed_at) {
   if (!error) return { lease, handled, acked_at: at };
   logger.error(error);
-  const non_retryable = error instanceof _chunkH6KVPVP4cjs.NonRetryableError;
+  const non_retryable = error instanceof _chunkYFFWCVXWcjs.NonRetryableError;
   const block2 = options.blockOnError && (non_retryable || lease.retry >= options.maxRetries);
   if (block2)
     logger.error(
       non_retryable ? `Blocking ${lease.stream} on non-retryable error.` : `Blocking ${lease.stream} after ${lease.retry} retries.`
     );
-  const next_attempt_at = block2 ? void 0 : Date.now() + compute_backoff_delay(lease.retry, _nullishCoalesce(options.backoff, () => ( _chunkPRDX3HP6cjs.DEFAULT_BACKOFF)));
+  const next_attempt_at = block2 ? void 0 : Date.now() + compute_backoff_delay(lease.retry, _nullishCoalesce(options.backoff, () => ( _chunkLUHPSF3Ccjs.DEFAULT_BACKOFF)));
   return {
     lease,
     handled,
@@ -2260,275 +1872,1165 @@ function finalize(lease, handled, at, error, options, logger, failed_at) {
     failed_at
   };
 }
-function warn_misrouted(seen, stream, handler, event) {
-  report_once(
-    seen,
-    `${stream}|${handler}|${event}`,
-    `Reaction "${handler}" on "${event}" resolved to target "${stream}", which a projection already serves. A target is served by one batch handler or one state projection, so this reaction can never run \u2014 and delivering to it would hand the projection an aggregate from another stream. Skipping it. The equivalent static \`.to({ target })\` is rejected at build; a dynamic resolver's target is only knowable here.`
-  );
+function warn_misrouted(seen, stream, handler, event) {
+  report_once(
+    seen,
+    `${stream}|${handler}|${event}`,
+    `Reaction "${handler}" on "${event}" resolved to target "${stream}", which a projection already serves. A target is served by one batch handler or one state projection, so this reaction can never run \u2014 and delivering to it would hand the projection an aggregate from another stream. Skipping it. The equivalent static \`.to({ target })\` is rejected at build; a dynamic resolver's target is only knowable here.`
+  );
+}
+async function run_drain_cycle(deps, cycle) {
+  const { ops, registry, batch_handlers, handle, handle_batch, lane } = deps;
+  const {
+    lagging,
+    leading,
+    eventLimit,
+    leaseMillis,
+    misrouted,
+    store_failing
+  } = cycle;
+  const leased = await ops.claim(
+    lagging,
+    leading,
+    _crypto.randomUUID.call(void 0, ),
+    leaseMillis,
+    lane
+  );
+  if (!leased.length) return void 0;
+  const fetched = await ops.fetch(leased, eventLimit);
+  const fetch_map = /* @__PURE__ */ new Map();
+  const fetch_window_at = fetched.reduce(
+    (max, { at, events }) => Math.max(max, _optionalChain([events, 'access', _102 => _102.at, 'call', _103 => _103(-1), 'optionalAccess', _104 => _104.id]) || at),
+    0
+  );
+  for (const f of fetched) {
+    const { stream, events } = f;
+    let failed;
+    const payloads = events.flatMap((event) => {
+      const register = registry.events[event.name];
+      if (!register) return [];
+      return [...register.reactions.values()].filter((reaction) => {
+        const resolver = reaction.resolver;
+        const dynamic = typeof resolver === "function";
+        let resolved;
+        try {
+          resolved = dynamic ? resolver(event) : resolver;
+        } catch (error) {
+          failed ??= {
+            error: new Error(
+              `Resolver of reaction "${reaction.handler.name}" threw on ${String(event.name)} #${event.id} (stream "${event.stream}"): ${String(error)}`
+            ),
+            options: reaction.options
+          };
+          return false;
+        }
+        if (!resolved || resolved.target !== stream) return false;
+        if (!dynamic || !batch_handlers.has(stream)) return true;
+        warn_misrouted(
+          misrouted,
+          stream,
+          reaction.handler.name,
+          String(event.name)
+        );
+        return false;
+      }).map((reaction) => ({ ...reaction, event }));
+    });
+    fetch_map.set(stream, { fetch: f, payloads, failed });
+  }
+  const handled = await Promise.all(
+    leased.map((lease) => {
+      const entry = fetch_map.get(lease.stream);
+      if (entry.fetch.error !== void 0) {
+        const policy = fetch_failure_policy(registry);
+        return Promise.resolve(
+          finalize(
+            lease,
+            0,
+            lease.at,
+            new Error(`Fetch failed for ${lease.stream}: ${entry.fetch.error}`),
+            store_failing ? { ...policy, blockOnError: false } : policy,
+            deps.logger
+          )
+        );
+      }
+      if (entry.failed)
+        return Promise.resolve(
+          finalize(
+            lease,
+            0,
+            lease.at,
+            entry.failed.error,
+            entry.failed.options,
+            deps.logger
+          )
+        );
+      const at = _optionalChain([entry, 'access', _105 => _105.fetch, 'access', _106 => _106.events, 'access', _107 => _107.at, 'call', _108 => _108(-1), 'optionalAccess', _109 => _109.id]) || fetch_window_at;
+      const { payloads } = entry;
+      const exhausted = budget_exhausted(
+        lease,
+        _optionalChain([payloads, 'access', _110 => _110[0], 'optionalAccess', _111 => _111.options]),
+        store_failing
+      );
+      if (exhausted) return Promise.resolve(exhausted);
+      const batchHandler = batch_handlers.get(lease.stream);
+      if (batchHandler && payloads.length > 0) {
+        return handle_batch({ ...lease, at }, payloads, batchHandler);
+      }
+      return handle({ ...lease, at }, payloads);
+    })
+  );
+  const to_block = handled.filter(({ block: block2 }) => block2).map(({ lease, error }) => ({ ...lease, error }));
+  const blocked = to_block.length ? await ops.block(to_block) : [];
+  if (blocked.length) deps.on_blocked(blocked);
+  const submitted = handled.flatMap((h, i) => {
+    const advance = h.handled > 0 ? h.acked_at : leased[i].at;
+    return h.defer !== void 0 ? { ...h.lease, at: advance, due: h.defer, retry: -1 } : h.next_attempt_at !== void 0 ? { ...h.lease, at: advance, due: h.next_attempt_at } : h.handled > 0 || !h.error ? { ...h.lease, at: h.acked_at } : [];
+  });
+  const acked = submitted.length ? await ops.ack(submitted) : [];
+  const expected = submitted.filter((l) => l.due === void 0).length;
+  if (acked.length < expected)
+    _chunkLUHPSF3Ccjs.log.call(void 0, ).warn(
+      `drain: ${expected - acked.length} of ${expected} acks were dropped \u2014 the lease was taken by another worker mid-handler. That work will be redelivered (at-least-once), but persistent drops mean leaseMillis is too short for this handler.`
+    );
+  const closeable = handled.filter((h) => h.close !== void 0).map((h) => h.close);
+  return { leased, fetched, handled, acked, blocked, closeable };
+}
+var EMPTY_DRAIN = {
+  fetched: [],
+  leased: [],
+  acked: [],
+  blocked: []
+};
+function merge_drains(drains) {
+  return {
+    fetched: drains.flatMap((d) => d.fetched),
+    leased: drains.flatMap((d) => d.leased),
+    acked: drains.flatMap((d) => d.acked),
+    blocked: drains.flatMap((d) => d.blocked)
+  };
+}
+var RETRY = "";
+var DrainController = (_class3 = class {
+  // Armed while `_raised` is ahead of `_lowered` (the raise count the last
+  // empty claim saw), so a claim never lowers over a raise that landed
+  // during it.
+  __init3() {this._raised = 0}
+  __init4() {this._lowered = 0}
+  __init5() {this._ratio = 0.5}
+  // Local wake at the earliest parked (backoff or defer) visit, or at the
+  // lease expiry after a failed pass (the {@link RETRY} key); the schedule
+  // itself is persisted. On an idle app nothing else would drain it. It
+  // drains until a pass leases nothing or the controller stops, and an entry
+  // stays until handled or until a later pass claims nothing.
+  __init6() {this._defer = new DeferTimer(() => {
+    this.arm();
+    void this._deps.run_scoped(async () => {
+      while ((await this.drain()).leased.length > 0) ;
+    });
+  })}
+  
+  __init7() {this._misrouted = /* @__PURE__ */ new Set()}
+  __init8() {this._stopped = false}
+  // The pass in flight. Never rejects; graceful shutdown waits on it.
+  
+  
+  constructor(deps) {;_class3.prototype.__init3.call(this);_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);
+    this._deps = deps;
+  }
+  arm() {
+    this._raised++;
+  }
+  /** Cold start: re-seed a persisted `deferred_at` into the local wake. */
+  seed_defer(stream, at) {
+    this._defer.set(stream, at);
+    this._defer.schedule();
+  }
+  get armed() {
+    return this._raised !== this._lowered;
+  }
+  get inflight() {
+    return this._inflight;
+  }
+  /** This lane's configured lease, or `undefined`; the shutdown grace basis. */
+  get lease_millis() {
+    return _optionalChain([this, 'access', _112 => _112._deps, 'access', _113 => _113.defaults, 'optionalAccess', _114 => _114.leaseMillis]);
+  }
+  get lane() {
+    return this._deps.lane;
+  }
+  /**
+   * Drains every `cycleMs` while armed; the unref'd timer never holds the
+   * process. Called once, when the controller is built.
+   */
+  start(cycleMs) {
+    const run = this._deps.run_scoped;
+    const tick = async () => {
+      if (this.armed) await run(() => this.drain());
+      if (this._stopped) return;
+      this._worker = setTimeout(tick, cycleMs);
+      this._worker.unref();
+    };
+    this._worker = setTimeout(tick, cycleMs);
+    this._worker.unref();
+  }
+  stop() {
+    this._stopped = true;
+    if (this._worker) {
+      clearTimeout(this._worker);
+      this._worker = void 0;
+    }
+    this._defer.stop();
+  }
+  async drain(options = {}) {
+    if (!this.armed || this._stopped || this._inflight)
+      return EMPTY_DRAIN;
+    const d = _nullishCoalesce(this._deps.defaults, () => ( {}));
+    const streamLimit = _nullishCoalesce(_nullishCoalesce(d.streamLimit, () => ( options.streamLimit)), () => ( _chunkLUHPSF3Ccjs.DEFAULT_STREAM_LIMIT));
+    const eventLimit = _nullishCoalesce(options.eventLimit, () => ( _chunkLUHPSF3Ccjs.DEFAULT_EVENT_LIMIT));
+    const leaseMillis = _nullishCoalesce(_nullishCoalesce(d.leaseMillis, () => ( options.leaseMillis)), () => ( _chunkLUHPSF3Ccjs.DEFAULT_LEASE_MILLIS));
+    if (this._deps.breaker.state(Date.now()) === "open")
+      return EMPTY_DRAIN;
+    const pass = this._pass(streamLimit, eventLimit, leaseMillis).finally(
+      () => {
+        this._inflight = void 0;
+      }
+    );
+    this._inflight = pass;
+    return pass;
+  }
+  // One claim → fetch → handle → ack pass. Never throws.
+  async _pass(streamLimit, eventLimit, leaseMillis) {
+    try {
+      const lagging = Math.ceil(streamLimit * this._ratio);
+      const leading = streamLimit - lagging;
+      const started = Date.now();
+      const raised = this._raised;
+      const cycle = await run_drain_cycle(this._deps, {
+        lagging,
+        leading,
+        eventLimit,
+        leaseMillis,
+        misrouted: this._misrouted,
+        store_failing: this._deps.breaker.failing
+      });
+      if (!cycle) {
+        this._defer.prune(started);
+        this._deps.breaker.passed();
+        this._lowered = raised;
+        return EMPTY_DRAIN;
+      }
+      const { leased, fetched, handled, acked, blocked, closeable } = cycle;
+      trace_cycle(this._deps.logger, leased, fetched, handled, acked, blocked);
+      this._ratio = compute_lag_lead_ratio(handled, lagging, leading);
+      for (const lease of acked) this._defer.delete(lease.stream);
+      for (const lease of blocked) this._defer.delete(lease.stream);
+      for (const h of handled) {
+        const next = _nullishCoalesce(h.defer, () => ( h.next_attempt_at));
+        if (next !== void 0) this._defer.set(h.lease.stream, next);
+      }
+      if (acked.length) this._deps.on_acked(acked);
+      if (closeable.length) await this._deps.on_close(closeable);
+      this._deps.breaker.passed();
+      return { fetched, leased, acked, blocked };
+    } catch (error) {
+      this._defer.set(
+        RETRY,
+        Date.now() + Math.max(leaseMillis, this._deps.breaker.cooldown_ms)
+      );
+      this._deps.breaker.failed(Date.now(), error);
+      return EMPTY_DRAIN;
+    } finally {
+      if (!this._stopped) this._defer.schedule();
+    }
+  }
+}, _class3);
+
+// src/internal/reaction-dispatch.ts
+var CloseSignal = class extends Error {
+  /**
+   * Stream to close. Omitted → the reaction's own lease stream (a self-close).
+   * The synthesized autoclose reaction sets it to the aggregate stream, since
+   * its lease runs on a synthetic `__autoclose__` target.
+   */
+  
+  /** Optional archive callback to run while the stream is guarded. */
+  
+  /**
+   * Watermark to ack the requesting reaction to before the close runs. The
+   * close-cycle safety guard skips a stream whose subscriptions (matched by
+   * source) lag the head; the autoclose reaction's `source` is the aggregate,
+   * so it must advance its own watermark to the live head id it evaluated
+   * against — otherwise it blocks its own close. Defaults to the triggering
+   * event id when omitted.
+   */
+  
+  /**
+   * Windowed close: prune events older than this cutoff behind
+   * the closest safe snapshot instead of retiring the stream. Thrown by
+   * the autoclose reaction of a `.autocloses({ keep })` state; flows
+   * into {@link CloseTarget.before}. Omitted → a full close.
+   */
+  
+  /**
+   * Revisit the requesting reaction at this time. Only useful with an `at`
+   * below the head: a reaction runs only when an event is waiting for it.
+   */
+  
+  constructor(opts) {
+    super("reaction requested close");
+    this.name = "CloseSignal";
+    this.stream = _optionalChain([opts, 'optionalAccess', _115 => _115.stream]);
+    this.archive = _optionalChain([opts, 'optionalAccess', _116 => _116.archive]);
+    this.at = _optionalChain([opts, 'optionalAccess', _117 => _117.at]);
+    this.before = _optionalChain([opts, 'optionalAccess', _118 => _118.before]);
+    this.defer = _optionalChain([opts, 'optionalAccess', _119 => _119.defer]);
+  }
+};
+function build_handle(deps) {
+  const { logger, reaction_scope } = deps;
+  return async (lease, payloads) => {
+    if (payloads.length === 0) return { lease, handled: 0, acked_at: lease.at };
+    const stream = lease.stream;
+    const last_index_of = /* @__PURE__ */ new Map();
+    for (let i = 0; i < payloads.length; i++)
+      last_index_of.set(payloads[i].event.id, i);
+    let at = lease.at;
+    let handled = 0;
+    if (lease.retry > 0)
+      logger.warn(
+        `Retrying ${stream}@${payloads.at(0).event.id} (${lease.retry}).`
+      );
+    for (let i = 0; i < payloads.length; i++) {
+      const payload = payloads[i];
+      const { event, handler } = payload;
+      try {
+        await reaction_scope.run(
+          event,
+          () => handler(event, stream, reaction_scope.app)
+        );
+        if (last_index_of.get(event.id) === i) {
+          at = event.id;
+          handled++;
+        }
+      } catch (error) {
+        if (error instanceof _chunkYFFWCVXWcjs.DeferSignal) {
+          let defer;
+          try {
+            defer = resolve_defer_at(error.when, event);
+          } catch (invalid) {
+            return finalize(
+              lease,
+              handled,
+              at,
+              invalid,
+              payload.options,
+              logger,
+              event.id
+            );
+          }
+          return { lease, handled, acked_at: at, defer };
+        }
+        if (error instanceof CloseSignal)
+          return {
+            lease,
+            handled: handled + 1,
+            // Advance to the live head the handler evaluated against (when
+            // provided) so the close-cycle guard sees this reaction caught up.
+            acked_at: _nullishCoalesce(error.at, () => ( event.id)),
+            defer: _optionalChain([error, 'access', _120 => _120.defer, 'optionalAccess', _121 => _121.getTime, 'call', _122 => _122()]),
+            // Close the signalled stream (the autoclose reaction's aggregate,
+            // which differs from its synthetic lease stream); a self-closing
+            // user reaction omits it and closes its own lease stream. A
+            // carried `before` makes it a windowed close (prune, not retire).
+            close: {
+              stream: _nullishCoalesce(error.stream, () => ( stream)),
+              archive: error.archive,
+              before: error.before
+            }
+          };
+        return finalize(
+          lease,
+          handled,
+          at,
+          error,
+          payload.options,
+          logger,
+          event.id
+        );
+      }
+    }
+    return finalize(lease, handled, at, void 0, payloads[0].options, logger);
+  };
+}
+function build_handle_batch(logger) {
+  return async (lease, payloads, batchHandler) => {
+    const stream = lease.stream;
+    const events = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of payloads) {
+      if (seen.has(p.event.id)) continue;
+      seen.add(p.event.id);
+      events.push(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/autoclose-reaction.ts
+var AUTOCLOSE_TARGET_PREFIX = "__autoclose__:";
+function synthesize_autoclose_reactions(registry, states, read_window) {
+  for (const st of states.values()) {
+    const predicate = st.autoclose;
+    if (!predicate) continue;
+    const after_windows = st.autoclose_after_windows;
+    const keep_days = st.autoclose_keep_days;
+    const archiver = st.archive;
+    const reaction = {
+      // Run on a SYNTHETIC stream — `source` is the aggregate, `target` is a
+      // per-aggregate `__autoclose__` key — so the autoclose reaction never
+      // shares a watermark with the aggregate's own reactions. A shared
+      // watermark would let autoclose's defer short-circuit the aggregate's
+      // other reactions (the "a defer affects all reactions on a stream"
+      // hazard). The close still targets the aggregate (`source`).
+      // An anchored stream name would read as a pattern, and a store may refuse
+      // it at subscribe, stopping every reaction. Such a stream has no
+      // autoclose: `app.close` still closes it.
+      resolver: (e) => _chunkLUHPSF3Ccjs.is_literal_source.call(void 0, e.stream) ? {
+        target: `${AUTOCLOSE_TARGET_PREFIX}${e.stream}`,
+        source: e.stream
+      } : void 0,
+      // Never block on autoclose: a transient query/store error should retry,
+      // not quarantine the synthetic stream.
+      options: { blockOnError: false, maxRetries: _chunkLUHPSF3Ccjs.DEFAULT_MAX_RETRIES },
+      handler: async (event) => {
+        const aggregate = event.stream;
+        const window = read_window();
+        if (!in_autoclose_window(window, /* @__PURE__ */ new Date()))
+          throw new (0, _chunkYFFWCVXWcjs.DeferSignal)({ at: next_window_open(window, /* @__PURE__ */ new Date()) });
+        const stats = await _chunkLUHPSF3Ccjs.store.call(void 0, ).query_stats([aggregate], {
+          count: true,
+          tail: keep_days !== void 0 ? true : void 0,
+          exclude: [_chunkYFFWCVXWcjs.TOMBSTONE_EVENT, _chunkYFFWCVXWcjs.SNAP_EVENT]
+        });
+        const entry = stats.get(aggregate);
+        if (!entry) return;
+        const head = entry.head;
+        if (predicate(aggregate, head, entry.count))
+          throw new CloseSignal({
+            stream: aggregate,
+            archive: archiver ? () => archiver(aggregate, head) : void 0,
+            // Ack this reaction's own watermark to the live head so the
+            // close-cycle guard (which matches subscriptions by source =
+            // aggregate) sees it caught up instead of blocking its own close.
+            at: head.id
+          });
+        if (keep_days !== void 0) {
+          const cutoff = days_before_now(keep_days);
+          if (entry.tail.created < cutoff) {
+            const waiting = after_windows.some(
+              (days) => days_after(head.created, days).getTime() > Date.now()
+            );
+            throw new CloseSignal({
+              stream: aggregate,
+              before: cutoff,
+              archive: archiver ? () => archiver(aggregate, head, cutoff) : void 0,
+              at: waiting ? head.id - 1 : head.id,
+              defer: waiting ? days_after(/* @__PURE__ */ new Date(), 1) : void 0
+            });
+          }
+        }
+        const dues = [];
+        for (const days of after_windows)
+          dues.push(days_after(head.created, days));
+        if (keep_days !== void 0)
+          dues.push(days_after(entry.tail.created, keep_days));
+        const future = dues.map((d) => d.getTime()).filter((t) => t > Date.now());
+        if (future.length)
+          throw new (0, _chunkYFFWCVXWcjs.DeferSignal)({ at: new Date(Math.min(...future)) });
+      }
+    };
+    const key = `__autoclose_${st.name}`;
+    for (const event_name of Object.keys(st.events)) {
+      _optionalChain([registry, 'access', _123 => _123.events, 'access', _124 => _124[event_name], 'optionalAccess', _125 => _125.reactions, 'access', _126 => _126.set, 'call', _127 => _127(
+        key,
+        reaction
+      )]);
+    }
+  }
+}
+
+// src/internal/close-cycle.ts
+var CLOSE_CATCH_UP_LIMIT = 1e3;
+var CLOSE_CATCH_UP_PASSES = 20;
+async function catch_up_correlation(cursor, correlate, until) {
+  for (let pass = 0; pass < CLOSE_CATCH_UP_PASSES && cursor.checkpoint < until; pass++) {
+    const before = cursor.checkpoint;
+    cursor.arm();
+    await correlate(CLOSE_CATCH_UP_LIMIT);
+    if (cursor.checkpoint <= before) break;
+  }
+  return cursor.checkpoint;
+}
+var CloseLock = (_class4 = class {constructor() { _class4.prototype.__init9.call(this); }
+  __init9() {this._tails = /* @__PURE__ */ new Map()}
+  /** Run `work` after every earlier close of `stream` has settled. */
+  run(stream, work) {
+    const prev = _nullishCoalesce(this._tails.get(stream), () => ( Promise.resolve()));
+    const next = prev.then(work, work);
+    this._tails.set(stream, next);
+    const cleanup = () => {
+      if (this._tails.get(stream) === next) this._tails.delete(stream);
+    };
+    next.then(cleanup, cleanup);
+    return next;
+  }
+}, _class4);
+var SAFETY_PROBE_PAGE_SIZE = 1e3;
+async function run_close_cycle(targets, deps) {
+  const target_map = new Map(targets.map((t) => [t.stream, t]));
+  for (const t of target_map.values()) {
+    if (t.before !== void 0 && t.restart)
+      throw new Error(
+        `close: \`before\` and \`restart\` are mutually exclusive (stream "${t.stream}") \u2014 a windowed close keeps the stream live behind a real snapshot; restart reseeds it`
+      );
+  }
+  const windowed = [...target_map.values()].filter(
+    (t) => t.before !== void 0
+  );
+  const full = [...target_map.values()].filter((t) => t.before === void 0);
+  const skipped = [];
+  const windowed_result = windowed.length ? await run_windowed_closes(windowed, deps, skipped) : /* @__PURE__ */ new Map();
+  if (!full.length) return { truncated: windowed_result, skipped };
+  const truncated = await with_stream_locks(
+    full.map((t) => t.stream),
+    deps,
+    () => run_full_closes(full, target_map, deps, skipped)
+  );
+  const retired = [...truncated.entries()].filter(([, r]) => r.committed.name === _chunkYFFWCVXWcjs.TOMBSTONE_EVENT).map(([stream]) => stream);
+  if (retired.length) _optionalChain([deps, 'access', _128 => _128.forget_subscribed, 'optionalCall', _129 => _129(retired)]);
+  for (const [stream, entry] of windowed_result) truncated.set(stream, entry);
+  return { truncated, skipped };
+}
+function with_stream_locks(streams, deps, work) {
+  const with_lock = _nullishCoalesce(deps.with_stream_lock, () => ( ((_stream, w) => w())));
+  return [...streams].sort().reduceRight(
+    (inner, stream) => () => with_lock(stream, inner),
+    work
+  )();
+}
+async function run_full_closes(full, target_map, deps, skipped) {
+  const none = /* @__PURE__ */ new Map();
+  const streams = full.map((t) => t.stream);
+  const stream_info = await scan_stream_heads(streams);
+  for (const target of full) {
+    if (!target.restart) continue;
+    const info = stream_info.get(target.stream);
+    if (!info) continue;
+    const owner = deps.event_to_state.get(info.last_event_name);
+    if (_optionalChain([owner, 'optionalAccess', _130 => _130.pii_aware])) {
+      deps.logger.error(
+        `Refusing to close "${target.stream}" with restart: state "${owner.name}" carries sensitive fields, so a restart seed would persist redacted values while deleting the originals. Close it without restart to retire the stream, or leave it open.`
+      );
+      skipped.push(target.stream);
+      stream_info.delete(target.stream);
+    }
+  }
+  const safe = await partition_by_safety(
+    stream_info,
+    deps.reactive,
+    skipped,
+    _nullishCoalesce(deps.probe_page_size, () => ( SAFETY_PROBE_PAGE_SIZE)),
+    deps.catch_up_correlation
+  );
+  if (!safe.length) return none;
+  const { guarded, guard_events } = await guard_with_tombstones(
+    safe,
+    stream_info,
+    deps.correlation,
+    deps.tombstone,
+    skipped
+  );
+  if (!guarded.length) return none;
+  const seed_states = await load_restart_seeds(
+    guarded,
+    target_map,
+    stream_info,
+    deps.event_to_state,
+    deps.load,
+    deps.logger
+  );
+  await run_archive_callbacks(guarded, target_map);
+  const still_guarded = await heads_still_guarded(
+    guarded,
+    guard_events,
+    skipped
+  );
+  if (!still_guarded.length) return none;
+  return truncate_and_warm_cache(
+    still_guarded,
+    seed_states,
+    guard_events,
+    deps.correlation
+  );
+}
+async function run_windowed_closes(windowed, deps, skipped) {
+  const checkpoint = deps.reactive ? await deps.catch_up_correlation(Number.MAX_SAFE_INTEGER) : -1;
+  const min_at = deps.reactive ? await probe_min_watermarks(
+    windowed.map((t) => t.stream),
+    _nullishCoalesce(deps.probe_page_size, () => ( SAFETY_PROBE_PAGE_SIZE)),
+    checkpoint
+  ) : /* @__PURE__ */ new Map();
+  const with_lock = _nullishCoalesce(deps.with_stream_lock, () => ( ((_stream, work) => work())));
+  const truncated = /* @__PURE__ */ new Map();
+  for (const t of windowed) {
+    const entry = await with_lock(t.stream, async () => {
+      const max_id = min_at.get(t.stream);
+      if (!await windowed_prune_pending(t.stream, t.before, max_id))
+        return void 0;
+      if (t.archive) await t.archive();
+      const result = await _chunkLUHPSF3Ccjs.store.call(void 0, ).truncate([
+        { stream: t.stream, before: t.before, max_id }
+      ]);
+      return result.get(t.stream);
+    });
+    if (entry) truncated.set(t.stream, entry);
+    else skipped.push(t.stream);
+  }
+  return truncated;
+}
+async function windowed_prune_pending(stream, before, max_id) {
+  let boundary_id;
+  let min_id;
+  await _chunkLUHPSF3Ccjs.store.call(void 0, ).query(
+    (event) => {
+      if (min_id === void 0 || event.id < min_id) min_id = event.id;
+      if (event.name === _chunkYFFWCVXWcjs.SNAP_EVENT && event.created < before && (max_id === void 0 || event.id <= max_id) && (boundary_id === void 0 || event.id > boundary_id))
+        boundary_id = event.id;
+    },
+    { stream, stream_exact: true, with_snaps: true, after: -1 }
+  );
+  return boundary_id !== void 0 && min_id < boundary_id;
+}
+async function probe_min_watermarks(streams, page_size, checkpoint) {
+  const min_at = /* @__PURE__ */ new Map();
+  const matches = source_matcher();
+  await walk_streams(
+    _chunkLUHPSF3Ccjs.store.call(void 0, ),
+    (position) => {
+      const pending = position.correlated_at === void 0 || position.at < position.correlated_at;
+      const cap = pending ? position.at : Math.max(position.at, checkpoint);
+      for (const stream of streams) {
+        if (matches(position.source, position.stream, stream)) {
+          const prev = min_at.get(stream);
+          if (prev === void 0 || cap < prev) min_at.set(stream, cap);
+        }
+      }
+    },
+    { limit: page_size }
+  );
+  return min_at;
+}
+function source_matcher() {
+  const compiled = /* @__PURE__ */ new Map();
+  return (source, target, stream) => {
+    if (!source) return true;
+    if (_chunkLUHPSF3Ccjs.is_literal_source.call(void 0, source, target)) return source === stream;
+    let re = compiled.get(source);
+    if (!re) {
+      re = new RegExp(source);
+      compiled.set(source, re);
+    }
+    return re.test(stream);
+  };
+}
+async function scan_stream_heads(streams) {
+  const stats = await _chunkLUHPSF3Ccjs.store.call(void 0, ).query_stats(streams, {
+    exclude: [_chunkYFFWCVXWcjs.SNAP_EVENT]
+  });
+  const domain_heads = await _chunkLUHPSF3Ccjs.store.call(void 0, ).query_stats(streams, {
+    exclude: [_chunkYFFWCVXWcjs.SNAP_EVENT, _chunkYFFWCVXWcjs.TOMBSTONE_EVENT]
+  });
+  const true_heads = await _chunkLUHPSF3Ccjs.store.call(void 0, ).query_stats(streams, {});
+  const out = /* @__PURE__ */ new Map();
+  for (const [stream, { head }] of domain_heads) {
+    const marker_head = _optionalChain([stats, 'access', _131 => _131.get, 'call', _132 => _132(stream), 'optionalAccess', _133 => _133.head]);
+    const interrupted = _optionalChain([marker_head, 'optionalAccess', _134 => _134.name]) === _chunkYFFWCVXWcjs.TOMBSTONE_EVENT;
+    out.set(stream, {
+      max_id: head.id,
+      version: true_heads.get(stream).head.version,
+      last_event_name: head.name,
+      ...interrupted ? { resumed_guard: { id: marker_head.id } } : {}
+    });
+  }
+  return out;
 }
-async function run_drain_cycle(deps, cycle) {
-  const { ops, registry, batch_handlers, handle, handle_batch, lane } = deps;
-  const {
-    lagging,
-    leading,
-    eventLimit,
-    leaseMillis,
-    misrouted,
-    store_failing
-  } = cycle;
-  const leased = await ops.claim(
-    lagging,
-    leading,
-    _crypto.randomUUID.call(void 0, ),
-    leaseMillis,
-    lane
-  );
-  if (!leased.length) return void 0;
-  const fetched = await ops.fetch(leased, eventLimit);
-  const fetch_map = /* @__PURE__ */ new Map();
-  const fetch_window_at = fetched.reduce(
-    (max, { at, events }) => Math.max(max, _optionalChain([events, 'access', _111 => _111.at, 'call', _112 => _112(-1), 'optionalAccess', _113 => _113.id]) || at),
-    0
+async function partition_by_safety(stream_info, reactive, skipped, page_size, catch_up_correlation2) {
+  if (!reactive) return [...stream_info.keys()];
+  let needed = -1;
+  for (const info of stream_info.values())
+    needed = Math.max(needed, info.max_id);
+  const checkpoint = await catch_up_correlation2(needed);
+  const uncorrelated = /* @__PURE__ */ new Set();
+  for (const [stream, info] of stream_info) {
+    if (checkpoint < info.max_id) uncorrelated.add(stream);
+  }
+  const pending_set = /* @__PURE__ */ new Set();
+  const matches = source_matcher();
+  await walk_streams(
+    _chunkLUHPSF3Ccjs.store.call(void 0, ),
+    (position) => {
+      const has_work = position.correlated_at !== void 0 && position.at < position.correlated_at;
+      if (!has_work) return;
+      if (position.stream.startsWith(AUTOCLOSE_TARGET_PREFIX)) return;
+      for (const [stream, info] of stream_info) {
+        if (matches(position.source, position.stream, stream) && position.at < info.max_id)
+          pending_set.add(stream);
+      }
+    },
+    { limit: page_size }
   );
-  for (const f of fetched) {
-    const { stream, events } = f;
-    let failed;
-    const payloads = events.flatMap((event) => {
-      const register = registry.events[event.name];
-      if (!register) return [];
-      return [...register.reactions.values()].filter((reaction) => {
-        const resolver = reaction.resolver;
-        const dynamic = typeof resolver === "function";
-        let resolved;
-        try {
-          resolved = dynamic ? resolver(event) : resolver;
-        } catch (error) {
-          failed ??= {
-            error: new Error(
-              `Resolver of reaction "${reaction.handler.name}" threw on ${String(event.name)} #${event.id} (stream "${event.stream}"): ${String(error)}`
-            ),
-            options: reaction.options
-          };
-          return false;
-        }
-        if (!resolved || resolved.target !== stream) return false;
-        if (!dynamic || !batch_handlers.has(stream)) return true;
-        warn_misrouted(
-          misrouted,
-          stream,
-          reaction.handler.name,
-          String(event.name)
-        );
-        return false;
-      }).map((reaction) => ({ ...reaction, event }));
-    });
-    fetch_map.set(stream, { fetch: f, payloads, failed });
+  const safe = [];
+  for (const [stream] of stream_info) {
+    if (pending_set.has(stream) || uncorrelated.has(stream))
+      skipped.push(stream);
+    else safe.push(stream);
   }
-  const handled = await Promise.all(
-    leased.map((lease) => {
-      const entry = fetch_map.get(lease.stream);
-      if (entry.fetch.error !== void 0) {
-        const policy = fetch_failure_policy(registry);
-        return Promise.resolve(
-          finalize(
-            lease,
-            0,
-            lease.at,
-            new Error(`Fetch failed for ${lease.stream}: ${entry.fetch.error}`),
-            store_failing ? { ...policy, blockOnError: false } : policy,
-            deps.logger
-          )
-        );
+  return safe;
+}
+async function guard_with_tombstones(safe, stream_info, correlation, tombstone2, skipped) {
+  const guarded = [];
+  const guard_events = /* @__PURE__ */ new Map();
+  await Promise.all(
+    safe.map(async (stream) => {
+      const info = stream_info.get(stream);
+      if (info.resumed_guard) {
+        guarded.push(stream);
+        guard_events.set(stream, { id: info.resumed_guard.id, stream });
+        return;
       }
-      if (entry.failed)
-        return Promise.resolve(
-          finalize(
-            lease,
-            0,
-            lease.at,
-            entry.failed.error,
-            entry.failed.options,
-            deps.logger
-          )
+      const committed = await tombstone2(stream, info.version, correlation);
+      if (committed) {
+        guarded.push(stream);
+        guard_events.set(stream, { id: committed.id, stream });
+      } else {
+        skipped.push(stream);
+      }
+    })
+  );
+  return { guarded, guard_events };
+}
+async function load_restart_seeds(guarded, target_map, stream_info, event_to_state, load2, logger) {
+  const seed_states = /* @__PURE__ */ new Map();
+  await Promise.all(
+    guarded.filter((s) => _optionalChain([target_map, 'access', _135 => _135.get, 'call', _136 => _136(s), 'optionalAccess', _137 => _137.restart])).map(async (stream) => {
+      const last_event_name = stream_info.get(stream).last_event_name;
+      const owner_state = event_to_state.get(last_event_name);
+      if (!owner_state) {
+        logger.error(
+          `Cannot seed restart for "${stream}": no registered state owns event "${last_event_name}". Stream will be tombstoned instead.`
         );
-      const at = _optionalChain([entry, 'access', _114 => _114.fetch, 'access', _115 => _115.events, 'access', _116 => _116.at, 'call', _117 => _117(-1), 'optionalAccess', _118 => _118.id]) || fetch_window_at;
-      const { payloads } = entry;
-      const exhausted = budget_exhausted(
-        lease,
-        _optionalChain([payloads, 'access', _119 => _119[0], 'optionalAccess', _120 => _120.options]),
-        store_failing
-      );
-      if (exhausted) return Promise.resolve(exhausted);
-      const batchHandler = batch_handlers.get(lease.stream);
-      if (batchHandler && payloads.length > 0) {
-        return handle_batch({ ...lease, at }, payloads, batchHandler);
+        return;
       }
-      return handle({ ...lease, at }, payloads);
+      const snap2 = await load2(owner_state, { stream });
+      seed_states.set(stream, snap2.state);
     })
   );
-  const to_block = handled.filter(({ block: block2 }) => block2).map(({ lease, error }) => ({ ...lease, error }));
-  const blocked = to_block.length ? await ops.block(to_block) : [];
-  if (blocked.length) deps.on_blocked(blocked);
-  const submitted = handled.flatMap((h, i) => {
-    const advance = h.handled > 0 ? h.acked_at : leased[i].at;
-    return h.defer !== void 0 ? { ...h.lease, at: advance, due: h.defer, retry: -1 } : h.next_attempt_at !== void 0 ? { ...h.lease, at: advance, due: h.next_attempt_at } : h.handled > 0 || !h.error ? { ...h.lease, at: h.acked_at } : [];
+  return seed_states;
+}
+async function run_archive_callbacks(guarded, target_map) {
+  for (const stream of guarded) {
+    const archive_fn = _optionalChain([target_map, 'access', _138 => _138.get, 'call', _139 => _139(stream), 'optionalAccess', _140 => _140.archive]);
+    if (archive_fn) await archive_fn();
+  }
+}
+async function heads_still_guarded(guarded, guard_events, skipped) {
+  const heads = await _chunkLUHPSF3Ccjs.store.call(void 0, ).query_stats(guarded, {});
+  return guarded.filter((stream) => {
+    if (_optionalChain([heads, 'access', _141 => _141.get, 'call', _142 => _142(stream), 'optionalAccess', _143 => _143.head, 'access', _144 => _144.id]) === guard_events.get(stream).id)
+      return true;
+    skipped.push(stream);
+    return false;
   });
-  const acked = submitted.length ? await ops.ack(submitted) : [];
-  const expected = submitted.filter((l) => l.due === void 0).length;
-  if (acked.length < expected)
-    _chunkPRDX3HP6cjs.log.call(void 0, ).warn(
-      `drain: ${expected - acked.length} of ${expected} acks were dropped \u2014 the lease was taken by another worker mid-handler. That work will be redelivered (at-least-once), but persistent drops mean leaseMillis is too short for this handler.`
-    );
-  const closeable = handled.filter((h) => h.close !== void 0).map((h) => h.close);
-  return { leased, fetched, handled, acked, blocked, closeable };
 }
-var EMPTY_DRAIN = {
-  fetched: [],
-  leased: [],
-  acked: [],
-  blocked: []
+async function truncate_and_warm_cache(guarded, seed_states, guard_events, correlation) {
+  const trunc_targets = guarded.map((stream) => {
+    const snapshot = seed_states.get(stream);
+    const guard = guard_events.get(stream);
+    return {
+      stream,
+      snapshot,
+      meta: {
+        correlation,
+        causation: {
+          event: { id: guard.id, name: _chunkYFFWCVXWcjs.TOMBSTONE_EVENT, stream: guard.stream }
+        }
+      }
+    };
+  });
+  const truncated = await _chunkLUHPSF3Ccjs.store.call(void 0, ).truncate(trunc_targets);
+  await Promise.all(
+    guarded.map(async (stream) => {
+      const entry = truncated.get(stream);
+      const state2 = seed_states.get(stream);
+      if (state2 && entry) {
+        await _chunkLUHPSF3Ccjs.cache.call(void 0, ).set(stream, {
+          stream,
+          state: state2,
+          version: entry.committed.version,
+          event_id: entry.committed.id,
+          patches: 0,
+          snaps: 1
+        });
+      } else {
+        await _chunkLUHPSF3Ccjs.cache.call(void 0, ).invalidate(stream);
+      }
+    })
+  );
+  return truncated;
+}
+
+// src/internal/correlate-cycle.ts
+
+var COLD_START_BACK_SCAN = 1e4;
+var CORRELATION_LEASE_MS = 5e3;
+var registry_key = (events) => {
+  const shape = Object.keys(events).filter((name) => events[name].reactions.size > 0).sort().map((name) => [name, [...events[name].reactions.keys()].sort()]);
+  return _crypto.createHash.call(void 0, "sha256").update(JSON.stringify(shape)).digest("hex").slice(0, 32);
 };
-function merge_drains(drains) {
-  return {
-    fetched: drains.flatMap((d) => d.fetched),
-    leased: drains.flatMap((d) => d.leased),
-    acked: drains.flatMap((d) => d.acked),
-    blocked: drains.flatMap((d) => d.blocked)
-  };
+var PATTERN_CACHE_SIZE = 32;
+function report_undeclared_lane(seen, handler, target, lane, declared) {
+  report_once(
+    seen,
+    `lane|${handler}|${lane}`,
+    `Reaction "${handler}" resolved onto undeclared lane "${lane}" \u2014 for example target "${target}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. No controller claims it, so the stream would never drain \u2014 running it on "default" instead. The equivalent static \`.to({ lane })\` is rejected at build; a dynamic resolver's lane is only knowable here.`
+  );
 }
-var RETRY = "";
-var DrainController = (_class5 = class {
-  // Armed while `_raised` is ahead of `_lowered` (the raise count the last
-  // empty claim saw), so a claim never lowers over a raise that landed
-  // during it.
-  __init15() {this._raised = 0}
-  __init16() {this._lowered = 0}
-  __init17() {this._ratio = 0.5}
-  // Local wake at the earliest parked (backoff or defer) visit, or at the
-  // lease expiry after a failed pass (the {@link RETRY} key); the schedule
-  // itself is persisted. On an idle app nothing else would drain it. It
-  // drains until a pass leases nothing or the controller stops, and an entry
-  // stays until handled or until a later pass claims nothing.
-  __init18() {this._defer = new DeferTimer(() => {
-    this.arm();
-    void this._deps.run_scoped(async () => {
-      while ((await this.drain()).leased.length > 0) ;
-    });
-  })}
+function report_lane_conflict(seen, handler, target, kept, dropped) {
+  report_once(
+    seen,
+    `conflict|${handler}|${kept}|${dropped}`,
+    `Reaction "${handler}" resolved lane "${dropped}" for a stream already on "${kept}" \u2014 for example "${target}". These are conflicting lane assignments from two dynamic resolutions at equal priority. Keeping "${kept}", the lane it was first discovered on \u2014 re-laning a live stream would move it out from under a worker holding its lease. The reaction resolving "${dropped}" runs inside the "${kept}" lane's budget, and a process restricted to "${dropped}" via onlyLanes never runs it. The equivalent static declaration is rejected at build; align the resolvers, or split the target.`
+  );
+}
+var CorrelateCycle = (_class5 = class {
+  __init10() {this._checkpoint = -1}
+  // Lease holder id; per instance, so a restart never inherits a stale claim.
+  __init11() {this._by = _crypto.randomUUID.call(void 0, )}
   
-  __init19() {this._misrouted = /* @__PURE__ */ new Set()}
-  __init20() {this._stopped = false}
-  // The pass in flight. Never rejects; graceful shutdown waits on it.
+  // Local expiry of the held lease (0 = none); stale only costs a duplicate scan.
+  __init12() {this._lease_until = 0}
+  // Armed while `_raised` (bumped by a commit or notification) is ahead of
+  // `_lowered` (the raise count the last short page saw). Starts armed.
+  __init13() {this._raised = 1}
+  __init14() {this._lowered = 0}
+  // Bumped by a release (shutdown), so a scan or lease reply that was out
+  // across one writes nothing.
+  __init15() {this._epoch = 0}
+  // Passes in flight: a restore waits for them, and refuses new ones.
+  __init16() {this._passes = /* @__PURE__ */ new Set()}
+  __init17() {this._restoring = false}
+  
+  // Bounded by `maxSubscribedStreams`; static records live apart so eviction
+  // never lets a resolution re-lane them.
   
+  __init18() {this._static_subscriptions = /* @__PURE__ */ new Map()}
+  __init19() {this._patterns = new (0, _chunkLUHPSF3Ccjs.LruMap)(PATTERN_CACHE_SIZE)}
   
-  constructor(deps) {;_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this);
-    this._deps = deps;
+  
+  
+  
+  
+  // Report-once keys; per instance because `internal/` holds no module state.
+  __init20() {this._reported = /* @__PURE__ */ new Set()}
+  constructor({
+    registry,
+    static_targets,
+    cd,
+    max_subscribed_streams,
+    declared_lanes,
+    shard,
+    on_init
+  }) {;_class5.prototype.__init10.call(this);_class5.prototype.__init11.call(this);_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this);
+    this._key = shard ? `${registry_key(registry.events)}:${[...shard].sort().join(",")}` : registry_key(registry.events);
+    this._dynamic_subscriptions = new (0, _chunkLUHPSF3Ccjs.LruMap)(max_subscribed_streams);
+    this._registry = registry;
+    this._declared_lanes = declared_lanes;
+    this._static_targets = static_targets;
+    this._cd = cd;
+    this._on_init = on_init;
+  }
+  get checkpoint() {
+    return this._checkpoint;
   }
+  /** A commit (local or remote) may have produced uncorrelated events. */
   arm() {
     this._raised++;
   }
-  /** Cold start: re-seed a persisted `deferred_at` into the local wake. */
-  seed_defer(stream, at) {
-    this._defer.set(stream, at);
-    this._defer.schedule();
+  async _init() {
+    this._init_promise ??= this._run_init().catch((error) => {
+      this._init_promise = void 0;
+      throw error;
+    });
+    await this._init_promise;
   }
-  get armed() {
-    return this._raised !== this._lowered;
+  async _run_init() {
+    const { watermark, correlated_at } = await this._cd.subscribe([
+      ...this._static_targets
+    ]);
+    this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - COLD_START_BACK_SCAN);
+    for (const { stream, priority = 0, lane } of this._static_targets) {
+      this._static_subscriptions.set(stream, {
+        priority,
+        lane
+      });
+    }
+    await _optionalChain([this, 'access', _145 => _145._on_init, 'optionalCall', _146 => _146()]);
   }
-  get inflight() {
-    return this._inflight;
+  /**
+   * Replace the log with no pass in flight, then cold-start: a pass that
+   * read the old log writes before the restore, never into the new one.
+   */
+  async restart(restore) {
+    this._restoring = true;
+    try {
+      await Promise.allSettled(this._passes);
+      await restore();
+    } finally {
+      this._restoring = false;
+    }
+    this._init_promise = void 0;
+    this._checkpoint = -1;
+    this._dynamic_subscriptions.clear();
+    this._static_subscriptions.clear();
   }
-  /** This lane's configured lease, or `undefined`; the shutdown grace basis. */
-  get lease_millis() {
-    return _optionalChain([this, 'access', _121 => _121._deps, 'access', _122 => _122.defaults, 'optionalAccess', _123 => _123.leaseMillis]);
+  /** Forget dynamic targets whose rows a full close deleted, so they re-subscribe. */
+  forget_subscribed(streams) {
+    for (const stream of streams) this._dynamic_subscriptions.delete(stream);
   }
-  get lane() {
-    return this._deps.lane;
+  // Would the target's own `fetch` (filtered by `source`) return this event?
+  _in_fetch_window(source, stream) {
+    if (source === void 0 || source === stream) return true;
+    if (_chunkLUHPSF3Ccjs.is_literal_source.call(void 0, source)) return false;
+    let pattern = this._patterns.get(source);
+    if (!pattern) {
+      pattern = new RegExp(source);
+      this._patterns.set(source, pattern);
+    }
+    return pattern.test(stream);
   }
-  /**
-   * Drains every `cycleMs` while armed; the unref'd timer never holds the
-   * process. Called once, when the controller is built.
-   */
-  start(cycleMs) {
-    const run = this._deps.run_scoped;
-    const tick = async () => {
-      if (this.armed) await run(() => this.drain());
-      if (this._stopped) return;
-      this._worker = setTimeout(tick, cycleMs);
-      this._worker.unref();
-    };
-    this._worker = setTimeout(tick, cycleMs);
-    this._worker.unref();
+  /** Scan past the checkpoint, subscribe new targets and raise their work marks. */
+  async correlate(limit, lease = false) {
+    if (this._restoring) return { kind: "idle", last_id: this._checkpoint };
+    const pass = this._scan(limit, lease);
+    this._passes.add(pass);
+    try {
+      return await pass;
+    } finally {
+      this._passes.delete(pass);
+    }
   }
-  stop() {
-    this._stopped = true;
-    if (this._worker) {
-      clearTimeout(this._worker);
-      this._worker = void 0;
+  async _scan(limit, lease) {
+    await this._init();
+    const epoch = this._epoch;
+    const idle = () => ({
+      kind: "idle",
+      last_id: this._checkpoint
+    });
+    if (this._raised === this._lowered) return idle();
+    const raised = this._raised;
+    const now = Date.now();
+    if (lease && now >= this._lease_until - CORRELATION_LEASE_MS / 2) {
+      const { correlating } = await this._cd.subscribe([], void 0, {
+        key: this._key,
+        by: this._by,
+        millis: CORRELATION_LEASE_MS
+      });
+      if (this._epoch !== epoch) return idle();
+      this._lease_until = correlating ? now + CORRELATION_LEASE_MS : 0;
+      if (correlating === false) return idle();
+    }
+    const after = this._checkpoint;
+    const correlated = /* @__PURE__ */ new Map();
+    let last_id = after;
+    let stopped = false;
+    const found = await _chunkLUHPSF3Ccjs.store.call(void 0, ).query(
+      (event) => {
+        if (stopped) return;
+        const register = this._registry.events[event.name];
+        if (register) {
+          for (const reaction of register.reactions.values()) {
+            let resolved;
+            try {
+              resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
+            } catch (error) {
+              stopped = true;
+              report_once(
+                this._reported,
+                `resolver|${reaction.handler.name}|${event.id}`,
+                `Resolver of reaction "${reaction.handler.name}" threw on ${String(event.name)} #${event.id} (stream "${event.stream}"): ${String(error)}. Correlation stops before this event until the resolver stops throwing; work already found keeps draining.`
+              );
+              return;
+            }
+            if (!resolved) continue;
+            let lane = resolved.lane;
+            if (lane !== void 0 && !this._declared_lanes.has(lane)) {
+              report_undeclared_lane(
+                this._reported,
+                reaction.handler.name,
+                resolved.target,
+                lane,
+                this._declared_lanes
+              );
+              lane = void 0;
+            }
+            const fixed = this._static_subscriptions.get(resolved.target);
+            const recorded = _nullishCoalesce(fixed, () => ( this._dynamic_subscriptions.get(resolved.target)));
+            const priority = _nullishCoalesce(resolved.priority, () => ( 0));
+            const upgraded = !recorded || !fixed && priority > recorded.priority;
+            const carried = upgraded ? { priority, lane } : { priority: recorded.priority, lane: recorded.lane };
+            const entry = correlated.get(resolved.target) || {
+              source: resolved.source,
+              priority: carried.priority,
+              lane: carried.lane,
+              upgraded,
+              missed: !recorded,
+              handler: reaction.handler.name,
+              correlated_at: void 0
+            };
+            const seen_in_scan = correlated.has(resolved.target);
+            const held_lane = _nullishCoalesce((seen_in_scan ? entry.lane : _optionalChain([recorded, 'optionalAccess', _147 => _147.lane])), () => ( _chunkYFFWCVXWcjs.DEFAULT_LANE));
+            const held_priority = seen_in_scan ? entry.priority : _optionalChain([recorded, 'optionalAccess', _148 => _148.priority]);
+            const resolved_lane = _nullishCoalesce(lane, () => ( _chunkYFFWCVXWcjs.DEFAULT_LANE));
+            if (held_priority === priority && held_lane !== resolved_lane)
+              report_lane_conflict(
+                this._reported,
+                reaction.handler.name,
+                resolved.target,
+                held_lane,
+                resolved_lane
+              );
+            if (carried.priority > entry.priority) {
+              entry.priority = carried.priority;
+              entry.lane = carried.lane;
+              entry.upgraded = upgraded;
+              entry.handler = reaction.handler.name;
+            }
+            if (this._in_fetch_window(resolved.source, event.stream))
+              entry.correlated_at = event.id;
+            correlated.set(resolved.target, entry);
+          }
+        }
+        last_id = event.id;
+      },
+      // Resolvers see `pii: null`: correlate runs actor-less, and one
+      // undecryptable row would otherwise stop every stream's reactions.
+      { after, limit, with_pii: false }
+    );
+    if (this._declared_lanes.size > 1) await this._recall(correlated);
+    const read = last_id > after;
+    if (this._epoch !== epoch) return idle();
+    const streams = [];
+    for (const [stream, entry] of correlated) {
+      if (entry.upgraded || entry.correlated_at !== void 0)
+        streams.push({
+          stream,
+          source: entry.source,
+          priority: entry.priority,
+          lane: entry.lane,
+          correlated_at: entry.correlated_at
+        });
+    }
+    if (streams.length) {
+      const renewed_at = Date.now();
+      const { subscribed, correlating } = await this._cd.subscribe(
+        streams,
+        last_id,
+        lease ? { key: this._key, by: this._by, millis: CORRELATION_LEASE_MS } : void 0
+      );
+      if (lease && correlating !== false)
+        this._lease_until = renewed_at + CORRELATION_LEASE_MS;
+      const marked = streams.filter(
+        (entry) => entry.correlated_at !== void 0
+      ).length;
+      this._checkpoint = last_id;
+      for (const { stream, priority, lane } of streams) {
+        if (_optionalChain([correlated, 'access', _149 => _149.get, 'call', _150 => _150(stream), 'optionalAccess', _151 => _151.upgraded]))
+          this._dynamic_subscriptions.set(stream, {
+            priority,
+            lane
+          });
+      }
+      return { kind: "scanned", last_id, subscribed, marked, read };
     }
-    this._defer.stop();
+    this._checkpoint = last_id;
+    if (!stopped && found !== limit) this._lowered = raised;
+    return { kind: "scanned", last_id, subscribed: 0, marked: 0, read };
   }
-  async drain(options = {}) {
-    if (!this.armed || this._stopped || this._inflight)
-      return EMPTY_DRAIN;
-    const d = _nullishCoalesce(this._deps.defaults, () => ( {}));
-    const streamLimit = _nullishCoalesce(_nullishCoalesce(d.streamLimit, () => ( options.streamLimit)), () => ( _chunkPRDX3HP6cjs.DEFAULT_STREAM_LIMIT));
-    const eventLimit = _nullishCoalesce(options.eventLimit, () => ( _chunkPRDX3HP6cjs.DEFAULT_EVENT_LIMIT));
-    const leaseMillis = _nullishCoalesce(_nullishCoalesce(d.leaseMillis, () => ( options.leaseMillis)), () => ( _chunkPRDX3HP6cjs.DEFAULT_LEASE_MILLIS));
-    if (this._deps.breaker.state(Date.now()) === "open")
-      return EMPTY_DRAIN;
-    const pass = this._pass(streamLimit, eventLimit, leaseMillis).finally(
-      () => {
-        this._inflight = void 0;
-      }
+  // Read the row of each target this scan had no record of (new or evicted),
+  // so a resolution that doesn't beat its priority keeps the row's lane.
+  // Only called with more than one lane declared.
+  async _recall(correlated) {
+    const missed = [...correlated].filter(([, entry]) => entry.missed);
+    await Promise.all(
+      missed.map(async ([stream, entry]) => {
+        let row;
+        await _chunkLUHPSF3Ccjs.store.call(void 0, ).query_streams(
+          (position) => {
+            row = position;
+          },
+          { stream, stream_exact: true, limit: 1 }
+        );
+        if (!row) return;
+        this._dynamic_subscriptions.set(stream, {
+          priority: row.priority,
+          lane: row.lane
+        });
+        if (entry.priority > row.priority) return;
+        const held_lane = _nullishCoalesce(row.lane, () => ( _chunkYFFWCVXWcjs.DEFAULT_LANE));
+        const resolved_lane = _nullishCoalesce(entry.lane, () => ( _chunkYFFWCVXWcjs.DEFAULT_LANE));
+        if (entry.priority === row.priority && held_lane !== resolved_lane)
+          report_lane_conflict(
+            this._reported,
+            entry.handler,
+            stream,
+            held_lane,
+            resolved_lane
+          );
+        entry.priority = row.priority;
+        entry.lane = row.lane;
+        entry.upgraded = false;
+      })
     );
-    this._inflight = pass;
-    return pass;
   }
-  // One claim → fetch → handle → ack pass. Never throws.
-  async _pass(streamLimit, eventLimit, leaseMillis) {
+  /** Release the lease early by re-acquiring it for zero ms. Best-effort. */
+  async release_correlation() {
     try {
-      const lagging = Math.ceil(streamLimit * this._ratio);
-      const leading = streamLimit - lagging;
-      const started = Date.now();
-      const raised = this._raised;
-      const cycle = await run_drain_cycle(this._deps, {
-        lagging,
-        leading,
-        eventLimit,
-        leaseMillis,
-        misrouted: this._misrouted,
-        store_failing: this._deps.breaker.failing
+      this._lease_until = 0;
+      this._epoch++;
+      await this._cd.subscribe([], void 0, {
+        key: this._key,
+        by: this._by,
+        millis: 0
       });
-      if (!cycle) {
-        this._defer.prune(started);
-        this._deps.breaker.passed();
-        this._lowered = raised;
-        return EMPTY_DRAIN;
-      }
-      const { leased, fetched, handled, acked, blocked, closeable } = cycle;
-      trace_cycle(this._deps.logger, leased, fetched, handled, acked, blocked);
-      this._ratio = compute_lag_lead_ratio(handled, lagging, leading);
-      for (const lease of acked) this._defer.delete(lease.stream);
-      for (const lease of blocked) this._defer.delete(lease.stream);
-      for (const h of handled) {
-        const next = _nullishCoalesce(h.defer, () => ( h.next_attempt_at));
-        if (next !== void 0) this._defer.set(h.lease.stream, next);
-      }
-      if (acked.length) this._deps.on_acked(acked);
-      if (closeable.length) await this._deps.on_close(closeable);
-      this._deps.breaker.passed();
-      return { fetched, leased, acked, blocked };
     } catch (error) {
-      this._defer.set(
-        RETRY,
-        Date.now() + Math.max(leaseMillis, this._deps.breaker.cooldown_ms)
+      _chunkLUHPSF3Ccjs.log.call(void 0, ).warn(
+        `Could not hand back the correlation lease during shutdown; it expires on its own within ${CORRELATION_LEASE_MS}ms and correlation resumes normally after that. On a single-writer store this usually means another connection holds the database. Cause: ${String(_nullishCoalesce(error.cause, () => ( error)))}`
       );
-      this._deps.breaker.failed(Date.now(), error);
-      return EMPTY_DRAIN;
-    } finally {
-      if (!this._stopped) this._defer.schedule();
     }
   }
 }, _class5);
@@ -2550,7 +3052,7 @@ function pii_gate(event, fields, predicate, actor) {
   const { pii, ...rest } = event;
   if (pii == null) {
     const shredded = { ...data };
-    for (const f of fields) shredded[f] = _chunkH6KVPVP4cjs.SHREDDED;
+    for (const f of fields) shredded[f] = _chunkYFFWCVXWcjs.SHREDDED;
     return { ...rest, data: shredded };
   }
   const allowed = !!actor && !!predicate && predicate(event, actor);
@@ -2561,7 +3063,7 @@ function pii_gate(event, fields, predicate, actor) {
     };
   }
   const redacted = { ...data };
-  for (const f of fields) redacted[f] = _chunkH6KVPVP4cjs.REDACTED;
+  for (const f of fields) redacted[f] = _chunkYFFWCVXWcjs.REDACTED;
   return { ...rest, data: redacted };
 }
 var IDENTITY_GATE = (event) => event;
@@ -2657,191 +3159,15 @@ function make_fold_handler(me, flush, config2, sensitive_fields) {
       } else {
         fold.dirty = true;
       }
-      if (++folded_since_flush >= config2.flushEvery) {
-        await flush_dirty();
-        folded_since_flush = 0;
-      }
-    }
-    await flush_dirty();
-  };
-  Object.defineProperty(handler, FOLD_RESET, { value: () => cache2.clear() });
-  return handler;
-}
-
-// src/internal/defer-config.ts
-
-var DeferDurationSchema = _zod.z.object({
-  days: _zod.z.number().positive().optional(),
-  hours: _zod.z.number().positive().optional(),
-  minutes: _zod.z.number().positive().optional()
-}).strict().refine((d) => d.days != null || d.hours != null || d.minutes != null, {
-  message: "defer: a duration needs at least one of days, hours, or minutes"
-});
-var DeferWhenSchema = _zod.z.object({
-  after: DeferDurationSchema.optional(),
-  at: _zod.z.date().optional()
-}).strict().refine((w) => w.after === void 0 !== (w.at === void 0), {
-  message: "defer: specify exactly one of `after` or `at`"
-});
-function duration_ms(d) {
-  return (_nullishCoalesce(d.days, () => ( 0))) * 864e5 + (_nullishCoalesce(d.hours, () => ( 0))) * 36e5 + (_nullishCoalesce(d.minutes, () => ( 0))) * 6e4;
-}
-function resolve_defer_at(when, event) {
-  const parsed = DeferWhenSchema.parse(when);
-  if (parsed.after) return event.created.getTime() + duration_ms(parsed.after);
-  return parsed.at.getTime();
-}
-function assert_defer_when(when) {
-  DeferWhenSchema.parse(when);
-}
-function make_deferred(handler, schedule) {
-  const call = handler;
-  const deferred = async (event, stream, app) => {
-    const when = typeof schedule === "function" ? schedule(event) : schedule;
-    if (Date.now() < resolve_defer_at(when, event)) throw new (0, _chunkH6KVPVP4cjs.DeferSignal)(when);
-    return call(event, stream, app);
-  };
-  Object.defineProperty(deferred, "name", { value: handler.name });
-  return deferred;
-}
-
-// src/internal/reaction-dispatch.ts
-var CloseSignal = class extends Error {
-  /**
-   * Stream to close. Omitted → the reaction's own lease stream (a self-close).
-   * The synthesized autoclose reaction sets it to the aggregate stream, since
-   * its lease runs on a synthetic `__autoclose__` target.
-   */
-  
-  /** Optional archive callback to run while the stream is guarded. */
-  
-  /**
-   * Watermark to ack the requesting reaction to before the close runs. The
-   * close-cycle safety guard skips a stream whose subscriptions (matched by
-   * source) lag the head; the autoclose reaction's `source` is the aggregate,
-   * so it must advance its own watermark to the live head id it evaluated
-   * against — otherwise it blocks its own close. Defaults to the triggering
-   * event id when omitted.
-   */
-  
-  /**
-   * Windowed close: prune events older than this cutoff behind
-   * the closest safe snapshot instead of retiring the stream. Thrown by
-   * the autoclose reaction of a `.autocloses({ keep })` state; flows
-   * into {@link CloseTarget.before}. Omitted → a full close.
-   */
-  
-  constructor(opts) {
-    super("reaction requested close");
-    this.name = "CloseSignal";
-    this.stream = _optionalChain([opts, 'optionalAccess', _124 => _124.stream]);
-    this.archive = _optionalChain([opts, 'optionalAccess', _125 => _125.archive]);
-    this.at = _optionalChain([opts, 'optionalAccess', _126 => _126.at]);
-    this.before = _optionalChain([opts, 'optionalAccess', _127 => _127.before]);
-  }
-};
-function build_handle(deps) {
-  const { logger, reaction_scope } = deps;
-  return async (lease, payloads) => {
-    if (payloads.length === 0) return { lease, handled: 0, acked_at: lease.at };
-    const stream = lease.stream;
-    const last_index_of = /* @__PURE__ */ new Map();
-    for (let i = 0; i < payloads.length; i++)
-      last_index_of.set(payloads[i].event.id, i);
-    let at = lease.at;
-    let handled = 0;
-    if (lease.retry > 0)
-      logger.warn(
-        `Retrying ${stream}@${payloads.at(0).event.id} (${lease.retry}).`
-      );
-    for (let i = 0; i < payloads.length; i++) {
-      const payload = payloads[i];
-      const { event, handler } = payload;
-      try {
-        await reaction_scope.run(
-          event,
-          () => handler(event, stream, reaction_scope.app)
-        );
-        if (last_index_of.get(event.id) === i) {
-          at = event.id;
-          handled++;
-        }
-      } catch (error) {
-        if (error instanceof _chunkH6KVPVP4cjs.DeferSignal) {
-          let defer;
-          try {
-            defer = resolve_defer_at(error.when, event);
-          } catch (invalid) {
-            return finalize(
-              lease,
-              handled,
-              at,
-              invalid,
-              payload.options,
-              logger,
-              event.id
-            );
-          }
-          return { lease, handled, acked_at: at, defer };
-        }
-        if (error instanceof CloseSignal)
-          return {
-            lease,
-            handled: handled + 1,
-            // Advance to the live head the handler evaluated against (when
-            // provided) so the close-cycle guard sees this reaction caught up.
-            acked_at: _nullishCoalesce(error.at, () => ( event.id)),
-            // Close the signalled stream (the autoclose reaction's aggregate,
-            // which differs from its synthetic lease stream); a self-closing
-            // user reaction omits it and closes its own lease stream. A
-            // carried `before` makes it a windowed close (prune, not retire).
-            close: {
-              stream: _nullishCoalesce(error.stream, () => ( stream)),
-              archive: error.archive,
-              before: error.before
-            }
-          };
-        return finalize(
-          lease,
-          handled,
-          at,
-          error,
-          payload.options,
-          logger,
-          event.id
-        );
+      if (++folded_since_flush >= config2.flushEvery) {
+        await flush_dirty();
+        folded_since_flush = 0;
       }
     }
-    return finalize(lease, handled, at, void 0, payloads[0].options, logger);
-  };
-}
-function build_handle_batch(logger) {
-  return async (lease, payloads, batchHandler) => {
-    const stream = lease.stream;
-    const events = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const p of payloads) {
-      if (seen.has(p.event.id)) continue;
-      seen.add(p.event.id);
-      events.push(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);
-    }
+    await flush_dirty();
   };
+  Object.defineProperty(handler, FOLD_RESET, { value: () => cache2.clear() });
+  return handler;
 }
 
 // src/internal/settle.ts
@@ -2882,7 +3208,7 @@ var SettleLoop = (_class6 = class {
       this._pending = true;
       return;
     }
-    const delay = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _128 => _128.debounceMs]), () => ( this._default_debounce_ms));
+    const delay = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _152 => _152.debounceMs]), () => ( this._default_debounce_ms));
     const due = Date.now() + delay;
     if (this._timer) {
       if (due >= this._due) return;
@@ -3039,7 +3365,7 @@ var Act = (_class7 = class {
   // Lanes to arm per event; `"all"` when a dynamic resolver hides the lane.
   
   
-  __init27() {this._logger = _chunkPRDX3HP6cjs.log.call(void 0, )}
+  __init27() {this._logger = _chunkLUHPSF3Ccjs.log.call(void 0, )}
   // This Act's ports: its own bag, or the singleton adapters.
   
   // Runs a body so internal `store()`/`cache()` calls resolve to `_ports`.
@@ -3061,9 +3387,10 @@ var Act = (_class7 = class {
     this._lanes = lanes;
     this._declared_lanes = ["default", ...lanes.map((l) => l.name)];
     validate_only_lanes(options.onlyLanes, this._declared_lanes);
-    this._ports = _nullishCoalesce(options.scoped, () => ( _chunkPRDX3HP6cjs.default_scope.call(void 0, )));
+    if (options.scoped) _chunkLUHPSF3Ccjs.check_store.call(void 0, options.scoped.store);
+    this._ports = _nullishCoalesce(options.scoped, () => ( _chunkLUHPSF3Ccjs.default_scope.call(void 0, )));
     const ports = this._ports;
-    this._scoped = _chunkPRDX3HP6cjs.make_run_scoped.call(void 0, {
+    this._scoped = _chunkLUHPSF3Ccjs.make_run_scoped.call(void 0, {
       // Getters, not a spread: the singletons resolve lazily, so a later
       // `store(...)` / `cache(...)` still takes effect.
       get store() {
@@ -3073,14 +3400,14 @@ var Act = (_class7 = class {
         return ports.cache;
       },
       // Parsed per build, so a bad window throws on every build.
-      autoclose_window: _chunkPRDX3HP6cjs.resolveAutocloseConfig.call(void 0, options).autocloseWindow
+      autoclose_window: _chunkLUHPSF3Ccjs.resolveAutocloseConfig.call(void 0, options).autocloseWindow
     });
     this._correlator = _nullishCoalesce(options.correlator, () => ( default_correlator));
     this._es = build_es(this._logger, this._correlator, patch_fn);
     this._cd = build_drain(this._logger);
     const handle = build_handle({
       logger: this._logger,
-      reaction_scope: _chunkPRDX3HP6cjs.make_reaction_scope.call(void 0, {
+      reaction_scope: _chunkLUHPSF3Ccjs.make_reaction_scope.call(void 0, {
         do: this.do.bind(this),
         load: this.load.bind(this),
         query: this.query.bind(this),
@@ -3110,12 +3437,12 @@ var Act = (_class7 = class {
       this._ports.store,
       options.listen !== false
     );
-    _chunkPRDX3HP6cjs.register_weak_disposer.call(void 0, new WeakRef(this), (self) => self.shutdown());
+    _chunkLUHPSF3Ccjs.register_weak_disposer.call(void 0, new WeakRef(this), (self) => self.shutdown());
   }
   // Shared by drain, settle and autoclose; bad knobs throw at build.
   _build_breaker(options) {
     return new CircuitBreaker(
-      _chunkPRDX3HP6cjs.resolveCircuitBreakerConfig.call(void 0, options.circuitBreaker),
+      _chunkLUHPSF3Ccjs.resolveCircuitBreakerConfig.call(void 0, options.circuitBreaker),
       {
         on_error: (error, circuit) => this._emit_error(error, circuit),
         // When the cooldown elapses, settle once: its scan or claim is the
@@ -3127,7 +3454,7 @@ var Act = (_class7 = class {
   // Apps that declare no lanes pass no lane filter to `claim`.
   _build_drain_controllers(options, lanes, handle, handle_batch) {
     const all_lanes = this._declared_lanes;
-    const only_set = _optionalChain([options, 'access', _129 => _129.onlyLanes, 'optionalAccess', _130 => _130.length]) ? new Set(options.onlyLanes) : void 0;
+    const only_set = _optionalChain([options, 'access', _153 => _153.onlyLanes, 'optionalAccess', _154 => _154.length]) ? new Set(options.onlyLanes) : void 0;
     const active_lanes = only_set ? all_lanes.filter((n) => only_set.has(n)) : all_lanes;
     const single_default_lane = lanes.length === 0;
     const controllers = /* @__PURE__ */ new Map();
@@ -3149,7 +3476,7 @@ var Act = (_class7 = class {
           try {
             await this._run_close(targets);
           } catch (error) {
-            if (error instanceof _chunkH6KVPVP4cjs.StoreError) throw error;
+            if (error instanceof _chunkYFFWCVXWcjs.StoreError) throw error;
             this._logger.error(
               error,
               `Reaction-requested close of ${targets.map((t) => `"${t.stream}"`).join(", ")} failed and was not retried; close it with app.close(...) once the cause is fixed.`
@@ -3164,7 +3491,7 @@ var Act = (_class7 = class {
           leaseMillis: cfg.leaseMillis
         }
       });
-      if (_optionalChain([cfg, 'optionalAccess', _131 => _131.cycleMs]) !== void 0 && this._drain)
+      if (_optionalChain([cfg, 'optionalAccess', _155 => _155.cycleMs]) !== void 0 && this._drain)
         controller.start(cfg.cycleMs);
       controllers.set(name, controller);
     }
@@ -3183,7 +3510,7 @@ var Act = (_class7 = class {
   // Audit deps, built after the controllers so the lane set is final.
   _build_audit_deps() {
     return {
-      store: _chunkPRDX3HP6cjs.store,
+      store: _chunkLUHPSF3Ccjs.store,
       event_to_state: this._event_to_state,
       // Declared lanes, not this process's controllers: a lane another
       // worker drains is not `unknown-lane`.
@@ -3196,7 +3523,7 @@ var Act = (_class7 = class {
       registry: this.registry,
       static_targets: classification.static_targets,
       cd: this._cd,
-      max_subscribed_streams: _nullishCoalesce(options.maxSubscribedStreams, () => ( _chunkH6KVPVP4cjs.DEFAULT_MAX_SUBSCRIBED_STREAMS)),
+      max_subscribed_streams: _nullishCoalesce(options.maxSubscribedStreams, () => ( _chunkYFFWCVXWcjs.DEFAULT_MAX_SUBSCRIBED_STREAMS)),
       // Declared lanes (not active ones): a lane another process claims is
       // still a valid destination.
       declared_lanes: new Set(this._declared_lanes),
@@ -3212,10 +3539,10 @@ var Act = (_class7 = class {
   // Cold start: an idle deferred stream still fires on time after a restart.
   async _seed_persisted_defers() {
     const now = Date.now();
-    await walk_streams(_chunkPRDX3HP6cjs.store.call(void 0, ), (pos) => {
+    await walk_streams(_chunkLUHPSF3Ccjs.store.call(void 0, ), (pos) => {
       if (pos.deferred_at === void 0 || pos.deferred_at <= now) return;
       const controller = this._drain_controllers.get(_nullishCoalesce(pos.lane, () => ( "default")));
-      _optionalChain([controller, 'optionalAccess', _132 => _132.seed_defer, 'call', _133 => _133(pos.stream, pos.deferred_at)]);
+      _optionalChain([controller, 'optionalAccess', _156 => _156.seed_defer, 'call', _157 => _157(pos.stream, pos.deferred_at)]);
     });
   }
   _build_settle(options) {
@@ -3228,7 +3555,7 @@ var Act = (_class7 = class {
         on_settled: (drain) => this.emit("settled", drain),
         breaker: this._breaker
       },
-      _nullishCoalesce(options.settleDebounceMs, () => ( _chunkH6KVPVP4cjs.DEFAULT_SETTLE_DEBOUNCE_MS))
+      _nullishCoalesce(options.settleDebounceMs, () => ( _chunkYFFWCVXWcjs.DEFAULT_SETTLE_DEBOUNCE_MS))
     );
   }
   
@@ -3248,7 +3575,7 @@ var Act = (_class7 = class {
    */
   shutdown(options) {
     if (!this._shutdown_promise) {
-      _chunkPRDX3HP6cjs.resolveShutdownConfig.call(void 0, options);
+      _chunkLUHPSF3Ccjs.resolveShutdownConfig.call(void 0, options);
       this._shutdown_promise = (async () => {
         this.stop_correlations();
         this._settle.stop(true);
@@ -3256,7 +3583,7 @@ var Act = (_class7 = class {
         for (const c of this._drain_controllers.values()) c.stop();
         const disposer = await this._notify_disposer;
         if (disposer) await disposer();
-        await this._await_inflight(_optionalChain([options, 'optionalAccess', _134 => _134.graceMs]));
+        await this._await_inflight(_optionalChain([options, 'optionalAccess', _158 => _158.graceMs]));
         await this._scoped(() => this._correlate.release_correlation());
         this._emitter.removeAllListeners();
       })();
@@ -3266,10 +3593,10 @@ var Act = (_class7 = class {
   // The largest `leaseMillis` among lanes with a cycle in flight (the
   // default for none or 0, and for a running settle), capped.
   _derive_grace_ms(running, settling) {
-    let max = settling ? _chunkPRDX3HP6cjs.DEFAULT_LEASE_MILLIS : 0;
+    let max = settling ? _chunkLUHPSF3Ccjs.DEFAULT_LEASE_MILLIS : 0;
     for (const c of running)
-      max = Math.max(max, c.lease_millis || _chunkPRDX3HP6cjs.DEFAULT_LEASE_MILLIS);
-    return Math.min(max, _chunkPRDX3HP6cjs.MAX_SHUTDOWN_GRACE_MS);
+      max = Math.max(max, c.lease_millis || _chunkLUHPSF3Ccjs.DEFAULT_LEASE_MILLIS);
+    return Math.min(max, _chunkLUHPSF3Ccjs.MAX_SHUTDOWN_GRACE_MS);
   }
   async _await_inflight(grace_ms) {
     const running = [...this._drain_controllers.values()].filter(
@@ -3316,7 +3643,7 @@ var Act = (_class7 = class {
    * Executes an action: validates the payload, loads the state, checks its
    * preconditions, runs the handler, folds the events it emits, checks the
    * state's invariants (its schema) on the result, and commits them with
-   * optimistic concurrency on the stream. The reactions to those events
+   * optimistic concurrency on every stream it appends to. The reactions to those events
    * settle on their own (unless `autoSettle: false`).
    *
    * @template TKey - Action name from registered actions
@@ -3326,7 +3653,8 @@ var Act = (_class7 = class {
    * @param options - Per-call dispatch options ({@link DoOptions}) —
    *   `reactingTo` to thread correlation, `correlator` to override the
    *   framework or orchestrator-level correlator for this call only.
-   * @returns Array of snapshots for all affected states (usually one)
+   * @returns The snapshots of the action's own stream, one per event appended
+   *   to it; the loaded snapshot alone when the action commits nothing
    *
    * @throws {ValidationError} If the payload doesn't match the action schema,
    *   or the state the action leaves breaks the state schema
@@ -3352,8 +3680,8 @@ var Act = (_class7 = class {
    * @see {@link ValidationError}, {@link PreconditionError}, {@link ConcurrencyError}
    */
   async do(action2, target, payload, options) {
-    const reacting_to = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _135 => _135.reactingTo]), () => ( _chunkPRDX3HP6cjs.current_reacting.call(void 0, )));
-    const do_options = reacting_to === _optionalChain([options, 'optionalAccess', _136 => _136.reactingTo]) ? options : { ...options, reactingTo: reacting_to };
+    const reacting_to = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _159 => _159.reactingTo]), () => ( _chunkLUHPSF3Ccjs.current_reacting.call(void 0, )));
+    const do_options = reacting_to === _optionalChain([options, 'optionalAccess', _160 => _160.reactingTo]) ? options : { ...options, reactingTo: reacting_to };
     return this._scoped(async () => {
       const snapshots = await this._es.action(
         this.registry.actions[action2],
@@ -3363,13 +3691,22 @@ var Act = (_class7 = class {
         do_options
       );
       if (!snapshots[0].patch) return snapshots;
+      const me = this.registry.actions[action2];
       this._wake(snapshots.map((s) => s.event.name));
-      this.emit("committed", snapshots);
-      this._notify(
-        `committed:${this.registry.actions[action2].name}`,
-        snapshots
-      );
-      return snapshots;
+      const by_stream = /* @__PURE__ */ new Map();
+      for (const s of snapshots) {
+        const of_stream = by_stream.get(s.event.stream);
+        if (of_stream) of_stream.push(s);
+        else by_stream.set(s.event.stream, [s]);
+      }
+      for (const [stream, of_stream] of by_stream) {
+        const owner = stream === target.stream ? me : me.loads[action2].find(
+          (l) => l.events.includes(of_stream[0].event.name)
+        ).state;
+        this.emit("committed", of_stream);
+        this._notify(`committed:${owner.name}`, of_stream);
+      }
+      return snapshots.filter((s) => s.event.stream === target.stream);
     });
   }
   async load(stateOrName, streamOrTarget, callback, asOf) {
@@ -3418,11 +3755,11 @@ var Act = (_class7 = class {
     return this._scoped(async () => {
       let first;
       let last;
-      const count = await _chunkPRDX3HP6cjs.store.call(void 0, ).query((e) => {
+      const count = await _chunkLUHPSF3Ccjs.store.call(void 0, ).query((e) => {
         const gated = this.registry.query_gate(e.name)(e);
         if (!first) first = gated;
         last = gated;
-        _optionalChain([callback, 'optionalCall', _137 => _137(gated)]);
+        _optionalChain([callback, 'optionalCall', _161 => _161(gated)]);
       }, query);
       return { first, last, count };
     });
@@ -3448,7 +3785,7 @@ var Act = (_class7 = class {
   async query_array(query) {
     return this._scoped(async () => {
       const events = [];
-      await _chunkPRDX3HP6cjs.store.call(void 0, ).query((e) => {
+      await _chunkLUHPSF3Ccjs.store.call(void 0, ).query((e) => {
         events.push(this.registry.query_gate(e.name)(e));
       }, query);
       return events;
@@ -3468,14 +3805,14 @@ var Act = (_class7 = class {
    */
   async forget(stream) {
     return this._scoped(async () => {
-      const s = _chunkPRDX3HP6cjs.store.call(void 0, );
+      const s = _chunkLUHPSF3Ccjs.store.call(void 0, );
       if (!s.forget_pii) {
         throw new Error(
           `Store does not implement forget_pii \u2014 adapter cannot comply with sensitive-data erasure. Use an adapter that declares pii_isolation: true (e.g. @rotorsoft/act on the in-memory store).`
         );
       }
       const eventCount = await s.forget_pii(stream);
-      await _chunkPRDX3HP6cjs.cache.call(void 0, ).invalidate(stream);
+      await _chunkLUHPSF3Ccjs.cache.call(void 0, ).invalidate(stream);
       if (eventCount > 0) {
         this.emit("forgotten", { stream, at: /* @__PURE__ */ new Date(), eventCount });
       }
@@ -3509,7 +3846,7 @@ var Act = (_class7 = class {
    * @see {@link correlate} for dynamic stream discovery
    */
   async drain(options = {}) {
-    _chunkPRDX3HP6cjs.resolveDrainConfig.call(void 0, options);
+    _chunkLUHPSF3Ccjs.resolveDrainConfig.call(void 0, options);
     if (!this._drain)
       return { fetched: [], leased: [], acked: [], blocked: [] };
     return this._scoped(() => this._drain_all(options));
@@ -3547,7 +3884,7 @@ var Act = (_class7 = class {
     }
     if (to_arm.size === 0) return false;
     this._correlate.arm();
-    for (const lane of to_arm) _optionalChain([this, 'access', _138 => _138._drain_controllers, 'access', _139 => _139.get, 'call', _140 => _140(lane), 'optionalAccess', _141 => _141.arm, 'call', _142 => _142()]);
+    for (const lane of to_arm) _optionalChain([this, 'access', _162 => _162._drain_controllers, 'access', _163 => _163.get, 'call', _164 => _164(lane), 'optionalAccess', _165 => _165.arm, 'call', _166 => _166()]);
     return true;
   }
   // In parallel, so a slow lane never holds up a fast one.
@@ -3689,9 +4026,9 @@ var Act = (_class7 = class {
    */
   async reset(input) {
     return this._scoped(async () => {
-      const count = await _chunkPRDX3HP6cjs.store.call(void 0, ).reset(input);
+      const count = await _chunkLUHPSF3Ccjs.store.call(void 0, ).reset(input);
       for (const handler of this._batch_handlers.values())
-        _optionalChain([handler, 'access', _143 => _143[FOLD_RESET], 'optionalCall', _144 => _144()]);
+        _optionalChain([handler, 'access', _167 => _167[FOLD_RESET], 'optionalCall', _168 => _168()]);
       if (count > 0) {
         this._wake();
       }
@@ -3725,7 +4062,7 @@ var Act = (_class7 = class {
    */
   async unblock(input) {
     return this._scoped(async () => {
-      const count = await _chunkPRDX3HP6cjs.store.call(void 0, ).unblock(input);
+      const count = await _chunkLUHPSF3Ccjs.store.call(void 0, ).unblock(input);
       if (count > 0) {
         this._wake();
       }
@@ -3780,7 +4117,7 @@ var Act = (_class7 = class {
         return { ...partial, duration_ms: Date.now() - started };
       }
       const target = _nullishCoalesce(sink, () => ( (() => {
-        const s = _chunkPRDX3HP6cjs.store.call(void 0, );
+        const s = _chunkLUHPSF3Ccjs.store.call(void 0, );
         if (!s.restore) throw new Error("adapter has no restore capability");
         return s;
       })()));
@@ -3826,11 +4163,11 @@ var Act = (_class7 = class {
   async blocked_streams(options) {
     return this._scoped(async () => {
       const positions = [];
-      await _chunkPRDX3HP6cjs.store.call(void 0, ).query_streams(
+      await _chunkLUHPSF3Ccjs.store.call(void 0, ).query_streams(
         (p) => {
           positions.push(p);
         },
-        { blocked: true, after: _optionalChain([options, 'optionalAccess', _145 => _145.after]), limit: _optionalChain([options, 'optionalAccess', _146 => _146.limit]) }
+        { blocked: true, after: _optionalChain([options, 'optionalAccess', _169 => _169.after]), limit: _optionalChain([options, 'optionalAccess', _170 => _170.limit]) }
       );
       return positions;
     });
@@ -3878,7 +4215,7 @@ var Act = (_class7 = class {
    * @see {@link Store.prioritize} for the underlying primitive
    */
   async prioritize(filter, priority) {
-    return this._scoped(() => _chunkPRDX3HP6cjs.store.call(void 0, ).prioritize(filter, priority));
+    return this._scoped(() => _chunkLUHPSF3Ccjs.store.call(void 0, ).prioritize(filter, priority));
   }
   // Shared by `close()` and reaction-requested closes.
   async _run_close(targets) {
@@ -3958,222 +4295,11 @@ var Act = (_class7 = class {
    * @see {@link correlate} for manual correlation
    */
   settle(options) {
-    _chunkPRDX3HP6cjs.resolveSettleConfig.call(void 0, _nullishCoalesce(options, () => ( {})));
+    _chunkLUHPSF3Ccjs.resolveSettleConfig.call(void 0, _nullishCoalesce(options, () => ( {})));
     this._schedule(options);
   }
 }, _class7);
 
-// src/internal/autoclose-policy.ts
-
-var DAY_MS = 864e5;
-var MIN_AFTER_DAYS = 1 / 1440;
-var MIN_KEEP_DAYS = 1;
-function days_after(date, days) {
-  return new Date(date.getTime() + days * DAY_MS);
-}
-function days_before_now(days) {
-  return new Date(Date.now() - days * DAY_MS);
-}
-var window_schema = (field, min_days, floor) => _zod.z.object({
-  days: _zod.z.number({ message: `autocloses: ${field}.days must be a number` }).positive(`autocloses: ${field}.days must be > 0`)
-}).refine((o) => o.days >= min_days, {
-  message: `autocloses: ${field} resolves to < ${floor}, which is too short to be a meaningful retention window`
-});
-var AfterSchema = window_schema("after", MIN_AFTER_DAYS, "one minute");
-var KeepSchema = window_schema("keep", MIN_KEEP_DAYS, "one day");
-var IsSchema = _zod.z.union([
-  _zod.z.string().min(1, "autocloses: is must be a non-empty event name"),
-  _zod.z.array(
-    _zod.z.string().min(1, "autocloses: is entries must be non-empty event names")
-  ).min(1, "autocloses: is must include at least one event name").readonly()
-]);
-var ReachesSchema = _zod.z.number({ message: "autocloses: reaches must be a number" }).int("autocloses: reaches must be an integer").min(1, "autocloses: reaches must be >= 1");
-var OrBlockSchema = _zod.z.object({
-  after: AfterSchema.optional(),
-  is: IsSchema.optional(),
-  reaches: ReachesSchema.optional()
-}).strict().refine(
-  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0,
-  {
-    message: "autocloses: `or` block must include at least one of after / is / reaches"
-  }
-);
-var AutoclosePolicySchema = _zod.z.object({
-  after: AfterSchema.optional(),
-  is: IsSchema.optional(),
-  reaches: ReachesSchema.optional(),
-  or: OrBlockSchema.optional(),
-  keep: KeepSchema.optional()
-}).strict().refine(
-  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0 || o.or !== void 0 || o.keep !== void 0,
-  {
-    message: "autocloses: at least one of after / is / reaches / or / keep must be specified \u2014 empty `{}` is a misconfiguration"
-  }
-);
-function compile_after(after) {
-  return (_stream, head) => days_after(head.created, after.days) <= /* @__PURE__ */ new Date();
-}
-function compile_is(is) {
-  const set = new Set(typeof is === "string" ? [is] : is);
-  return (_stream, head) => set.has(head.name);
-}
-function compile_reaches(reaches) {
-  return (_stream, _head, count) => count >= reaches;
-}
-function policy_min_after_days(options) {
-  const parsed = AutoclosePolicySchema.parse(options);
-  const windows = [];
-  if (parsed.after) windows.push(parsed.after.days);
-  if (_optionalChain([parsed, 'access', _147 => _147.or, 'optionalAccess', _148 => _148.after])) windows.push(parsed.or.after.days);
-  return windows.length ? Math.min(...windows) : void 0;
-}
-function policy_after_windows(options) {
-  const parsed = AutoclosePolicySchema.parse(options);
-  return [parsed.after, _optionalChain([parsed, 'access', _149 => _149.or, 'optionalAccess', _150 => _150.after])].flatMap((w) => w ? [w.days] : []);
-}
-function policy_keep_days(options) {
-  const parsed = AutoclosePolicySchema.parse(options);
-  return _optionalChain([parsed, 'access', _151 => _151.keep, 'optionalAccess', _152 => _152.days]);
-}
-function compile_autoclose_policy(options) {
-  const parsed = AutoclosePolicySchema.parse(options);
-  const and_preds = [];
-  if (parsed.after) and_preds.push(compile_after(parsed.after));
-  if (parsed.is) and_preds.push(compile_is(parsed.is));
-  if (parsed.reaches) and_preds.push(compile_reaches(parsed.reaches));
-  const or_preds = [];
-  if (parsed.or) {
-    if (parsed.or.after) or_preds.push(compile_after(parsed.or.after));
-    if (parsed.or.is) or_preds.push(compile_is(parsed.or.is));
-    if (parsed.or.reaches) or_preds.push(compile_reaches(parsed.or.reaches));
-  }
-  return (stream, head, count) => {
-    if (and_preds.length > 0 && and_preds.every((p) => p(stream, head, count))) {
-      return true;
-    }
-    if (or_preds.some((p) => p(stream, head, count))) {
-      return true;
-    }
-    return false;
-  };
-}
-
-// src/internal/autoclose-window.ts
-function hour_in_zone(now, timeZone) {
-  const parts = new Intl.DateTimeFormat("en-US", {
-    timeZone,
-    hour: "2-digit",
-    hourCycle: "h23"
-  }).formatToParts(now);
-  return Number(_optionalChain([parts, 'access', _153 => _153.find, 'call', _154 => _154((p) => p.type === "hour"), 'optionalAccess', _155 => _155.value]));
-}
-function hour_in_range(hour, start, end) {
-  return start < end ? hour >= start && hour < end : hour >= start || hour < end;
-}
-function is_dst_gap_open(now, timeZone, start) {
-  const hour = hour_in_zone(now, timeZone);
-  if (hour <= start) return false;
-  const prev = hour_in_zone(new Date(now.getTime() - 36e5), timeZone);
-  return prev === start - 1 && hour === start + 1;
-}
-function in_autoclose_window(window, now) {
-  if (!window) return true;
-  const hour = hour_in_zone(now, window.timeZone);
-  return hour_in_range(hour, window.start, window.end) || is_dst_gap_open(now, window.timeZone, window.start);
-}
-function next_window_open(window, now) {
-  const start_ms = now.getTime();
-  for (let h = 0; h <= 48; h++) {
-    const candidate = new Date(start_ms + h * 36e5);
-    if (hour_in_zone(candidate, window.timeZone) === window.start)
-      return candidate;
-    const boundary = new Date(
-      candidate.getTime() - candidate.getTime() % 36e5
-    );
-    if (boundary.getTime() >= start_ms && is_dst_gap_open(boundary, window.timeZone, window.start))
-      return boundary;
-  }
-  return new Date(start_ms + 864e5);
-}
-
-// src/internal/autoclose-reaction.ts
-var AUTOCLOSE_TARGET_PREFIX = "__autoclose__:";
-function synthesize_autoclose_reactions(registry, states, read_window) {
-  for (const st of states.values()) {
-    const predicate = st.autoclose;
-    if (!predicate) continue;
-    const after_windows = st.autoclose_after_windows;
-    const keep_days = st.autoclose_keep_days;
-    const archiver = st.archive;
-    const reaction = {
-      // Run on a SYNTHETIC stream — `source` is the aggregate, `target` is a
-      // per-aggregate `__autoclose__` key — so the autoclose reaction never
-      // shares a watermark with the aggregate's own reactions. A shared
-      // watermark would let autoclose's defer short-circuit the aggregate's
-      // other reactions (the "a defer affects all reactions on a stream"
-      // hazard). The close still targets the aggregate (`source`).
-      // A stream name with a regex metacharacter would read as a pattern, and a
-      // store may refuse it at subscribe, stopping every reaction. Such a stream
-      // has no autoclose: `app.close` still closes it.
-      resolver: (e) => _chunkPRDX3HP6cjs.is_literal_source.call(void 0, e.stream) ? {
-        target: `${AUTOCLOSE_TARGET_PREFIX}${e.stream}`,
-        source: e.stream
-      } : void 0,
-      // Never block on autoclose: a transient query/store error should retry,
-      // not quarantine the synthetic stream.
-      options: { blockOnError: false, maxRetries: _chunkPRDX3HP6cjs.DEFAULT_MAX_RETRIES },
-      handler: async (event) => {
-        const aggregate = event.stream;
-        const window = read_window();
-        if (!in_autoclose_window(window, /* @__PURE__ */ new Date()))
-          throw new (0, _chunkH6KVPVP4cjs.DeferSignal)({ at: next_window_open(window, /* @__PURE__ */ new Date()) });
-        const stats = await _chunkPRDX3HP6cjs.store.call(void 0, ).query_stats([aggregate], {
-          count: true,
-          tail: keep_days !== void 0 ? true : void 0,
-          exclude: [_chunkH6KVPVP4cjs.TOMBSTONE_EVENT, _chunkH6KVPVP4cjs.SNAP_EVENT]
-        });
-        const entry = stats.get(aggregate);
-        if (!entry) return;
-        const head = entry.head;
-        if (predicate(aggregate, head, entry.count))
-          throw new CloseSignal({
-            stream: aggregate,
-            archive: archiver ? () => archiver(aggregate, head) : void 0,
-            // Ack this reaction's own watermark to the live head so the
-            // close-cycle guard (which matches subscriptions by source =
-            // aggregate) sees it caught up instead of blocking its own close.
-            at: head.id
-          });
-        if (keep_days !== void 0) {
-          const cutoff = days_before_now(keep_days);
-          if (entry.tail.created < cutoff)
-            throw new CloseSignal({
-              stream: aggregate,
-              before: cutoff,
-              archive: archiver ? () => archiver(aggregate, head, cutoff) : void 0,
-              at: head.id
-            });
-        }
-        const dues = [];
-        for (const days of after_windows)
-          dues.push(days_after(head.created, days));
-        if (keep_days !== void 0)
-          dues.push(days_after(entry.tail.created, keep_days));
-        const future = dues.map((d) => d.getTime()).filter((t) => t > Date.now());
-        if (future.length)
-          throw new (0, _chunkH6KVPVP4cjs.DeferSignal)({ at: new Date(Math.min(...future)) });
-      }
-    };
-    const key = `__autoclose_${st.name}`;
-    for (const event_name of Object.keys(st.events)) {
-      _optionalChain([registry, 'access', _156 => _156.events, 'access', _157 => _157[event_name], 'optionalAccess', _158 => _158.reactions, 'access', _159 => _159.set, 'call', _160 => _160(
-        key,
-        reaction
-      )]);
-    }
-  }
-}
-
 // src/builders/merge.ts
 
 function base_type_name(zodType) {
@@ -4273,8 +4399,8 @@ function merge_into_existing(state2, existing, states, actions, events) {
     actions: { ...existing.actions, ...state2.actions },
     patch: merged_patch,
     on: { ...existing.on, ...state2.on },
-    given: { ...existing.given, ...state2.given },
     requires: { ...existing.requires, ...state2.requires },
+    loads: existing.loads || state2.loads ? { ...existing.loads, ...state2.loads } : void 0,
     snap: pick_declared(existing.snap, state2.snap, "snap strategy", state2.name),
     // Per-action retry policy is keyed by action name, so the two partials'
     // maps combine. Left `undefined` when neither declared one, so the
@@ -4367,9 +4493,9 @@ var _this_ = ({ stream }) => ({
 
 // src/builders/builder-utils.ts
 function register_lane(config2, lanes) {
-  _chunkPRDX3HP6cjs.resolveLaneConfig.call(void 0, config2);
-  if (config2.name === _chunkH6KVPVP4cjs.DEFAULT_LANE)
-    throw new Error(`Lane "${_chunkH6KVPVP4cjs.DEFAULT_LANE}" is reserved`);
+  _chunkLUHPSF3Ccjs.resolveLaneConfig.call(void 0, config2);
+  if (config2.name === _chunkYFFWCVXWcjs.DEFAULT_LANE)
+    throw new Error(`Lane "${_chunkYFFWCVXWcjs.DEFAULT_LANE}" is reserved`);
   const existing = lanes.find((l) => l.name === config2.name);
   if (!existing) return void lanes.push(config2);
   if (existing.leaseMillis !== config2.leaseMillis || existing.streamLimit !== config2.streamLimit || existing.cycleMs !== config2.cycleMs)
@@ -4411,10 +4537,10 @@ function reaction_on(event, events, builder) {
         // Validate the whole bag at the declaration site so a bad
         // `maxRetries`/`backoff`/`blockOnError` throws ZodError at build,
         // not a NaN gate on the first retry.
-        options: _chunkPRDX3HP6cjs.resolveReactionConfig.call(void 0, {
-          blockOnError: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _161 => _161.blockOnError]), () => ( _chunkPRDX3HP6cjs.DEFAULT_BLOCK_ON_ERROR)),
-          maxRetries: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _162 => _162.maxRetries]), () => ( _chunkPRDX3HP6cjs.DEFAULT_MAX_RETRIES)),
-          backoff: _optionalChain([options, 'optionalAccess', _163 => _163.backoff])
+        options: _chunkLUHPSF3Ccjs.resolveReactionConfig.call(void 0, {
+          blockOnError: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _171 => _171.blockOnError]), () => ( _chunkLUHPSF3Ccjs.DEFAULT_BLOCK_ON_ERROR)),
+          maxRetries: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _172 => _172.maxRetries]), () => ( _chunkLUHPSF3Ccjs.DEFAULT_MAX_RETRIES)),
+          backoff: _optionalChain([options, 'optionalAccess', _173 => _173.backoff])
         })
       };
     },
@@ -4433,25 +4559,47 @@ function reaction_on(event, events, builder) {
 
 // src/internal/date-reviver.ts
 
-function variant_schema(schema) {
-  const shape = _optionalChain([_chunkH6KVPVP4cjs.def_of.call(void 0, schema), 'optionalAccess', _164 => _164.shape]);
+function variant_schema(schema, walk) {
+  const shape = _optionalChain([_chunkYFFWCVXWcjs.def_of.call(void 0, schema), 'optionalAccess', _174 => _174.shape]);
   if (!shape) {
-    const dates = date_reviver_schema(schema);
+    const dates = walk(schema);
     return { schema: _nullishCoalesce(dates, () => ( schema)), dated: !!dates };
   }
   const next = {};
   let dated = false;
   for (const [key, field] of Object.entries(shape)) {
-    const dates = date_reviver_schema(field);
+    const dates = walk(field);
     if (dates) dated = true;
     next[key] = (_nullishCoalesce(dates, () => ( field))).optional();
   }
   return { schema: _zod.z.looseObject(next), dated };
 }
 function date_reviver_schema(schema) {
-  const def = _chunkH6KVPVP4cjs.def_of.call(void 0, schema);
+  let recursive = false;
+  const pass = (tie) => {
+    const done = /* @__PURE__ */ new Map();
+    const active = /* @__PURE__ */ new Set();
+    const walk = (node) => {
+      if (done.has(node)) return done.get(node);
+      if (active.has(node)) {
+        recursive = true;
+        return tie ? _zod.z.lazy(() => done.get(node)) : void 0;
+      }
+      active.add(node);
+      const result = build(node, walk);
+      active.delete(node);
+      done.set(node, result);
+      return result;
+    };
+    return walk(schema);
+  };
+  const first = pass(false);
+  return first && recursive ? pass(true) : first;
+}
+function build(schema, walk) {
+  const def = _chunkYFFWCVXWcjs.def_of.call(void 0, schema);
   if (!def) return void 0;
-  const inner = () => date_reviver_schema(def.innerType);
+  const inner = () => walk(def.innerType);
   switch (def.type) {
     case "date":
       return _zod.z.coerce.date();
@@ -4460,39 +4608,48 @@ function date_reviver_schema(schema) {
       if (!shape) return void 0;
       const dated = {};
       for (const [key, field] of Object.entries(shape)) {
-        const dates = date_reviver_schema(field);
+        const dates = walk(field);
         if (dates) dated[key] = dates.optional();
       }
       return Object.keys(dated).length ? _zod.z.looseObject(dated) : void 0;
     }
     case "array": {
-      const element = date_reviver_schema(def.element);
+      const element = walk(def.element);
       return element && _zod.z.array(element);
     }
     case "tuple": {
-      const items = def.items.map((i) => date_reviver_schema(i));
+      const items = def.items.map((i) => walk(i));
       return items.some(Boolean) ? _zod.z.tuple(items.map((i) => _nullishCoalesce(i, () => ( _zod.z.unknown())))) : void 0;
     }
     case "record": {
-      const value = date_reviver_schema(def.valueType);
+      const value = walk(def.valueType);
       return value && _zod.z.record(_zod.z.string(), value);
     }
     case "union": {
-      const variants = def.options.map(variant_schema);
+      const variants = def.options.map(
+        (o) => variant_schema(o, walk)
+      );
       return variants.some((v) => v.dated) ? _zod.z.union(variants.map((v) => v.schema)) : void 0;
     }
     case "nullable":
-      return _optionalChain([inner, 'call', _165 => _165(), 'optionalAccess', _166 => _166.nullable, 'call', _167 => _167()]);
+      return _optionalChain([inner, 'call', _175 => _175(), 'optionalAccess', _176 => _176.nullable, 'call', _177 => _177()]);
     case "pipe":
-      return date_reviver_schema(def.out);
+      return walk(def.out);
+    case "lazy":
+      return walk(def.getter());
+    case "intersection": {
+      const left = walk(def.left);
+      const right = walk(def.right);
+      return left && right ? left.pipe(right) : _nullishCoalesce(left, () => ( right));
+    }
     default:
-      return _chunkH6KVPVP4cjs.inner_of.call(void 0, def) ? inner() : void 0;
+      return _chunkYFFWCVXWcjs.inner_of.call(void 0, def) ? inner() : void 0;
   }
 }
 
 // src/builders/event-builder.ts
 function event_tags(schema) {
-  const pii = _chunkH6KVPVP4cjs.pii_schemas.call(void 0, schema);
+  const pii = _chunkYFFWCVXWcjs.pii_schemas.call(void 0, schema);
   const pii_dates = {};
   for (const [key, field] of Object.entries(pii)) {
     const dates = date_reviver_schema(field);
@@ -4530,7 +4687,7 @@ function make_event_reader(tags, disclosure, predicate = null) {
   });
 }
 function build_events(registry, states, lanes, owners) {
-  const declared = /* @__PURE__ */ new Set([_chunkH6KVPVP4cjs.DEFAULT_LANE, ...lanes.map((l) => l.name)]);
+  const declared = /* @__PURE__ */ new Set([_chunkYFFWCVXWcjs.DEFAULT_LANE, ...lanes.map((l) => l.name)]);
   const lane_errors = [];
   const tags = /* @__PURE__ */ new Map();
   const sensitive2 = /* @__PURE__ */ new Map();
@@ -4605,7 +4762,7 @@ function build_events(registry, states, lanes, owners) {
       if (reader) readers.set(event_name, reader);
     }
     const snap2 = make_event_reader(event_tags(state2.state), "redact", null);
-    if (snap2) readers.set(_chunkH6KVPVP4cjs.SNAP_EVENT, snap2);
+    if (snap2) readers.set(_chunkYFFWCVXWcjs.SNAP_EVENT, snap2);
     if (readers.size === 0) continue;
     state2.view = (event, actor) => (_nullishCoalesce(readers.get(event.name), () => ( IDENTITY_GATE)))(event, actor);
   }
@@ -4613,7 +4770,7 @@ function build_events(registry, states, lanes, owners) {
   return { sensitive: sensitive2, advisory, query_readers, handler_readers };
 }
 function reads_as_string(schema) {
-  const type = _optionalChain([_chunkH6KVPVP4cjs.def_of.call(void 0, _chunkH6KVPVP4cjs.output_of.call(void 0, schema)), 'optionalAccess', _168 => _168.type]);
+  const type = _optionalChain([_chunkYFFWCVXWcjs.def_of.call(void 0, _chunkYFFWCVXWcjs.output_of.call(void 0, schema)), 'optionalAccess', _178 => _178.type]);
   return type === "string" || type === "transform";
 }
 
@@ -4671,7 +4828,7 @@ function act() {
   let _built = false;
   const read_wrap = (original) => {
     const wrapped = async (events, stream) => {
-      const read = events.map((e) => _nullishCoalesce(_optionalChain([_hr, 'access', _169 => _169.get, 'call', _170 => _170(e.name), 'optionalCall', _171 => _171(e)]), () => ( e)));
+      const read = events.map((e) => _nullishCoalesce(_optionalChain([_hr, 'access', _179 => _179.get, 'call', _180 => _180(e.name), 'optionalCall', _181 => _181(e)]), () => ( e)));
       return original(read, stream);
     };
     const reset = original[FOLD_RESET];
@@ -4712,7 +4869,7 @@ function act() {
         });
       }
       for (const [action_name, handler] of Object.entries(state2.on)) {
-        const static_target = _optionalChain([handler, 'optionalAccess', _172 => _172._static_emit]);
+        const static_target = _optionalChain([handler, 'optionalAccess', _182 => _182._static_emit]);
         if (static_target && deprecated.has(static_target)) {
           const current = current_version_of(static_target, event_names);
           throw new Error(
@@ -4725,7 +4882,7 @@ function act() {
       const list = deprecation_summary.map(
         (d) => `"${d.deprecated}" (current: "${d.current}", state: "${d.state_name}")`
       ).join(", ");
-      _chunkPRDX3HP6cjs.log.call(void 0, ).info(
+      _chunkLUHPSF3Ccjs.log.call(void 0, ).info(
         `Act registered ${deprecation_summary.length} deprecated event(s): ${list}. These are legacy versions kept for the read path. Consider truncating closed streams via app.close() when feasible to reduce historical event load. See docs/docs/architecture/event-schema-evolution.md.`
       );
     }
@@ -4767,7 +4924,7 @@ function act() {
       return reaction_on(event, registry.events, builder);
     },
     build: (options) => {
-      _chunkPRDX3HP6cjs.resolveActConfig.call(void 0, options);
+      _chunkLUHPSF3Ccjs.resolveActConfig.call(void 0, options);
       if (!_built) {
         for (const proj of pending_projections) add_projection(proj);
         for (const proj of fold_projections) {
@@ -4785,7 +4942,7 @@ function act() {
               `State projection "${proj.target}" of "${fold.name}" is missing events ${missing.join(", ")} \u2014 pass every partial of the state to .of()`
             );
           const claimed = fold_specs.find((s) => s.target === proj.target);
-          if (_optionalChain([claimed, 'optionalAccess', _173 => _173.projection]) === proj) continue;
+          if (_optionalChain([claimed, 'optionalAccess', _183 => _183.projection]) === proj) continue;
           if (batch_handlers.has(proj.target) || claimed)
             throw new Error(
               `Duplicate projection target "${proj.target}" \u2014 a target is served by one batch handler or one state projection, never both`
@@ -4807,7 +4964,39 @@ function act() {
         for (const [name, gate] of built.query_readers) _qg.set(name, gate);
         for (const [name, gate] of built.handler_readers) _hr.set(name, gate);
         finalize_deprecations();
-        if (built.advisory) _chunkPRDX3HP6cjs.log.call(void 0, ).warn(built.advisory);
+        if (built.advisory) _chunkLUHPSF3Ccjs.log.call(void 0, ).warn(built.advisory);
+        for (const [name, state2] of states) {
+          if (!state2.loads) continue;
+          const resolved = {};
+          for (const [action2, loads] of Object.entries(state2.loads)) {
+            resolved[action2] = loads.map((l) => {
+              const registered = states.get(l.state.name);
+              if (!registered)
+                throw new Error(
+                  `Action "${action2}" loads "${l.state.name}", which is not registered \u2014 add it via withState/withSlice before build()`
+                );
+              const deprecated = l.events.find(
+                (e) => _optionalChain([_de, 'access', _184 => _184.get, 'call', _185 => _185(registered.name), 'optionalAccess', _186 => _186.has, 'call', _187 => _187(e)])
+              );
+              if (deprecated)
+                throw new Error(
+                  `Action "${action2}" lists deprecated event "${deprecated}" on its load of "${registered.name}". A newer version exists: "${current_version_of(deprecated, Object.keys(registered.events))}". List the current version instead.`
+                );
+              return { ...l, state: registered };
+            });
+          }
+          for (const [action2, loads] of Object.entries(resolved)) {
+            const static_target = state2.on[action2]._static_emit;
+            if (static_target && loads.some((l) => l.events.includes(static_target)))
+              throw new Error(
+                `Action "${action2}" statically emits "${static_target}", which its load lists, so nothing goes to its own stream; emit one of its own events too`
+              );
+          }
+          const own = { ...state2, loads: resolved };
+          states.set(name, own);
+          for (const action2 of Object.keys(own.actions))
+            registry.actions[action2] = own;
+        }
         for (const state2 of states.values()) {
           if (state2.disclose) _dp.set(state2.name, state2.disclose);
           if (state2.autoclose) _ac.set(state2.name, state2.autoclose);
@@ -4819,7 +5008,7 @@ function act() {
         synthesize_autoclose_reactions(
           registry,
           states,
-          _chunkPRDX3HP6cjs.current_autoclose_window
+          _chunkLUHPSF3Ccjs.current_autoclose_window
         );
         Object.freeze(registry.actions);
         Object.freeze(registry.events);
@@ -4867,8 +5056,8 @@ function _projection(target) {
               handler,
               resolver: _nullishCoalesce(default_resolver, () => ( _this_)),
               options: {
-                blockOnError: _chunkPRDX3HP6cjs.DEFAULT_BLOCK_ON_ERROR,
-                maxRetries: _chunkPRDX3HP6cjs.DEFAULT_MAX_RETRIES
+                blockOnError: _chunkLUHPSF3Ccjs.DEFAULT_BLOCK_ON_ERROR,
+                maxRetries: _chunkLUHPSF3Ccjs.DEFAULT_MAX_RETRIES
               }
             }),
             widened
@@ -4909,7 +5098,7 @@ function _projection(target) {
             throw new Error(
               `Projection "${target}" .of() partials must share one state name \u2014 got "${name}" and "${partial.name}"`
             );
-        const config2 = _chunkPRDX3HP6cjs.resolveFoldConfig.call(void 0, options);
+        const config2 = _chunkLUHPSF3Ccjs.resolveFoldConfig.call(void 0, options);
         const fold_events = {};
         for (const partial of partials)
           for (const [event_name, schema] of Object.entries(partial.events)) {
@@ -4927,8 +5116,8 @@ function _projection(target) {
                     handler: noop,
                     resolver: { target },
                     options: {
-                      blockOnError: _chunkPRDX3HP6cjs.DEFAULT_BLOCK_ON_ERROR,
-                      maxRetries: _chunkPRDX3HP6cjs.DEFAULT_MAX_RETRIES
+                      blockOnError: _chunkLUHPSF3Ccjs.DEFAULT_BLOCK_ON_ERROR,
+                      maxRetries: _chunkLUHPSF3Ccjs.DEFAULT_MAX_RETRIES
                     }
                   }
                 ]
@@ -5044,13 +5233,29 @@ function action_builder(state2) {
         throw new Error(`Duplicate action "${action2}"`);
       internal.actions[action2] = schema;
       if (options) {
-        _chunkPRDX3HP6cjs.resolveActionConfig.call(void 0, options);
+        _chunkLUHPSF3Ccjs.resolveActionConfig.call(void 0, options);
         internal.options ??= {};
         internal.options[action2] = options;
       }
-      function given(rules) {
-        (internal.given ??= {})[action2] = rules;
-        return { requires, emit };
+      const loads = [];
+      function load2(state3, target, events = [], name = state3.name) {
+        if (loads.some((l) => l.name === name))
+          throw new Error(
+            `Action "${action2}" loads "${name}" twice; name each load of the same state`
+          );
+        for (const event of events) {
+          if (!(event in state3.events))
+            throw new Error(
+              `Action "${action2}" lists "${event}" on its load of "${state3.name}", which doesn't emit it`
+            );
+          if (loads.some((l) => l.events.includes(event)))
+            throw new Error(
+              `Action "${action2}" lists "${event}" on two loads; an event goes to one stream`
+            );
+        }
+        loads.push({ state: state3, target, events, name });
+        (internal.loads ??= {})[action2] = loads;
+        return { loads: load2, requires, emit };
       }
       function requires(rules) {
         (internal.requires ??= {})[action2] = rules;
@@ -5071,7 +5276,7 @@ function action_builder(state2) {
         }
         return builder;
       }
-      return { given, requires, emit };
+      return { loads: load2, requires, emit };
     },
     snap(snap2) {
       internal.snap = snap2;
@@ -5338,5 +5543,7 @@ function write_line(writer, line) {
 
 
 
-exports.Act = Act; exports.ActorSchema = _chunkH6KVPVP4cjs.ActorSchema; exports.CausationEventSchema = _chunkH6KVPVP4cjs.CausationEventSchema; exports.CommittedMetaSchema = _chunkH6KVPVP4cjs.CommittedMetaSchema; exports.ConcurrencyError = _chunkH6KVPVP4cjs.ConcurrencyError; exports.ConsoleLogger = _chunkPRDX3HP6cjs.ConsoleLogger; exports.CsvFile = CsvFile; exports.DEFAULT_LANE = _chunkH6KVPVP4cjs.DEFAULT_LANE; exports.DEFAULT_MAX_SUBSCRIBED_STREAMS = _chunkH6KVPVP4cjs.DEFAULT_MAX_SUBSCRIBED_STREAMS; exports.DEFAULT_SETTLE_DEBOUNCE_MS = _chunkH6KVPVP4cjs.DEFAULT_SETTLE_DEBOUNCE_MS; exports.DeferSignal = _chunkH6KVPVP4cjs.DeferSignal; exports.Environments = _chunkH6KVPVP4cjs.Environments; exports.Errors = _chunkH6KVPVP4cjs.Errors; exports.EventMetaSchema = _chunkH6KVPVP4cjs.EventMetaSchema; exports.ExitCodes = _chunkH6KVPVP4cjs.ExitCodes; exports.InMemoryCache = _chunkPRDX3HP6cjs.InMemoryCache; exports.InMemoryStore = _chunkPRDX3HP6cjs.InMemoryStore; exports.InvariantError = _chunkH6KVPVP4cjs.InvariantError; exports.LogLevels = _chunkH6KVPVP4cjs.LogLevels; exports.NonRetryableError = _chunkH6KVPVP4cjs.NonRetryableError; exports.PackageSchema = _chunkPRDX3HP6cjs.PackageSchema; exports.PreconditionError = _chunkH6KVPVP4cjs.PreconditionError; exports.QuerySchema = _chunkH6KVPVP4cjs.QuerySchema; exports.REDACTED = _chunkH6KVPVP4cjs.REDACTED; exports.SHREDDED = _chunkH6KVPVP4cjs.SHREDDED; exports.SNAP_EVENT = _chunkH6KVPVP4cjs.SNAP_EVENT; exports.StoreError = _chunkH6KVPVP4cjs.StoreError; exports.StreamClosedError = _chunkH6KVPVP4cjs.StreamClosedError; exports.TOMBSTONE_EVENT = _chunkH6KVPVP4cjs.TOMBSTONE_EVENT; exports.TargetSchema = _chunkH6KVPVP4cjs.TargetSchema; exports.ValidationError = _chunkH6KVPVP4cjs.ValidationError; exports.ZodEmpty = _chunkH6KVPVP4cjs.ZodEmpty; exports.act = act; exports.cache = _chunkPRDX3HP6cjs.cache; exports.config = _chunkPRDX3HP6cjs.config; exports.dateReviver = _chunkPRDX3HP6cjs.dateReviver; exports.default_scope = _chunkPRDX3HP6cjs.default_scope; exports.dispose = _chunkPRDX3HP6cjs.dispose; exports.disposeAndExit = _chunkPRDX3HP6cjs.disposeAndExit; exports.extend = _chunkPRDX3HP6cjs.extend; exports.is_literal_source = _chunkPRDX3HP6cjs.is_literal_source; exports.log = _chunkPRDX3HP6cjs.log; exports.pii_fields = _chunkH6KVPVP4cjs.pii_fields; exports.port = _chunkPRDX3HP6cjs.port; exports.projection = projection; exports.resolveAutocloseConfig = _chunkPRDX3HP6cjs.resolveAutocloseConfig2; exports.sensitive = _chunkH6KVPVP4cjs.sensitive; exports.sleep = _chunkPRDX3HP6cjs.sleep; exports.slice = slice; exports.state = state; exports.store = _chunkPRDX3HP6cjs.store; exports.validate = _chunkPRDX3HP6cjs.validate;
+
+
+exports.Act = Act; exports.ActorSchema = _chunkYFFWCVXWcjs.ActorSchema; exports.CausationEventSchema = _chunkYFFWCVXWcjs.CausationEventSchema; exports.CommittedMetaSchema = _chunkYFFWCVXWcjs.CommittedMetaSchema; exports.ConcurrencyError = _chunkYFFWCVXWcjs.ConcurrencyError; exports.ConsoleLogger = _chunkLUHPSF3Ccjs.ConsoleLogger; exports.CsvFile = CsvFile; exports.DEFAULT_LANE = _chunkYFFWCVXWcjs.DEFAULT_LANE; exports.DEFAULT_MAX_SUBSCRIBED_STREAMS = _chunkYFFWCVXWcjs.DEFAULT_MAX_SUBSCRIBED_STREAMS; exports.DEFAULT_QUERY_STREAMS_LIMIT = _chunkLUHPSF3Ccjs.DEFAULT_QUERY_STREAMS_LIMIT; exports.DEFAULT_SETTLE_DEBOUNCE_MS = _chunkYFFWCVXWcjs.DEFAULT_SETTLE_DEBOUNCE_MS; exports.DeferSignal = _chunkYFFWCVXWcjs.DeferSignal; exports.Environments = _chunkYFFWCVXWcjs.Environments; exports.Errors = _chunkYFFWCVXWcjs.Errors; exports.EventMetaSchema = _chunkYFFWCVXWcjs.EventMetaSchema; exports.ExitCodes = _chunkYFFWCVXWcjs.ExitCodes; exports.InMemoryCache = _chunkLUHPSF3Ccjs.InMemoryCache; exports.InMemoryStore = _chunkLUHPSF3Ccjs.InMemoryStore; exports.LogLevels = _chunkYFFWCVXWcjs.LogLevels; exports.NonRetryableError = _chunkYFFWCVXWcjs.NonRetryableError; exports.PackageSchema = _chunkLUHPSF3Ccjs.PackageSchema; exports.PreconditionError = _chunkYFFWCVXWcjs.PreconditionError; exports.QuerySchema = _chunkYFFWCVXWcjs.QuerySchema; exports.REDACTED = _chunkYFFWCVXWcjs.REDACTED; exports.SHREDDED = _chunkYFFWCVXWcjs.SHREDDED; exports.SNAP_EVENT = _chunkYFFWCVXWcjs.SNAP_EVENT; exports.StoreError = _chunkYFFWCVXWcjs.StoreError; exports.StreamClosedError = _chunkYFFWCVXWcjs.StreamClosedError; exports.TOMBSTONE_EVENT = _chunkYFFWCVXWcjs.TOMBSTONE_EVENT; exports.TargetSchema = _chunkYFFWCVXWcjs.TargetSchema; exports.ValidationError = _chunkYFFWCVXWcjs.ValidationError; exports.ZodEmpty = _chunkYFFWCVXWcjs.ZodEmpty; exports.act = act; exports.cache = _chunkLUHPSF3Ccjs.cache; exports.check_appends = _chunkLUHPSF3Ccjs.check_appends; exports.config = _chunkLUHPSF3Ccjs.config; exports.dateReviver = _chunkLUHPSF3Ccjs.dateReviver; exports.default_scope = _chunkLUHPSF3Ccjs.default_scope; exports.dispose = _chunkLUHPSF3Ccjs.dispose; exports.disposeAndExit = _chunkLUHPSF3Ccjs.disposeAndExit; exports.extend = _chunkLUHPSF3Ccjs.extend; exports.fair_slots = _chunkLUHPSF3Ccjs.fair_slots; exports.is_literal_source = _chunkLUHPSF3Ccjs.is_literal_source; exports.log = _chunkLUHPSF3Ccjs.log; exports.pii_fields = _chunkYFFWCVXWcjs.pii_fields; exports.port = _chunkLUHPSF3Ccjs.port; exports.projection = projection; exports.resolveAutocloseConfig = _chunkLUHPSF3Ccjs.resolveAutocloseConfig2; exports.sensitive = _chunkYFFWCVXWcjs.sensitive; exports.sleep = _chunkLUHPSF3Ccjs.sleep; exports.slice = slice; exports.state = state; exports.store = _chunkLUHPSF3Ccjs.store; exports.validate = _chunkLUHPSF3Ccjs.validate;
 //# sourceMappingURL=index.cjs.map