@rotorsoft/act 1.31.2 → 1.31.3

package/dist/index.cjs

@@ -77,7 +77,6 @@ __export(index_exports, {
   port: () => port,
   projection: () => projection,
   resolveAutocloseConfig: () => resolveAutocloseConfig,
-  scoped: () => scoped,
   sensitive: () => sensitive,
   sleep: () => sleep,
   slice: () => slice,
@@ -87,9 +86,6 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/ports.ts
-var import_node_async_hooks = require("async_hooks");
-
 // src/adapters/console-logger.ts
 var LEVEL_VALUES = {
   fatal: 60,
@@ -1576,7 +1572,7 @@ var InMemoryStore = class {
   }
 };
 
-// src/internal/disposers.ts
+// src/disposers.ts
 var entries = [];
 var prune = () => {
   for (let i = entries.length - 1; i >= 0; i--) {
@@ -1606,8 +1602,27 @@ var run_disposers = async () => {
   }
 };
 
-// src/ports.ts
+// src/scoped.ts
+var import_node_async_hooks = require("async_hooks");
 var scoped = new import_node_async_hooks.AsyncLocalStorage();
+var reacting = new import_node_async_hooks.AsyncLocalStorage();
+function make_run_scoped(bag) {
+  return bag ? (fn) => scoped.run(bag, fn) : (fn) => fn();
+}
+function current_ports() {
+  return scoped.getStore();
+}
+function run_reacting(event, fn) {
+  return reacting.run(event, fn);
+}
+function current_reacting() {
+  return reacting.getStore();
+}
+function make_reaction_scope(app) {
+  return { app, run: run_reacting };
+}
+
+// src/ports.ts
 var ExitCodes = ["ERROR", "EXIT"];
 var adapters = /* @__PURE__ */ new Map();
 function port(injector) {
@@ -1631,13 +1646,13 @@ var _store = port(function store(adapter) {
   return adapter ?? new InMemoryStore();
 });
 var store2 = ((adapter) => {
-  return scoped.getStore()?.store ?? _store(adapter);
+  return current_ports()?.store ?? _store(adapter);
 });
 var _cache = port(function cache(adapter) {
   return adapter ?? new InMemoryCache();
 });
 var cache2 = ((adapter) => {
-  return scoped.getStore()?.cache ?? _cache(adapter);
+  return current_ports()?.cache ?? _cache(adapter);
 });
 async function disposeAndExit(code = "EXIT") {
   if (code === "ERROR" && config().env === "production") {
@@ -1683,6 +1698,58 @@ process.once("unhandledRejection", async (arg) => {
 // src/act.ts
 var import_node_events = __toESM(require("events"), 1);
 
+// src/builders/build-classify.ts
+var ALL_LANES = /* @__PURE__ */ Symbol("act-1103/all-lanes");
+function classify_registry(registry, states) {
+  const statics = /* @__PURE__ */ new Map();
+  const target_lanes = /* @__PURE__ */ new Map();
+  const reactive_events = /* @__PURE__ */ new Set();
+  const event_to_lanes = /* @__PURE__ */ new Map();
+  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") {
+        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);
+        }
+        if (!target_lanes.has(target)) {
+          target_lanes.set(target, lane);
+        } else if ((target_lanes.get(target) ?? void 0) !== (lane ?? void 0)) {
+          throw new Error(
+            `Stream "${target}" has conflicting lane assignments ("${target_lanes.get(target) ?? "default"}" vs "${lane ?? "default"}")`
+          );
+        }
+        const key = `${target}|${source ?? ""}`;
+        const existing = statics.get(key);
+        if (!existing) {
+          statics.set(key, { stream: target, source, priority, lane });
+        } else if (priority > existing.priority) {
+          statics.set(key, { ...existing, priority });
+        }
+      }
+    }
+  }
+  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 {
+    static_targets: [...statics.values()],
+    reactive_events,
+    event_to_state,
+    event_to_lanes
+  };
+}
+
 // src/internal/event-versions.ts
 var VERSION_SUFFIX = /^(.+?)_v(\d+)$/;
 function parse(name) {
@@ -2434,432 +2501,43 @@ function synthesize_autoclose_reactions(registry, states, config2) {
   }
 }
 
-// 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 target_lanes = /* @__PURE__ */ new Map();
-  const reactive_events = /* @__PURE__ */ new Set();
-  const event_to_lanes = /* @__PURE__ */ new Map();
-  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") {
-        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);
-        }
-        if (!target_lanes.has(target)) {
-          target_lanes.set(target, lane);
-        } else if ((target_lanes.get(target) ?? void 0) !== (lane ?? void 0)) {
-          throw new Error(
-            `Stream "${target}" has conflicting lane assignments ("${target_lanes.get(target) ?? "default"}" vs "${lane ?? "default"}")`
-          );
-        }
-        const key = `${target}|${source ?? ""}`;
-        const existing = statics.get(key);
-        if (!existing) {
-          statics.set(key, { stream: target, source, priority, lane });
-        } else if (priority > existing.priority) {
-          statics.set(key, { ...existing, priority });
-        }
-      }
-    }
-  }
-  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);
+// src/internal/backoff.ts
+function compute_backoff_delay(retry, opts) {
+  if (!opts || opts.baseMs <= 0) return 0;
+  const r = Math.max(0, retry);
+  let delay;
+  switch (opts.strategy) {
+    case "fixed":
+      delay = opts.baseMs;
+      break;
+    case "linear":
+      delay = opts.baseMs * (r + 1);
+      break;
+    case "exponential":
+      delay = opts.baseMs * 2 ** r;
+      if (opts.maxMs !== void 0) delay = Math.min(delay, opts.maxMs);
+      break;
+    default: {
+      const _never = opts.strategy;
+      throw new Error(`unknown backoff strategy: ${String(_never)}`);
     }
   }
-  return {
-    static_targets: [...statics.values()],
-    reactive_events,
-    event_to_state,
-    event_to_lanes
-  };
+  if (opts.jitter) delay = delay * (0.5 + Math.random());
+  return Math.max(0, Math.floor(delay));
 }
 
