@rotorsoft/act 1.16.1 → 1.18.0

package/dist/index.cjs

@@ -43,6 +43,7 @@ __export(index_exports, {
   DEFAULT_LANE: () => DEFAULT_LANE,
   DEFAULT_MAX_SUBSCRIBED_STREAMS: () => DEFAULT_MAX_SUBSCRIBED_STREAMS,
   DEFAULT_SETTLE_DEBOUNCE_MS: () => DEFAULT_SETTLE_DEBOUNCE_MS,
+  DeferSignal: () => DeferSignal,
   Environments: () => Environments,
   Errors: () => Errors,
   EventMetaSchema: () => EventMetaSchema,
@@ -631,6 +632,11 @@ var InMemoryStream = class {
   _leased_until = void 0;
   _priority = 0;
   _lane = DEFAULT_LANE;
+  // Persisted next-visit time (#1090). When set and still in the future, the
+  // stream is held out of `claim` entirely — so a deferred reaction is not
+  // re-claimed (and `retry` is never bumped) until its due-time passes. Unlike
+  // in-process backoff, this is durable store state shared across workers.
+  _deferred_at = void 0;
   constructor(stream, source, priority = 0, lane = DEFAULT_LANE) {
     this.stream = stream;
     this.source = source;
@@ -662,7 +668,17 @@ var InMemoryStream = class {
     this._priority = priority;
   }
   get is_available() {
-    return !this._blocked && (!this._leased_until || this._leased_until <= /* @__PURE__ */ new Date());
+    return !this._blocked && (!this._leased_until || this._leased_until <= /* @__PURE__ */ new Date()) && // A stream deferred to a future time is not claimable until due (#1090).
+    (!this._deferred_at || this._deferred_at <= Date.now());
+  }
+  /**
+   * Hold this stream out of `claim` until `deferred_at` (ms since epoch).
+   * Set by a deliberate `defer` outcome — not a failure, so retry/blocked
+   * state is untouched. Cleared by ack/block/reset/unblock.
+   */
+  defer(deferred_at) {
+    this._deferred_at = deferred_at;
+    this._retry = -1;
   }
   get at() {
     return this._at;
@@ -714,6 +730,7 @@ var InMemoryStream = class {
       this._leased_until = void 0;
       this._at = lease.at;
       this._retry = -1;
+      this._deferred_at = void 0;
       return {
         stream: this.stream,
         source: this.source,
@@ -734,6 +751,7 @@ var InMemoryStream = class {
     if (this._leased_by === lease.by) {
       this._blocked = true;
       this._error = error;
+      this._deferred_at = void 0;
       return {
         stream: this.stream,
         source: this.source,
@@ -758,6 +776,7 @@ var InMemoryStream = class {
     this._error = "";
     this._leased_by = void 0;
     this._leased_until = void 0;
+    this._deferred_at = void 0;
   }
   /**
    * Clear the blocked flag and lease bookkeeping without touching the
@@ -771,6 +790,7 @@ var InMemoryStream = class {
     this._error = "";
     this._leased_by = void 0;
     this._leased_until = void 0;
+    this._deferred_at = void 0;
     return true;
   }
 };
@@ -1050,6 +1070,37 @@ var InMemoryStore = class {
     await sleep();
     return leases.map((l) => this._streams.get(l.stream)?.block(l, l.error)).filter((l) => !!l);
   }
+  /**
+   * Hold the matched streams out of {@link claim} until `deferred_at`
+   * (ms since epoch) — see {@link Store.defer}. Accepts an explicit list
+   * of names or a {@link StreamFilter}, mirroring {@link reset}/{@link unblock}.
+   * Persisted store state (unlike in-process backoff), so the skip is honored
+   * by every competing worker. Unknown names are silently skipped.
+   *
+   * @returns Count of streams whose `deferred_at` was set.
+   */
+  async defer(input, deferred_at) {
+    await sleep();
+    let count = 0;
+    if (Array.isArray(input)) {
+      for (const name of input) {
+        const s = this._streams.get(name);
+        if (s) {
+          s.defer(deferred_at);
+          count++;
+        }
+      }
+    } else {
+      const matches = this._filter_predicate(input);
+      for (const s of this._streams.values()) {
+        if (matches(s)) {
+          s.defer(deferred_at);
+          count++;
+        }
+      }
+    }
+    return count;
+  }
   /**
    * Build a predicate from a {@link StreamFilter}. Compiled regexes are
    * cached in the closure so callers can apply it across the streams
@@ -1950,483 +2001,388 @@ function in_autoclose_window(window, now) {
   return window.start < window.end ? hour >= window.start && hour < window.end : hour >= window.start || hour < window.end;
 }
 
-// src/internal/close-cycle.ts
-var SAFETY_PROBE_PAGE_SIZE = 1e3;
-async function run_close_cycle(targets, deps) {
-  const target_map = new Map(targets.map((t) => [t.stream, t]));
-  const streams = [...target_map.keys()];
-  const skipped = [];
-  const stream_info = await scan_stream_heads(streams);
-  const safe = await partition_by_safety(
-    stream_info,
-    deps.reactive_events_size,
-    skipped,
-    deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE
-  );
-  if (!safe.length) return { truncated: /* @__PURE__ */ new Map(), skipped };
-  const { guarded, guard_events } = await guard_with_tombstones(
-    safe,
-    stream_info,
-    deps.correlation,
-    deps.tombstone,
-    skipped
-  );
-  if (!guarded.length) return { truncated: /* @__PURE__ */ new Map(), skipped };
-  const seed_states = await load_restart_seeds(
-    guarded,
-    target_map,
-    stream_info,
-    deps.event_to_state,
-    deps.load,
-    deps.logger
-  );
-  await run_archive_callbacks(guarded, target_map);
-  const truncated = await truncate_and_warm_cache(
-    guarded,
-    seed_states,
-    guard_events,
-    deps.correlation
-  );
-  return { truncated, skipped };
-}
-async function scan_stream_heads(streams) {
-  const stats = await store2().query_stats(streams, {
-    exclude: [SNAP_EVENT]
-  });
-  const out = /* @__PURE__ */ new Map();
-  for (const [stream, { head }] of stats) {
-    if (head.name === TOMBSTONE_EVENT) continue;
-    out.set(stream, {
-      max_id: head.id,
-      version: head.version,
-      last_event_name: head.name
-    });
+// src/internal/autoclose-policy.ts
+var import_zod6 = require("zod");
+var MIN_AFTER_MS = 6e4;
+var AfterSchema = import_zod6.z.object({
+  days: import_zod6.z.number({ message: "autocloses: after.days must be a number" }).positive("autocloses: after.days must be > 0")
+}).refine((o) => o.days * 864e5 >= MIN_AFTER_MS, {
+  message: `autocloses: after resolves to < ${MIN_AFTER_MS}ms (one minute), which is too short to be a meaningful retention window`
+});
+var IsSchema = import_zod6.z.union([
+  import_zod6.z.string().min(1, "autocloses: is must be a non-empty event name"),
+  import_zod6.z.array(
+    import_zod6.z.string().min(1, "autocloses: is entries must be non-empty event names")
+  ).min(1, "autocloses: is must include at least one event name").readonly()
+]);
+var ReachesSchema = import_zod6.z.number({ message: "autocloses: reaches must be a number" }).int("autocloses: reaches must be an integer").min(1, "autocloses: reaches must be >= 1");
+var OrBlockSchema = import_zod6.z.object({
+  after: AfterSchema.optional(),
+  is: IsSchema.optional(),
+  reaches: ReachesSchema.optional()
+}).strict().refine(
+  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0,
+  {
+    message: "autocloses: `or` block must include at least one of after / is / reaches"
   }
-  return out;
+);
+var AutoclosePolicySchema = import_zod6.z.object({
+  after: AfterSchema.optional(),
+  is: IsSchema.optional(),
+  reaches: ReachesSchema.optional(),
+  or: OrBlockSchema.optional()
+}).strict().refine(
+  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0 || o.or !== void 0,
+  {
+    message: "autocloses: at least one of after / is / reaches / or must be specified \u2014 empty `{}` is a misconfiguration"
+  }
+);
+function compile_after(after) {
+  const after_ms = after.days * 864e5;
+  return (_stream, head) => Date.now() - head.created.getTime() >= after_ms;
 }
-async function partition_by_safety(stream_info, reactive_events_size, skipped, page_size) {
-  if (reactive_events_size === 0) return [...stream_info.keys()];
-  const pending_set = /* @__PURE__ */ new Set();
-  const source_regex = /* @__PURE__ */ new Map();
-  const get_regex = (source) => {
-    let re = source_regex.get(source);
-    if (!re) {
-      re = new RegExp(source);
-      source_regex.set(source, re);
+function compile_is(is) {
+  const set = new Set(typeof is === "string" ? [is] : is);
+  return (_stream, head) => set.has(head.name);
+}
+function compile_reaches(reaches) {
+  return (_stream, _head, count) => count >= reaches;
+}
+function policy_min_after_ms(options) {
+  const parsed = AutoclosePolicySchema.parse(options);
+  const windows = [];
+  if (parsed.after) windows.push(parsed.after.days * 864e5);
+  if (parsed.or?.after) windows.push(parsed.or.after.days * 864e5);
+  return windows.length ? Math.min(...windows) : void 0;
+}
+function compile_autoclose_policy(options) {
+  const parsed = AutoclosePolicySchema.parse(options);
+  const and_preds = [];
+  if (parsed.after) and_preds.push(compile_after(parsed.after));
+  if (parsed.is) and_preds.push(compile_is(parsed.is));
+  if (parsed.reaches) and_preds.push(compile_reaches(parsed.reaches));
+  const or_preds = [];
+  if (parsed.or) {
+    if (parsed.or.after) or_preds.push(compile_after(parsed.or.after));
+    if (parsed.or.is) or_preds.push(compile_is(parsed.or.is));
+    if (parsed.or.reaches) or_preds.push(compile_reaches(parsed.or.reaches));
+  }
+  return (stream, head, count) => {
+    if (and_preds.length > 0 && and_preds.every((p) => p(stream, head, count))) {
+      return true;
     }
-    return re;
+    if (or_preds.some((p) => p(stream, head, count))) {
+      return true;
+    }
+    return false;
   };
-  const targets = [...stream_info.keys()];
-  let after;
-  for (; ; ) {
-    let last;
-    const { count } = await store2().query_streams(
-      (position) => {
-        last = position.stream;
-        const source_re = position.source ? get_regex(position.source) : void 0;
-        for (const [stream, info] of stream_info) {
-          if ((!source_re || source_re.test(stream)) && position.at < info.max_id) {
-            pending_set.add(stream);
+}
+
+// src/internal/build-classify.ts
+var ALL_LANES = /* @__PURE__ */ Symbol("act-1103/all-lanes");
+function classify_registry(registry, states) {
+  const statics = /* @__PURE__ */ new Map();
+  const reactive_events = /* @__PURE__ */ new Set();
+  const event_to_lanes = /* @__PURE__ */ new Map();
+  let has_dynamic_resolvers = false;
+  for (const [name, register] of Object.entries(registry.events)) {
+    if (register.reactions.size > 0) reactive_events.add(name);
+    for (const reaction of register.reactions.values()) {
+      if (typeof reaction.resolver === "function") {
+        has_dynamic_resolvers = true;
+        event_to_lanes.set(name, ALL_LANES);
+      } else {
+        const { target, source, priority = 0, lane } = reaction.resolver;
+        const lane_name = lane ?? "default";
+        const existing_lanes = event_to_lanes.get(name);
+        if (existing_lanes !== ALL_LANES) {
+          const set = existing_lanes ?? /* @__PURE__ */ new Set();
+          set.add(lane_name);
+          event_to_lanes.set(name, set);
+        }
+        const key = `${target}|${source ?? ""}`;
+        const existing = statics.get(key);
+        if (!existing) {
+          statics.set(key, { stream: target, source, priority, lane });
+        } else {
+          if ((existing.lane ?? void 0) !== (lane ?? void 0))
+            throw new Error(
+              `Stream "${target}" has conflicting lane assignments ("${existing.lane ?? "default"}" vs "${lane ?? "default"}")`
+            );
+          if (priority > existing.priority) {
+            statics.set(key, { ...existing, priority });
           }
         }
-      },
-      { after, limit: page_size, source_matches: targets }
-    );
-    if (count < page_size) break;
-    after = last;
+      }
+    }
   }
-  const safe = [];
-  for (const [stream] of stream_info) {
-    if (pending_set.has(stream)) skipped.push(stream);
-    else safe.push(stream);
+  const event_to_state = /* @__PURE__ */ new Map();
+  for (const merged of states.values()) {
+    for (const event_name of Object.keys(merged.events)) {
+      event_to_state.set(event_name, merged);
+    }
   }
-  return safe;
+  return {
+    static_targets: [...statics.values()],
+    has_dynamic_resolvers,
+    reactive_events,
+    event_to_state,
+    event_to_lanes
+  };
 }
-async function guard_with_tombstones(safe, stream_info, correlation, tombstone2, skipped) {
-  const guarded = [];
-  const guard_events = /* @__PURE__ */ new Map();
-  await Promise.all(
-    safe.map(async (stream) => {
-      const info = stream_info.get(stream);
-      const committed = await tombstone2(stream, info.version, correlation);
-      if (committed) {
-        guarded.push(stream);
-        guard_events.set(stream, { id: committed.id, stream });
-      } else {
-        skipped.push(stream);
-      }
-    })
-  );
-  return { guarded, guard_events };
+
+// src/internal/defer-config.ts
+var import_zod7 = require("zod");
+
+// src/internal/defer-signal.ts
+var DeferSignal = class extends Error {
+  /**
+   * The unresolved schedule. The dispatcher turns this into an absolute
+   * due-time by resolving it against the triggering event.
+   */
+  when;
+  constructor(when) {
+    super("reaction deferred");
+    this.name = "DeferSignal";
+    this.when = when;
+  }
+};
+
+// src/internal/defer-config.ts
+var DeferDurationSchema = import_zod7.z.object({
+  days: import_zod7.z.number().positive().optional(),
+  hours: import_zod7.z.number().positive().optional(),
+  minutes: import_zod7.z.number().positive().optional()
+}).strict().refine((d) => d.days != null || d.hours != null || d.minutes != null, {
+  message: "defer: a duration needs at least one of days, hours, or minutes"
+});
+var DeferWhenSchema = import_zod7.z.object({
+  after: DeferDurationSchema.optional(),
+  at: import_zod7.z.date().optional()
+}).strict().refine((w) => w.after === void 0 !== (w.at === void 0), {
+  message: "defer: specify exactly one of `after` or `at`"
+});
+function duration_ms(d) {
+  return (d.days ?? 0) * 864e5 + (d.hours ?? 0) * 36e5 + (d.minutes ?? 0) * 6e4;
 }
-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) => target_map.get(s)?.restart).map(async (stream) => {
-      const last_event_name = stream_info.get(stream).last_event_name;
-      const owner_state = event_to_state.get(last_event_name);
-      if (!owner_state) {
-        logger.error(
-          `Cannot seed restart for "${stream}": no registered state owns event "${last_event_name}". Stream will be tombstoned instead.`
-        );
-        return;
-      }
-      const snap2 = await load2(owner_state, { stream });
-      seed_states.set(stream, snap2.state);
-    })
-  );
-  return seed_states;
+function resolve_defer_at(when, event) {
+  const parsed = DeferWhenSchema.parse(when);
+  if (parsed.after) return event.created.getTime() + duration_ms(parsed.after);
+  return parsed.at.getTime();
 }
-async function run_archive_callbacks(guarded, target_map) {
-  for (const stream of guarded) {
-    const archive_fn = target_map.get(stream)?.archive;
-    if (archive_fn) await archive_fn();
-  }
+function assert_defer_when(when) {
+  DeferWhenSchema.parse(when);
 }
-async function truncate_and_warm_cache(guarded, seed_states, guard_events, correlation) {
-  const trunc_targets = guarded.map((stream) => {
-    const snapshot = seed_states.get(stream);
-    const guard = guard_events.get(stream);
-    return {
-      stream,
-      snapshot,
-      meta: {
-        correlation,
-        causation: {
-          event: { id: guard.id, name: TOMBSTONE_EVENT, stream: guard.stream }
-        }
-      }
-    };
-  });
-  const truncated = await store2().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 cache2().set(stream, {
-          state: state2,
-          version: entry.committed.version,
-          event_id: entry.committed.id,
-          patches: 0,
-          snaps: 1
-        });
-      } else {
-        await cache2().invalidate(stream);
-      }
-    })
-  );
-  return truncated;
-}
-
-// src/internal/correlator.ts
-var import_node_crypto = require("crypto");
-var BASE = 36;
-var SEG_WIDTH = 4;
-var SEG_SPACE = BASE ** SEG_WIDTH;
-function seg(n) {
-  return n.toString(BASE).padStart(SEG_WIDTH, "0");
-}
-var default_correlator = ({ state: state2, action: action2 }) => {
-  const s = state2.slice(0, SEG_WIDTH).toLowerCase();
-  const a = action2.slice(0, SEG_WIDTH).toLowerCase();
-  const ts = seg(Date.now() % SEG_SPACE);
-  const rnd = seg((0, import_node_crypto.randomInt)(SEG_SPACE));
-  return `${s}-${a}-${ts}${rnd}`;
-};
-function close_correlation(correlator, actor) {
-  return correlator({
-    state: "$close",
-    action: "close",
-    stream: "$close",
-    actor
-  });
+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 DeferSignal(when);
+    return call(event, stream, app);
+  };
+  Object.defineProperty(deferred, "name", { value: handler.name });
+  return deferred;
 }
 
-// src/internal/autoclose-cycle.ts
-function yield_between_batches(ms) {
-  if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve) => setTimeout(resolve, ms));
+// src/internal/merge.ts
+var import_zod8 = require("zod");
+function base_type_name(zodType) {
+  let t = zodType;
+  while (typeof t.unwrap === "function") {
+    t = t.unwrap();
+  }
+  return t.constructor.name;
 }
-async function run_autoclose_cycle(deps) {
-  const s = store2();
-  let inspected = 0;
-  let evaluated = 0;
-  let predicate_errors = 0;
-  const truncated = /* @__PURE__ */ new Map();
-  const skipped = [];
-  const page = deps.config.closeBatchSize;
-  let after;
-  for (; ; ) {
-    const stats = await s.query_stats(
-      {},
-      { count: true, exclude: [TOMBSTONE_EVENT], after, limit: page }
-    );
-    if (stats.size === 0) break;
-    inspected += stats.size;
-    const candidates = [];
-    for (const [stream, { head, count }] of stats) {
-      const owner = deps.event_to_state.get(head.name);
-      if (!owner) continue;
-      const predicate = deps.autoclose_policy(owner.name);
-      if (!predicate) continue;
-      let close = false;
-      try {
-        close = predicate(stream, head, count ?? 0);
-        evaluated += 1;
-      } catch (err) {
-        predicate_errors += 1;
-        deps.logger.error(
-          `Autoclose predicate for state "${owner.name}" threw on stream "${stream}": ${err instanceof Error ? err.message : String(err)}`
-        );
-        close = deps.config.closeOnError;
+function merge_schemas(existing, incoming, state_name) {
+  if (existing instanceof import_zod8.ZodObject && incoming instanceof import_zod8.ZodObject) {
+    const existing_shape = existing.shape;
+    const incoming_shape = incoming.shape;
+    for (const key of Object.keys(incoming_shape)) {
+      if (key in existing_shape) {
+        const existing_base = base_type_name(existing_shape[key]);
+        const incoming_base = base_type_name(incoming_shape[key]);
+        if (existing_base !== incoming_base) {
+          throw new Error(
+            `Schema conflict in "${state_name}": key "${key}" has type "${existing_base}" but incoming partial declares "${incoming_base}"`
+          );
+        }
       }
-      if (!close) continue;
-      const archiver = deps.autoclose_archiver(owner.name);
-      const archive = archiver ? () => archiver(stream, head) : void 0;
-      candidates.push({ stream, archive });
     }
-    if (candidates.length > 0) {
-      const result = await run_close_cycle(candidates, {
-        reactive_events_size: deps.reactive_events_size,
-        event_to_state: deps.event_to_state,
-        load: deps.load,
-        tombstone: deps.tombstone,
-        logger: deps.logger,
-        correlation: deps.correlation
-      });
-      for (const [stream, entry] of result.truncated)
-        truncated.set(stream, entry);
-      for (const stream of result.skipped) skipped.push(stream);
-      await yield_between_batches(deps.config.closeYieldMs);
-    }
-    if (stats.size < page) break;
-    after = [...stats.keys()].at(-1);
+    return existing.extend(incoming_shape);
   }
-  return {
-    inspected,
-    evaluated,
-    predicate_errors,
-    close_result: { truncated, skipped }
-  };
+  return existing;
 }
-var AutocloseController = class {
-  deps;
-  _timer;
-  /**
-   * Reentrancy guard. The interval fires the next tick on cadence
-   * regardless of how long the previous one took; this flag drops
-   * overlapping ticks so the cycle stays sequential per controller.
-   */
-  _running = false;
-  constructor(deps) {
-    this.deps = deps;
+function merge_inits(existing, incoming) {
+  return () => ({ ...existing(), ...incoming() });
+}
+function register_state(state2, states, actions, events) {
+  const existing = states.get(state2.name);
+  if (existing) {
+    merge_into_existing(state2, existing, states, actions, events);
+  } else {
+    register_new_state(state2, states, actions, events);
   }
-  /**
-   * Start the cycle ticker. Returns `false` if already running so
-   * accidental double-start doesn't stack timers (matches
-   * `_correlate.start_polling` semantics).
-   */
-  start() {
-    if (this._timer) return false;
-    this._timer = setInterval(() => {
-      this.run_once().catch(() => {
-      });
-    }, this.deps.config.autocloseCycleMinutes * 6e4);
-    this._timer.unref();
-    return true;
+}
+function register_new_state(state2, states, actions, events) {
+  states.set(state2.name, state2);
+  for (const name of Object.keys(state2.actions)) {
+    if (actions[name]) throw new Error(`Duplicate action "${name}"`);
+    actions[name] = state2;
   }
-  /**
-   * Stop the cycle ticker. Idempotent.
-   */
-  stop() {
-    if (this._timer) {
-      clearInterval(this._timer);
-      this._timer = void 0;
-    }
+  for (const name of Object.keys(state2.events)) {
+    if (events[name]) throw new Error(`Duplicate event "${name}"`);
+    events[name] = { schema: state2.events[name], reactions: /* @__PURE__ */ new Map() };
   }
-  /**
-   * Whether the ticker is currently running.
-   */
-  get is_running() {
-    return this._timer !== void 0;
+}
+function merge_into_existing(state2, existing, states, actions, events) {
+  for (const name of Object.keys(state2.actions)) {
+    if (existing.actions[name] === state2.actions[name]) continue;
+    if (actions[name]) throw new Error(`Duplicate action "${name}"`);
   }
-  /**
-   * Run one cycle synchronously. The controller's interval callback
-   * delegates here; tests can invoke it directly to deterministically
-   * exercise the cycle without spinning real timers.
-   *
-   * Overlapping invocations short-circuit: if a previous tick is
-   * still running, this one drops and returns `null`. The orchestrator
-   * never sees a queue of pending ticks regardless of how slow the
-   * predicate / archive / truncate are.
-   */
-  async run_once() {
-    if (this._running) return null;
-    if (this.deps.breaker.state(Date.now()) === "open") return null;
-    if (!in_autoclose_window(this.deps.config.autocloseWindow, /* @__PURE__ */ new Date()))
-      return null;
-    this._running = true;
-    try {
-      const correlation = close_correlation(
-        this.deps.correlator,
-        this.deps.close_actor
+  for (const name of Object.keys(state2.events)) {
+    if (existing.events[name] === state2.events[name]) continue;
+    if (existing.events[name]) {
+      throw new Error(
+        `Event "${name}" in state "${state2.name}" is declared with different Zod schemas across slices. Cross-slice event schemas must reference the same instance \u2014 extract a shared schema (e.g. \`export const ${name} = z.object({ ... })\` in a shared module) and import it in every slice that declares it.`
       );
-      const result = await run_autoclose_cycle({
-        autoclose_policy: this.deps.autoclose_policy,
-        autoclose_archiver: this.deps.autoclose_archiver,
-        event_to_state: this.deps.event_to_state,
-        reactive_events_size: this.deps.reactive_events_size,
-        load: this.deps.load,
-        tombstone: this.deps.tombstone,
-        logger: this.deps.logger,
-        config: this.deps.config,
-        correlation
-      });
-      this.deps.breaker.passed();
-      if (result.close_result.truncated.size > 0) {
-        this.deps.on_closed(result.close_result);
-      }
-      return result;
-    } catch (error) {
-      this.deps.breaker.failed(Date.now(), error);
-      throw error;
-    } finally {
-      this._running = false;
     }
+    if (events[name]) throw new Error(`Duplicate event "${name}"`);
   }
-};
-
-// src/internal/autoclose-policy.ts
-var import_zod6 = require("zod");
-var MIN_AFTER_MS = 6e4;
-var AfterSchema = import_zod6.z.object({
-  days: import_zod6.z.number({ message: "autocloses: after.days must be a number" }).positive("autocloses: after.days must be > 0")
-}).refine((o) => o.days * 864e5 >= MIN_AFTER_MS, {
-  message: `autocloses: after resolves to < ${MIN_AFTER_MS}ms (one minute), which is too short to be a meaningful retention window`
-});
-var IsSchema = import_zod6.z.union([
-  import_zod6.z.string().min(1, "autocloses: is must be a non-empty event name"),
-  import_zod6.z.array(
-    import_zod6.z.string().min(1, "autocloses: is entries must be non-empty event names")
-  ).min(1, "autocloses: is must include at least one event name").readonly()
-]);
-var ReachesSchema = import_zod6.z.number({ message: "autocloses: reaches must be a number" }).int("autocloses: reaches must be an integer").min(1, "autocloses: reaches must be >= 1");
-var OrBlockSchema = import_zod6.z.object({
-  after: AfterSchema.optional(),
-  is: IsSchema.optional(),
-  reaches: ReachesSchema.optional()
-}).strict().refine(
-  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0,
-  {
-    message: "autocloses: `or` block must include at least one of after / is / reaches"
+  const merged_patch = merge_patches(existing.patch, state2.patch, state2.name);
+  const merged = {
+    ...existing,
+    state: merge_schemas(existing.state, state2.state, state2.name),
+    init: merge_inits(existing.init, state2.init),
+    events: { ...existing.events, ...state2.events },
+    actions: { ...existing.actions, ...state2.actions },
+    patch: merged_patch,
+    on: { ...existing.on, ...state2.on },
+    given: { ...existing.given, ...state2.given },
+    snap: state2.snap && existing.snap && state2.snap !== existing.snap ? (() => {
+      throw new Error(
+        `Duplicate snap strategy for state "${state2.name}"`
+      );
+    })() : state2.snap || existing.snap
+  };
+  states.set(state2.name, merged);
+  for (const name of Object.keys(merged.actions)) {
+    actions[name] = merged;
   }
-);
-var AutoclosePolicySchema = import_zod6.z.object({
-  after: AfterSchema.optional(),
-  is: IsSchema.optional(),
-  reaches: ReachesSchema.optional(),
-  or: OrBlockSchema.optional()
-}).strict().refine(
-  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0 || o.or !== void 0,
-  {
-    message: "autocloses: at least one of after / is / reaches / or must be specified \u2014 empty `{}` is a misconfiguration"
+  for (const name of Object.keys(state2.events)) {
+    if (events[name]) continue;
+    events[name] = { schema: state2.events[name], reactions: /* @__PURE__ */ new Map() };
   }
-);
-function compile_after(after) {
-  const after_ms = after.days * 864e5;
-  return (_stream, head) => Date.now() - head.created.getTime() >= after_ms;
-}
-function compile_is(is) {
-  const set = new Set(typeof is === "string" ? [is] : is);
-  return (_stream, head) => set.has(head.name);
 }
-function compile_reaches(reaches) {
-  return (_stream, _head, count) => count >= reaches;
-}
-function compile_autoclose_policy(options) {
-  const parsed = AutoclosePolicySchema.parse(options);
-  const and_preds = [];
-  if (parsed.after) and_preds.push(compile_after(parsed.after));
-  if (parsed.is) and_preds.push(compile_is(parsed.is));
-  if (parsed.reaches) and_preds.push(compile_reaches(parsed.reaches));
-  const or_preds = [];
-  if (parsed.or) {
-    if (parsed.or.after) or_preds.push(compile_after(parsed.or.after));
-    if (parsed.or.is) or_preds.push(compile_is(parsed.or.is));
-    if (parsed.or.reaches) or_preds.push(compile_reaches(parsed.or.reaches));
-  }
-  return (stream, head, count) => {
-    if (and_preds.length > 0 && and_preds.every((p) => p(stream, head, count))) {
-      return true;
+function merge_patches(existing, incoming, state_name) {
+  const merged = { ...existing };
+  for (const name of Object.keys(incoming)) {
+    const existing_p = existing[name];
+    const incoming_p = incoming[name];
+    if (!existing_p) {
+      merged[name] = incoming_p;
+      continue;
     }
-    if (or_preds.some((p) => p(stream, head, count))) {
-      return true;
+    const existing_is_default = existing_p._passthrough;
+    const incoming_is_default = incoming_p._passthrough;
+    if (!existing_is_default && !incoming_is_default && existing_p !== incoming_p) {
+      throw new Error(
+        `Duplicate custom patch for event "${name}" in state "${state_name}"`
+      );
     }
-    return false;
-  };
+    if (existing_is_default && !incoming_is_default) {
+      merged[name] = incoming_p;
+    }
+  }
+  return merged;
 }
-
-// src/internal/build-classify.ts
-var ALL_LANES = /* @__PURE__ */ Symbol("act-1103/all-lanes");
-function classify_registry(registry, states) {
-  const statics = /* @__PURE__ */ new Map();
-  const reactive_events = /* @__PURE__ */ new Set();
-  const event_to_lanes = /* @__PURE__ */ new Map();
-  let has_dynamic_resolvers = false;
-  for (const [name, register] of Object.entries(registry.events)) {
-    if (register.reactions.size > 0) reactive_events.add(name);
-    for (const reaction of register.reactions.values()) {
-      if (typeof reaction.resolver === "function") {
-        has_dynamic_resolvers = true;
-        event_to_lanes.set(name, ALL_LANES);
-      } else {
-        const { target, source, priority = 0, lane } = reaction.resolver;
-        const lane_name = lane ?? "default";
-        const existing_lanes = event_to_lanes.get(name);
-        if (existing_lanes !== ALL_LANES) {
-          const set = existing_lanes ?? /* @__PURE__ */ new Set();
-          set.add(lane_name);
-          event_to_lanes.set(name, set);
-        }
-        const key = `${target}|${source ?? ""}`;
-        const existing = statics.get(key);
-        if (!existing) {
-          statics.set(key, { stream: target, source, priority, lane });
-        } else {
-          if ((existing.lane ?? void 0) !== (lane ?? void 0))
-            throw new Error(
-              `Stream "${target}" has conflicting lane assignments ("${existing.lane ?? "default"}" vs "${lane ?? "default"}")`
-            );
-          if (priority > existing.priority) {
-            statics.set(key, { ...existing, priority });
-          }
-        }
+function merge_event_register(target, source) {
+  for (const [event_name, source_reg] of Object.entries(source)) {
+    const target_reg = target[event_name];
+    if (!target_reg) continue;
+    for (const [name, reaction] of source_reg.reactions) {
+      const existing = target_reg.reactions.get(name);
+      if (existing !== void 0 && existing !== reaction)
+        throw new Error(
+          `Duplicate reaction "${name}" for event "${event_name}". Reaction handlers are keyed by function name; rename one of them.`
+        );
+      target_reg.reactions.set(name, reaction);
+    }
+  }
+}
+function merge_projection(proj, events) {
+  for (const event_name of Object.keys(proj.events)) {
+    const proj_register = proj.events[event_name];
+    const existing = events[event_name];
+    if (!existing) {
+      events[event_name] = {
+        schema: proj_register.schema,
+        reactions: new Map(proj_register.reactions)
+      };
+    } else {
+      for (const [name, reaction] of proj_register.reactions) {
+        let key = name;
+        while (existing.reactions.has(key)) key = `${key}_p`;
+        existing.reactions.set(key, reaction);
       }
     }
   }
-  const event_to_state = /* @__PURE__ */ new Map();
-  for (const merged of states.values()) {
-    for (const event_name of Object.keys(merged.events)) {
-      event_to_state.set(event_name, merged);
-    }
-  }
+}
+var _this_ = ({ stream }) => ({
+  source: stream,
+  target: stream
+});
+
+// src/internal/builder-utils.ts
+function register_lane(config2, lanes) {
+  if (config2.name === DEFAULT_LANE)
+    throw new Error(`Lane "${DEFAULT_LANE}" is reserved`);
+  if (lanes.some((l) => l.name === config2.name))
+    throw new Error(`Lane "${config2.name}" was already declared`);
+  lanes.push(config2);
+}
+function reaction_on(event, events, builder) {
+  const register = (handler, options, schedule) => {
+    if (!handler.name)
+      throw new Error(
+        `Reaction handler for "${String(event)}" must be a named function`
+      );
+    if (events[event].reactions.has(handler.name))
+      throw new Error(
+        `Duplicate reaction "${handler.name}" for event "${String(event)}". Reaction handlers are keyed by function name; rename one of them.`
+      );
+    if (schedule && typeof schedule !== "function") assert_defer_when(schedule);
+    const reaction = {
+      handler: schedule ? make_deferred(handler, schedule) : handler,
+      resolver: _this_,
+      options: {
+        blockOnError: options?.blockOnError ?? true,
+        maxRetries: options?.maxRetries ?? 3,
+        backoff: options?.backoff
+      }
+    };
+    events[event].reactions.set(handler.name, reaction);
+    return Object.assign(builder, {
+      to(resolver) {
+        reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
+        return builder;
+      }
+    });
+  };
   return {
-    static_targets: [...statics.values()],
-    has_dynamic_resolvers,
-    reactive_events,
-    event_to_state,
-    event_to_lanes
+    do: (handler, options) => register(handler, options),
+    defer: (schedule) => ({
+      do: (handler, options) => register(handler, options, schedule)
+    })
   };
 }
 
 // src/internal/circuit-breaker.ts
-var import_zod7 = require("zod");
+var import_zod9 = require("zod");
 var DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 5;
 var DEFAULT_CIRCUIT_COOLDOWN_MS = 3e4;
-var CircuitBreakerOptionsSchema = import_zod7.z.object({
-  failureThreshold: import_zod7.z.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
-  cooldownMs: import_zod7.z.number().int().min(100).max(36e5).default(DEFAULT_CIRCUIT_COOLDOWN_MS)
+var CircuitBreakerOptionsSchema = import_zod9.z.object({
+  failureThreshold: import_zod9.z.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
+  cooldownMs: import_zod9.z.number().int().min(100).max(36e5).default(DEFAULT_CIRCUIT_COOLDOWN_MS)
 });
 var resolveCircuitBreakerConfig = (options) => CircuitBreakerOptionsSchema.parse(options ?? {});
 var CircuitBreaker = class {
@@ -2507,6 +2463,203 @@ var CircuitBreaker = class {
   }
 };
 
+// src/internal/close-cycle.ts
+var SAFETY_PROBE_PAGE_SIZE = 1e3;
+async function run_close_cycle(targets, deps) {
+  const target_map = new Map(targets.map((t) => [t.stream, t]));
+  const streams = [...target_map.keys()];
+  const skipped = [];
+  const stream_info = await scan_stream_heads(streams);
+  const safe = await partition_by_safety(
+    stream_info,
+    deps.reactive_events_size,
+    skipped,
+    deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE
+  );
+  if (!safe.length) return { truncated: /* @__PURE__ */ new Map(), skipped };
+  const { guarded, guard_events } = await guard_with_tombstones(
+    safe,
+    stream_info,
+    deps.correlation,
+    deps.tombstone,
+    skipped
+  );
+  if (!guarded.length) return { truncated: /* @__PURE__ */ new Map(), skipped };
+  const seed_states = await load_restart_seeds(
+    guarded,
+    target_map,
+    stream_info,
+    deps.event_to_state,
+    deps.load,
+    deps.logger
+  );
+  await run_archive_callbacks(guarded, target_map);
+  const truncated = await truncate_and_warm_cache(
+    guarded,
+    seed_states,
+    guard_events,
+    deps.correlation
+  );
+  return { truncated, skipped };
+}
+async function scan_stream_heads(streams) {
+  const stats = await store2().query_stats(streams, {
+    exclude: [SNAP_EVENT]
+  });
+  const out = /* @__PURE__ */ new Map();
+  for (const [stream, { head }] of stats) {
+    if (head.name === TOMBSTONE_EVENT) continue;
+    out.set(stream, {
+      max_id: head.id,
+      version: head.version,
+      last_event_name: head.name
+    });
+  }
+  return out;
+}
+async function partition_by_safety(stream_info, reactive_events_size, skipped, page_size) {
+  if (reactive_events_size === 0) return [...stream_info.keys()];
+  const pending_set = /* @__PURE__ */ new Set();
+  const source_regex = /* @__PURE__ */ new Map();
+  const get_regex = (source) => {
+    let re = source_regex.get(source);
+    if (!re) {
+      re = new RegExp(source);
+      source_regex.set(source, re);
+    }
+    return re;
+  };
+  const targets = [...stream_info.keys()];
+  let after;
+  for (; ; ) {
+    let last;
+    const { count } = await store2().query_streams(
+      (position) => {
+        last = position.stream;
+        const source_re = position.source ? get_regex(position.source) : void 0;
+        for (const [stream, info] of stream_info) {
+          if ((!source_re || source_re.test(stream)) && position.at < info.max_id) {
+            pending_set.add(stream);
+          }
+        }
+      },
+      { after, limit: page_size, source_matches: targets }
+    );
+    if (count < page_size) break;
+    after = last;
+  }
+  const safe = [];
+  for (const [stream] of stream_info) {
+    if (pending_set.has(stream)) skipped.push(stream);
+    else safe.push(stream);
+  }
+  return safe;
+}
+async function guard_with_tombstones(safe, stream_info, correlation, tombstone2, skipped) {
+  const guarded = [];
+  const guard_events = /* @__PURE__ */ new Map();
+  await Promise.all(
+    safe.map(async (stream) => {
+      const info = stream_info.get(stream);
+      const committed = await tombstone2(stream, info.version, correlation);
+      if (committed) {
+        guarded.push(stream);
+        guard_events.set(stream, { id: committed.id, stream });
+      } else {
+        skipped.push(stream);
+      }
+    })
+  );
+  return { guarded, guard_events };
+}
+async function load_restart_seeds(guarded, target_map, stream_info, event_to_state, load2, logger) {
+  const seed_states = /* @__PURE__ */ new Map();
+  await Promise.all(
+    guarded.filter((s) => target_map.get(s)?.restart).map(async (stream) => {
+      const last_event_name = stream_info.get(stream).last_event_name;
+      const owner_state = event_to_state.get(last_event_name);
+      if (!owner_state) {
+        logger.error(
+          `Cannot seed restart for "${stream}": no registered state owns event "${last_event_name}". Stream will be tombstoned instead.`
+        );
+        return;
+      }
+      const snap2 = await load2(owner_state, { stream });
+      seed_states.set(stream, snap2.state);
+    })
+  );
+  return seed_states;
+}
+async function run_archive_callbacks(guarded, target_map) {
+  for (const stream of guarded) {
+    const archive_fn = target_map.get(stream)?.archive;
+    if (archive_fn) await archive_fn();
+  }
+}
+async function truncate_and_warm_cache(guarded, seed_states, guard_events, correlation) {
+  const trunc_targets = guarded.map((stream) => {
+    const snapshot = seed_states.get(stream);
+    const guard = guard_events.get(stream);
+    return {
+      stream,
+      snapshot,
+      meta: {
+        correlation,
+        causation: {
+          event: { id: guard.id, name: TOMBSTONE_EVENT, stream: guard.stream }
+        }
+      }
+    };
+  });
+  const truncated = await store2().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 cache2().set(stream, {
+          state: state2,
+          version: entry.committed.version,
+          event_id: entry.committed.id,
+          patches: 0,
+          snaps: 1
+        });
+      } else {
+        await cache2().invalidate(stream);
+      }
+    })
+  );
+  return truncated;
+}
+
+// src/internal/close-signal.ts
+var CloseSignal = class extends Error {
+  /**
+   * Stream to close. Omitted → the reaction's own lease stream (a self-close).
+   * The synthesized autoclose reaction sets it to the aggregate stream, since
+   * its lease runs on a synthetic `__autoclose__` target.
+   */
+  stream;
+  /** Optional archive callback to run while the stream is guarded. */
+  archive;
+  /**
+   * Watermark to ack the requesting reaction to before the close runs. The
+   * close-cycle safety guard skips a stream whose subscriptions (matched by
+   * source) lag the head; the autoclose reaction's `source` is the aggregate,
+   * so it must advance its own watermark to the live head id it evaluated
+   * against — otherwise it blocks its own close. Defaults to the triggering
+   * event id when omitted.
+   */
+  at;
+  constructor(opts) {
+    super("reaction requested close");
+    this.name = "CloseSignal";
+    this.stream = opts?.stream;
+    this.archive = opts?.archive;
+    this.at = opts?.at;
+  }
+};
+
 // src/internal/correlate-cycle.ts
 var CorrelateCycle = class {
   _checkpoint = -1;
@@ -2611,33 +2764,135 @@ var CorrelateCycle = class {
     return { subscribed: 0, last_id };
   }
   /**
-   * Start a periodic correlation worker. Returns false if one is already
-   * running. Errors from `correlate()` are routed through `log()` so they
-   * land in the configured logger (the timer keeps running on failure).
+   * Start a periodic correlation worker. Returns false if one is already
+   * running. Errors from `correlate()` are routed through `log()` so they
+   * land in the configured logger (the timer keeps running on failure).
+   */
+  start_polling(query = {}, frequency = 1e4, callback) {
+    if (this._timer) return false;
+    const limit = query.limit || 100;
+    this._timer = setInterval(
+      () => this.correlate({ ...query, after: this._checkpoint, limit }).then((result) => {
+        if (callback && result.subscribed) callback(result.subscribed);
+      }).catch((err) => log().error(err)),
+      frequency
+    );
+    return true;
+  }
+  /** Stop the periodic correlation worker. Idempotent. */
+  stop_polling() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = void 0;
+    }
+  }
+};
+
+// src/internal/correlator.ts
+var import_node_crypto = require("crypto");
+var BASE = 36;
+var SEG_WIDTH = 4;
+var SEG_SPACE = BASE ** SEG_WIDTH;
+function seg(n) {
+  return n.toString(BASE).padStart(SEG_WIDTH, "0");
+}
+var default_correlator = ({ state: state2, action: action2 }) => {
+  const s = state2.slice(0, SEG_WIDTH).toLowerCase();
+  const a = action2.slice(0, SEG_WIDTH).toLowerCase();
+  const ts = seg(Date.now() % SEG_SPACE);
+  const rnd = seg((0, import_node_crypto.randomInt)(SEG_SPACE));
+  return `${s}-${a}-${ts}${rnd}`;
+};
+function close_correlation(correlator, actor) {
+  return correlator({
+    state: "$close",
+    action: "close",
+    stream: "$close",
+    actor
+  });
+}
+
+// src/internal/drain-cycle.ts
+var import_node_crypto2 = require("crypto");
+
+// src/internal/defer-timer.ts
+var MAX_TIMER_DELAY_MS = 2147483647;
+var DeferTimer = class {
+  _due = /* @__PURE__ */ new Map();
+  _timer;
+  _on_wake;
+  /**
+   * @param on_wake - invoked once each time the earliest due-time elapses,
+   *   after the come-due entries have been removed. Consumers use it to
+   *   re-arm their loop (the drain sets its `armed` flag; autoclose runs a
+   *   tick).
+   */
+  constructor(on_wake) {
+    this._on_wake = on_wake;
+  }
+  /** Number of currently parked streams. */
+  get size() {
+    return this._due.size;
+  }
+  /**
+   * True while `stream` is parked with a due-time still in the future.
+   * Consumers skip work for deferred streams until their window elapses.
    */
-  start_polling(query = {}, frequency = 1e4, callback) {
-    if (this._timer) return false;
-    const limit = query.limit || 100;
-    this._timer = setInterval(
-      () => this.correlate({ ...query, after: this._checkpoint, limit }).then((result) => {
-        if (callback && result.subscribed) callback(result.subscribed);
-      }).catch((err) => log().error(err)),
-      frequency
+  is_deferred = (stream) => {
+    const next = this._due.get(stream);
+    return next !== void 0 && next > Date.now();
+  };
+  /**
+   * Park `stream` for a re-visit at `at` (ms since epoch). A plain
+   * overwrite: the caller computes the authoritative next-visit for the
+   * stream (the drain's `handle` already reconciles a stream's reactions
+   * into one result per cycle), so there is no stale value to merge against.
+   */
+  set(stream, at) {
+    this._due.set(stream, at);
+  }
+  /** Drop `stream` from the parked set (e.g. on a successful ack or block). */
+  delete(stream) {
+    this._due.delete(stream);
+  }
+  /**
+   * (Re)schedule the wake timer at the earliest pending due-time. Idempotent
+   * — collapses many parked streams into a single timer. A no-op clears any
+   * pending timer when the map is empty.
+   *
+   * The timer is `unref()`-ed so pending re-visits never keep the process
+   * alive on their own.
+   */
+  schedule() {
+    if (this._timer) clearTimeout(this._timer);
+    if (this._due.size === 0) {
+      this._timer = void 0;
+      return;
+    }
+    let earliest = Number.POSITIVE_INFINITY;
+    for (const t of this._due.values()) if (t < earliest) earliest = t;
+    const delay = Math.min(
+      Math.max(0, earliest - Date.now()),
+      MAX_TIMER_DELAY_MS
     );
-    return true;
+    this._timer = setTimeout(() => {
+      this._timer = void 0;
+      const now = Date.now();
+      for (const [stream, at] of this._due)
+        if (at <= now) this._due.delete(stream);
+      this._on_wake();
+    }, delay);
+    this._timer.unref();
   }
-  /** Stop the periodic correlation worker. Idempotent. */
-  stop_polling() {
+  /** Cancel any pending wake timer. Idempotent. Leaves the parked set intact. */
+  stop() {
     if (this._timer) {
-      clearInterval(this._timer);
+      clearTimeout(this._timer);
       this._timer = void 0;
     }
   }
 };
 
-// src/internal/drain-cycle.ts
-var import_node_crypto2 = require("crypto");
-
 // src/internal/drain-ratio.ts
 var RATIO_MIN = 0.2;
 var RATIO_MAX = 0.8;
@@ -2673,6 +2928,7 @@ async function fetch(leased, eventLimit) {
 }
 var ack = (leases) => store2().ack(leases);
 var block = (leases) => store2().block(leases);
+var defer = (input, deferred_at) => store2().defer(input, deferred_at);
 var subscribe = (streams) => store2().subscribe(streams);
 
 // src/internal/event-sourcing.ts
@@ -3150,6 +3406,7 @@ function build_drain(logger) {
     fetch,
     ack,
     block,
+    defer,
     subscribe: logger.level !== "trace" ? subscribe : traced(subscribe, (result, streams) => {
       if (!result.subscribed) return;
       const lanes = new Set(streams.map((s) => s.lane ?? "default"));
@@ -3218,7 +3475,8 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
       fetched: [],
       handled: [],
       acked: [],
-      blocked: []
+      blocked: [],
+      closeable: []
     };
   }
   const fetched = await ops.fetch(active, eventLimit);
@@ -3252,12 +3510,23 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
     })
   );
   const acked = await ops.ack(
-    handled.filter((h) => h.handled > 0 || !h.error).map((h) => ({ ...h.lease, at: h.acked_at }))
+    handled.filter((h) => h.defer === void 0 && (h.handled > 0 || !h.error)).map((h) => ({ ...h.lease, at: h.acked_at }))
   );
   const blocked = await ops.block(
     handled.filter(({ block: block2 }) => block2).map(({ lease, error }) => ({ ...lease, error }))
   );
-  return { leased, fetched, handled, acked, blocked };
+  const deferrals = handled.filter((h) => h.defer !== void 0);
+  if (deferrals.length) {
+    const by_time = /* @__PURE__ */ new Map();
+    for (const h of deferrals) {
+      const list = by_time.get(h.defer);
+      if (list) list.push(h.lease.stream);
+      else by_time.set(h.defer, [h.lease.stream]);
+    }
+    for (const [at, streams] of by_time) await ops.defer(streams, at);
+  }
+  const closeable = handled.filter((h) => h.close !== void 0).map((h) => h.close);
+  return { leased, fetched, handled, acked, blocked, closeable };
 }
 var EMPTY_DRAIN = {
   fetched: [],
@@ -3270,14 +3539,16 @@ var DrainController = class {
   _locked = false;
   _ratio = 0.5;
   /**
-   * Per-stream backoff: `stream → next_attempt_at` (ms since epoch). Set by
-   * `_finalize` via `HandleResult.next_attempt_at`; cleared on successful
-   * ack or terminal block. Lives in process memory — per-worker pacing
-   * by design (see {@link BackoffOptions} for the multi-worker trade-off).
+   * Per-stream re-visit schedule (#1090): `stream → next visit` (ms since
+   * epoch). Holds both retry backoff (`HandleResult.next_attempt_at`) and the
+   * `defer` outcome; cleared on successful ack or terminal block. Lives in
+   * process memory — per-worker pacing by design (see {@link BackoffOptions}
+   * for the multi-worker trade-off). Its wake re-arms drain at the earliest
+   * pending visit.
    */
-  _backoff = /* @__PURE__ */ new Map();
-  /** Timer re-arming drain at the earliest pending `next_attempt_at`. */
-  _backoff_timer;
+  _defer = new DeferTimer(() => {
+    this._armed = true;
+  });
   /** Worker timer (ACT-1103). Set when `start()` is active, undefined otherwise. */
   _worker;
   _stopped = false;
@@ -3297,32 +3568,6 @@ var DrainController = class {
   get armed() {
     return this._armed;
   }
-  /** Returns true when `stream` is currently within a backoff window. */
-  is_deferred = (stream) => {
-    const next = this._backoff.get(stream);
-    return next !== void 0 && next > Date.now();
-  };
-  /**
-   * Schedule the next drain re-arm at the earliest pending backoff
-   * expiry. Called only when the backoff map is non-empty (caller guard).
-   * Idempotent — collapses many simultaneously deferred streams into a
-   * single timer.
-   */
-  schedule_backoff_wake() {
-    if (this._backoff_timer) clearTimeout(this._backoff_timer);
-    let earliest = Number.POSITIVE_INFINITY;
-    for (const t of this._backoff.values()) if (t < earliest) earliest = t;
-    const delay = Math.max(0, earliest - Date.now());
-    this._backoff_timer = setTimeout(() => {
-      this._backoff_timer = void 0;
-      const now = Date.now();
-      for (const [stream, at] of this._backoff) {
-        if (at <= now) this._backoff.delete(stream);
-      }
-      this._armed = true;
-    }, delay);
-    this._backoff_timer.unref();
-  }
   /** Lane this controller drains (undefined = legacy single-lane span). */
   get lane() {
     return this._deps.lane;
@@ -3354,6 +3599,7 @@ var DrainController = class {
       clearTimeout(this._worker);
       this._worker = void 0;
     }
+    this._defer.stop();
   }
   /** Run one drain pass. Short-circuits when not armed or already running. */
   async drain(options = {}) {
@@ -3379,7 +3625,7 @@ var DrainController = class {
         leading,
         eventLimit,
         leaseMillis,
-        this._backoff.size > 0 ? this.is_deferred : void 0,
+        this._defer.size > 0 ? this._defer.is_deferred : void 0,
         this._deps.lane
       );
       this._deps.breaker.passed();
@@ -3387,19 +3633,19 @@ var DrainController = class {
         this._armed = false;
         return EMPTY_DRAIN;
       }
-      const { leased, fetched, handled, acked, blocked } = cycle;
+      const { leased, fetched, handled, acked, blocked, closeable } = cycle;
       trace_cycle(this._deps.logger, leased, fetched, handled, acked, blocked);
       this._ratio = compute_lag_lead_ratio(handled, lagging, leading);
-      for (const lease of acked) this._backoff.delete(lease.stream);
-      for (const lease of blocked) this._backoff.delete(lease.stream);
+      for (const lease of acked) this._defer.delete(lease.stream);
+      for (const lease of blocked) this._defer.delete(lease.stream);
       for (const h of handled) {
-        if (h.next_attempt_at !== void 0 && !h.block) {
-          this._backoff.set(h.lease.stream, h.next_attempt_at);
-        }
+        const next = h.defer ?? (h.block ? void 0 : h.next_attempt_at);
+        if (next !== void 0) this._defer.set(h.lease.stream, next);
       }
-      if (this._backoff.size > 0) this.schedule_backoff_wake();
+      if (this._defer.size > 0) this._defer.schedule();
       if (acked.length) this._deps.on_acked(acked);
       if (blocked.length) this._deps.on_blocked(blocked);
+      if (closeable.length) await this._deps.on_close(closeable);
       const has_errors = handled.some(({ error }) => error);
       if (!acked.length && !blocked.length && !has_errors) this._armed = false;
       return { fetched, leased, acked, blocked };
@@ -3412,154 +3658,6 @@ var DrainController = class {
   }
 };
 
-// src/internal/merge.ts
-var import_zod8 = require("zod");
-function base_type_name(zodType) {
-  let t = zodType;
-  while (typeof t.unwrap === "function") {
-    t = t.unwrap();
-  }
-  return t.constructor.name;
-}
-function merge_schemas(existing, incoming, state_name) {
-  if (existing instanceof import_zod8.ZodObject && incoming instanceof import_zod8.ZodObject) {
-    const existing_shape = existing.shape;
-    const incoming_shape = incoming.shape;
-    for (const key of Object.keys(incoming_shape)) {
-      if (key in existing_shape) {
-        const existing_base = base_type_name(existing_shape[key]);
-        const incoming_base = base_type_name(incoming_shape[key]);
-        if (existing_base !== incoming_base) {
-          throw new Error(
-            `Schema conflict in "${state_name}": key "${key}" has type "${existing_base}" but incoming partial declares "${incoming_base}"`
-          );
-        }
-      }
-    }
-    return existing.extend(incoming_shape);
-  }
-  return existing;
-}
-function merge_inits(existing, incoming) {
-  return () => ({ ...existing(), ...incoming() });
-}
-function register_state(state2, states, actions, events) {
-  const existing = states.get(state2.name);
-  if (existing) {
-    merge_into_existing(state2, existing, states, actions, events);
-  } else {
-    register_new_state(state2, states, actions, events);
-  }
-}
-function register_new_state(state2, states, actions, events) {
-  states.set(state2.name, state2);
-  for (const name of Object.keys(state2.actions)) {
-    if (actions[name]) throw new Error(`Duplicate action "${name}"`);
-    actions[name] = state2;
-  }
-  for (const name of Object.keys(state2.events)) {
-    if (events[name]) throw new Error(`Duplicate event "${name}"`);
-    events[name] = { schema: state2.events[name], reactions: /* @__PURE__ */ new Map() };
-  }
-}
-function merge_into_existing(state2, existing, states, actions, events) {
-  for (const name of Object.keys(state2.actions)) {
-    if (existing.actions[name] === state2.actions[name]) continue;
-    if (actions[name]) throw new Error(`Duplicate action "${name}"`);
-  }
-  for (const name of Object.keys(state2.events)) {
-    if (existing.events[name] === state2.events[name]) continue;
-    if (existing.events[name]) {
-      throw new Error(
-        `Event "${name}" in state "${state2.name}" is declared with different Zod schemas across slices. Cross-slice event schemas must reference the same instance \u2014 extract a shared schema (e.g. \`export const ${name} = z.object({ ... })\` in a shared module) and import it in every slice that declares it.`
-      );
-    }
-    if (events[name]) throw new Error(`Duplicate event "${name}"`);
-  }
-  const merged_patch = merge_patches(existing.patch, state2.patch, state2.name);
-  const merged = {
-    ...existing,
-    state: merge_schemas(existing.state, state2.state, state2.name),
-    init: merge_inits(existing.init, state2.init),
-    events: { ...existing.events, ...state2.events },
-    actions: { ...existing.actions, ...state2.actions },
-    patch: merged_patch,
-    on: { ...existing.on, ...state2.on },
-    given: { ...existing.given, ...state2.given },
-    snap: state2.snap && existing.snap && state2.snap !== existing.snap ? (() => {
-      throw new Error(
-        `Duplicate snap strategy for state "${state2.name}"`
-      );
-    })() : state2.snap || existing.snap
-  };
-  states.set(state2.name, merged);
-  for (const name of Object.keys(merged.actions)) {
-    actions[name] = merged;
-  }
-  for (const name of Object.keys(state2.events)) {
-    if (events[name]) continue;
-    events[name] = { schema: state2.events[name], reactions: /* @__PURE__ */ new Map() };
-  }
-}
-function merge_patches(existing, incoming, state_name) {
-  const merged = { ...existing };
-  for (const name of Object.keys(incoming)) {
-    const existing_p = existing[name];
-    const incoming_p = incoming[name];
-    if (!existing_p) {
-      merged[name] = incoming_p;
-      continue;
-    }
-    const existing_is_default = existing_p._passthrough;
-    const incoming_is_default = incoming_p._passthrough;
-    if (!existing_is_default && !incoming_is_default && existing_p !== incoming_p) {
-      throw new Error(
-        `Duplicate custom patch for event "${name}" in state "${state_name}"`
-      );
-    }
-    if (existing_is_default && !incoming_is_default) {
-      merged[name] = incoming_p;
-    }
-  }
-  return merged;
-}
-function merge_event_register(target, source) {
-  for (const [event_name, source_reg] of Object.entries(source)) {
-    const target_reg = target[event_name];
-    if (!target_reg) continue;
-    for (const [name, reaction] of source_reg.reactions) {
-      const existing = target_reg.reactions.get(name);
-      if (existing !== void 0 && existing !== reaction)
-        throw new Error(
-          `Duplicate reaction "${name}" for event "${event_name}". Reaction handlers are keyed by function name; rename one of them.`
-        );
-      target_reg.reactions.set(name, reaction);
-    }
-  }
-}
-function merge_projection(proj, events) {
-  for (const event_name of Object.keys(proj.events)) {
-    const proj_register = proj.events[event_name];
-    const existing = events[event_name];
-    if (!existing) {
-      events[event_name] = {
-        schema: proj_register.schema,
-        reactions: new Map(proj_register.reactions)
-      };
-    } else {
-      for (const [name, reaction] of proj_register.reactions) {
-        let key = name;
-        while (existing.reactions.has(key)) key = `${key}_p`;
-        existing.reactions.set(key, reaction);
-      }
-    }
-  }
-}
-var _this_ = ({ stream }) => ({
-  source: stream,
-  target: stream
-});
-
 // src/internal/reactions.ts
 function finalize(lease, handled, at, error, options, logger, failed_at) {
   if (!error) return { lease, handled, acked_at: at };
@@ -3615,6 +3713,25 @@ function build_handle(deps) {
         at = event.id;
         handled++;
       } catch (error) {
+        if (error instanceof DeferSignal)
+          return {
+            lease,
+            handled,
+            acked_at: at,
+            defer: resolve_defer_at(error.when, event)
+          };
+        if (error instanceof CloseSignal)
+          return {
+            lease,
+            handled: handled + 1,
+            // Advance to the live head the handler evaluated against (when
+            // provided) so the close-cycle guard sees this reaction caught up.
+            acked_at: error.at ?? event.id,
+            // Close the signalled stream (the autoclose reaction's aggregate,
+            // which differs from its synthetic lease stream); a self-closing
+            // user reaction omits it and closes its own lease stream.
+            close: { stream: error.stream ?? stream, archive: error.archive }
+          };
         return finalize(
           lease,
           handled,
@@ -3717,6 +3834,7 @@ var SettleLoop = class {
 // src/act.ts
 var DEFAULT_MAX_SUBSCRIBED_STREAMS = 1e3;
 var DEFAULT_SETTLE_DEBOUNCE_MS = 10;
+var AUTOCLOSE_TARGET_PREFIX = "__autoclose__:";
 var Act = class {
   _emitter = new import_node_events.default();
   /** ACT-984: orchestrator-owned circuit breaker shared by all drain lanes. */
@@ -3758,15 +3876,6 @@ var Act = class {
    * @internal
    */
   _autoclose_config;
-  /**
-   * App-level autoclose controller. `undefined` when no state declares
-   * `.autocloses(...)` — the controller is never constructed, so
-   * `start_correlations()` / `stop_correlations()` skip the autoclose
-   * lifecycle and the orchestrator pays zero per-tick cost.
-   *
-   * @internal
-   */
-  _autoclose;
   /**
    * Emit a lifecycle event. The payload type is inferred from the event name
    * via {@link ActLifecycleEvents}.
@@ -3907,6 +4016,62 @@ var Act = class {
       bound_forget: this._bound_forget
     });
     this._handle_batch = build_handle_batch(this._logger);
+    for (const st of this._states.values()) {
+      const predicate = st.autoclose;
+      if (!predicate) continue;
+      const after_ms = st.autoclose_after_ms;
+      const archiver = st.archive;
+      const reaction = {
+        // Run on a SYNTHETIC stream — `source` is the aggregate, `target` is a
+        // per-aggregate `__autoclose__` key — so the autoclose reaction never
+        // shares a watermark with the aggregate's own reactions. A shared
+        // watermark would let autoclose's defer short-circuit the aggregate's
+        // other reactions (the "a defer affects all reactions on a stream"
+        // hazard). The close still targets the aggregate (`source`).
+        resolver: (e) => ({
+          target: `${AUTOCLOSE_TARGET_PREFIX}${e.stream}`,
+          source: e.stream
+        }),
+        // Never block on autoclose: a transient query/store error should retry,
+        // not quarantine the synthetic stream.
+        options: { blockOnError: false, maxRetries: 3 },
+        handler: async (event) => {
+          const aggregate = event.stream;
+          const config2 = this._autoclose_config;
+          if (!in_autoclose_window(config2.autocloseWindow, /* @__PURE__ */ new Date()))
+            throw new DeferSignal({
+              at: new Date(Date.now() + config2.autocloseCycleMinutes * 6e4)
+            });
+          const stats = await store2().query_stats([aggregate], {
+            count: true,
+            exclude: [TOMBSTONE_EVENT]
+          });
+          const entry = stats.get(aggregate);
+          if (!entry) return;
+          const head = entry.head;
+          if (predicate(aggregate, head, entry.count))
+            throw new CloseSignal({
+              stream: aggregate,
+              archive: archiver ? () => archiver(aggregate, head) : void 0,
+              // Ack this reaction's own watermark to the live head so the
+              // close-cycle guard (which matches subscriptions by source =
+              // aggregate) sees it caught up instead of blocking its own close.
+              at: head.id
+            });
+          if (after_ms !== void 0)
+            throw new DeferSignal({
+              at: new Date(head.created.getTime() + after_ms)
+            });
+        }
+      };
+      const key = `__autoclose_${st.name}`;
+      for (const event_name of Object.keys(st.events)) {
+        this.registry.events[event_name]?.reactions.set(
+          key,
+          reaction
+        );
+      }
+    }
     const {
       static_targets,
       has_dynamic_resolvers,
@@ -3955,6 +4120,22 @@ var Act = class {
         handle_batch: this._handle_batch,
         on_acked: (acked) => this.emit("acked", acked),
         on_blocked: (blocked) => this.emit("blocked", blocked),
+        // Reaction-requested close (#1090). Runs the same close machinery as
+        // `app.close` (tombstone guard + archive + atomic truncate) for the
+        // targets a handler signalled via `CloseSignal`. No `correlate()` here
+        // — the drain that produced these targets has already correlated.
+        on_close: async (targets) => {
+          const close_actor = { id: "$close", name: "close" };
+          const result = await run_close_cycle(targets, {
+            reactive_events_size: this._reactive_events.size,
+            event_to_state: this._event_to_state,
+            load: this._es.load,
+            tombstone: this._es.tombstone,
+            logger: this._logger,
+            correlation: close_correlation(this._correlator, close_actor)
+          });
+          this.emit("closed", result);
+        },
         breaker: this._breaker,
         // Pass lane only when a true per-lane controller is active.
         // The all-lanes (single default) case keeps lane=undefined so
@@ -4001,27 +4182,6 @@ var Act = class {
       },
       options.settleDebounceMs ?? DEFAULT_SETTLE_DEBOUNCE_MS
     );
-    const states_with_policy = [...this._states.values()].filter(
-      (s) => s.autoclose
-    );
-    this._autoclose = states_with_policy.length ? new AutocloseController({
-      // Internal cycle takes the loose `(string) => …` signature; the
-      // public `registry.autoclose_policy` narrows to
-      // `keyof TStateMap & string`. Thin lambdas bridge across the
-      // narrowing — runtime semantics are unchanged.
-      autoclose_policy: (name) => this.registry.autoclose_policy(name),
-      autoclose_archiver: (name) => this.registry.autoclose_archiver(name),
-      event_to_state: this._event_to_state,
-      reactive_events_size: this._reactive_events.size,
-      load: this._es.load,
-      tombstone: this._es.tombstone,
-      logger: this._logger,
-      config: this._autoclose_config,
-      correlator: this._correlator,
-      close_actor: { id: "$autoclose", name: "autoclose" },
-      on_closed: (result) => this.emit("closed", result),
-      breaker: this._breaker
-    }) : void 0;
     this._notify_disposer = this._wire_notify(options.scoped?.store ?? store2());
     dispose(() => this.shutdown());
   }
@@ -4515,7 +4675,6 @@ var Act = class {
    */
   start_correlations(query = {}, frequency = 1e4, callback) {
     const started = this._correlate.start_polling(query, frequency, callback);
-    this._autoclose?.start();
     return started;
   }
   /**
@@ -4537,7 +4696,6 @@ var Act = class {
    */
   stop_correlations() {
     this._correlate.stop_polling();
-    this._autoclose?.stop();
   }
   /**
    * Cancels any pending or active settle cycle.
@@ -5004,41 +5162,10 @@ function act() {
     },
     withActor: () => builder,
     withLane: (config2) => {
-      if (config2.name === DEFAULT_LANE)
-        throw new Error(`Lane "${DEFAULT_LANE}" is reserved`);
-      if (lanes.some((l) => l.name === config2.name))
-        throw new Error(`Lane "${config2.name}" was already declared`);
-      lanes.push(config2);
+      register_lane(config2, lanes);
       return builder;
     },
-    on: (event) => ({
-      do: (handler, options) => {
-        const reaction = {
-          handler,
-          resolver: _this_,
-          options: {
-            blockOnError: options?.blockOnError ?? true,
-            maxRetries: options?.maxRetries ?? 3,
-            backoff: options?.backoff
-          }
-        };
-        if (!handler.name)
-          throw new Error(
-            `Reaction handler for "${String(event)}" must be a named function`
-          );
-        if (registry.events[event].reactions.has(handler.name))
-          throw new Error(
-            `Duplicate reaction "${handler.name}" for event "${String(event)}". Reaction handlers are keyed by function name; rename one of them.`
-          );
-        registry.events[event].reactions.set(handler.name, reaction);
-        return Object.assign(builder, {
-          to(resolver) {
-            reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
-            return builder;
-          }
-        });
-      }
-    }),
+    on: (event) => reaction_on(event, registry.events, builder),
     build: (options) => {
       if (!_built) {
         for (const proj of pending_projections) {
@@ -5203,41 +5330,10 @@ function slice() {
       return builder;
     },
     withLane: (config2) => {
-      if (config2.name === DEFAULT_LANE)
-        throw new Error(`Lane "${DEFAULT_LANE}" is reserved`);
-      if (lanes.some((l) => l.name === config2.name))
-        throw new Error(`Lane "${config2.name}" was already declared`);
-      lanes.push(config2);
+      register_lane(config2, lanes);
       return builder;
     },
-    on: (event) => ({
-      do: (handler, options) => {
-        const reaction = {
-          handler,
-          resolver: _this_,
-          options: {
-            blockOnError: options?.blockOnError ?? true,
-            maxRetries: options?.maxRetries ?? 3,
-            backoff: options?.backoff
-          }
-        };
-        if (!handler.name)
-          throw new Error(
-            `Reaction handler for "${String(event)}" must be a named function`
-          );
-        if (events[event].reactions.has(handler.name))
-          throw new Error(
-            `Duplicate reaction "${handler.name}" for event "${String(event)}". Reaction handlers are keyed by function name; rename one of them.`
-          );
-        events[event].reactions.set(handler.name, reaction);
-        return Object.assign(builder, {
-          to(resolver) {
-            reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
-            return builder;
-          }
-        });
-      }
-    }),
+    on: (event) => reaction_on(event, events, builder),
     build: () => ({
       _tag: "Slice",
       states,
@@ -5340,20 +5436,21 @@ function action_builder(state2) {
       internal.disclose = disclose;
       return builder;
     },
-    autocloses(predicate_or_policy) {
-      let predicate;
-      if (typeof predicate_or_policy === "function") {
-        predicate = predicate_or_policy;
-      } else if (predicate_or_policy !== null && typeof predicate_or_policy === "object") {
-        predicate = compile_autoclose_policy(
-          predicate_or_policy
+    autocloses(policy) {
+      if (typeof policy === "function") {
+        throw new Error(
+          ".autocloses(fn) is no longer supported \u2014 pass a declarative policy ({ after, is, reaches, or }) or call app.close(...) from your own reaction for custom logic."
         );
-      } else {
+      }
+      if (policy === null || typeof policy !== "object") {
         throw new Error(
-          ".autocloses(...) requires a function or a policy object; got " + typeof predicate_or_policy
+          ".autocloses(...) requires a policy object; got " + typeof policy
         );
       }
-      internal.autoclose = predicate;
+      internal.autoclose = compile_autoclose_policy(
+        policy
+      );
+      internal.autoclose_after_ms = policy_min_after_ms(policy);
       return builder;
     },
     archives(archive) {
@@ -5547,6 +5644,7 @@ function write_line(writer, line) {
   DEFAULT_LANE,
   DEFAULT_MAX_SUBSCRIBED_STREAMS,
   DEFAULT_SETTLE_DEBOUNCE_MS,
+  DeferSignal,
   Environments,
   Errors,
   EventMetaSchema,