@rotorsoft/act 1.33.7 → 1.33.9

package/dist/index.cjs

@@ -1162,23 +1162,27 @@ var CorrelateCycle = (_class3 = class {
   
   /** Local expiry of the held lease (0 = none); stale only costs a duplicate scan. */
   __init6() {this._lease_until = 0}
-  /** Raised by a commit or notification, lowered by a short page. Starts armed. */
-  __init7() {this._armed = true}
+  /**
+   * Armed while `_raised` (bumped by a commit or notification) is ahead of
+   * `_lowered` (the raise count the last short page saw). Starts armed.
+   */
+  __init7() {this._raised = 1}
+  __init8() {this._lowered = 0}
+  /** Counts releases, so a lease reply that lands after one is dropped. */
+  __init9() {this._releases = 0}
   
   // Bounded by `maxSubscribedStreams`; static records live apart so eviction
   // never drops their +Infinity floor.
   
-  __init8() {this._static_subscriptions = /* @__PURE__ */ new Map()}
-  __init9() {this._patterns = new (0, _chunkO6QIJQRNcjs.LruMap)(PATTERN_CACHE_SIZE)}
-  
+  __init10() {this._static_subscriptions = /* @__PURE__ */ new Map()}
+  __init11() {this._patterns = new (0, _chunkO6QIJQRNcjs.LruMap)(PATTERN_CACHE_SIZE)}
   
   
   
-  /** Runs once after `on_init`; re-seeds defer timers across a restart. */
   
   
   /** Report-once keys; per instance because `internal/` holds no module state. */
-  __init10() {this._reported = /* @__PURE__ */ new Set()}
+  __init12() {this._reported = /* @__PURE__ */ new Set()}
   constructor({
     registry,
     static_targets,
@@ -1186,9 +1190,8 @@ var CorrelateCycle = (_class3 = class {
     max_subscribed_streams,
     declared_lanes,
     shard,
-    on_init,
-    on_init_async
-  }) {;_class3.prototype.__init3.call(this);_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);
+    on_init
+  }) {;_class3.prototype.__init3.call(this);_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);
     this._key = shard ? `${registry_key(registry.events)}:${[...shard].sort().join(",")}` : registry_key(registry.events);
     this._dynamic_subscriptions = new (0, _chunkO6QIJQRNcjs.LruMap)(max_subscribed_streams);
     this._registry = registry;
@@ -1196,14 +1199,13 @@ var CorrelateCycle = (_class3 = class {
     this._static_targets = static_targets;
     this._cd = cd;
     this._on_init = on_init;
-    this._on_init_async = on_init_async;
   }
   get checkpoint() {
     return this._checkpoint;
   }
   /** A commit (local or remote) may have produced uncorrelated events. */
   arm() {
-    this._armed = true;
+    this._raised++;
   }
   async init() {
     if (this._initialized) return;
@@ -1221,7 +1223,6 @@ var CorrelateCycle = (_class3 = class {
       ...this._static_targets
     ]);
     this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - COLD_START_BACK_SCAN);
-    _optionalChain([this, 'access', _59 => _59._on_init, 'optionalCall', _60 => _60()]);
     for (const { stream, priority = 0, lane } of this._static_targets) {
       this._static_subscriptions.set(stream, {
         floor: Number.POSITIVE_INFINITY,
@@ -1229,7 +1230,7 @@ var CorrelateCycle = (_class3 = class {
         lane
       });
     }
-    await _optionalChain([this, 'access', _61 => _61._on_init_async, 'optionalCall', _62 => _62()]);
+    await _optionalChain([this, 'access', _59 => _59._on_init, 'optionalCall', _60 => _60()]);
   }
   /** After `restore` replaced the log: forget everything and cold-start again. */
   restart() {
@@ -1238,7 +1239,7 @@ var CorrelateCycle = (_class3 = class {
     this._checkpoint = -1;
     this._dynamic_subscriptions.clear();
     this._static_subscriptions.clear();
-    this._armed = true;
+    this._raised++;
   }
   /** Forget dynamic targets whose rows a full close deleted, so they re-subscribe. */
   forget_subscribed(streams) {
@@ -1258,22 +1259,26 @@ var CorrelateCycle = (_class3 = class {
   /** Scan past the checkpoint, subscribe new targets and raise their work marks. */
   async correlate(query = { after: -1, limit: 10 }, lease = false) {
     await this.init();
-    if (!this._armed)
+    if (this._raised === this._lowered)
       return {
         subscribed: 0,
         last_id: this._checkpoint,
         marked: 0,
         scanned: false
       };
+    const raised = this._raised;
     const now = Date.now();
     if (lease && now >= this._lease_until - CORRELATION_LEASE_MS / 2) {
+      const releases = this._releases;
       const { correlating } = await this._cd.subscribe([], void 0, {
         key: this._key,
         by: this._by,
         millis: CORRELATION_LEASE_MS
       });
-      this._lease_until = correlating ? now + CORRELATION_LEASE_MS : 0;
-      if (correlating === false)
+      const released = this._releases !== releases;
+      if (!released)
+        this._lease_until = correlating ? now + CORRELATION_LEASE_MS : 0;
+      if (correlating === false || released)
         return {
           subscribed: 0,
           last_id: this._checkpoint,
@@ -1329,8 +1334,8 @@ var CorrelateCycle = (_class3 = 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', _63 => _63.lane])), () => ( _chunk7AHW7FCNcjs.DEFAULT_LANE));
-            const held_priority = seen_in_scan ? entry.priority : _optionalChain([recorded, 'optionalAccess', _64 => _64.priority]);
+            const held_lane = _nullishCoalesce((seen_in_scan ? entry.lane : _optionalChain([recorded, 'optionalAccess', _61 => _61.lane])), () => ( _chunk7AHW7FCNcjs.DEFAULT_LANE));
+            const held_priority = seen_in_scan ? entry.priority : _optionalChain([recorded, 'optionalAccess', _62 => _62.priority]);
             const resolved_lane = _nullishCoalesce(lane, () => ( _chunk7AHW7FCNcjs.DEFAULT_LANE));
             if (held_priority === priority && held_lane !== resolved_lane)
               report_lane_conflict(
@@ -1384,7 +1389,7 @@ var CorrelateCycle = (_class3 = class {
       ).length;
       this._checkpoint = last_id;
       for (const { stream, priority, lane } of streams) {
-        if (_optionalChain([correlated, 'access', _65 => _65.get, 'call', _66 => _66(stream), 'optionalAccess', _67 => _67.upgraded]))
+        if (_optionalChain([correlated, 'access', _63 => _63.get, 'call', _64 => _64(stream), 'optionalAccess', _65 => _65.upgraded]))
           this._dynamic_subscriptions.set(stream, {
             floor: priority,
             priority,
@@ -1394,7 +1399,7 @@ var CorrelateCycle = (_class3 = class {
       return { subscribed, last_id, marked, scanned: true };
     }
     this._checkpoint = last_id;
-    this._armed = stopped || found === query.limit;
+    if (!stopped && found !== query.limit) this._lowered = raised;
     return { subscribed: 0, last_id, marked: 0, scanned: true };
   }
   /**
@@ -1440,6 +1445,7 @@ var CorrelateCycle = (_class3 = class {
   async release_correlation() {
     try {
       this._lease_until = 0;
+      this._releases++;
       await this._cd.subscribe([], void 0, {
         key: this._key,
         by: this._by,
@@ -1508,14 +1514,14 @@ function compute_backoff_delay(retry, opts) {
 // src/internal/defer-timer.ts
 var MAX_TIMER_DELAY_MS = 2147483647;
 var DeferTimer = (_class4 = class {
-  __init11() {this._due = /* @__PURE__ */ new Map()}
+  __init13() {this._due = /* @__PURE__ */ new Map()}
   
   
   /**
    * @param on_wake - invoked once each time the earliest due-time elapses.
    *   The consumer re-schedules for whatever is still parked.
    */
-  constructor(on_wake) {;_class4.prototype.__init11.call(this);
+  constructor(on_wake) {;_class4.prototype.__init13.call(this);
     this._on_wake = on_wake;
   }
   /** Number of currently parked streams. */
@@ -1619,7 +1625,7 @@ async function fetch(leased, eventLimit) {
           at,
           lagging,
           events: [],
-          error: _nullishCoalesce(_optionalChain([error, 'optionalAccess', _68 => _68.message]), () => ( String(error)))
+          error: _nullishCoalesce(_optionalChain([error, 'optionalAccess', _66 => _66.message]), () => ( String(error)))
         };
       }
       return { stream, source, at, lagging, events };
@@ -1748,7 +1754,7 @@ async function scan(source, opts = {}, callback) {
           return;
         }
         let migrated = event;
-        const migration = _optionalChain([event_migrations, 'optionalAccess', _69 => _69[event.name]]);
+        const migration = _optionalChain([event_migrations, 'optionalAccess', _67 => _67[event.name]]);
         if (migration) {
           const old_data = migration.from_schema.parse(event.data);
           const new_data = migration.migrate(old_data);
@@ -1770,7 +1776,7 @@ async function scan(source, opts = {}, callback) {
           return;
         }
         let remapped = migrated;
-        const caused_by = _optionalChain([migrated, 'access', _70 => _70.meta, 'access', _71 => _71.causation, 'access', _72 => _72.event, 'optionalAccess', _73 => _73.id]);
+        const caused_by = _optionalChain([migrated, 'access', _68 => _68.meta, 'access', _69 => _69.causation, 'access', _70 => _70.event, 'optionalAccess', _71 => _71.id]);
         if (caused_by !== void 0) {
           const new_caused_by = id_map.get(caused_by);
           if (new_caused_by !== void 0 && new_caused_by !== caused_by) {
@@ -1812,9 +1818,9 @@ async function load(me, target, callback, patch_fn = bare_patch) {
   const time_travel = !!asOf && Object.values(asOf).some((v) => v !== void 0);
   const cached = time_travel ? void 0 : await _chunkO6QIJQRNcjs.cache.call(void 0, ).get(stream);
   const cache_hit = !!cached;
-  let state2 = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _74 => _74.state]), () => ( (me.init ? me.init() : {})));
-  let patches = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _75 => _75.patches]), () => ( 0));
-  let snaps = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _76 => _76.snaps]), () => ( 0));
+  let state2 = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _72 => _72.state]), () => ( (me.init ? me.init() : {})));
+  let patches = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _73 => _73.patches]), () => ( 0));
+  let snaps = _nullishCoalesce(_optionalChain([cached, 'optionalAccess', _74 => _74.snaps]), () => ( 0));
   let replayed = 0;
   let event;
   await _chunkO6QIJQRNcjs.store.call(void 0, ).query(
@@ -1834,7 +1840,7 @@ async function load(me, target, callback, patch_fn = bare_patch) {
           `Skipping unknown event "${String(event.name)}" on stream "${stream}" (id=${event.id}) \u2014 no reducer in state "${me.name}"`
         );
       }
-      _optionalChain([callback, 'optionalCall', _77 => _77({
+      _optionalChain([callback, 'optionalCall', _75 => _75({
         event,
         state: state2,
         version: event.version,
@@ -1854,7 +1860,7 @@ async function load(me, target, callback, patch_fn = bare_patch) {
       ...cached ? { after: cached.event_id, with_snaps: true } : { ...time_travel ? {} : { with_snaps: true }, ...asOf }
     }
   );
-  const head_is_tombstone = _optionalChain([event, 'optionalAccess', _78 => _78.name]) === _chunk7AHW7FCNcjs.TOMBSTONE_EVENT;
+  const head_is_tombstone = _optionalChain([event, 'optionalAccess', _76 => _76.name]) === _chunk7AHW7FCNcjs.TOMBSTONE_EVENT;
   if (replayed > 0 && !time_travel && event && !me.pii_aware && !head_is_tombstone) {
     await cache_put(stream, {
       stream,
@@ -1868,9 +1874,9 @@ async function load(me, target, callback, patch_fn = bare_patch) {
   return {
     event,
     state: state2,
-    version: _nullishCoalesce(_nullishCoalesce(_optionalChain([event, 'optionalAccess', _79 => _79.version]), () => ( _optionalChain([cached, 'optionalAccess', _80 => _80.version]))), () => ( -1)),
+    version: _nullishCoalesce(_nullishCoalesce(_optionalChain([event, 'optionalAccess', _77 => _77.version]), () => ( _optionalChain([cached, 'optionalAccess', _78 => _78.version]))), () => ( -1)),
     // Captured with `state`, so consumers never race a separate cache lookup.
-    id: _nullishCoalesce(_nullishCoalesce(_optionalChain([event, 'optionalAccess', _81 => _81.id]), () => ( _optionalChain([cached, 'optionalAccess', _82 => _82.event_id]))), () => ( -1)),
+    id: _nullishCoalesce(_nullishCoalesce(_optionalChain([event, 'optionalAccess', _79 => _79.id]), () => ( _optionalChain([cached, 'optionalAccess', _80 => _80.event_id]))), () => ( -1)),
     patches,
     snaps,
     cache_hit,
@@ -1880,11 +1886,11 @@ async function load(me, target, callback, patch_fn = bare_patch) {
 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', _83 => _83.reactingTo]);
-  const correlator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _84 => _84.correlator]), () => ( default_correlator));
+  const reactingTo = _optionalChain([options, 'optionalAccess', _81 => _81.reactingTo]);
+  const correlator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _82 => _82.correlator]), () => ( default_correlator));
   const validated = _chunkO6QIJQRNcjs.validate.call(void 0, action2, payload, me.actions[action2]);
-  const opts = _optionalChain([me, 'access', _85 => _85.options, 'optionalAccess', _86 => _86[action2]]);
-  const max_retries = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _87 => _87.maxRetries]), () => ( 0));
+  const opts = _optionalChain([me, 'access', _83 => _83.options, 'optionalAccess', _84 => _84[action2]]);
+  const max_retries = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _85 => _85.maxRetries]), () => ( 0));
   for (let attempt = 0; ; attempt++) {
     try {
       const snapshot = await load(
@@ -1893,7 +1899,7 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
         void 0,
         patch_fn
       );
-      if (_optionalChain([snapshot, 'access', _88 => _88.event, 'optionalAccess', _89 => _89.name]) === _chunk7AHW7FCNcjs.TOMBSTONE_EVENT)
+      if (_optionalChain([snapshot, 'access', _86 => _86.event, 'optionalAccess', _87 => _87.name]) === _chunk7AHW7FCNcjs.TOMBSTONE_EVENT)
         throw new (0, _chunk7AHW7FCNcjs.StreamClosedError)(stream);
       const expected = _nullishCoalesce(expectedVersion, () => ( (snapshot.version >= 0 ? snapshot.version : void 0)));
       if (me.given) {
@@ -1921,7 +1927,7 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
       }));
       const emitted = valid.map((e) => me.message(e));
       const meta = {
-        correlation: _optionalChain([reactingTo, 'optionalAccess', _90 => _90.meta, 'access', _91 => _91.correlation]) || correlator({
+        correlation: _optionalChain([reactingTo, 'optionalAccess', _88 => _88.meta, 'access', _89 => _89.correlation]) || correlator({
           action: action2,
           state: me.name,
           stream,
@@ -1974,15 +1980,15 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
       });
       const last = snapshots.at(-1);
       const contiguous = committed[0].version === snapshot.version + 1;
-      const snapped = contiguous && _optionalChain([me, 'access', _92 => _92.snap, 'optionalCall', _93 => _93(last)]);
+      const snapped = contiguous && _optionalChain([me, 'access', _90 => _90.snap, 'optionalCall', _91 => _91(last)]);
       const snap_event = snapped ? await snap(last) : void 0;
       if (!me.pii_aware) {
         if (contiguous)
           void cache_put(stream, {
             stream,
             state: last.state,
-            version: _nullishCoalesce(_optionalChain([snap_event, 'optionalAccess', _94 => _94.version]), () => ( last.event.version)),
-            event_id: _nullishCoalesce(_optionalChain([snap_event, 'optionalAccess', _95 => _95.id]), () => ( last.event.id)),
+            version: _nullishCoalesce(_optionalChain([snap_event, 'optionalAccess', _92 => _92.version]), () => ( last.event.version)),
+            event_id: _nullishCoalesce(_optionalChain([snap_event, 'optionalAccess', _93 => _93.id]), () => ( last.event.id)),
             patches: snap_event ? 0 : last.patches,
             snaps: snap_event ? last.snaps + 1 : last.snaps
           });
@@ -1993,7 +1999,7 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
       if (!(error instanceof _chunk7AHW7FCNcjs.ConcurrencyError)) throw error;
       if (expectedVersion !== void 0) throw error;
       if (attempt >= max_retries) throw error;
-      if (_optionalChain([opts, 'optionalAccess', _96 => _96.backoff])) {
+      if (_optionalChain([opts, 'optionalAccess', _94 => _94.backoff])) {
         const delay_ms = compute_backoff_delay(attempt, opts.backoff);
         if (delay_ms > 0) await _chunkO6QIJQRNcjs.sleep.call(void 0, delay_ms);
       }
@@ -2048,9 +2054,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', _97 => _97(...args)]);
+  _optionalChain([entry, 'optionalCall', _95 => _95(...args)]);
   const result = await inner(...args);
-  _optionalChain([exit, 'optionalCall', _98 => _98(result, ...args)]);
+  _optionalChain([exit, 'optionalCall', _96 => _96(result, ...args)]);
   return result;
 });
 function build_es(logger, correlator = default_correlator, patch_fn = bare_patch) {
@@ -2135,7 +2141,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', _99 => _99[0], 'optionalAccess', _100 => _100.lane]) : void 0;
+      const uniform_lane = lanes.size === 1 ? _optionalChain([streams, 'access', _97 => _97[0], 'optionalAccess', _98 => _98.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(" ");
@@ -2147,7 +2153,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', _101 => _101[0], 'optionalAccess', _102 => _102.lane]);
+  const lane = _optionalChain([leased, 'access', _99 => _99[0], 'optionalAccess', _100 => _100.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]));
@@ -2156,8 +2162,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', _103 => _103.source]) ? `${hue(C_STREAM, stream)}${dim(`<-${f.source}`)}` : hue(C_STREAM, stream);
-    const events = _optionalChain([f, 'optionalAccess', _104 => _104.events, 'access', _105 => _105.length]) ? ` ${dim(
+    const key = _optionalChain([f, 'optionalAccess', _101 => _101.source]) ? `${hue(C_STREAM, stream)}${dim(`<-${f.source}`)}` : hue(C_STREAM, stream);
+    const events = _optionalChain([f, 'optionalAccess', _102 => _102.events, 'access', _103 => _103.length]) ? ` ${dim(
       `[${f.events.map(({ id, name }) => `#${id} ${String(name)}`).join(", ")}]`
     )}` : "";
     const acked_at = acked_by_stream.get(stream);
@@ -2185,7 +2191,7 @@ 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', _106 => _106.blockOnError]) || lease.retry <= options.maxRetries)
+  if (store_failing || !_optionalChain([options, 'optionalAccess', _104 => _104.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.`;
   _chunkO6QIJQRNcjs.log.call(void 0, ).error(error);
@@ -2249,7 +2255,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', _107 => _107.at, 'call', _108 => _108(-1), 'optionalAccess', _109 => _109.id]) || at),
+    (max, { at, events }) => Math.max(max, _optionalChain([events, 'access', _105 => _105.at, 'call', _106 => _106(-1), 'optionalAccess', _107 => _107.id]) || at),
     0
   );
   for (const f of fetched) {
@@ -2313,11 +2319,11 @@ async function run_drain_cycle(deps, cycle) {
             deps.logger
           )
         );
-      const at = _optionalChain([entry, 'access', _110 => _110.fetch, 'access', _111 => _111.events, 'access', _112 => _112.at, 'call', _113 => _113(-1), 'optionalAccess', _114 => _114.id]) || fetch_window_at;
+      const at = _optionalChain([entry, 'access', _108 => _108.fetch, 'access', _109 => _109.events, 'access', _110 => _110.at, 'call', _111 => _111(-1), 'optionalAccess', _112 => _112.id]) || fetch_window_at;
       const { payloads } = entry;
       const exhausted = budget_exhausted(
         lease,
-        _optionalChain([payloads, 'access', _115 => _115[0], 'optionalAccess', _116 => _116.options]),
+        _optionalChain([payloads, 'access', _113 => _113[0], 'optionalAccess', _114 => _114.options]),
         store_failing
       );
       if (exhausted) return Promise.resolve(exhausted);
@@ -2353,9 +2359,14 @@ var EMPTY_DRAIN = {
 };
 var RETRY = "";
 var DrainController = (_class5 = class {
-  __init12() {this._armed = false}
-  __init13() {this._locked = false}
-  __init14() {this._ratio = 0.5}
+  /**
+   * Armed while `_raised` is ahead of `_lowered` (the raise count the last
+   * empty claim saw), so a claim never lowers over a raise that landed
+   * during it.
+   */
+  __init14() {this._raised = 0}
+  __init15() {this._lowered = 0}
+  __init16() {this._ratio = 0.5}
   /**
    * Local wake at the earliest parked (backoff or defer) visit, or at the
    * lease expiry after a failed pass (the {@link RETRY} key); the schedule
@@ -2363,24 +2374,24 @@ var DrainController = (_class5 = class {
    * drains until a pass leases nothing or the controller stops, and an entry
    * stays until handled or until a later pass claims nothing.
    */
-  __init15() {this._defer = new DeferTimer(() => {
-    this._armed = true;
+  __init17() {this._defer = new DeferTimer(() => {
+    this.arm();
     void this._deps.run_scoped(async () => {
       while ((await this.drain()).leased.length > 0) ;
     });
   })}
   
-  __init16() {this._misrouted = /* @__PURE__ */ new Set()}
-  __init17() {this._stopped = false}
+  __init18() {this._misrouted = /* @__PURE__ */ new Set()}
+  __init19() {this._stopped = false}
   /** Never rejects; graceful shutdown waits on it. */
   
   
   
-  constructor(deps) {;_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);
+  constructor(deps) {;_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);
     this._deps = deps;
   }
   arm() {
-    this._armed = true;
+    this._raised++;
   }
   /** Cold start: re-seed a persisted `deferred_at` into the local wake. */
   seed_defer(stream, at) {
@@ -2388,14 +2399,14 @@ var DrainController = (_class5 = class {
     this._defer.schedule();
   }
   get armed() {
-    return this._armed;
+    return this._raised !== this._lowered;
   }
   get inflight() {
     return this._inflight;
   }
   /** This lane's configured lease, or `undefined`; the shutdown grace basis. */
   get lease_millis() {
-    return _optionalChain([this, 'access', _117 => _117._deps, 'access', _118 => _118.defaults, 'optionalAccess', _119 => _119.leaseMillis]);
+    return _optionalChain([this, 'access', _115 => _115._deps, 'access', _116 => _116.defaults, 'optionalAccess', _117 => _117.leaseMillis]);
   }
   get lane() {
     return this._deps.lane;
@@ -2405,7 +2416,7 @@ var DrainController = (_class5 = class {
     if (this._worker || this._stopped) return;
     const run = this._deps.run_scoped;
     const tick = async () => {
-      if (this._armed) await run(() => this.drain());
+      if (this.armed) await run(() => this.drain());
       if (this._stopped) return;
       this._worker = setTimeout(tick, cycleMs);
       this._worker.unref();
@@ -2422,8 +2433,8 @@ var DrainController = (_class5 = class {
     this._defer.stop();
   }
   async drain(options = {}) {
-    if (!this._armed || this._stopped) return EMPTY_DRAIN;
-    if (this._locked) return EMPTY_DRAIN;
+    if (!this.armed || this._stopped || this._inflight)
+      return EMPTY_DRAIN;
     const d = _nullishCoalesce(this._deps.defaults, () => ( {}));
     const streamLimit = _nullishCoalesce(_nullishCoalesce(d.streamLimit, () => ( options.streamLimit)), () => ( _chunkO6QIJQRNcjs.DEFAULT_STREAM_LIMIT));
     const eventLimit = _nullishCoalesce(options.eventLimit, () => ( _chunkO6QIJQRNcjs.DEFAULT_EVENT_LIMIT));
@@ -2431,13 +2442,13 @@ var DrainController = (_class5 = class {
     if (this._deps.breaker.state(Date.now()) === "open")
       return EMPTY_DRAIN;
     try {
-      this._locked = true;
       this._inflight = new Promise((done) => {
         this._inflight_done = done;
       });
       const lagging = Math.ceil(streamLimit * this._ratio);
       const leading = streamLimit - lagging;
       const started = Date.now();
+      const raised = this._raised;
       const cycle = await run_drain_cycle(this._deps, {
         lagging,
         leading,
@@ -2449,7 +2460,7 @@ var DrainController = (_class5 = class {
       if (!cycle) {
         this._defer.prune(started);
         this._deps.breaker.passed();
-        this._armed = false;
+        this._lowered = raised;
         return EMPTY_DRAIN;
       }
       const { leased, fetched, handled, acked, blocked, closeable } = cycle;
@@ -2474,9 +2485,8 @@ var DrainController = (_class5 = class {
       return EMPTY_DRAIN;
     } finally {
       if (!this._stopped) this._defer.schedule();
-      this._locked = false;
       this._inflight = void 0;
-      _optionalChain([this, 'access', _120 => _120._inflight_done, 'optionalCall', _121 => _121()]);
+      _optionalChain([this, 'access', _118 => _118._inflight_done, 'optionalCall', _119 => _119()]);
       this._inflight_done = void 0;
     }
   }
@@ -2683,10 +2693,10 @@ var CloseSignal = class extends Error {
   constructor(opts) {
     super("reaction requested close");
     this.name = "CloseSignal";
-    this.stream = _optionalChain([opts, 'optionalAccess', _122 => _122.stream]);
-    this.archive = _optionalChain([opts, 'optionalAccess', _123 => _123.archive]);
-    this.at = _optionalChain([opts, 'optionalAccess', _124 => _124.at]);
-    this.before = _optionalChain([opts, 'optionalAccess', _125 => _125.before]);
+    this.stream = _optionalChain([opts, 'optionalAccess', _120 => _120.stream]);
+    this.archive = _optionalChain([opts, 'optionalAccess', _121 => _121.archive]);
+    this.at = _optionalChain([opts, 'optionalAccess', _122 => _122.at]);
+    this.before = _optionalChain([opts, 'optionalAccess', _123 => _123.before]);
   }
 };
 function build_handle(deps) {
@@ -2716,13 +2726,23 @@ function build_handle(deps) {
           handled++;
         }
       } catch (error) {
-        if (error instanceof _chunk7AHW7FCNcjs.DeferSignal)
-          return {
-            lease,
-            handled,
-            acked_at: at,
-            defer: resolve_defer_at(error.when, event)
-          };
+        if (error instanceof _chunk7AHW7FCNcjs.DeferSignal) {
+          let defer;
+          try {
+            defer = resolve_defer_at(error.when, event);
+          } catch (invalid) {
+            return finalize(
+              lease,
+              handled,
+              at,
+              invalid,
+              payload.options,
+              logger,
+              event.id
+            );
+          }
+          return { lease, handled, acked_at: at, defer };
+        }
         if (error instanceof CloseSignal)
           return {
             lease,
@@ -2785,24 +2805,24 @@ function build_handle_batch(logger) {
 
 // src/internal/settle.ts
 var SettleLoop = (_class6 = class {
-  __init18() {this._timer = void 0}
+  __init20() {this._timer = void 0}
   /**
    * The cycle in flight, set while one runs. Shutdown waits for it
    * (`stop()` cancels scheduling only). Never rejects.
    */
   
   /** A wake-up arrived while a cycle ran: run one more pass after it. */
-  __init19() {this._pending = false}
+  __init21() {this._pending = false}
   /** The last caller's options, used by the next pass. */
-  __init20() {this._next = void 0}
+  __init22() {this._next = void 0}
   /** When the scheduled pass fires (epoch ms). */
-  __init21() {this._due = 0}
+  __init23() {this._due = 0}
   /** Set at shutdown: nothing schedules again. */
-  __init22() {this._stopped = false}
+  __init24() {this._stopped = false}
   
   /** Debounce window applied when the caller doesn't override via `SettleOptions.debounceMs`. */
   
-  constructor(deps, default_debounce_ms) {;_class6.prototype.__init18.call(this);_class6.prototype.__init19.call(this);_class6.prototype.__init20.call(this);_class6.prototype.__init21.call(this);_class6.prototype.__init22.call(this);
+  constructor(deps, default_debounce_ms) {;_class6.prototype.__init20.call(this);_class6.prototype.__init21.call(this);_class6.prototype.__init22.call(this);_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);
     this._deps = deps;
     this._default_debounce_ms = default_debounce_ms;
   }
@@ -2824,7 +2844,7 @@ var SettleLoop = (_class6 = class {
       this._pending = true;
       return;
     }
-    const delay = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _126 => _126.debounceMs]), () => ( this._default_debounce_ms));
+    const delay = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _124 => _124.debounceMs]), () => ( this._default_debounce_ms));
     const due = Date.now() + delay;
     if (this._timer) {
       if (due >= this._due) return;
@@ -2906,8 +2926,7 @@ function validate_only_lanes(options, lanes) {
     );
 }
 var Act = (_class7 = class {
-  __init23() {this._emitter = new (0, _events2.default)()}
-  
+  __init25() {this._emitter = new (0, _events2.default)()}
   
   
   
@@ -2983,22 +3002,14 @@ var Act = (_class7 = class {
   /** Lanes to arm per event; `"all"` when a dynamic resolver hides the lane. */
   
   
-  __init24() {this._logger = _chunkO6QIJQRNcjs.log.call(void 0, )}
+  __init26() {this._logger = _chunkO6QIJQRNcjs.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`. */
   
   
-  // Bound once, reused by every reaction payload.
-  __init25() {this._bound_do = this.do.bind(this)}
-  __init26() {this._bound_load = this.load.bind(this)}
-  __init27() {this._bound_query = this.query.bind(this)}
-  __init28() {this._bound_query_array = this.query_array.bind(this)}
-  __init29() {this._bound_forget = this.forget.bind(this)}
-  
   
-  
-  __init30() {this._close_lock = new CloseLock()}
+  __init27() {this._close_lock = new CloseLock()}
   /** Every lane a controller can exist for: `"default"` plus each declared one. */
   
   /** Drain lanes declared via `.withLane(...)`. Implicit default not included. */
@@ -3006,7 +3017,7 @@ var Act = (_class7 = class {
     return this._lanes;
   }
   /** Use the {@link act} builder rather than constructing directly. */
-  constructor(registry, states = /* @__PURE__ */ new Map(), batch_handlers = /* @__PURE__ */ new Map(), options = {}, lanes = [], patch_fn = bare_patch) {;_class7.prototype.__init23.call(this);_class7.prototype.__init24.call(this);_class7.prototype.__init25.call(this);_class7.prototype.__init26.call(this);_class7.prototype.__init27.call(this);_class7.prototype.__init28.call(this);_class7.prototype.__init29.call(this);_class7.prototype.__init30.call(this);
+  constructor(registry, states = /* @__PURE__ */ new Map(), batch_handlers = /* @__PURE__ */ new Map(), options = {}, lanes = [], patch_fn = bare_patch) {;_class7.prototype.__init25.call(this);_class7.prototype.__init26.call(this);_class7.prototype.__init27.call(this);
     this.registry = registry;
     this._states = states;
     this._batch_handlers = batch_handlers;
@@ -3030,31 +3041,38 @@ var Act = (_class7 = class {
     this._correlator = _nullishCoalesce(options.correlator, () => ( default_correlator));
     this._es = build_es(this._logger, this._correlator, patch_fn);
     this._cd = build_drain(this._logger);
-    this._handle = build_handle({
+    const handle = build_handle({
       logger: this._logger,
       reaction_scope: _chunkO6QIJQRNcjs.make_reaction_scope.call(void 0, {
-        do: this._bound_do,
-        load: this._bound_load,
-        query: this._bound_query,
-        query_array: this._bound_query_array,
-        forget: this._bound_forget
+        do: this.do.bind(this),
+        load: this.load.bind(this),
+        query: this.query.bind(this),
+        query_array: this.query_array.bind(this),
+        forget: this.forget.bind(this)
       })
     });
-    this._handle_batch = build_handle_batch(this._logger);
+    const handle_batch = build_handle_batch(this._logger);
     const classification = classify_registry(this.registry, this._states);
     this._reactive = classification.event_to_lanes.size > 0;
     this._event_to_state = classification.event_to_state;
     this._event_to_lanes = classification.event_to_lanes;
-    this._listen = options.listen !== false;
     this._drain = options.drain !== false;
     this._auto_settle = options.autoSettle !== false;
     this._breaker = this._build_breaker(options);
-    this._drain_controllers = this._build_drain_controllers(options, lanes);
+    this._drain_controllers = this._build_drain_controllers(
+      options,
+      lanes,
+      handle,
+      handle_batch
+    );
     this._advise_orphaned_lanes(options);
     this._audit_deps = this._build_audit_deps();
     this._correlate = this._build_correlate(options, classification);
     this._settle = this._build_settle(options);
-    this._notify_disposer = this._wire_notify(this._ports.store);
+    this._notify_disposer = this._wire_notify(
+      this._ports.store,
+      options.listen !== false
+    );
     _chunkO6QIJQRNcjs.register_weak_disposer.call(void 0, new WeakRef(this), (self) => self.shutdown());
   }
   /** Shared by drain, settle and autoclose; bad knobs throw at build. */
@@ -3070,7 +3088,7 @@ var Act = (_class7 = class {
     );
   }
   /** Apps that declare no lanes pass no lane filter to `claim`. */
-  _build_drain_controllers(options, lanes) {
+  _build_drain_controllers(options, lanes, handle, handle_batch) {
     const all_lanes = this._declared_lanes;
     const only_set = options.onlyLanes && options.onlyLanes.length > 0 ? new Set(options.onlyLanes) : void 0;
     const active_lanes = only_set ? all_lanes.filter((n) => only_set.has(n)) : all_lanes;
@@ -3083,8 +3101,8 @@ var Act = (_class7 = class {
         ops: this._cd,
         registry: this.registry,
         batch_handlers: this._batch_handlers,
-        handle: this._handle,
-        handle_batch: this._handle_batch,
+        handle,
+        handle_batch,
         on_acked: (acked) => this.emit("acked", acked),
         on_blocked: (blocked) => this.emit("blocked", blocked),
         // Reaction-requested close: the same machinery as `app.close`.
@@ -3109,7 +3127,7 @@ var Act = (_class7 = class {
           leaseMillis: cfg.leaseMillis
         }
       });
-      if (_optionalChain([cfg, 'optionalAccess', _127 => _127.cycleMs]) !== void 0 && options.drain !== false)
+      if (_optionalChain([cfg, 'optionalAccess', _125 => _125.cycleMs]) !== void 0 && options.drain !== false)
         controller.start(cfg.cycleMs);
       controllers.set(name, controller);
     }
@@ -3149,8 +3167,10 @@ var Act = (_class7 = class {
       // Built after the controllers, so their keys are the active lanes.
       shard: this._drain_controllers.size < this._declared_lanes.length ? [...this._drain_controllers.keys()] : void 0,
       // Only reached on a draining app: writer-only ones never correlate.
-      on_init: () => this._arm_all(),
-      on_init_async: this._drain ? () => this._seed_persisted_defers() : void 0
+      on_init: async () => {
+        this._arm_all();
+        await this._seed_persisted_defers();
+      }
     });
   }
   /** Cold start: an idle deferred stream still fires on time after a restart. */
@@ -3159,7 +3179,7 @@ var Act = (_class7 = class {
     await walk_streams(_chunkO6QIJQRNcjs.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', _128 => _128.seed_defer, 'call', _129 => _129(pos.stream, pos.deferred_at)]);
+      _optionalChain([controller, 'optionalAccess', _126 => _126.seed_defer, 'call', _127 => _127(pos.stream, pos.deferred_at)]);
     });
   }
   _build_settle(options) {
@@ -3204,7 +3224,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', _130 => _130.graceMs]));
+        await this._await_inflight(_optionalChain([options, 'optionalAccess', _128 => _128.graceMs]));
         await this._scoped(() => this._correlate.release_correlation());
         this._emitter.removeAllListeners();
       })();
@@ -3243,10 +3263,10 @@ var Act = (_class7 = class {
     }
   }
   /** Failures are logged, never thrown: `notify` is a hint. */
-  async _wire_notify(s) {
+  async _wire_notify(s, listen) {
     if (!this._reactive) return void 0;
     if (!s.notify) return void 0;
-    if (!this._listen) return void 0;
+    if (!listen) return void 0;
     try {
       return await s.notify((notification) => {
         try {
@@ -3299,8 +3319,8 @@ var Act = (_class7 = class {
    * @see {@link ValidationError}, {@link InvariantError}, {@link ConcurrencyError}
    */
   async do(action2, target, payload, options) {
-    const reacting_to = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _131 => _131.reactingTo]), () => ( _chunkO6QIJQRNcjs.current_reacting.call(void 0, )));
-    const do_options = reacting_to === _optionalChain([options, 'optionalAccess', _132 => _132.reactingTo]) ? options : { ...options, reactingTo: reacting_to };
+    const reacting_to = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _129 => _129.reactingTo]), () => ( _chunkO6QIJQRNcjs.current_reacting.call(void 0, )));
+    const do_options = reacting_to === _optionalChain([options, 'optionalAccess', _130 => _130.reactingTo]) ? options : { ...options, reactingTo: reacting_to };
     return this._scoped(async () => {
       const snapshots = await this._es.action(
         this.registry.actions[action2],
@@ -3364,7 +3384,7 @@ var Act = (_class7 = class {
         const gated = this.registry.query_gate(e.name)(e);
         if (!first) first = gated;
         last = gated;
-        _optionalChain([callback, 'optionalCall', _133 => _133(gated)]);
+        _optionalChain([callback, 'optionalCall', _131 => _131(gated)]);
       }, query);
       return { first, last, count };
     });
@@ -3491,7 +3511,7 @@ var Act = (_class7 = class {
     }
     if (to_arm.size === 0) return false;
     this._correlate.arm();
-    for (const lane of to_arm) _optionalChain([this, 'access', _134 => _134._drain_controllers, 'access', _135 => _135.get, 'call', _136 => _136(lane), 'optionalAccess', _137 => _137.arm, 'call', _138 => _138()]);
+    for (const lane of to_arm) _optionalChain([this, 'access', _132 => _132._drain_controllers, 'access', _133 => _133.get, 'call', _134 => _134(lane), 'optionalAccess', _135 => _135.arm, 'call', _136 => _136()]);
     return true;
   }
   /** In parallel, so a slow lane never holds up a fast one. */
@@ -3636,7 +3656,7 @@ var Act = (_class7 = class {
     return this._scoped(async () => {
       const count = await _chunkO6QIJQRNcjs.store.call(void 0, ).reset(input);
       for (const handler of this._batch_handlers.values())
-        _optionalChain([handler, 'access', _139 => _139[FOLD_RESET], 'optionalCall', _140 => _140()]);
+        _optionalChain([handler, 'access', _137 => _137[FOLD_RESET], 'optionalCall', _138 => _138()]);
       if (count > 0) {
         this._wake();
       }
@@ -3768,7 +3788,7 @@ var Act = (_class7 = class {
         (p) => {
           positions.push(p);
         },
-        { blocked: true, after: _optionalChain([options, 'optionalAccess', _141 => _141.after]), limit: _optionalChain([options, 'optionalAccess', _142 => _142.limit]) }
+        { blocked: true, after: _optionalChain([options, 'optionalAccess', _139 => _139.after]), limit: _optionalChain([options, 'optionalAccess', _140 => _140.limit]) }
       );
       return positions;
     });
@@ -3964,12 +3984,12 @@ function policy_min_after_days(options) {
   const parsed = AutoclosePolicySchema.parse(options);
   const windows = [];
   if (parsed.after) windows.push(parsed.after.days);
-  if (_optionalChain([parsed, 'access', _143 => _143.or, 'optionalAccess', _144 => _144.after])) windows.push(parsed.or.after.days);
+  if (_optionalChain([parsed, 'access', _141 => _141.or, 'optionalAccess', _142 => _142.after])) windows.push(parsed.or.after.days);
   return windows.length ? Math.min(...windows) : void 0;
 }
 function policy_keep_days(options) {
   const parsed = AutoclosePolicySchema.parse(options);
-  return _optionalChain([parsed, 'access', _145 => _145.keep, 'optionalAccess', _146 => _146.days]);
+  return _optionalChain([parsed, 'access', _143 => _143.keep, 'optionalAccess', _144 => _144.days]);
 }
 function compile_autoclose_policy(options) {
   const parsed = AutoclosePolicySchema.parse(options);
@@ -4001,7 +4021,7 @@ function hour_in_zone(now, timeZone) {
     hour: "2-digit",
     hourCycle: "h23"
   }).formatToParts(now);
-  return Number(_optionalChain([parts, 'access', _147 => _147.find, 'call', _148 => _148((p) => p.type === "hour"), 'optionalAccess', _149 => _149.value]));
+  return Number(_optionalChain([parts, 'access', _145 => _145.find, 'call', _146 => _146((p) => p.type === "hour"), 'optionalAccess', _147 => _147.value]));
 }
 function hour_in_range(hour, start, end) {
   return start < end ? hour >= start && hour < end : hour >= start || hour < end;
@@ -4099,7 +4119,7 @@ function synthesize_autoclose_reactions(registry, states, read_window) {
     };
     const key = `__autoclose_${st.name}`;
     for (const event_name of Object.keys(st.events)) {
-      _optionalChain([registry, 'access', _150 => _150.events, 'access', _151 => _151[event_name], 'optionalAccess', _152 => _152.reactions, 'access', _153 => _153.set, 'call', _154 => _154(
+      _optionalChain([registry, 'access', _148 => _148.events, 'access', _149 => _149[event_name], 'optionalAccess', _150 => _150.reactions, 'access', _151 => _151.set, 'call', _152 => _152(
         key,
         reaction
       )]);
@@ -4343,9 +4363,9 @@ function reaction_on(event, events, builder) {
         // `maxRetries`/`backoff`/`blockOnError` throws ZodError at build,
         // not a NaN gate on the first retry.
         options: _chunkO6QIJQRNcjs.resolveReactionConfig.call(void 0, {
-          blockOnError: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _155 => _155.blockOnError]), () => ( _chunkO6QIJQRNcjs.DEFAULT_BLOCK_ON_ERROR)),
-          maxRetries: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _156 => _156.maxRetries]), () => ( _chunkO6QIJQRNcjs.DEFAULT_MAX_RETRIES)),
-          backoff: _optionalChain([options, 'optionalAccess', _157 => _157.backoff])
+          blockOnError: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _153 => _153.blockOnError]), () => ( _chunkO6QIJQRNcjs.DEFAULT_BLOCK_ON_ERROR)),
+          maxRetries: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _154 => _154.maxRetries]), () => ( _chunkO6QIJQRNcjs.DEFAULT_MAX_RETRIES)),
+          backoff: _optionalChain([options, 'optionalAccess', _155 => _155.backoff])
         })
       };
     },
@@ -4364,9 +4384,9 @@ function reaction_on(event, events, builder) {
 
 // src/internal/date-reviver.ts
 
-var def_of = (schema) => _nullishCoalesce(_optionalChain([schema, 'access', _158 => _158._zod, 'optionalAccess', _159 => _159.def]), () => ( schema.def));
+var def_of = (schema) => _nullishCoalesce(_optionalChain([schema, 'access', _156 => _156._zod, 'optionalAccess', _157 => _157.def]), () => ( schema.def));
 function variant_schema(schema) {
-  const shape = _optionalChain([def_of, 'call', _160 => _160(schema), 'optionalAccess', _161 => _161.shape]);
+  const shape = _optionalChain([def_of, 'call', _158 => _158(schema), 'optionalAccess', _159 => _159.shape]);
   if (!shape) {
     const dates = date_reviver_schema(schema);
     return { schema: _nullishCoalesce(dates, () => ( schema)), dated: !!dates };
@@ -4414,7 +4434,7 @@ function date_reviver_schema(schema) {
       return variants.some((v) => v.dated) ? _zod2.z.union(variants.map((v) => v.schema)) : void 0;
     }
     case "nullable":
-      return _optionalChain([inner, 'call', _162 => _162(), 'optionalAccess', _163 => _163.nullable, 'call', _164 => _164()]);
+      return _optionalChain([inner, 'call', _160 => _160(), 'optionalAccess', _161 => _161.nullable, 'call', _162 => _162()]);
     case "optional":
     case "nonoptional":
     case "readonly":
@@ -4483,7 +4503,7 @@ function build_events(registry, states, lanes, owners) {
         throw new Error(
           `Reaction on target "${resolver.target}" conflicts with the projection that already serves it \u2014 a target is served by one batch handler or one state projection, and a reaction to it would never run`
         );
-      if (resolver.lane && !declared.has(resolver.lane))
+      if (resolver.lane !== void 0 && !declared.has(resolver.lane))
         lane_errors.push(
           `Reaction "${handler_name}" on "${event_name}" targets undeclared lane "${resolver.lane}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. Add \`.withLane({ name: "${resolver.lane}", ... })\` to act() or correct the .to() declaration.`
         );
@@ -4591,7 +4611,7 @@ function act() {
   let _built = false;
   const read_wrap = (original) => {
     const wrapped = async (events, stream) => {
-      const read = events.map((e) => _nullishCoalesce(_optionalChain([_hr, 'access', _165 => _165.get, 'call', _166 => _166(e.name), 'optionalCall', _167 => _167(e)]), () => ( e)));
+      const read = events.map((e) => _nullishCoalesce(_optionalChain([_hr, 'access', _163 => _163.get, 'call', _164 => _164(e.name), 'optionalCall', _165 => _165(e)]), () => ( e)));
       return original(read, stream);
     };
     const reset = original[FOLD_RESET];
@@ -4633,7 +4653,7 @@ function act() {
         });
       }
       for (const [action_name, handler] of Object.entries(state2.on)) {
-        const static_target = _optionalChain([handler, 'optionalAccess', _168 => _168._static_emit]);
+        const static_target = _optionalChain([handler, 'optionalAccess', _166 => _166._static_emit]);
         if (static_target && deprecated.has(static_target)) {
           const current = current_version_of(static_target, event_names);
           throw new Error(
@@ -4689,7 +4709,7 @@ function act() {
     },
     build: (options) => {
       _chunkO6QIJQRNcjs.resolveActConfig.call(void 0, options);
-      const patch_fn = _optionalChain([options, 'optionalAccess', _169 => _169.validateFoldedState]) === true ? validating_patch : bare_patch;
+      const patch_fn = _optionalChain([options, 'optionalAccess', _167 => _167.validateFoldedState]) === true ? validating_patch : bare_patch;
       if (!_built) {
         for (const proj of pending_projections) add_projection(proj);
         for (const proj of fold_projections) {
@@ -4707,7 +4727,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', _170 => _170.projection]) === proj) continue;
+          if (_optionalChain([claimed, 'optionalAccess', _168 => _168.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`