-// src/internal/config.ts
-var import_zod6 = require("zod");
-var BackoffOptionsSchema = import_zod6.z.object({
-  strategy: import_zod6.z.enum(["fixed", "linear", "exponential"]),
-  baseMs: import_zod6.z.number().min(0),
-  maxMs: import_zod6.z.number().gt(0).optional(),
-  jitter: import_zod6.z.boolean().optional()
-});
-var ReactionOptionsSchema = import_zod6.z.object({
-  blockOnError: import_zod6.z.boolean(),
-  maxRetries: import_zod6.z.number().int().min(0),
-  backoff: BackoffOptionsSchema.optional()
-});
-function resolveReactionConfig(options) {
-  return ReactionOptionsSchema.parse(options);
-}
-var ActionOptionsSchema = import_zod6.z.object({
-  maxRetries: import_zod6.z.number().int().min(0).optional(),
-  backoff: BackoffOptionsSchema.optional()
-});
-function resolveActionConfig(options) {
-  return ActionOptionsSchema.parse(options);
-}
-var LaneConfigSchema = import_zod6.z.object({
-  name: import_zod6.z.string().min(1),
-  leaseMillis: import_zod6.z.number().min(0).optional(),
-  streamLimit: import_zod6.z.number().int().min(0).optional(),
-  cycleMs: import_zod6.z.number().min(0).optional()
-});
-function resolveLaneConfig(options) {
-  LaneConfigSchema.parse(options);
-  return options;
-}
-var DrainOptionsSchema = import_zod6.z.object({
-  streamLimit: import_zod6.z.number().int().min(0).optional(),
-  eventLimit: import_zod6.z.number().int().min(0).optional(),
-  leaseMillis: import_zod6.z.number().min(0).optional()
-});
-function resolveDrainConfig(options) {
-  if (options === void 0) return void 0;
-  DrainOptionsSchema.parse(options);
-  return options;
-}
-var SettleOptionsSchema = DrainOptionsSchema.extend({
-  debounceMs: import_zod6.z.number().min(0).optional(),
-  // `maxPasses` defaults to Infinity (no cap) when omitted; a present value is
-  // a non-negative integer — `0` is legal and means "run no passes".
-  maxPasses: import_zod6.z.number().int().min(0).optional()
-}).loose();
-function resolveSettleConfig(options) {
-  if (options === void 0) return void 0;
-  SettleOptionsSchema.parse(options);
-  return options;
-}
-var MAX_SHUTDOWN_GRACE_MS = 3e4;
-var DEFAULT_SHUTDOWN_GRACE_MS = 1e4;
-var ShutdownOptionsSchema = import_zod6.z.object({
-  // `0` is legal and is exactly today's behavior: stop scheduling and
-  // return without waiting.
-  graceMs: import_zod6.z.number().min(0).optional()
-}).loose();
-function resolveShutdownConfig(options) {
-  if (options === void 0) return void 0;
-  ShutdownOptionsSchema.parse(options);
-  return options;
-}
-var ActOptionsSchema = import_zod6.z.object({
-  maxSubscribedStreams: import_zod6.z.number().int().min(1).optional(),
-  settleDebounceMs: import_zod6.z.number().int().min(0).optional()
-}).loose();
-function resolveActConfig(options) {
-  if (options === void 0) return void 0;
-  ActOptionsSchema.parse(options);
-  return options;
-}
-var DEFAULT_AUTOCLOSE_CYCLE_MINUTES = 720;
-var DEFAULT_CLOSE_BATCH_SIZE = 64;
-var DEFAULT_CLOSE_YIELD_MS = 0;
-var DEFAULT_AUTOCLOSE_WINDOW_TZ = "UTC";
-function is_valid_time_zone(tz) {
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone: tz });
-    return true;
-  } catch {
-    return false;
-  }
-}
-var AutocloseWindowSchema = import_zod6.z.object({
-  start: import_zod6.z.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
-  end: import_zod6.z.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
-  timeZone: import_zod6.z.string().refine(is_valid_time_zone, {
-    message: "autocloseWindow.timeZone must be a valid IANA time zone"
-  }).default(DEFAULT_AUTOCLOSE_WINDOW_TZ)
-}).refine((w) => w.start !== w.end, {
-  message: "autocloseWindow.start and end must differ \u2014 an empty window disables autoclose"
-});
-var AutocloseOptionsSchema = import_zod6.z.object({
-  autocloseCycleMinutes: import_zod6.z.number().int().min(1).max(1440).default(DEFAULT_AUTOCLOSE_CYCLE_MINUTES),
-  closeBatchSize: import_zod6.z.number().int().min(1).max(1024).default(DEFAULT_CLOSE_BATCH_SIZE),
-  closeYieldMs: import_zod6.z.number().min(0).max(1e3).default(DEFAULT_CLOSE_YIELD_MS),
-  closeOnError: import_zod6.z.boolean().default(false),
-  autocloseWindow: AutocloseWindowSchema.optional()
-});
-function resolveAutocloseConfig(options) {
-  return AutocloseOptionsSchema.parse({
-    autocloseCycleMinutes: options?.autocloseCycleMinutes,
-    closeBatchSize: options?.closeBatchSize,
-    closeYieldMs: options?.closeYieldMs,
-    closeOnError: options?.closeOnError,
-    autocloseWindow: options?.autocloseWindow
-  });
-}
-var DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 5;
-var DEFAULT_CIRCUIT_COOLDOWN_MS = 3e4;
-var CircuitBreakerOptionsSchema = import_zod6.z.object({
-  failureThreshold: import_zod6.z.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
-  cooldownMs: import_zod6.z.number().int().min(100).max(36e5).default(DEFAULT_CIRCUIT_COOLDOWN_MS)
-});
-var resolveCircuitBreakerConfig = (options) => CircuitBreakerOptionsSchema.parse(options ?? {});
-var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
-var DEFAULT_MAX_CACHED_STATES = 1e4;
-var FoldOptionsSchema = import_zod6.z.object({
-  flushEvery: import_zod6.z.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
-  maxCachedStates: import_zod6.z.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
-});
-function resolveFoldConfig(options) {
-  return FoldOptionsSchema.parse(options);
-}
-
-// src/internal/defer-config.ts
-var import_zod7 = require("zod");
-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;
-}
-function resolve_defer_at(when, event) {
-  const parsed = DeferWhenSchema.parse(when);
-  if (parsed.after) return event.created.getTime() + duration_ms(parsed.after);
-  return parsed.at.getTime();
-}
-function assert_defer_when(when) {
-  DeferWhenSchema.parse(when);
-}
-function make_deferred(handler, schedule) {
-  const call = handler;
-  const deferred = async (event, stream, app) => {
-    const when = typeof schedule === "function" ? schedule(event) : schedule;
-    if (Date.now() < resolve_defer_at(when, event)) throw new DeferSignal(when);
-    return call(event, stream, app);
-  };
-  Object.defineProperty(deferred, "name", { value: handler.name });
-  return deferred;
-}
-
-// 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) {
-        if ([...existing.reactions.values()].includes(reaction)) continue;
-        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/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_,
-      // #1269: validate the whole bag at the declaration site so a bad
-      // `maxRetries`/`backoff`/`blockOnError` throws ZodError at build,
-      // not a NaN gate on the first retry.
-      options: resolveReactionConfig({
-        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 {
-    do: (handler, options) => register(handler, options),
-    defer: (schedule) => ({
-      do: (handler, options) => register(handler, options, schedule)
-    })
-  };
-}
-
-// src/internal/circuit-breaker.ts
-var CircuitBreaker = class {
-  _failures = 0;
-  _opened_at;
-  _wake;
-  _threshold;
-  _cooldown_ms;
-  _hooks;
-  constructor(config2, hooks = {}) {
-    this._threshold = config2.failureThreshold;
-    this._cooldown_ms = config2.cooldownMs;
-    this._hooks = hooks;
+// src/internal/circuit-breaker.ts
+var CircuitBreaker = class {
+  _failures = 0;
+  _opened_at;
+  _wake;
+  _threshold;
+  _cooldown_ms;
+  _hooks;
+  constructor(config2, hooks = {}) {
+    this._threshold = config2.failureThreshold;
+    this._cooldown_ms = config2.cooldownMs;
+    this._hooks = hooks;
   }
   /** Current state given the wall-clock `now`. */
   state(now) {
@@ -3218,6 +2896,135 @@ async function truncate_and_warm_cache(guarded, seed_states, guard_events, corre
   return truncated;
 }
 
+// src/internal/config.ts
+var import_zod6 = require("zod");
+var BackoffOptionsSchema = import_zod6.z.object({
+  strategy: import_zod6.z.enum(["fixed", "linear", "exponential"]),
+  baseMs: import_zod6.z.number().min(0),
+  maxMs: import_zod6.z.number().gt(0).optional(),
+  jitter: import_zod6.z.boolean().optional()
+});
+var ReactionOptionsSchema = import_zod6.z.object({
+  blockOnError: import_zod6.z.boolean(),
+  maxRetries: import_zod6.z.number().int().min(0),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveReactionConfig(options) {
+  return ReactionOptionsSchema.parse(options);
+}
+var ActionOptionsSchema = import_zod6.z.object({
+  maxRetries: import_zod6.z.number().int().min(0).optional(),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveActionConfig(options) {
+  return ActionOptionsSchema.parse(options);
+}
+var LaneConfigSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1),
+  leaseMillis: import_zod6.z.number().min(0).optional(),
+  streamLimit: import_zod6.z.number().int().min(0).optional(),
+  cycleMs: import_zod6.z.number().min(0).optional()
+});
+function resolveLaneConfig(options) {
+  LaneConfigSchema.parse(options);
+  return options;
+}
+var DrainOptionsSchema = import_zod6.z.object({
+  streamLimit: import_zod6.z.number().int().min(0).optional(),
+  eventLimit: import_zod6.z.number().int().min(0).optional(),
+  leaseMillis: import_zod6.z.number().min(0).optional()
+});
+function resolveDrainConfig(options) {
+  if (options === void 0) return void 0;
+  DrainOptionsSchema.parse(options);
+  return options;
+}
+var SettleOptionsSchema = DrainOptionsSchema.extend({
+  debounceMs: import_zod6.z.number().min(0).optional(),
+  // `maxPasses` defaults to Infinity (no cap) when omitted; a present value is
+  // a non-negative integer — `0` is legal and means "run no passes".
+  maxPasses: import_zod6.z.number().int().min(0).optional()
+}).loose();
+function resolveSettleConfig(options) {
+  if (options === void 0) return void 0;
+  SettleOptionsSchema.parse(options);
+  return options;
+}
+var MAX_SHUTDOWN_GRACE_MS = 3e4;
+var DEFAULT_SHUTDOWN_GRACE_MS = 1e4;
+var ShutdownOptionsSchema = import_zod6.z.object({
+  // `0` is legal and is exactly today's behavior: stop scheduling and
+  // return without waiting.
+  graceMs: import_zod6.z.number().min(0).optional()
+}).loose();
+function resolveShutdownConfig(options) {
+  if (options === void 0) return void 0;
+  ShutdownOptionsSchema.parse(options);
+  return options;
+}
+var ActOptionsSchema = import_zod6.z.object({
+  maxSubscribedStreams: import_zod6.z.number().int().min(1).optional(),
+  settleDebounceMs: import_zod6.z.number().int().min(0).optional()
+}).loose();
+function resolveActConfig(options) {
+  if (options === void 0) return void 0;
+  ActOptionsSchema.parse(options);
+  return options;
+}
+var DEFAULT_AUTOCLOSE_CYCLE_MINUTES = 720;
+var DEFAULT_CLOSE_BATCH_SIZE = 64;
+var DEFAULT_CLOSE_YIELD_MS = 0;
+var DEFAULT_AUTOCLOSE_WINDOW_TZ = "UTC";
+function is_valid_time_zone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var AutocloseWindowSchema = import_zod6.z.object({
+  start: import_zod6.z.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
+  end: import_zod6.z.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
+  timeZone: import_zod6.z.string().refine(is_valid_time_zone, {
+    message: "autocloseWindow.timeZone must be a valid IANA time zone"
+  }).default(DEFAULT_AUTOCLOSE_WINDOW_TZ)
+}).refine((w) => w.start !== w.end, {
+  message: "autocloseWindow.start and end must differ \u2014 an empty window disables autoclose"
+});
+var AutocloseOptionsSchema = import_zod6.z.object({
+  autocloseCycleMinutes: import_zod6.z.number().int().min(1).max(1440).default(DEFAULT_AUTOCLOSE_CYCLE_MINUTES),
+  closeBatchSize: import_zod6.z.number().int().min(1).max(1024).default(DEFAULT_CLOSE_BATCH_SIZE),
+  closeYieldMs: import_zod6.z.number().min(0).max(1e3).default(DEFAULT_CLOSE_YIELD_MS),
+  closeOnError: import_zod6.z.boolean().default(false),
+  autocloseWindow: AutocloseWindowSchema.optional()
+});
+function resolveAutocloseConfig(options) {
+  return AutocloseOptionsSchema.parse({
+    autocloseCycleMinutes: options?.autocloseCycleMinutes,
+    closeBatchSize: options?.closeBatchSize,
+    closeYieldMs: options?.closeYieldMs,
+    closeOnError: options?.closeOnError,
+    autocloseWindow: options?.autocloseWindow
+  });
+}
+var DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 5;
+var DEFAULT_CIRCUIT_COOLDOWN_MS = 3e4;
+var CircuitBreakerOptionsSchema = import_zod6.z.object({
+  failureThreshold: import_zod6.z.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
+  cooldownMs: import_zod6.z.number().int().min(100).max(36e5).default(DEFAULT_CIRCUIT_COOLDOWN_MS)
+});
+var resolveCircuitBreakerConfig = (options) => CircuitBreakerOptionsSchema.parse(options ?? {});
+var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
+var DEFAULT_MAX_CACHED_STATES = 1e4;
+var FoldOptionsSchema = import_zod6.z.object({
+  flushEvery: import_zod6.z.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
+  maxCachedStates: import_zod6.z.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
+});
+function resolveFoldConfig(options) {
+  return FoldOptionsSchema.parse(options);
+}
+
 // src/internal/correlate-cycle.ts
 var import_node_crypto = require("crypto");
 var DEFAULT_COLD_START_BACK_SCAN = 1e4;
@@ -3612,6 +3419,43 @@ function close_correlation(correlator, actor) {
   });
 }
 
+// src/internal/defer-config.ts
+var import_zod7 = require("zod");
+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;
+}
+function resolve_defer_at(when, event) {
+  const parsed = DeferWhenSchema.parse(when);
+  if (parsed.after) return event.created.getTime() + duration_ms(parsed.after);
+  return parsed.at.getTime();
+}
+function assert_defer_when(when) {
+  DeferWhenSchema.parse(when);
+}
+function make_deferred(handler, schedule) {
+  const call = handler;
+  const deferred = async (event, stream, app) => {
+    const when = typeof schedule === "function" ? schedule(event) : schedule;
+    if (Date.now() < resolve_defer_at(when, event)) throw new DeferSignal(when);
+    return call(event, stream, app);
+  };
+  Object.defineProperty(deferred, "name", { value: handler.name });
+  return deferred;
+}
+
 // src/internal/drain-cycle.ts
 var import_node_crypto3 = require("crypto");
 
@@ -3739,37 +3583,6 @@ var subscribe = (streams, correlated_at, correlator) => store2().subscribe(strea
 
 // src/internal/event-sourcing.ts
 var import_act_patch = require("@rotorsoft/act-patch");
-
-// src/internal/backoff.ts
-function compute_backoff_delay(retry, opts) {
-  if (!opts || opts.baseMs <= 0) return 0;
-  const r = Math.max(0, retry);
-  let delay;
-  switch (opts.strategy) {
-    case "fixed":
-      delay = opts.baseMs;
-      break;
-    case "linear":
-      delay = opts.baseMs * (r + 1);
-      break;
-    case "exponential":
-      delay = opts.baseMs * 2 ** r;
-      if (opts.maxMs !== void 0) delay = Math.min(delay, opts.maxMs);
-      break;
-    default: {
-      const _never = opts.strategy;
-      throw new Error(`unknown backoff strategy: ${String(_never)}`);
-    }
-  }
-  if (opts.jitter) delay = delay * (0.5 + Math.random());
-  return Math.max(0, Math.floor(delay));
-}
-
-// src/internal/reacting.ts
-var import_node_async_hooks2 = require("async_hooks");
-var reacting = new import_node_async_hooks2.AsyncLocalStorage();
-
-// src/internal/event-sourcing.ts
 var bare_patch = (_me, state2, partial) => (0, import_act_patch.patch)(state2, partial);
 var validating_patch = (me, state2, partial, event) => {
   const next = (0, import_act_patch.patch)(state2, partial);
@@ -4026,7 +3839,7 @@ 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 = options?.reactingTo ?? reacting.getStore();
+  const reactingTo = options?.reactingTo;
   const correlator = options?.correlator ?? default_correlator;
   const validated = validate(action2, payload, me.actions[action2]);
   const opts = me.options?.[action2];
@@ -4675,131 +4488,6 @@ function make_fold_handler(me, flush, config2, patch_fn = bare_patch, sensitive_
   return handler;
 }
 
-// src/internal/reactions.ts
-function finalize(lease, handled, at, error, options, logger, failed_at) {
-  if (!error) return { lease, handled, acked_at: at };
-  logger.error(error);
-  const non_retryable = error instanceof NonRetryableError;
-  const block2 = options.blockOnError && (non_retryable || lease.retry >= options.maxRetries);
-  if (block2)
-    logger.error(
-      non_retryable ? `Blocking ${lease.stream} on non-retryable error.` : `Blocking ${lease.stream} after ${lease.retry} retries.`
-    );
-  const next_attempt_at = !block2 && options.backoff ? Date.now() + compute_backoff_delay(lease.retry, options.backoff) : void 0;
-  return {
-    lease,
-    handled,
-    acked_at: at,
-    error: error.message,
-    block: block2,
-    next_attempt_at,
-    failed_at
-  };
-}
-function build_handle(deps) {
-  const {
-    logger,
-    bound_do,
-    bound_load,
-    bound_query,
-    bound_query_array,
-    bound_forget
-  } = deps;
-  return async (lease, payloads) => {
-    if (payloads.length === 0) return { lease, handled: 0, acked_at: lease.at };
-    const stream = lease.stream;
-    const last_index_of = /* @__PURE__ */ new Map();
-    for (let i = 0; i < payloads.length; i++)
-      last_index_of.set(payloads[i].event.id, i);
-    let at = lease.at;
-    let handled = 0;
-    if (lease.retry > 0)
-      logger.warn(
-        `Retrying ${stream}@${payloads.at(0).event.id} (${lease.retry}).`
-      );
-    const scoped_app = {
-      do: bound_do,
-      load: bound_load,
-      query: bound_query,
-      query_array: bound_query_array,
-      forget: bound_forget
-    };
-    for (let i = 0; i < payloads.length; i++) {
-      const payload = payloads[i];
-      const { event, handler } = payload;
-      try {
-        await reacting.run(
-          event,
-          () => handler(event, stream, scoped_app)
-        );
-        if (last_index_of.get(event.id) === i) {
-          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. A
-            // carried `before` makes it a windowed close (prune, not retire).
-            close: {
-              stream: error.stream ?? stream,
-              archive: error.archive,
-              before: error.before
-            }
-          };
-        return finalize(
-          lease,
-          handled,
-          at,
-          error,
-          payload.options,
-          logger,
-          event.id
-        );
-      }
-    }
-    return finalize(lease, handled, at, void 0, payloads[0].options, logger);
-  };
-}
-function build_handle_batch(logger) {
-  return async (lease, payloads, batchHandler) => {
-    const stream = lease.stream;
-    const events = payloads.map(
-      (p) => p.event
-    );
-    const options = payloads[0].options;
-    if (lease.retry > 0)
-      logger.warn(`Retrying batch ${stream}@${events[0].id} (${lease.retry}).`);
-    try {
-      await batchHandler(events, stream);
-      return finalize(
-        lease,
-        events.length,
-        events.at(-1).id,
-        void 0,
-        options,
-        logger
-      );
-    } catch (error) {
-      return finalize(lease, 0, lease.at, error, options, logger);
-    }
-  };
-}
-
 // src/internal/settle.ts
 var SettleLoop = class {
   _timer = void 0;
@@ -4910,8 +4598,119 @@ var SettleLoop = class {
       clearTimeout(this._timer);
       this._timer = void 0;
     }
-  }
-};
+  }
+};
+
+// src/builders/reaction-builder.ts
+function finalize(lease, handled, at, error, options, logger, failed_at) {
+  if (!error) return { lease, handled, acked_at: at };
+  logger.error(error);
+  const non_retryable = error instanceof NonRetryableError;
+  const block2 = options.blockOnError && (non_retryable || lease.retry >= options.maxRetries);
+  if (block2)
+    logger.error(
+      non_retryable ? `Blocking ${lease.stream} on non-retryable error.` : `Blocking ${lease.stream} after ${lease.retry} retries.`
+    );
+  const next_attempt_at = !block2 && options.backoff ? Date.now() + compute_backoff_delay(lease.retry, options.backoff) : void 0;
+  return {
+    lease,
+    handled,
+    acked_at: at,
+    error: error.message,
+    block: block2,
+    next_attempt_at,
+    failed_at
+  };
+}
+function build_handle(deps) {
+  const { logger, reaction_scope } = deps;
+  return async (lease, payloads) => {
+    if (payloads.length === 0) return { lease, handled: 0, acked_at: lease.at };
+    const stream = lease.stream;
+    const last_index_of = /* @__PURE__ */ new Map();
+    for (let i = 0; i < payloads.length; i++)
+      last_index_of.set(payloads[i].event.id, i);
+    let at = lease.at;
+    let handled = 0;
+    if (lease.retry > 0)
+      logger.warn(
+        `Retrying ${stream}@${payloads.at(0).event.id} (${lease.retry}).`
+      );
+    for (let i = 0; i < payloads.length; i++) {
+      const payload = payloads[i];
+      const { event, handler } = payload;
+      try {
+        await reaction_scope.run(
+          event,
+          () => handler(event, stream, reaction_scope.app)
+        );
+        if (last_index_of.get(event.id) === i) {
+          at = event.id;
+          handled++;
+        }
+      } catch (error) {
+        if (error instanceof 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. A
+            // carried `before` makes it a windowed close (prune, not retire).
+            close: {
+              stream: error.stream ?? stream,
+              archive: error.archive,
+              before: error.before
+            }
+          };
+        return finalize(
+          lease,
+          handled,
+          at,
+          error,
+          payload.options,
+          logger,
+          event.id
+        );
+      }
+    }
+    return finalize(lease, handled, at, void 0, payloads[0].options, logger);
+  };
+}
+function build_handle_batch(logger) {
+  return async (lease, payloads, batchHandler) => {
+    const stream = lease.stream;
+    const events = payloads.map(
+      (p) => p.event
+    );
+    const options = payloads[0].options;
+    if (lease.retry > 0)
+      logger.warn(`Retrying batch ${stream}@${events[0].id} (${lease.retry}).`);
+    try {
+      await batchHandler(events, stream);
+      return finalize(
+        lease,
+        events.length,
+        events.at(-1).id,
+        void 0,
+        options,
+        logger
+      );
+    } catch (error) {
+      return finalize(lease, 0, lease.at, error, options, logger);
+    }
+  };
+}
 
 // src/act.ts
 var DEFAULT_MAX_SUBSCRIBED_STREAMS = 1e3;
@@ -5144,17 +4943,21 @@ var Act = class {
     this._batch_handlers = batch_handlers;
     this._lanes = lanes;
     validate_only_lanes(options, lanes);
-    this._scoped = options.scoped ? (fn) => scoped.run(options.scoped, fn) : (fn) => fn();
+    this._scoped = make_run_scoped(options.scoped);
     this._correlator = options.correlator ?? default_correlator;
     this._es = build_es(this._logger, this._correlator, patch_fn);
     this._cd = build_drain(this._logger);
     this._handle = build_handle({
       logger: this._logger,
-      bound_do: this._bound_do,
-      bound_load: this._bound_load,
-      bound_query: this._bound_query,
-      bound_query_array: this._bound_query_array,
-      bound_forget: this._bound_forget
+      // The orchestrator owns ambient context; `build_handle` only asks for
+      // the triggering event to be in scope while the handler runs.
+      reaction_scope: make_reaction_scope({
+        do: this._bound_do,
+        load: this._bound_load,
+        query: this._bound_query,
+        query_array: this._bound_query_array,
+        forget: this._bound_forget
+      })
     });
     this._handle_batch = build_handle_batch(this._logger);
     const classification = classify_registry(this.registry, this._states);
@@ -5573,13 +5376,15 @@ var Act = class {
    * @see {@link ValidationError}, {@link InvariantError}, {@link ConcurrencyError}
    */
   async do(action2, target, payload, options) {
+    const reacting_to = options?.reactingTo ?? current_reacting();
+    const do_options = reacting_to === options?.reactingTo ? options : { ...options, reactingTo: reacting_to };
     return this._scoped(async () => {
       const snapshots = await this._es.action(
         this.registry.actions[action2],
         action2,
         target,
         payload,
-        options
+        do_options
       );
       if (this._reactive_events.size > 0)
         this._arm_for_event_names(
@@ -6412,6 +6217,202 @@ var Act = class {
   }
 };
 
+// src/builders/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) {
+        if ([...existing.reactions.values()].includes(reaction)) continue;
+        let key = name;
+        while (existing.reactions.has(key)) key = `${key}_p`;
+        existing.reactions.set(key, reaction);
+      }
+    }
+  }
+}
+var _this_ = ({ stream }) => ({
+  source: stream,
+  target: stream
+});
+
+// src/builders/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_,
+      // #1269: validate the whole bag at the declaration site so a bad
+      // `maxRetries`/`backoff`/`blockOnError` throws ZodError at build,
+      // not a NaN gate on the first retry.
+      options: resolveReactionConfig({
+        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 {
+    do: (handler, options) => register(handler, options),
+    defer: (schedule) => ({
+      do: (handler, options) => register(handler, options, schedule)
+    })
+  };
+}
+
 // src/builders/act-builder.ts
 function register_batch_handler(proj, batch_handlers) {
   if (!proj.batchHandler || !proj.target) return;
@@ -7197,7 +7198,6 @@ function write_line(writer, line) {
   port,
   projection,
   resolveAutocloseConfig,
-  scoped,
   sensitive,
   sleep,
   slice,