@rotorsoft/act 1.37.8 → 2.0.1

package/dist/index.cjs

@@ -42,9 +42,9 @@
 
 
 
-var _chunk4UWU5FANcjs = require('./chunk-4UWU5FAN.cjs');
 
 
+var _chunkS2BEPQ5Zcjs = require('./chunk-S2BEPQ5Z.cjs');
 
 
 
@@ -76,24 +76,25 @@ var _chunk4UWU5FANcjs = require('./chunk-4UWU5FAN.cjs');
 
 
 
-var _chunkBCA423WPcjs = require('./chunk-BCA423WP.cjs');
+
+var _chunk3CQWJ4UAcjs = require('./chunk-3CQWJ4UA.cjs');
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
-  _chunk4UWU5FANcjs.log.call(void 0, ).info(arg, "SIGINT");
-  await _chunk4UWU5FANcjs.disposeAndExit.call(void 0, "EXIT");
+  _chunkS2BEPQ5Zcjs.log.call(void 0, ).info(arg, "SIGINT");
+  await _chunkS2BEPQ5Zcjs.disposeAndExit.call(void 0, "EXIT");
 });
 process.once("SIGTERM", async (arg) => {
-  _chunk4UWU5FANcjs.log.call(void 0, ).info(arg, "SIGTERM");
-  await _chunk4UWU5FANcjs.disposeAndExit.call(void 0, "EXIT");
+  _chunkS2BEPQ5Zcjs.log.call(void 0, ).info(arg, "SIGTERM");
+  await _chunkS2BEPQ5Zcjs.disposeAndExit.call(void 0, "EXIT");
 });
 process.once("uncaughtException", async (arg) => {
-  _chunk4UWU5FANcjs.log.call(void 0, ).error(arg, "Uncaught Exception");
-  await _chunk4UWU5FANcjs.disposeAndExit.call(void 0, "ERROR");
+  _chunkS2BEPQ5Zcjs.log.call(void 0, ).error(arg, "Uncaught Exception");
+  await _chunkS2BEPQ5Zcjs.disposeAndExit.call(void 0, "ERROR");
 });
 process.once("unhandledRejection", async (arg) => {
-  _chunk4UWU5FANcjs.log.call(void 0, ).error(arg, "Unhandled Rejection");
-  await _chunk4UWU5FANcjs.disposeAndExit.call(void 0, "ERROR");
+  _chunkS2BEPQ5Zcjs.log.call(void 0, ).error(arg, "Unhandled Rejection");
+  await _chunkS2BEPQ5Zcjs.disposeAndExit.call(void 0, "ERROR");
 });
 
 // src/act.ts
@@ -201,7 +202,7 @@ async function* audit(deps, categories, options = {}) {
   if (need_stats) {
     const stats = await deps.store().query_stats(
       {},
-      { count: true, names: true, exclude: [_chunkBCA423WPcjs.SNAP_EVENT] }
+      { count: true, names: true, exclude: [_chunk3CQWJ4UAcjs.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)]);
@@ -283,7 +284,7 @@ var make_schema_pass = (deps) => {
         return;
       }
       const schema = state2.events[name];
-      const sensitive2 = _chunkBCA423WPcjs.pii_fields.call(void 0, schema);
+      const sensitive2 = _chunk3CQWJ4UAcjs.pii_fields.call(void 0, schema);
       let parse_schema = schema;
       if (sensitive2.length > 0) {
         const omitter = schema.omit;
@@ -417,7 +418,7 @@ var make_restart_candidate_pass = (deps, options) => {
           {
             stream,
             stream_exact: true,
-            names: [_chunkBCA423WPcjs.SNAP_EVENT],
+            names: [_chunk3CQWJ4UAcjs.SNAP_EVENT],
             with_snaps: true,
             // From the start: on its own, `with_snaps` resumes at the latest.
             after: -1
@@ -577,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 !== _chunkBCA423WPcjs.TOMBSTONE_EVENT) {
+      if (parent_id !== void 0 && e.name !== _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT) {
         checks.push({ stream: e.stream, id: e.id, parent_id });
       }
     },
@@ -752,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();
@@ -778,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) {
@@ -962,7 +968,7 @@ 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, _chunkBCA423WPcjs.DeferSignal)(when);
+    if (Date.now() < resolve_defer_at(when, event)) throw new (0, _chunk3CQWJ4UAcjs.DeferSignal)(when);
     return call(event, stream, app);
   };
   Object.defineProperty(deferred, "name", { value: handler.name });
@@ -1094,7 +1100,7 @@ function compute_lag_lead_ratio(handled, lagging, leading) {
 function report_once(seen, key, message) {
   if (seen.has(key)) return;
   seen.add(key);
-  _chunk4UWU5FANcjs.log.call(void 0, ).error(new Error(message));
+  _chunkS2BEPQ5Zcjs.log.call(void 0, ).error(new Error(message));
 }
 
 // src/internal/correlation-id.ts
@@ -1122,14 +1128,14 @@ function close_correlation(correlator, actor) {
 }
 
 // src/internal/drain-ops.ts
-var claim = (lagging, leading, by, millis, lane) => _chunk4UWU5FANcjs.store.call(void 0, ).claim(lagging, leading, by, millis, lane);
+var claim = (lagging, leading, by, millis, lane) => _chunkS2BEPQ5Zcjs.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 && _chunk4UWU5FANcjs.is_literal_source.call(void 0, source, stream) ? true : void 0;
+      const stream_exact = source !== void 0 && _chunkS2BEPQ5Zcjs.is_literal_source.call(void 0, source, stream) ? true : void 0;
       try {
-        await _chunk4UWU5FANcjs.store.call(void 0, ).query((e) => events.push(e), {
+        await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query((e) => events.push(e), {
           stream: source,
           stream_exact,
           after: at,
@@ -1149,9 +1155,9 @@ async function fetch(leased, eventLimit) {
     })
   );
 }
-var ack = (leases) => _chunk4UWU5FANcjs.store.call(void 0, ).ack(leases);
-var block = (leases) => _chunk4UWU5FANcjs.store.call(void 0, ).block(leases);
-var subscribe = (streams, correlated_at, correlator) => _chunk4UWU5FANcjs.store.call(void 0, ).subscribe(streams, correlated_at, correlator);
+var ack = (leases) => _chunkS2BEPQ5Zcjs.store.call(void 0, ).ack(leases);
+var block = (leases) => _chunkS2BEPQ5Zcjs.store.call(void 0, ).block(leases);
+var subscribe = (streams, correlated_at, correlator) => _chunkS2BEPQ5Zcjs.store.call(void 0, ).subscribe(streams, correlated_at, correlator);
 
 // src/internal/event-sourcing.ts
 var _actpatch = require('@rotorsoft/act-patch');
@@ -1166,29 +1172,29 @@ var check_invariants = (target, state2, schema, pii_aware) => {
   try {
     result = schema.safeParse(state2);
   } catch (error) {
-    throw new (0, _chunkBCA423WPcjs.ValidationError)(target, state2, error);
+    throw new (0, _chunk3CQWJ4UAcjs.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 !== _chunkBCA423WPcjs.REDACTED && value !== _chunkBCA423WPcjs.SHREDDED;
+    return value !== _chunk3CQWJ4UAcjs.REDACTED && value !== _chunk3CQWJ4UAcjs.SHREDDED;
   }) : result.error.issues;
   if (issues.length)
-    throw new (0, _chunkBCA423WPcjs.ValidationError)(
+    throw new (0, _chunk3CQWJ4UAcjs.ValidationError)(
       target,
       state2,
       _zod.prettifyError.call(void 0, new (0, _zod.ZodError)(issues))
     );
 };
 var DEFAULT_BATCH = 500;
-var cache_put = (stream, entry) => _chunk4UWU5FANcjs.cache.call(void 0, ).set(stream, entry).catch(
-  (err) => _chunk4UWU5FANcjs.log.call(void 0, ).warn(
+var cache_put = (stream, entry) => _chunkS2BEPQ5Zcjs.cache.call(void 0, ).set(stream, entry).catch(
+  (err) => _chunkS2BEPQ5Zcjs.log.call(void 0, ).warn(
     err,
     "cache set skipped; the next load re-folds from the store"
   )
 );
-var cache_drop = (stream) => _chunk4UWU5FANcjs.cache.call(void 0, ).invalidate(stream).catch(
-  (err) => _chunk4UWU5FANcjs.log.call(void 0, ).warn(
+var cache_drop = (stream) => _chunkS2BEPQ5Zcjs.cache.call(void 0, ).invalidate(stream).catch(
+  (err) => _chunkS2BEPQ5Zcjs.log.call(void 0, ).warn(
     err,
     "cache invalidate skipped; a stale checkpoint re-folds from its event_id"
   )
@@ -1196,35 +1202,43 @@ var cache_drop = (stream) => _chunk4UWU5FANcjs.cache.call(void 0, ).invalidate(s
 async function snap(snapshot) {
   const { id, stream, name, meta, version } = snapshot.event;
   try {
-    const [committed] = await _chunk4UWU5FANcjs.store.call(void 0, ).commit(
-      stream,
-      [{ name: _chunkBCA423WPcjs.SNAP_EVENT, data: snapshot.state }],
+    const [committed] = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).commit(
+      [
+        {
+          stream,
+          msgs: [{ name: _chunk3CQWJ4UAcjs.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);
-    _chunk4UWU5FANcjs.log.call(void 0, ).warn(
+    _chunkS2BEPQ5Zcjs.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 _chunk4UWU5FANcjs.store.call(void 0, ).commit(
-      stream,
-      [{ name: _chunkBCA423WPcjs.TOMBSTONE_EVENT, data: {} }],
-      { correlation, causation: {} },
-      expectedVersion
+    const [committed] = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).commit(
+      [
+        {
+          stream,
+          msgs: [{ name: _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT, data: {} }],
+          expectedVersion
+        }
+      ],
+      { correlation, causation: {} }
     );
     return committed;
   } catch (error) {
-    if (error instanceof _chunkBCA423WPcjs.ConcurrencyError) return void 0;
+    if (error instanceof _chunk3CQWJ4UAcjs.ConcurrencyError) return void 0;
     throw error;
   }
 }
@@ -1254,9 +1268,9 @@ async function scan(source, opts = {}, callback) {
   if (drop_closed_streams) {
     await source.query(
       (e) => {
-        if (e.name === _chunkBCA423WPcjs.TOMBSTONE_EVENT) closed_streams.add(e.stream);
+        if (e.name === _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT) closed_streams.add(e.stream);
       },
-      { names: [_chunkBCA423WPcjs.TOMBSTONE_EVENT] }
+      { names: [_chunk3CQWJ4UAcjs.TOMBSTONE_EVENT] }
     );
   }
   let max_id;
@@ -1278,11 +1292,11 @@ 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 === _chunkBCA423WPcjs.SNAP_EVENT) {
+        if (drop_snapshots && event.name === _chunk3CQWJ4UAcjs.SNAP_EVENT) {
           dropped_snaps++;
           return;
         }
-        if (closed_streams.has(event.stream) && event.name !== _chunkBCA423WPcjs.TOMBSTONE_EVENT) {
+        if (closed_streams.has(event.stream) && event.name !== _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT) {
           dropped_closed++;
           return;
         }
@@ -1350,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 _chunk4UWU5FANcjs.cache.call(void 0, ).get(stream);
+  const cached = time_travel ? void 0 : await _chunkS2BEPQ5Zcjs.cache.call(void 0, ).get(stream);
   const cache_hit = !!cached;
   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 _chunk4UWU5FANcjs.store.call(void 0, ).query(
+  await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query(
     (raw) => {
-      if (seeded && raw.name === _chunkBCA423WPcjs.SNAP_EVENT && replayed > 0) return;
+      if (seeded && raw.name === _chunk3CQWJ4UAcjs.SNAP_EVENT && replayed > 0) return;
       event = me.view(raw, actor);
-      if (event.name === _chunkBCA423WPcjs.SNAP_EVENT) {
+      if (event.name === _chunk3CQWJ4UAcjs.SNAP_EVENT) {
         state2 = event.data;
         snaps++;
         patches = 0;
@@ -1370,8 +1384,8 @@ 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 !== _chunkBCA423WPcjs.TOMBSTONE_EVENT) {
-        _chunk4UWU5FANcjs.log.call(void 0, ).warn(
+      } else if (event.name !== _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT) {
+        _chunkS2BEPQ5Zcjs.log.call(void 0, ).warn(
           `Skipping unknown event "${String(event.name)}" on stream "${stream}" (id=${event.id}) \u2014 no reducer in state "${me.name}"`
         );
       }
@@ -1399,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', _62 => _62.name]) === _chunkBCA423WPcjs.TOMBSTONE_EVENT;
+  const head_is_tombstone = _optionalChain([event, 'optionalAccess', _62 => _62.name]) === _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT;
   if (replayed > 0 && !time_travel && event && !me.pii_aware && !head_is_tombstone) {
     await cache_put(stream, {
       stream,
@@ -1422,14 +1436,47 @@ async function load(me, target, callback, patch_fn = bare_patch) {
     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]) === _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT)
+        throw new (0, _chunk3CQWJ4UAcjs.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', _67 => _67.reactingTo]);
-  const correlator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _68 => _68.correlator]), () => ( default_correlator));
-  const validated = _chunk4UWU5FANcjs.validate.call(void 0, action2, payload, me.actions[action2]);
-  const opts = _optionalChain([me, 'access', _69 => _69.options, 'optionalAccess', _70 => _70[action2]]);
-  const max_retries = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _71 => _71.maxRetries]), () => ( 0));
+  const reactingTo = _optionalChain([options, 'optionalAccess', _69 => _69.reactingTo]);
+  const correlator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _70 => _70.correlator]), () => ( default_correlator));
+  const validated = _chunkS2BEPQ5Zcjs.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(
@@ -1438,38 +1485,68 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
         void 0,
         patch_fn
       );
-      if (_optionalChain([snapshot, 'access', _72 => _72.event, 'optionalAccess', _73 => _73.name]) === _chunkBCA423WPcjs.TOMBSTONE_EVENT)
-        throw new (0, _chunkBCA423WPcjs.StreamClosedError)(stream);
-      const expected = _nullishCoalesce(expectedVersion, () => ( snapshot.version));
-      for (const { valid, description } of _nullishCoalesce(_optionalChain([me, 'access', _74 => _74.given, 'optionalAccess', _75 => _75[action2]]), () => ( [])))
-        if (!valid(snapshot.state, actor))
-          throw new (0, _chunkBCA423WPcjs.InvariantError)(
-            action2,
-            validated,
-            target,
-            snapshot,
-            description
-          );
-      for (const { holds, description } of _nullishCoalesce(_optionalChain([me, 'access', _76 => _76.requires, 'optionalAccess', _77 => _77[action2]]), () => ( [])))
-        if (!holds(validated, snapshot.state, actor))
-          throw new (0, _chunkBCA423WPcjs.PreconditionError)(
+      if (_optionalChain([snapshot, 'access', _76 => _76.event, 'optionalAccess', _77 => _77.name]) === _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT)
+        throw new (0, _chunk3CQWJ4UAcjs.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, _chunk3CQWJ4UAcjs.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, _chunk3CQWJ4UAcjs.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: _chunk4UWU5FANcjs.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: _chunkS2BEPQ5Zcjs.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', _78 => _78.meta, 'access', _79 => _79.correlation]) || correlator({
+        correlation: _optionalChain([reactingTo, 'optionalAccess', _84 => _84.meta, 'access', _85 => _85.correlation]) || correlator({
           action: action2,
           state: me.name,
           stream,
@@ -1488,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 _chunk4UWU5FANcjs.store.call(void 0, ).commit(stream, emitted, meta, expected);
+        committed = await _chunkS2BEPQ5Zcjs.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 _chunkBCA423WPcjs.ConcurrencyError) void cache_drop(stream);
+        if (error instanceof _chunk3CQWJ4UAcjs.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', _80 => _80.snap, 'optionalCall', _81 => _81(last)]) ? await snap(last) : void 0;
-      if (!me.pii_aware)
-        void cache_put(stream, {
-          stream,
-          state: last.state,
-          version: _nullishCoalesce(_optionalChain([snap_event, 'optionalAccess', _82 => _82.version]), () => ( last.event.version)),
-          event_id: _nullishCoalesce(_optionalChain([snap_event, 'optionalAccess', _83 => _83.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 _chunkBCA423WPcjs.ConcurrencyError)) throw error;
-      if (expectedVersion !== void 0) throw error;
+      if (!(error instanceof _chunk3CQWJ4UAcjs.ConcurrencyError)) throw error;
+      if (expectedVersion !== void 0 && error.stream === stream) throw error;
       if (attempt >= max_retries) throw error;
-      if (_optionalChain([opts, 'optionalAccess', _84 => _84.backoff])) {
+      if (_optionalChain([opts, 'optionalAccess', _90 => _90.backoff])) {
         const delay_ms = compute_backoff_delay(attempt, opts.backoff);
-        if (delay_ms > 0) await _chunk4UWU5FANcjs.sleep.call(void 0, delay_ms);
+        if (delay_ms > 0) await _chunkS2BEPQ5Zcjs.sleep.call(void 0, delay_ms);
       }
     }
   }
 }
 
 // src/internal/tracing.ts
-var PRETTY = _chunk4UWU5FANcjs.config.call(void 0, ).env !== "production";
+var PRETTY = _chunkS2BEPQ5Zcjs.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";
@@ -1599,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', _85 => _85(...args)]);
+  _optionalChain([entry, 'optionalCall', _91 => _91(...args)]);
   const result = await inner(...args);
-  _optionalChain([exit, 'optionalCall', _86 => _86(result, ...args)]);
+  _optionalChain([exit, 'optionalCall', _92 => _92(result, ...args)]);
   return result;
 });
 function build_es(logger, correlator = default_correlator, patch_fn = bare_patch) {
@@ -1610,7 +1712,7 @@ function build_es(logger, correlator = default_correlator, patch_fn = bare_patch
     action_name,
     target,
     payload,
-    { ...options, correlator: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _87 => _87.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);
@@ -1649,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(", ")
             )
           );
       },
@@ -1684,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', _88 => _88[0], 'optionalAccess', _89 => _89.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(" ");
@@ -1696,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', _90 => _90[0], 'optionalAccess', _91 => _91.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]));
@@ -1705,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', _92 => _92.source]) ? `${hue(C_STREAM, stream)}${dim(`<-${f.source}`)}` : hue(C_STREAM, stream);
-    const events = _optionalChain([f, 'optionalAccess', _93 => _93.events, 'access', _94 => _94.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);
@@ -1734,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', _95 => _95.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.`;
-  _chunk4UWU5FANcjs.log.call(void 0, ).error(error);
+  _chunkS2BEPQ5Zcjs.log.call(void 0, ).error(error);
   return { lease, handled: 0, acked_at: lease.at, error, block: true };
 }
 function fetch_failure_policy(registry) {
@@ -1753,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 _chunkBCA423WPcjs.NonRetryableError;
+  const non_retryable = error instanceof _chunk3CQWJ4UAcjs.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, () => ( _chunk4UWU5FANcjs.DEFAULT_BACKOFF)));
+  const next_attempt_at = block2 ? void 0 : Date.now() + compute_backoff_delay(lease.retry, _nullishCoalesce(options.backoff, () => ( _chunkS2BEPQ5Zcjs.DEFAULT_BACKOFF)));
   return {
     lease,
     handled,
@@ -1798,7 +1900,7 @@ async function run_drain_cycle(deps, cycle) {
   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', _96 => _96.at, 'call', _97 => _97(-1), 'optionalAccess', _98 => _98.id]) || at),
+    (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) {
@@ -1862,11 +1964,11 @@ async function run_drain_cycle(deps, cycle) {
             deps.logger
           )
         );
-      const at = _optionalChain([entry, 'access', _99 => _99.fetch, 'access', _100 => _100.events, 'access', _101 => _101.at, 'call', _102 => _102(-1), 'optionalAccess', _103 => _103.id]) || fetch_window_at;
+      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', _104 => _104[0], 'optionalAccess', _105 => _105.options]),
+        _optionalChain([payloads, 'access', _110 => _110[0], 'optionalAccess', _111 => _111.options]),
         store_failing
       );
       if (exhausted) return Promise.resolve(exhausted);
@@ -1887,7 +1989,7 @@ async function run_drain_cycle(deps, cycle) {
   const acked = submitted.length ? await ops.ack(submitted) : [];
   const expected = submitted.filter((l) => l.due === void 0).length;
   if (acked.length < expected)
-    _chunk4UWU5FANcjs.log.call(void 0, ).warn(
+    _chunkS2BEPQ5Zcjs.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);
@@ -1951,7 +2053,7 @@ var DrainController = (_class3 = class {
   }
   /** This lane's configured lease, or `undefined`; the shutdown grace basis. */
   get lease_millis() {
-    return _optionalChain([this, 'access', _106 => _106._deps, 'access', _107 => _107.defaults, 'optionalAccess', _108 => _108.leaseMillis]);
+    return _optionalChain([this, 'access', _112 => _112._deps, 'access', _113 => _113.defaults, 'optionalAccess', _114 => _114.leaseMillis]);
   }
   get lane() {
     return this._deps.lane;
@@ -1983,9 +2085,9 @@ var DrainController = (_class3 = class {
     if (!this.armed || this._stopped || this._inflight)
       return EMPTY_DRAIN;
     const d = _nullishCoalesce(this._deps.defaults, () => ( {}));
-    const streamLimit = _nullishCoalesce(_nullishCoalesce(d.streamLimit, () => ( options.streamLimit)), () => ( _chunk4UWU5FANcjs.DEFAULT_STREAM_LIMIT));
-    const eventLimit = _nullishCoalesce(options.eventLimit, () => ( _chunk4UWU5FANcjs.DEFAULT_EVENT_LIMIT));
-    const leaseMillis = _nullishCoalesce(_nullishCoalesce(d.leaseMillis, () => ( options.leaseMillis)), () => ( _chunk4UWU5FANcjs.DEFAULT_LEASE_MILLIS));
+    const streamLimit = _nullishCoalesce(_nullishCoalesce(d.streamLimit, () => ( options.streamLimit)), () => ( _chunkS2BEPQ5Zcjs.DEFAULT_STREAM_LIMIT));
+    const eventLimit = _nullishCoalesce(options.eventLimit, () => ( _chunkS2BEPQ5Zcjs.DEFAULT_EVENT_LIMIT));
+    const leaseMillis = _nullishCoalesce(_nullishCoalesce(d.leaseMillis, () => ( options.leaseMillis)), () => ( _chunkS2BEPQ5Zcjs.DEFAULT_LEASE_MILLIS));
     if (this._deps.breaker.state(Date.now()) === "open")
       return EMPTY_DRAIN;
     const pass = this._pass(streamLimit, eventLimit, leaseMillis).finally(
@@ -2077,11 +2179,11 @@ var CloseSignal = class extends Error {
   constructor(opts) {
     super("reaction requested close");
     this.name = "CloseSignal";
-    this.stream = _optionalChain([opts, 'optionalAccess', _109 => _109.stream]);
-    this.archive = _optionalChain([opts, 'optionalAccess', _110 => _110.archive]);
-    this.at = _optionalChain([opts, 'optionalAccess', _111 => _111.at]);
-    this.before = _optionalChain([opts, 'optionalAccess', _112 => _112.before]);
-    this.defer = _optionalChain([opts, 'optionalAccess', _113 => _113.defer]);
+    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) {
@@ -2111,7 +2213,7 @@ function build_handle(deps) {
           handled++;
         }
       } catch (error) {
-        if (error instanceof _chunkBCA423WPcjs.DeferSignal) {
+        if (error instanceof _chunk3CQWJ4UAcjs.DeferSignal) {
           let defer;
           try {
             defer = resolve_defer_at(error.when, event);
@@ -2135,7 +2237,7 @@ function build_handle(deps) {
             // 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', _114 => _114.defer, 'optionalAccess', _115 => _115.getTime, 'call', _116 => _116()]),
+            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
@@ -2205,25 +2307,25 @@ function synthesize_autoclose_reactions(registry, states, read_window) {
       // 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) => _chunk4UWU5FANcjs.is_literal_source.call(void 0, e.stream) ? {
+      // 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) => _chunkS2BEPQ5Zcjs.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: _chunk4UWU5FANcjs.DEFAULT_MAX_RETRIES },
+      options: { blockOnError: false, maxRetries: _chunkS2BEPQ5Zcjs.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, _chunkBCA423WPcjs.DeferSignal)({ at: next_window_open(window, /* @__PURE__ */ new Date()) });
-        const stats = await _chunk4UWU5FANcjs.store.call(void 0, ).query_stats([aggregate], {
+          throw new (0, _chunk3CQWJ4UAcjs.DeferSignal)({ at: next_window_open(window, /* @__PURE__ */ new Date()) });
+        const stats = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query_stats([aggregate], {
           count: true,
           tail: keep_days !== void 0 ? true : void 0,
-          exclude: [_chunkBCA423WPcjs.TOMBSTONE_EVENT, _chunkBCA423WPcjs.SNAP_EVENT]
+          exclude: [_chunk3CQWJ4UAcjs.TOMBSTONE_EVENT, _chunk3CQWJ4UAcjs.SNAP_EVENT]
         });
         const entry = stats.get(aggregate);
         if (!entry) return;
@@ -2259,12 +2361,12 @@ function synthesize_autoclose_reactions(registry, states, read_window) {
           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, _chunkBCA423WPcjs.DeferSignal)({ at: new Date(Math.min(...future)) });
+          throw new (0, _chunk3CQWJ4UAcjs.DeferSignal)({ at: new Date(Math.min(...future)) });
       }
     };
     const key = `__autoclose_${st.name}`;
     for (const event_name of Object.keys(st.events)) {
-      _optionalChain([registry, 'access', _117 => _117.events, 'access', _118 => _118[event_name], 'optionalAccess', _119 => _119.reactions, 'access', _120 => _120.set, 'call', _121 => _121(
+      _optionalChain([registry, 'access', _123 => _123.events, 'access', _124 => _124[event_name], 'optionalAccess', _125 => _125.reactions, 'access', _126 => _126.set, 'call', _127 => _127(
         key,
         reaction
       )]);
@@ -2319,8 +2421,8 @@ async function run_close_cycle(targets, deps) {
     deps,
     () => run_full_closes(full, target_map, deps, skipped)
   );
-  const retired = [...truncated.entries()].filter(([, r]) => r.committed.name === _chunkBCA423WPcjs.TOMBSTONE_EVENT).map(([stream]) => stream);
-  if (retired.length) _optionalChain([deps, 'access', _122 => _122.forget_subscribed, 'optionalCall', _123 => _123(retired)]);
+  const retired = [...truncated.entries()].filter(([, r]) => r.committed.name === _chunk3CQWJ4UAcjs.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 };
 }
@@ -2340,7 +2442,7 @@ async function run_full_closes(full, target_map, deps, skipped) {
     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', _124 => _124.pii_aware])) {
+    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.`
       );
@@ -2401,7 +2503,7 @@ async function run_windowed_closes(windowed, deps, skipped) {
       if (!await windowed_prune_pending(t.stream, t.before, max_id))
         return void 0;
       if (t.archive) await t.archive();
-      const result = await _chunk4UWU5FANcjs.store.call(void 0, ).truncate([
+      const result = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).truncate([
         { stream: t.stream, before: t.before, max_id }
       ]);
       return result.get(t.stream);
@@ -2414,10 +2516,10 @@ async function run_windowed_closes(windowed, deps, skipped) {
 async function windowed_prune_pending(stream, before, max_id) {
   let boundary_id;
   let min_id;
-  await _chunk4UWU5FANcjs.store.call(void 0, ).query(
+  await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query(
     (event) => {
       if (min_id === void 0 || event.id < min_id) min_id = event.id;
-      if (event.name === _chunkBCA423WPcjs.SNAP_EVENT && event.created < before && (max_id === void 0 || event.id <= max_id) && (boundary_id === void 0 || event.id > boundary_id))
+      if (event.name === _chunk3CQWJ4UAcjs.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 }
@@ -2428,7 +2530,7 @@ async function probe_min_watermarks(streams, page_size, checkpoint) {
   const min_at = /* @__PURE__ */ new Map();
   const matches = source_matcher();
   await walk_streams(
-    _chunk4UWU5FANcjs.store.call(void 0, ),
+    _chunkS2BEPQ5Zcjs.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);
@@ -2447,7 +2549,7 @@ function source_matcher() {
   const compiled = /* @__PURE__ */ new Map();
   return (source, target, stream) => {
     if (!source) return true;
-    if (_chunk4UWU5FANcjs.is_literal_source.call(void 0, source, target)) return source === stream;
+    if (_chunkS2BEPQ5Zcjs.is_literal_source.call(void 0, source, target)) return source === stream;
     let re = compiled.get(source);
     if (!re) {
       re = new RegExp(source);
@@ -2457,17 +2559,17 @@ function source_matcher() {
   };
 }
 async function scan_stream_heads(streams) {
-  const stats = await _chunk4UWU5FANcjs.store.call(void 0, ).query_stats(streams, {
-    exclude: [_chunkBCA423WPcjs.SNAP_EVENT]
+  const stats = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query_stats(streams, {
+    exclude: [_chunk3CQWJ4UAcjs.SNAP_EVENT]
   });
-  const domain_heads = await _chunk4UWU5FANcjs.store.call(void 0, ).query_stats(streams, {
-    exclude: [_chunkBCA423WPcjs.SNAP_EVENT, _chunkBCA423WPcjs.TOMBSTONE_EVENT]
+  const domain_heads = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query_stats(streams, {
+    exclude: [_chunk3CQWJ4UAcjs.SNAP_EVENT, _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT]
   });
-  const true_heads = await _chunk4UWU5FANcjs.store.call(void 0, ).query_stats(streams, {});
+  const true_heads = await _chunkS2BEPQ5Zcjs.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', _125 => _125.get, 'call', _126 => _126(stream), 'optionalAccess', _127 => _127.head]);
-    const interrupted = _optionalChain([marker_head, 'optionalAccess', _128 => _128.name]) === _chunkBCA423WPcjs.TOMBSTONE_EVENT;
+    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]) === _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT;
     out.set(stream, {
       max_id: head.id,
       version: true_heads.get(stream).head.version,
@@ -2490,7 +2592,7 @@ async function partition_by_safety(stream_info, reactive, skipped, page_size, ca
   const pending_set = /* @__PURE__ */ new Set();
   const matches = source_matcher();
   await walk_streams(
-    _chunk4UWU5FANcjs.store.call(void 0, ),
+    _chunkS2BEPQ5Zcjs.store.call(void 0, ),
     (position) => {
       const has_work = position.correlated_at !== void 0 && position.at < position.correlated_at;
       if (!has_work) return;
@@ -2535,7 +2637,7 @@ async function guard_with_tombstones(safe, stream_info, correlation, tombstone2,
 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', _129 => _129.get, 'call', _130 => _130(s), 'optionalAccess', _131 => _131.restart])).map(async (stream) => {
+    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) {
@@ -2552,14 +2654,14 @@ async function load_restart_seeds(guarded, target_map, stream_info, event_to_sta
 }
 async function run_archive_callbacks(guarded, target_map) {
   for (const stream of guarded) {
-    const archive_fn = _optionalChain([target_map, 'access', _132 => _132.get, 'call', _133 => _133(stream), 'optionalAccess', _134 => _134.archive]);
+    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 _chunk4UWU5FANcjs.store.call(void 0, ).query_stats(guarded, {});
+  const heads = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query_stats(guarded, {});
   return guarded.filter((stream) => {
-    if (_optionalChain([heads, 'access', _135 => _135.get, 'call', _136 => _136(stream), 'optionalAccess', _137 => _137.head, 'access', _138 => _138.id]) === guard_events.get(stream).id)
+    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;
@@ -2575,18 +2677,18 @@ async function truncate_and_warm_cache(guarded, seed_states, guard_events, corre
       meta: {
         correlation,
         causation: {
-          event: { id: guard.id, name: _chunkBCA423WPcjs.TOMBSTONE_EVENT, stream: guard.stream }
+          event: { id: guard.id, name: _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT, stream: guard.stream }
         }
       }
     };
   });
-  const truncated = await _chunk4UWU5FANcjs.store.call(void 0, ).truncate(trunc_targets);
+  const truncated = await _chunkS2BEPQ5Zcjs.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 _chunk4UWU5FANcjs.cache.call(void 0, ).set(stream, {
+        await _chunkS2BEPQ5Zcjs.cache.call(void 0, ).set(stream, {
           stream,
           state: state2,
           version: entry.committed.version,
@@ -2595,7 +2697,7 @@ async function truncate_and_warm_cache(guarded, seed_states, guard_events, corre
           snaps: 1
         });
       } else {
-        await _chunk4UWU5FANcjs.cache.call(void 0, ).invalidate(stream);
+        await _chunkS2BEPQ5Zcjs.cache.call(void 0, ).invalidate(stream);
       }
     })
   );
@@ -2647,7 +2749,7 @@ var CorrelateCycle = (_class5 = class {
   // never lets a resolution re-lane them.
   
   __init18() {this._static_subscriptions = /* @__PURE__ */ new Map()}
-  __init19() {this._patterns = new (0, _chunk4UWU5FANcjs.LruMap)(PATTERN_CACHE_SIZE)}
+  __init19() {this._patterns = new (0, _chunkS2BEPQ5Zcjs.LruMap)(PATTERN_CACHE_SIZE)}
   
   
   
@@ -2665,7 +2767,7 @@ var CorrelateCycle = (_class5 = class {
     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, _chunk4UWU5FANcjs.LruMap)(max_subscribed_streams);
+    this._dynamic_subscriptions = new (0, _chunkS2BEPQ5Zcjs.LruMap)(max_subscribed_streams);
     this._registry = registry;
     this._declared_lanes = declared_lanes;
     this._static_targets = static_targets;
@@ -2697,7 +2799,7 @@ var CorrelateCycle = (_class5 = class {
         lane
       });
     }
-    await _optionalChain([this, 'access', _139 => _139._on_init, 'optionalCall', _140 => _140()]);
+    await _optionalChain([this, 'access', _145 => _145._on_init, 'optionalCall', _146 => _146()]);
   }
   /**
    * Replace the log with no pass in flight, then cold-start: a pass that
@@ -2723,7 +2825,7 @@ var CorrelateCycle = (_class5 = class {
   // 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 (_chunk4UWU5FANcjs.is_literal_source.call(void 0, source)) return false;
+    if (_chunkS2BEPQ5Zcjs.is_literal_source.call(void 0, source)) return false;
     let pattern = this._patterns.get(source);
     if (!pattern) {
       pattern = new RegExp(source);
@@ -2766,7 +2868,7 @@ var CorrelateCycle = (_class5 = class {
     const correlated = /* @__PURE__ */ new Map();
     let last_id = after;
     let stopped = false;
-    const found = await _chunk4UWU5FANcjs.store.call(void 0, ).query(
+    const found = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query(
       (event) => {
         if (stopped) return;
         const register = this._registry.events[event.name];
@@ -2811,9 +2913,9 @@ var CorrelateCycle = (_class5 = class {
               correlated_at: void 0
             };
             const seen_in_scan = correlated.has(resolved.target);
-            const held_lane = _nullishCoalesce((seen_in_scan ? entry.lane : _optionalChain([recorded, 'optionalAccess', _141 => _141.lane])), () => ( _chunkBCA423WPcjs.DEFAULT_LANE));
-            const held_priority = seen_in_scan ? entry.priority : _optionalChain([recorded, 'optionalAccess', _142 => _142.priority]);
-            const resolved_lane = _nullishCoalesce(lane, () => ( _chunkBCA423WPcjs.DEFAULT_LANE));
+            const held_lane = _nullishCoalesce((seen_in_scan ? entry.lane : _optionalChain([recorded, 'optionalAccess', _147 => _147.lane])), () => ( _chunk3CQWJ4UAcjs.DEFAULT_LANE));
+            const held_priority = seen_in_scan ? entry.priority : _optionalChain([recorded, 'optionalAccess', _148 => _148.priority]);
+            const resolved_lane = _nullishCoalesce(lane, () => ( _chunk3CQWJ4UAcjs.DEFAULT_LANE));
             if (held_priority === priority && held_lane !== resolved_lane)
               report_lane_conflict(
                 this._reported,
@@ -2867,7 +2969,7 @@ var CorrelateCycle = (_class5 = class {
       ).length;
       this._checkpoint = last_id;
       for (const { stream, priority, lane } of streams) {
-        if (_optionalChain([correlated, 'access', _143 => _143.get, 'call', _144 => _144(stream), 'optionalAccess', _145 => _145.upgraded]))
+        if (_optionalChain([correlated, 'access', _149 => _149.get, 'call', _150 => _150(stream), 'optionalAccess', _151 => _151.upgraded]))
           this._dynamic_subscriptions.set(stream, {
             priority,
             lane
@@ -2887,7 +2989,7 @@ var CorrelateCycle = (_class5 = class {
     await Promise.all(
       missed.map(async ([stream, entry]) => {
         let row;
-        await _chunk4UWU5FANcjs.store.call(void 0, ).query_streams(
+        await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query_streams(
           (position) => {
             row = position;
           },
@@ -2899,8 +3001,8 @@ var CorrelateCycle = (_class5 = class {
           lane: row.lane
         });
         if (entry.priority > row.priority) return;
-        const held_lane = _nullishCoalesce(row.lane, () => ( _chunkBCA423WPcjs.DEFAULT_LANE));
-        const resolved_lane = _nullishCoalesce(entry.lane, () => ( _chunkBCA423WPcjs.DEFAULT_LANE));
+        const held_lane = _nullishCoalesce(row.lane, () => ( _chunk3CQWJ4UAcjs.DEFAULT_LANE));
+        const resolved_lane = _nullishCoalesce(entry.lane, () => ( _chunk3CQWJ4UAcjs.DEFAULT_LANE));
         if (entry.priority === row.priority && held_lane !== resolved_lane)
           report_lane_conflict(
             this._reported,
@@ -2926,7 +3028,7 @@ var CorrelateCycle = (_class5 = class {
         millis: 0
       });
     } catch (error) {
-      _chunk4UWU5FANcjs.log.call(void 0, ).warn(
+      _chunkS2BEPQ5Zcjs.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)))}`
       );
     }
@@ -2950,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] = _chunkBCA423WPcjs.SHREDDED;
+    for (const f of fields) shredded[f] = _chunk3CQWJ4UAcjs.SHREDDED;
     return { ...rest, data: shredded };
   }
   const allowed = !!actor && !!predicate && predicate(event, actor);
@@ -2961,7 +3063,7 @@ function pii_gate(event, fields, predicate, actor) {
     };
   }
   const redacted = { ...data };
-  for (const f of fields) redacted[f] = _chunkBCA423WPcjs.REDACTED;
+  for (const f of fields) redacted[f] = _chunk3CQWJ4UAcjs.REDACTED;
   return { ...rest, data: redacted };
 }
 var IDENTITY_GATE = (event) => event;
@@ -3106,7 +3208,7 @@ var SettleLoop = (_class6 = class {
       this._pending = true;
       return;
     }
-    const delay = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _146 => _146.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;
@@ -3263,7 +3365,7 @@ var Act = (_class7 = class {
   // Lanes to arm per event; `"all"` when a dynamic resolver hides the lane.
   
   
-  __init27() {this._logger = _chunk4UWU5FANcjs.log.call(void 0, )}
+  __init27() {this._logger = _chunkS2BEPQ5Zcjs.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`.
@@ -3285,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, () => ( _chunk4UWU5FANcjs.default_scope.call(void 0, )));
+    if (options.scoped) _chunkS2BEPQ5Zcjs.check_store.call(void 0, options.scoped.store);
+    this._ports = _nullishCoalesce(options.scoped, () => ( _chunkS2BEPQ5Zcjs.default_scope.call(void 0, )));
     const ports = this._ports;
-    this._scoped = _chunk4UWU5FANcjs.make_run_scoped.call(void 0, {
+    this._scoped = _chunkS2BEPQ5Zcjs.make_run_scoped.call(void 0, {
       // Getters, not a spread: the singletons resolve lazily, so a later
       // `store(...)` / `cache(...)` still takes effect.
       get store() {
@@ -3297,14 +3400,14 @@ var Act = (_class7 = class {
         return ports.cache;
       },
       // Parsed per build, so a bad window throws on every build.
-      autoclose_window: _chunk4UWU5FANcjs.resolveAutocloseConfig.call(void 0, options).autocloseWindow
+      autoclose_window: _chunkS2BEPQ5Zcjs.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: _chunk4UWU5FANcjs.make_reaction_scope.call(void 0, {
+      reaction_scope: _chunkS2BEPQ5Zcjs.make_reaction_scope.call(void 0, {
         do: this.do.bind(this),
         load: this.load.bind(this),
         query: this.query.bind(this),
@@ -3334,12 +3437,12 @@ var Act = (_class7 = class {
       this._ports.store,
       options.listen !== false
     );
-    _chunk4UWU5FANcjs.register_weak_disposer.call(void 0, new WeakRef(this), (self) => self.shutdown());
+    _chunkS2BEPQ5Zcjs.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(
-      _chunk4UWU5FANcjs.resolveCircuitBreakerConfig.call(void 0, options.circuitBreaker),
+      _chunkS2BEPQ5Zcjs.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
@@ -3351,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', _147 => _147.onlyLanes, 'optionalAccess', _148 => _148.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();
@@ -3373,7 +3476,7 @@ var Act = (_class7 = class {
           try {
             await this._run_close(targets);
           } catch (error) {
-            if (error instanceof _chunkBCA423WPcjs.StoreError) throw error;
+            if (error instanceof _chunk3CQWJ4UAcjs.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.`
@@ -3388,7 +3491,7 @@ var Act = (_class7 = class {
           leaseMillis: cfg.leaseMillis
         }
       });
-      if (_optionalChain([cfg, 'optionalAccess', _149 => _149.cycleMs]) !== void 0 && this._drain)
+      if (_optionalChain([cfg, 'optionalAccess', _155 => _155.cycleMs]) !== void 0 && this._drain)
         controller.start(cfg.cycleMs);
       controllers.set(name, controller);
     }
@@ -3407,7 +3510,7 @@ var Act = (_class7 = class {
   // Audit deps, built after the controllers so the lane set is final.
   _build_audit_deps() {
     return {
-      store: _chunk4UWU5FANcjs.store,
+      store: _chunkS2BEPQ5Zcjs.store,
       event_to_state: this._event_to_state,
       // Declared lanes, not this process's controllers: a lane another
       // worker drains is not `unknown-lane`.
@@ -3420,7 +3523,7 @@ var Act = (_class7 = class {
       registry: this.registry,
       static_targets: classification.static_targets,
       cd: this._cd,
-      max_subscribed_streams: _nullishCoalesce(options.maxSubscribedStreams, () => ( _chunkBCA423WPcjs.DEFAULT_MAX_SUBSCRIBED_STREAMS)),
+      max_subscribed_streams: _nullishCoalesce(options.maxSubscribedStreams, () => ( _chunk3CQWJ4UAcjs.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),
@@ -3436,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(_chunk4UWU5FANcjs.store.call(void 0, ), (pos) => {
+    await walk_streams(_chunkS2BEPQ5Zcjs.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', _150 => _150.seed_defer, 'call', _151 => _151(pos.stream, pos.deferred_at)]);
+      _optionalChain([controller, 'optionalAccess', _156 => _156.seed_defer, 'call', _157 => _157(pos.stream, pos.deferred_at)]);
     });
   }
   _build_settle(options) {
@@ -3452,7 +3555,7 @@ var Act = (_class7 = class {
         on_settled: (drain) => this.emit("settled", drain),
         breaker: this._breaker
       },
-      _nullishCoalesce(options.settleDebounceMs, () => ( _chunkBCA423WPcjs.DEFAULT_SETTLE_DEBOUNCE_MS))
+      _nullishCoalesce(options.settleDebounceMs, () => ( _chunk3CQWJ4UAcjs.DEFAULT_SETTLE_DEBOUNCE_MS))
     );
   }
   
@@ -3472,7 +3575,7 @@ var Act = (_class7 = class {
    */
   shutdown(options) {
     if (!this._shutdown_promise) {
-      _chunk4UWU5FANcjs.resolveShutdownConfig.call(void 0, options);
+      _chunkS2BEPQ5Zcjs.resolveShutdownConfig.call(void 0, options);
       this._shutdown_promise = (async () => {
         this.stop_correlations();
         this._settle.stop(true);
@@ -3480,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', _152 => _152.graceMs]));
+        await this._await_inflight(_optionalChain([options, 'optionalAccess', _158 => _158.graceMs]));
         await this._scoped(() => this._correlate.release_correlation());
         this._emitter.removeAllListeners();
       })();
@@ -3490,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 ? _chunk4UWU5FANcjs.DEFAULT_LEASE_MILLIS : 0;
+    let max = settling ? _chunkS2BEPQ5Zcjs.DEFAULT_LEASE_MILLIS : 0;
     for (const c of running)
-      max = Math.max(max, c.lease_millis || _chunk4UWU5FANcjs.DEFAULT_LEASE_MILLIS);
-    return Math.min(max, _chunk4UWU5FANcjs.MAX_SHUTDOWN_GRACE_MS);
+      max = Math.max(max, c.lease_millis || _chunkS2BEPQ5Zcjs.DEFAULT_LEASE_MILLIS);
+    return Math.min(max, _chunkS2BEPQ5Zcjs.MAX_SHUTDOWN_GRACE_MS);
   }
   async _await_inflight(grace_ms) {
     const running = [...this._drain_controllers.values()].filter(
@@ -3540,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
@@ -3550,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
@@ -3576,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', _153 => _153.reactingTo]), () => ( _chunk4UWU5FANcjs.current_reacting.call(void 0, )));
-    const do_options = reacting_to === _optionalChain([options, 'optionalAccess', _154 => _154.reactingTo]) ? options : { ...options, reactingTo: reacting_to };
+    const reacting_to = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _159 => _159.reactingTo]), () => ( _chunkS2BEPQ5Zcjs.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],
@@ -3587,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) {
@@ -3642,11 +3755,11 @@ var Act = (_class7 = class {
     return this._scoped(async () => {
       let first;
       let last;
-      const count = await _chunk4UWU5FANcjs.store.call(void 0, ).query((e) => {
+      const count = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query((e) => {
         const gated = this.registry.query_gate(e.name)(e);
         if (!first) first = gated;
         last = gated;
-        _optionalChain([callback, 'optionalCall', _155 => _155(gated)]);
+        _optionalChain([callback, 'optionalCall', _161 => _161(gated)]);
       }, query);
       return { first, last, count };
     });
@@ -3672,7 +3785,7 @@ var Act = (_class7 = class {
   async query_array(query) {
     return this._scoped(async () => {
       const events = [];
-      await _chunk4UWU5FANcjs.store.call(void 0, ).query((e) => {
+      await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query((e) => {
         events.push(this.registry.query_gate(e.name)(e));
       }, query);
       return events;
@@ -3692,14 +3805,14 @@ var Act = (_class7 = class {
    */
   async forget(stream) {
     return this._scoped(async () => {
-      const s = _chunk4UWU5FANcjs.store.call(void 0, );
+      const s = _chunkS2BEPQ5Zcjs.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 _chunk4UWU5FANcjs.cache.call(void 0, ).invalidate(stream);
+      await _chunkS2BEPQ5Zcjs.cache.call(void 0, ).invalidate(stream);
       if (eventCount > 0) {
         this.emit("forgotten", { stream, at: /* @__PURE__ */ new Date(), eventCount });
       }
@@ -3733,7 +3846,7 @@ var Act = (_class7 = class {
    * @see {@link correlate} for dynamic stream discovery
    */
   async drain(options = {}) {
-    _chunk4UWU5FANcjs.resolveDrainConfig.call(void 0, options);
+    _chunkS2BEPQ5Zcjs.resolveDrainConfig.call(void 0, options);
     if (!this._drain)
       return { fetched: [], leased: [], acked: [], blocked: [] };
     return this._scoped(() => this._drain_all(options));
@@ -3771,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', _156 => _156._drain_controllers, 'access', _157 => _157.get, 'call', _158 => _158(lane), 'optionalAccess', _159 => _159.arm, 'call', _160 => _160()]);
+    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.
@@ -3913,9 +4026,9 @@ var Act = (_class7 = class {
    */
   async reset(input) {
     return this._scoped(async () => {
-      const count = await _chunk4UWU5FANcjs.store.call(void 0, ).reset(input);
+      const count = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).reset(input);
       for (const handler of this._batch_handlers.values())
-        _optionalChain([handler, 'access', _161 => _161[FOLD_RESET], 'optionalCall', _162 => _162()]);
+        _optionalChain([handler, 'access', _167 => _167[FOLD_RESET], 'optionalCall', _168 => _168()]);
       if (count > 0) {
         this._wake();
       }
@@ -3949,7 +4062,7 @@ var Act = (_class7 = class {
    */
   async unblock(input) {
     return this._scoped(async () => {
-      const count = await _chunk4UWU5FANcjs.store.call(void 0, ).unblock(input);
+      const count = await _chunkS2BEPQ5Zcjs.store.call(void 0, ).unblock(input);
       if (count > 0) {
         this._wake();
       }
@@ -4004,7 +4117,7 @@ var Act = (_class7 = class {
         return { ...partial, duration_ms: Date.now() - started };
       }
       const target = _nullishCoalesce(sink, () => ( (() => {
-        const s = _chunk4UWU5FANcjs.store.call(void 0, );
+        const s = _chunkS2BEPQ5Zcjs.store.call(void 0, );
         if (!s.restore) throw new Error("adapter has no restore capability");
         return s;
       })()));
@@ -4050,11 +4163,11 @@ var Act = (_class7 = class {
   async blocked_streams(options) {
     return this._scoped(async () => {
       const positions = [];
-      await _chunk4UWU5FANcjs.store.call(void 0, ).query_streams(
+      await _chunkS2BEPQ5Zcjs.store.call(void 0, ).query_streams(
         (p) => {
           positions.push(p);
         },
-        { blocked: true, after: _optionalChain([options, 'optionalAccess', _163 => _163.after]), limit: _optionalChain([options, 'optionalAccess', _164 => _164.limit]) }
+        { blocked: true, after: _optionalChain([options, 'optionalAccess', _169 => _169.after]), limit: _optionalChain([options, 'optionalAccess', _170 => _170.limit]) }
       );
       return positions;
     });
@@ -4102,7 +4215,7 @@ var Act = (_class7 = class {
    * @see {@link Store.prioritize} for the underlying primitive
    */
   async prioritize(filter, priority) {
-    return this._scoped(() => _chunk4UWU5FANcjs.store.call(void 0, ).prioritize(filter, priority));
+    return this._scoped(() => _chunkS2BEPQ5Zcjs.store.call(void 0, ).prioritize(filter, priority));
   }
   // Shared by `close()` and reaction-requested closes.
   async _run_close(targets) {
@@ -4182,19 +4295,18 @@ var Act = (_class7 = class {
    * @see {@link correlate} for manual correlation
    */
   settle(options) {
-    _chunk4UWU5FANcjs.resolveSettleConfig.call(void 0, _nullishCoalesce(options, () => ( {})));
+    _chunkS2BEPQ5Zcjs.resolveSettleConfig.call(void 0, _nullishCoalesce(options, () => ( {})));
     this._schedule(options);
   }
 }, _class7);
 
 // src/builders/merge.ts
 
-function base_type_name(zodType) {
-  let t = zodType;
-  while (typeof t.unwrap === "function") {
-    t = t.unwrap();
-  }
-  return t.constructor.name;
+function base_type_name(schema) {
+  let def = _chunk3CQWJ4UAcjs.def_of.call(void 0, schema);
+  for (let inner = _chunk3CQWJ4UAcjs.inner_of.call(void 0, def); inner; inner = _chunk3CQWJ4UAcjs.inner_of.call(void 0, def))
+    def = _chunk3CQWJ4UAcjs.def_of.call(void 0, inner);
+  return def.type === "array" ? `array of ${base_type_name(def.element)}` : def.type;
 }
 function merge_schemas(existing, incoming, state_name) {
   if (existing === incoming) return existing;
@@ -4286,8 +4398,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
@@ -4380,9 +4492,9 @@ var _this_ = ({ stream }) => ({
 
 // src/builders/builder-utils.ts
 function register_lane(config2, lanes) {
-  _chunk4UWU5FANcjs.resolveLaneConfig.call(void 0, config2);
-  if (config2.name === _chunkBCA423WPcjs.DEFAULT_LANE)
-    throw new Error(`Lane "${_chunkBCA423WPcjs.DEFAULT_LANE}" is reserved`);
+  _chunkS2BEPQ5Zcjs.resolveLaneConfig.call(void 0, config2);
+  if (config2.name === _chunk3CQWJ4UAcjs.DEFAULT_LANE)
+    throw new Error(`Lane "${_chunk3CQWJ4UAcjs.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)
@@ -4424,10 +4536,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: _chunk4UWU5FANcjs.resolveReactionConfig.call(void 0, {
-          blockOnError: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _165 => _165.blockOnError]), () => ( _chunk4UWU5FANcjs.DEFAULT_BLOCK_ON_ERROR)),
-          maxRetries: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _166 => _166.maxRetries]), () => ( _chunk4UWU5FANcjs.DEFAULT_MAX_RETRIES)),
-          backoff: _optionalChain([options, 'optionalAccess', _167 => _167.backoff])
+        options: _chunkS2BEPQ5Zcjs.resolveReactionConfig.call(void 0, {
+          blockOnError: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _171 => _171.blockOnError]), () => ( _chunkS2BEPQ5Zcjs.DEFAULT_BLOCK_ON_ERROR)),
+          maxRetries: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _172 => _172.maxRetries]), () => ( _chunkS2BEPQ5Zcjs.DEFAULT_MAX_RETRIES)),
+          backoff: _optionalChain([options, 'optionalAccess', _173 => _173.backoff])
         })
       };
     },
@@ -4447,7 +4559,7 @@ function reaction_on(event, events, builder) {
 // src/internal/date-reviver.ts
 
 function variant_schema(schema, walk) {
-  const shape = _optionalChain([_chunkBCA423WPcjs.def_of.call(void 0, schema), 'optionalAccess', _168 => _168.shape]);
+  const shape = _optionalChain([_chunk3CQWJ4UAcjs.def_of.call(void 0, schema), 'optionalAccess', _174 => _174.shape]);
   if (!shape) {
     const dates = walk(schema);
     return { schema: _nullishCoalesce(dates, () => ( schema)), dated: !!dates };
@@ -4484,7 +4596,7 @@ function date_reviver_schema(schema) {
   return first && recursive ? pass(true) : first;
 }
 function build(schema, walk) {
-  const def = _chunkBCA423WPcjs.def_of.call(void 0, schema);
+  const def = _chunk3CQWJ4UAcjs.def_of.call(void 0, schema);
   if (!def) return void 0;
   const inner = () => walk(def.innerType);
   switch (def.type) {
@@ -4519,7 +4631,7 @@ function build(schema, walk) {
       return variants.some((v) => v.dated) ? _zod.z.union(variants.map((v) => v.schema)) : void 0;
     }
     case "nullable":
-      return _optionalChain([inner, 'call', _169 => _169(), 'optionalAccess', _170 => _170.nullable, 'call', _171 => _171()]);
+      return _optionalChain([inner, 'call', _175 => _175(), 'optionalAccess', _176 => _176.nullable, 'call', _177 => _177()]);
     case "pipe":
       return walk(def.out);
     case "lazy":
@@ -4530,13 +4642,13 @@ function build(schema, walk) {
       return left && right ? left.pipe(right) : _nullishCoalesce(left, () => ( right));
     }
     default:
-      return _chunkBCA423WPcjs.inner_of.call(void 0, def) ? inner() : void 0;
+      return _chunk3CQWJ4UAcjs.inner_of.call(void 0, def) ? inner() : void 0;
   }
 }
 
 // src/builders/event-builder.ts
 function event_tags(schema) {
-  const pii = _chunkBCA423WPcjs.pii_schemas.call(void 0, schema);
+  const pii = _chunk3CQWJ4UAcjs.pii_schemas.call(void 0, schema);
   const pii_dates = {};
   for (const [key, field] of Object.entries(pii)) {
     const dates = date_reviver_schema(field);
@@ -4574,7 +4686,7 @@ function make_event_reader(tags, disclosure, predicate = null) {
   });
 }
 function build_events(registry, states, lanes, owners) {
-  const declared = /* @__PURE__ */ new Set([_chunkBCA423WPcjs.DEFAULT_LANE, ...lanes.map((l) => l.name)]);
+  const declared = /* @__PURE__ */ new Set([_chunk3CQWJ4UAcjs.DEFAULT_LANE, ...lanes.map((l) => l.name)]);
   const lane_errors = [];
   const tags = /* @__PURE__ */ new Map();
   const sensitive2 = /* @__PURE__ */ new Map();
@@ -4649,7 +4761,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(_chunkBCA423WPcjs.SNAP_EVENT, snap2);
+    if (snap2) readers.set(_chunk3CQWJ4UAcjs.SNAP_EVENT, snap2);
     if (readers.size === 0) continue;
     state2.view = (event, actor) => (_nullishCoalesce(readers.get(event.name), () => ( IDENTITY_GATE)))(event, actor);
   }
@@ -4657,7 +4769,7 @@ function build_events(registry, states, lanes, owners) {
   return { sensitive: sensitive2, advisory, query_readers, handler_readers };
 }
 function reads_as_string(schema) {
-  const type = _optionalChain([_chunkBCA423WPcjs.def_of.call(void 0, _chunkBCA423WPcjs.output_of.call(void 0, schema)), 'optionalAccess', _172 => _172.type]);
+  const type = _optionalChain([_chunk3CQWJ4UAcjs.def_of.call(void 0, _chunk3CQWJ4UAcjs.output_of.call(void 0, schema)), 'optionalAccess', _178 => _178.type]);
   return type === "string" || type === "transform";
 }
 
@@ -4715,7 +4827,7 @@ function act() {
   let _built = false;
   const read_wrap = (original) => {
     const wrapped = async (events, stream) => {
-      const read = events.map((e) => _nullishCoalesce(_optionalChain([_hr, 'access', _173 => _173.get, 'call', _174 => _174(e.name), 'optionalCall', _175 => _175(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];
@@ -4756,7 +4868,7 @@ function act() {
         });
       }
       for (const [action_name, handler] of Object.entries(state2.on)) {
-        const static_target = _optionalChain([handler, 'optionalAccess', _176 => _176._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(
@@ -4769,7 +4881,7 @@ function act() {
       const list = deprecation_summary.map(
         (d) => `"${d.deprecated}" (current: "${d.current}", state: "${d.state_name}")`
       ).join(", ");
-      _chunk4UWU5FANcjs.log.call(void 0, ).info(
+      _chunkS2BEPQ5Zcjs.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.`
       );
     }
@@ -4811,7 +4923,7 @@ function act() {
       return reaction_on(event, registry.events, builder);
     },
     build: (options) => {
-      _chunk4UWU5FANcjs.resolveActConfig.call(void 0, options);
+      _chunkS2BEPQ5Zcjs.resolveActConfig.call(void 0, options);
       if (!_built) {
         for (const proj of pending_projections) add_projection(proj);
         for (const proj of fold_projections) {
@@ -4829,7 +4941,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', _177 => _177.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`
@@ -4851,7 +4963,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) _chunk4UWU5FANcjs.log.call(void 0, ).warn(built.advisory);
+        if (built.advisory) _chunkS2BEPQ5Zcjs.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);
@@ -4863,7 +5007,7 @@ function act() {
         synthesize_autoclose_reactions(
           registry,
           states,
-          _chunk4UWU5FANcjs.current_autoclose_window
+          _chunkS2BEPQ5Zcjs.current_autoclose_window
         );
         Object.freeze(registry.actions);
         Object.freeze(registry.events);
@@ -4911,8 +5055,8 @@ function _projection(target) {
               handler,
               resolver: _nullishCoalesce(default_resolver, () => ( _this_)),
               options: {
-                blockOnError: _chunk4UWU5FANcjs.DEFAULT_BLOCK_ON_ERROR,
-                maxRetries: _chunk4UWU5FANcjs.DEFAULT_MAX_RETRIES
+                blockOnError: _chunkS2BEPQ5Zcjs.DEFAULT_BLOCK_ON_ERROR,
+                maxRetries: _chunkS2BEPQ5Zcjs.DEFAULT_MAX_RETRIES
               }
             }),
             widened
@@ -4953,7 +5097,7 @@ function _projection(target) {
             throw new Error(
               `Projection "${target}" .of() partials must share one state name \u2014 got "${name}" and "${partial.name}"`
             );
-        const config2 = _chunk4UWU5FANcjs.resolveFoldConfig.call(void 0, options);
+        const config2 = _chunkS2BEPQ5Zcjs.resolveFoldConfig.call(void 0, options);
         const fold_events = {};
         for (const partial of partials)
           for (const [event_name, schema] of Object.entries(partial.events)) {
@@ -4971,8 +5115,8 @@ function _projection(target) {
                     handler: noop,
                     resolver: { target },
                     options: {
-                      blockOnError: _chunk4UWU5FANcjs.DEFAULT_BLOCK_ON_ERROR,
-                      maxRetries: _chunk4UWU5FANcjs.DEFAULT_MAX_RETRIES
+                      blockOnError: _chunkS2BEPQ5Zcjs.DEFAULT_BLOCK_ON_ERROR,
+                      maxRetries: _chunkS2BEPQ5Zcjs.DEFAULT_MAX_RETRIES
                     }
                   }
                 ]
@@ -5088,13 +5232,29 @@ function action_builder(state2) {
         throw new Error(`Duplicate action "${action2}"`);
       internal.actions[action2] = schema;
       if (options) {
-        _chunk4UWU5FANcjs.resolveActionConfig.call(void 0, options);
+        _chunkS2BEPQ5Zcjs.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;
@@ -5115,7 +5275,7 @@ function action_builder(state2) {
         }
         return builder;
       }
-      return { given, requires, emit };
+      return { loads: load2, requires, emit };
     },
     snap(snap2) {
       internal.snap = snap2;
@@ -5384,5 +5544,5 @@ function write_line(writer, line) {
 
 
 
-exports.Act = Act; exports.ActorSchema = _chunkBCA423WPcjs.ActorSchema; exports.CausationEventSchema = _chunkBCA423WPcjs.CausationEventSchema; exports.CommittedMetaSchema = _chunkBCA423WPcjs.CommittedMetaSchema; exports.ConcurrencyError = _chunkBCA423WPcjs.ConcurrencyError; exports.ConsoleLogger = _chunk4UWU5FANcjs.ConsoleLogger; exports.CsvFile = CsvFile; exports.DEFAULT_LANE = _chunkBCA423WPcjs.DEFAULT_LANE; exports.DEFAULT_MAX_SUBSCRIBED_STREAMS = _chunkBCA423WPcjs.DEFAULT_MAX_SUBSCRIBED_STREAMS; exports.DEFAULT_QUERY_STREAMS_LIMIT = _chunk4UWU5FANcjs.DEFAULT_QUERY_STREAMS_LIMIT; exports.DEFAULT_SETTLE_DEBOUNCE_MS = _chunkBCA423WPcjs.DEFAULT_SETTLE_DEBOUNCE_MS; exports.DeferSignal = _chunkBCA423WPcjs.DeferSignal; exports.Environments = _chunkBCA423WPcjs.Environments; exports.Errors = _chunkBCA423WPcjs.Errors; exports.EventMetaSchema = _chunkBCA423WPcjs.EventMetaSchema; exports.ExitCodes = _chunkBCA423WPcjs.ExitCodes; exports.InMemoryCache = _chunk4UWU5FANcjs.InMemoryCache; exports.InMemoryStore = _chunk4UWU5FANcjs.InMemoryStore; exports.InvariantError = _chunkBCA423WPcjs.InvariantError; exports.LogLevels = _chunkBCA423WPcjs.LogLevels; exports.NonRetryableError = _chunkBCA423WPcjs.NonRetryableError; exports.PackageSchema = _chunk4UWU5FANcjs.PackageSchema; exports.PreconditionError = _chunkBCA423WPcjs.PreconditionError; exports.QuerySchema = _chunkBCA423WPcjs.QuerySchema; exports.REDACTED = _chunkBCA423WPcjs.REDACTED; exports.SHREDDED = _chunkBCA423WPcjs.SHREDDED; exports.SNAP_EVENT = _chunkBCA423WPcjs.SNAP_EVENT; exports.StoreError = _chunkBCA423WPcjs.StoreError; exports.StreamClosedError = _chunkBCA423WPcjs.StreamClosedError; exports.TOMBSTONE_EVENT = _chunkBCA423WPcjs.TOMBSTONE_EVENT; exports.TargetSchema = _chunkBCA423WPcjs.TargetSchema; exports.ValidationError = _chunkBCA423WPcjs.ValidationError; exports.ZodEmpty = _chunkBCA423WPcjs.ZodEmpty; exports.act = act; exports.cache = _chunk4UWU5FANcjs.cache; exports.config = _chunk4UWU5FANcjs.config; exports.dateReviver = _chunk4UWU5FANcjs.dateReviver; exports.default_scope = _chunk4UWU5FANcjs.default_scope; exports.dispose = _chunk4UWU5FANcjs.dispose; exports.disposeAndExit = _chunk4UWU5FANcjs.disposeAndExit; exports.extend = _chunk4UWU5FANcjs.extend; exports.fair_slots = _chunk4UWU5FANcjs.fair_slots; exports.is_literal_source = _chunk4UWU5FANcjs.is_literal_source; exports.log = _chunk4UWU5FANcjs.log; exports.pii_fields = _chunkBCA423WPcjs.pii_fields; exports.port = _chunk4UWU5FANcjs.port; exports.projection = projection; exports.resolveAutocloseConfig = _chunk4UWU5FANcjs.resolveAutocloseConfig2; exports.sensitive = _chunkBCA423WPcjs.sensitive; exports.sleep = _chunk4UWU5FANcjs.sleep; exports.slice = slice; exports.state = state; exports.store = _chunk4UWU5FANcjs.store; exports.validate = _chunk4UWU5FANcjs.validate;
+exports.Act = Act; exports.ActorSchema = _chunk3CQWJ4UAcjs.ActorSchema; exports.CausationEventSchema = _chunk3CQWJ4UAcjs.CausationEventSchema; exports.CommittedMetaSchema = _chunk3CQWJ4UAcjs.CommittedMetaSchema; exports.ConcurrencyError = _chunk3CQWJ4UAcjs.ConcurrencyError; exports.ConsoleLogger = _chunkS2BEPQ5Zcjs.ConsoleLogger; exports.CsvFile = CsvFile; exports.DEFAULT_LANE = _chunk3CQWJ4UAcjs.DEFAULT_LANE; exports.DEFAULT_MAX_SUBSCRIBED_STREAMS = _chunk3CQWJ4UAcjs.DEFAULT_MAX_SUBSCRIBED_STREAMS; exports.DEFAULT_QUERY_STREAMS_LIMIT = _chunkS2BEPQ5Zcjs.DEFAULT_QUERY_STREAMS_LIMIT; exports.DEFAULT_SETTLE_DEBOUNCE_MS = _chunk3CQWJ4UAcjs.DEFAULT_SETTLE_DEBOUNCE_MS; exports.DeferSignal = _chunk3CQWJ4UAcjs.DeferSignal; exports.Environments = _chunk3CQWJ4UAcjs.Environments; exports.Errors = _chunk3CQWJ4UAcjs.Errors; exports.EventMetaSchema = _chunk3CQWJ4UAcjs.EventMetaSchema; exports.ExitCodes = _chunk3CQWJ4UAcjs.ExitCodes; exports.InMemoryCache = _chunkS2BEPQ5Zcjs.InMemoryCache; exports.InMemoryStore = _chunkS2BEPQ5Zcjs.InMemoryStore; exports.LogLevels = _chunk3CQWJ4UAcjs.LogLevels; exports.NonRetryableError = _chunk3CQWJ4UAcjs.NonRetryableError; exports.PackageSchema = _chunkS2BEPQ5Zcjs.PackageSchema; exports.PreconditionError = _chunk3CQWJ4UAcjs.PreconditionError; exports.QuerySchema = _chunk3CQWJ4UAcjs.QuerySchema; exports.REDACTED = _chunk3CQWJ4UAcjs.REDACTED; exports.SHREDDED = _chunk3CQWJ4UAcjs.SHREDDED; exports.SNAP_EVENT = _chunk3CQWJ4UAcjs.SNAP_EVENT; exports.StoreError = _chunk3CQWJ4UAcjs.StoreError; exports.StreamClosedError = _chunk3CQWJ4UAcjs.StreamClosedError; exports.TOMBSTONE_EVENT = _chunk3CQWJ4UAcjs.TOMBSTONE_EVENT; exports.TargetSchema = _chunk3CQWJ4UAcjs.TargetSchema; exports.ValidationError = _chunk3CQWJ4UAcjs.ValidationError; exports.ZodEmpty = _chunk3CQWJ4UAcjs.ZodEmpty; exports.act = act; exports.cache = _chunkS2BEPQ5Zcjs.cache; exports.check_appends = _chunkS2BEPQ5Zcjs.check_appends; exports.config = _chunkS2BEPQ5Zcjs.config; exports.dateReviver = _chunkS2BEPQ5Zcjs.dateReviver; exports.default_scope = _chunkS2BEPQ5Zcjs.default_scope; exports.dispose = _chunkS2BEPQ5Zcjs.dispose; exports.disposeAndExit = _chunkS2BEPQ5Zcjs.disposeAndExit; exports.extend = _chunkS2BEPQ5Zcjs.extend; exports.fair_slots = _chunkS2BEPQ5Zcjs.fair_slots; exports.is_literal_source = _chunkS2BEPQ5Zcjs.is_literal_source; exports.log = _chunkS2BEPQ5Zcjs.log; exports.pii_fields = _chunk3CQWJ4UAcjs.pii_fields; exports.port = _chunkS2BEPQ5Zcjs.port; exports.projection = projection; exports.resolveAutocloseConfig = _chunkS2BEPQ5Zcjs.resolveAutocloseConfig2; exports.sensitive = _chunk3CQWJ4UAcjs.sensitive; exports.sleep = _chunkS2BEPQ5Zcjs.sleep; exports.slice = slice; exports.state = state; exports.store = _chunkS2BEPQ5Zcjs.store; exports.validate = _chunkS2BEPQ5Zcjs.validate;
 //# sourceMappingURL=index.cjs.map