@rotorsoft/act 0.32.1 → 0.32.3

package/dist/index.js

@@ -154,7 +154,7 @@ var InMemoryCache = class {
 };
 
 // src/utils.ts
-import { prettifyError } from "zod";
+import { ZodError, prettifyError } from "zod";
 
 // src/config.ts
 import * as fs from "fs";
@@ -181,7 +181,7 @@ var { NODE_ENV, LOG_LEVEL, LOG_SINGLE_LINE, SLEEP_MS } = process.env;
 var env = NODE_ENV || "development";
 var logLevel = LOG_LEVEL || (NODE_ENV === "test" ? "error" : NODE_ENV === "production" ? "info" : "trace");
 var logSingleLine = (LOG_SINGLE_LINE || "true") === "true";
-var sleepMs = parseInt(NODE_ENV === "test" ? "0" : SLEEP_MS ?? "100");
+var sleepMs = parseInt(NODE_ENV === "test" ? "0" : SLEEP_MS ?? "100", 10);
 var pkg = getPackage();
 var config = () => {
   return extend({ ...pkg, env, logLevel, logSingleLine, sleepMs }, BaseSchema);
@@ -192,19 +192,15 @@ var validate = (target, payload, schema) => {
   try {
     return schema ? schema.parse(payload) : payload;
   } catch (error) {
-    if (error instanceof Error && error.name === "ZodError") {
-      throw new ValidationError(
-        target,
-        payload,
-        prettifyError(error)
-      );
+    if (error instanceof ZodError) {
+      throw new ValidationError(target, payload, prettifyError(error));
     }
     throw new ValidationError(target, payload, error);
   }
 };
 var extend = (source, schema, target) => {
   const value = validate("config", source, schema);
-  return Object.assign(target || {}, value);
+  return { ...target, ...value };
 };
 async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms ?? config().sleepMs));
@@ -632,13 +628,13 @@ var cache = port(function cache2(adapter) {
 var disposers = [];
 async function disposeAndExit(code = "EXIT") {
   if (code === "ERROR" && config().env === "production") return;
-  await Promise.all(disposers.map((disposer) => disposer()));
-  await Promise.all(
-    [...adapters.values()].reverse().map(async (adapter) => {
-      await adapter.dispose();
-      console.log(`[act] - ${adapter.constructor.name}`);
-    })
-  );
+  for (const disposer of [...disposers].reverse()) {
+    await disposer();
+  }
+  for (const adapter of [...adapters.values()].reverse()) {
+    await adapter.dispose();
+    console.log(`[act] - ${adapter.constructor.name}`);
+  }
   adapters.clear();
   config().env !== "test" && process.exit(code === "ERROR" ? 1 : 0);
 }
@@ -650,21 +646,20 @@ var SNAP_EVENT = "__snapshot__";
 var TOMBSTONE_EVENT = "__tombstone__";
 
 // src/signals.ts
-var logger = log();
 process.once("SIGINT", async (arg) => {
-  logger.info(arg, "SIGINT");
+  log().info(arg, "SIGINT");
   await disposeAndExit("EXIT");
 });
 process.once("SIGTERM", async (arg) => {
-  logger.info(arg, "SIGTERM");
+  log().info(arg, "SIGTERM");
   await disposeAndExit("EXIT");
 });
 process.once("uncaughtException", async (arg) => {
-  logger.error(arg, "Uncaught Exception");
+  log().error(arg, "Uncaught Exception");
   await disposeAndExit("ERROR");
 });
 process.once("unhandledRejection", async (arg) => {
-  logger.error(arg, "Unhandled Rejection");
+  log().error(arg, "Unhandled Rejection");
   await disposeAndExit("ERROR");
 });
 
@@ -672,6 +667,136 @@ process.once("unhandledRejection", async (arg) => {
 import { randomUUID as randomUUID2 } from "crypto";
 import EventEmitter from "events";
 
+// src/internal/merge.ts
+import { ZodObject } from "zod";
+function baseTypeName(zodType) {
+  let t = zodType;
+  while (typeof t.unwrap === "function") {
+    t = t.unwrap();
+  }
+  return t.constructor.name;
+}
+function mergeSchemas(existing, incoming, stateName) {
+  if (existing instanceof ZodObject && incoming instanceof ZodObject) {
+    const existingShape = existing.shape;
+    const incomingShape = incoming.shape;
+    for (const key of Object.keys(incomingShape)) {
+      if (key in existingShape) {
+        const existingBase = baseTypeName(existingShape[key]);
+        const incomingBase = baseTypeName(incomingShape[key]);
+        if (existingBase !== incomingBase) {
+          throw new Error(
+            `Schema conflict in "${stateName}": key "${key}" has type "${existingBase}" but incoming partial declares "${incomingBase}"`
+          );
+        }
+      }
+    }
+    return existing.extend(incomingShape);
+  }
+  return existing;
+}
+function mergeInits(existing, incoming) {
+  return () => ({ ...existing(), ...incoming() });
+}
+function registerState(state2, states, actions, events) {
+  const existing = states.get(state2.name);
+  if (existing) {
+    mergeIntoExisting(state2, existing, states, actions, events);
+  } else {
+    registerNewState(state2, states, actions, events);
+  }
+}
+function registerNewState(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 mergeIntoExisting(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]) continue;
+    if (events[name]) throw new Error(`Duplicate event "${name}"`);
+  }
+  const mergedPatch = mergePatches(existing.patch, state2.patch, state2.name);
+  const merged = {
+    ...existing,
+    state: mergeSchemas(existing.state, state2.state, state2.name),
+    init: mergeInits(existing.init, state2.init),
+    events: { ...existing.events, ...state2.events },
+    actions: { ...existing.actions, ...state2.actions },
+    patch: mergedPatch,
+    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 mergePatches(existing, incoming, stateName) {
+  const merged = { ...existing };
+  for (const name of Object.keys(incoming)) {
+    const existingP = existing[name];
+    const incomingP = incoming[name];
+    if (!existingP) {
+      merged[name] = incomingP;
+      continue;
+    }
+    const existingIsDefault = existingP._passthrough;
+    const incomingIsDefault = incomingP._passthrough;
+    if (!existingIsDefault && !incomingIsDefault && existingP !== incomingP) {
+      throw new Error(
+        `Duplicate custom patch for event "${name}" in state "${stateName}"`
+      );
+    }
+    if (existingIsDefault && !incomingIsDefault) {
+      merged[name] = incomingP;
+    }
+  }
+  return merged;
+}
+function mergeProjection(proj, events) {
+  for (const eventName of Object.keys(proj.events)) {
+    const projRegister = proj.events[eventName];
+    const existing = events[eventName];
+    if (!existing) {
+      events[eventName] = {
+        schema: projRegister.schema,
+        reactions: new Map(projRegister.reactions)
+      };
+    } else {
+      for (const [name, reaction] of projRegister.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/drain.ts
 var claim = (lagging, leading, by, millis) => store().claim(lagging, leading, by, millis);
 async function fetch(leased, eventLimit) {
@@ -694,7 +819,6 @@ var subscribe = (streams) => store().subscribe(streams);
 // src/internal/event-sourcing.ts
 import { patch } from "@rotorsoft/act-patch";
 import { randomUUID } from "crypto";
-var logger2 = log();
 async function snap(snapshot) {
   try {
     const { id, stream, name, meta, version } = snapshot.event;
@@ -709,11 +833,11 @@ async function snap(snapshot) {
       // IMPORTANT! - state events are committed right after the snapshot event
     );
   } catch (error) {
-    logger2.error(error);
+    log().error(error);
   }
 }
 async function load(me, stream, callback, asOf) {
-  const timeTravel = asOf && (asOf.before !== void 0 || asOf.created_before !== void 0 || asOf.created_after !== void 0 || asOf.limit !== void 0);
+  const timeTravel = !!asOf && Object.values(asOf).some((v) => v !== void 0);
   const cached = timeTravel ? void 0 : await cache().get(stream);
   let state2 = cached?.state ?? (me.init ? me.init() : {});
   let patches = cached?.patches ?? 0;
@@ -729,6 +853,10 @@ async function load(me, stream, callback, asOf) {
       } else if (me.patch[e.name]) {
         state2 = patch(state2, me.patch[e.name](event, state2));
         patches++;
+      } else if (e.name !== TOMBSTONE_EVENT) {
+        log().warn(
+          `Skipping unknown event "${String(e.name)}" on stream "${stream}" (id=${e.id}) \u2014 no reducer in state "${me.name}"`
+        );
       }
       callback && callback({ event, state: state2, patches, snaps });
     },
@@ -797,7 +925,7 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
       reactingTo ? void 0 : expected
     );
   } catch (error) {
-    if (error.name === "ERR_CONCURRENCY") {
+    if (error instanceof ConcurrencyError) {
       await cache().invalidate(stream);
     }
     throw error;
@@ -811,241 +939,56 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   });
   const last = snapshots.at(-1);
   const snapped = me.snap && me.snap(last);
-  void cache().set(stream, {
+  cache().set(stream, {
     state: last.state,
     version: last.event.version,
     event_id: last.event.id,
     patches: snapped ? 0 : last.patches,
     snaps: snapped ? last.snaps + 1 : last.snaps
-  });
+  }).catch((err) => log().error(err));
   if (snapped) void snap(last);
   return snapshots;
 }
 
-// src/internal/merge.ts
-import { ZodObject } from "zod";
-function baseTypeName(zodType) {
-  let t = zodType;
-  while (typeof t.unwrap === "function") {
-    t = t.unwrap();
-  }
-  return t.constructor.name;
-}
-function mergeSchemas(existing, incoming, stateName) {
-  if (existing instanceof ZodObject && incoming instanceof ZodObject) {
-    const existingShape = existing.shape;
-    const incomingShape = incoming.shape;
-    for (const key of Object.keys(incomingShape)) {
-      if (key in existingShape) {
-        const existingBase = baseTypeName(existingShape[key]);
-        const incomingBase = baseTypeName(incomingShape[key]);
-        if (existingBase !== incomingBase) {
-          throw new Error(
-            `Schema conflict in "${stateName}": key "${key}" has type "${existingBase}" but incoming partial declares "${incomingBase}"`
-          );
-        }
-      }
-    }
-    return existing.extend(incomingShape);
-  }
-  return existing;
-}
-function mergeInits(existing, incoming) {
-  return () => ({ ...existing(), ...incoming() });
-}
-function registerState(state2, states, actions, events) {
-  if (states.has(state2.name)) {
-    const existing = states.get(state2.name);
-    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]) continue;
-      if (events[name]) throw new Error(`Duplicate event "${name}"`);
-    }
-    const mergedPatch = { ...existing.patch };
-    for (const name of Object.keys(state2.patch)) {
-      const existingP = existing.patch[name];
-      const incomingP = state2.patch[name];
-      if (!existingP) {
-        mergedPatch[name] = incomingP;
-      } else {
-        const existingIsDefault = existingP._passthrough;
-        const incomingIsDefault = incomingP._passthrough;
-        if (!existingIsDefault && !incomingIsDefault && existingP !== incomingP) {
-          throw new Error(
-            `Duplicate custom patch for event "${name}" in state "${state2.name}"`
-          );
-        }
-        if (existingIsDefault && !incomingIsDefault) {
-          mergedPatch[name] = incomingP;
-        }
-      }
-    }
-    const merged = {
-      ...existing,
-      state: mergeSchemas(existing.state, state2.state, state2.name),
-      init: mergeInits(existing.init, state2.init),
-      events: { ...existing.events, ...state2.events },
-      actions: { ...existing.actions, ...state2.actions },
-      patch: mergedPatch,
-      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()
-      };
-    }
-  } else {
-    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 mergeProjection(proj, events) {
-  for (const eventName of Object.keys(proj.events)) {
-    const projRegister = proj.events[eventName];
-    const existing = events[eventName];
-    if (!existing) {
-      events[eventName] = {
-        schema: projRegister.schema,
-        reactions: new Map(projRegister.reactions)
-      };
-    } else {
-      for (const [name, reaction] of projRegister.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/tracing.ts
-var logger3 = log();
-var withSnapTrace = (inner) => async (snapshot) => {
-  logger3.trace(
-    `\u{1F7E0} snap ${snapshot.event.stream}@${snapshot.event.version}`
-  );
-  return inner(snapshot);
-};
-var withLoadTrace = (inner) => async (me, stream, callback, asOf) => {
-  logger3.trace(`\u{1F7E2} load ${stream}${asOf ? " (as-of)" : ""}`);
-  return inner(me, stream, callback, asOf);
-};
-var withActionTrace = (inner) => async (me, action2, target, payload, reactingTo, skipValidation) => {
-  logger3.trace(payload, `\u{1F535} ${target.stream}.${action2}`);
-  const snapshots = await inner(
-    me,
-    action2,
-    target,
-    payload,
-    reactingTo,
-    skipValidation
-  );
-  const committed = snapshots.filter((s) => s.event);
-  if (committed.length) {
-    logger3.trace(
-      committed.map((s) => s.event.data),
-      `\u{1F534} commit ${target.stream}.${committed.map((s) => s.event.name).join(", ")}`
-    );
-  }
-  return snapshots;
-};
-function buildEs(level) {
-  if (level !== "trace") {
+var traced = (inner, exit, entry) => (async (...args) => {
+  entry?.(...args);
+  const result = await inner(...args);
+  exit?.(result, ...args);
+  return result;
+});
+function buildEs(logger) {
+  if (logger.level !== "trace") {
     return { snap, load, action };
   }
   return {
-    snap: withSnapTrace(snap),
-    load: withLoadTrace(load),
-    action: withActionTrace(action)
+    snap: traced(snap, void 0, (snapshot) => {
+      logger.trace(
+        `\u{1F7E0} snap ${snapshot.event.stream}@${snapshot.event.version}`
+      );
+    }),
+    load: traced(load, void 0, (_me, stream, _cb, asOf) => {
+      logger.trace(`\u{1F7E2} load ${stream}${asOf ? " (as-of)" : ""}`);
+    }),
+    action: traced(
+      action,
+      (snapshots, _me, _action, target) => {
+        const committed = snapshots.filter((s) => s.event);
+        if (committed.length) {
+          logger.trace(
+            committed.map((s) => s.event.data),
+            `\u{1F534} commit ${target.stream}.${committed.map((s) => s.event.name).join(", ")}`
+          );
+        }
+      },
+      (_me, action2, target, payload) => {
+        logger.trace(payload, `\u{1F535} ${target.stream}.${action2}`);
+      }
+    )
   };
 }
-var withClaimTrace = (inner) => async (lagging, leading, by, millis) => {
-  const leased = await inner(lagging, leading, by, millis);
-  if (leased.length) {
-    const data = Object.fromEntries(
-      leased.map(({ stream, at, retry }) => [stream, { at, retry }])
-    );
-    logger3.trace(data, ">> lease");
-  }
-  return leased;
-};
-var withFetchTrace = (inner) => async (leased, eventLimit) => {
-  const fetched = await inner(leased, eventLimit);
-  const data = Object.fromEntries(
-    fetched.map(({ stream, source, events }) => {
-      const key = source ? `${stream}<-${source}` : stream;
-      const value = Object.fromEntries(
-        events.map(({ id, stream: stream2, name }) => [id, { [stream2]: name }])
-      );
-      return [key, value];
-    })
-  );
-  logger3.trace(data, ">> fetch");
-  return fetched;
-};
-var withAckTrace = (inner) => async (leases) => {
-  const acked = await inner(leases);
-  if (acked.length) {
-    const data = Object.fromEntries(
-      acked.map(({ stream, at, retry }) => [stream, { at, retry }])
-    );
-    logger3.trace(data, ">> ack");
-  }
-  return acked;
-};
-var withBlockTrace = (inner) => async (leases) => {
-  const blocked = await inner(leases);
-  if (blocked.length) {
-    const data = Object.fromEntries(
-      blocked.map(({ stream, at, retry, error }) => [
-        stream,
-        { at, retry, error }
-      ])
-    );
-    logger3.trace(data, ">> block");
-  }
-  return blocked;
-};
-var withSubscribeTrace = (inner) => async (streams) => {
-  const result = await inner(streams);
-  if (result.subscribed) {
-    const data = streams.map(({ stream }) => stream).join(" ");
-    logger3.trace(`>> correlate ${data}`);
-  }
-  return result;
-};
-function buildDrain(level) {
-  if (level !== "trace") {
+function buildDrain(logger) {
+  if (logger.level !== "trace") {
     return {
       claim,
       fetch,
@@ -1055,24 +998,62 @@ function buildDrain(level) {
     };
   }
   return {
-    claim: withClaimTrace(claim),
-    fetch: withFetchTrace(fetch),
-    ack: withAckTrace(ack),
-    block: withBlockTrace(block),
-    subscribe: withSubscribeTrace(subscribe)
+    claim: traced(claim, (leased) => {
+      if (leased.length) {
+        const data = Object.fromEntries(
+          leased.map(({ stream, at, retry }) => [stream, { at, retry }])
+        );
+        logger.trace(data, ">> lease");
+      }
+    }),
+    fetch: traced(fetch, (fetched) => {
+      const data = Object.fromEntries(
+        fetched.map(({ stream, source, events }) => {
+          const key = source ? `${stream}<-${source}` : stream;
+          const value = Object.fromEntries(
+            events.map(({ id, stream: stream2, name }) => [id, { [stream2]: name }])
+          );
+          return [key, value];
+        })
+      );
+      logger.trace(data, ">> fetch");
+    }),
+    ack: traced(ack, (acked) => {
+      if (acked.length) {
+        const data = Object.fromEntries(
+          acked.map(({ stream, at, retry }) => [stream, { at, retry }])
+        );
+        logger.trace(data, ">> ack");
+      }
+    }),
+    block: traced(block, (blocked) => {
+      if (blocked.length) {
+        const data = Object.fromEntries(
+          blocked.map(({ stream, at, retry, error }) => [
+            stream,
+            { at, retry, error }
+          ])
+        );
+        logger.trace(data, ">> block");
+      }
+    }),
+    subscribe: traced(subscribe, (result, streams) => {
+      if (result.subscribed) {
+        const data = streams.map(({ stream }) => stream).join(" ");
+        logger.trace(`>> correlate ${data}`);
+      }
+    })
   };
 }
 
 // src/act.ts
-var logger4 = log();
 var Act = class {
   constructor(registry, _states = /* @__PURE__ */ new Map(), batchHandlers = /* @__PURE__ */ new Map()) {
     this.registry = registry;
     this._states = _states;
     this._batch_handlers = batchHandlers;
-    const level = log().level;
-    this._es = buildEs(level);
-    this._cd = buildDrain(level);
+    this._es = buildEs(this._logger);
+    this._cd = buildDrain(this._logger);
     const statics = [];
     for (const [name, register] of Object.entries(this.registry.events)) {
       if (register.reactions.size > 0) {
@@ -1090,6 +1071,11 @@ var Act = class {
       }
     }
     this._static_targets = statics;
+    for (const merged of this._states.values()) {
+      for (const eventName of Object.keys(merged.events)) {
+        this._event_to_state.set(eventName, merged);
+      }
+    }
     dispose(() => {
       this._emitter.removeAllListeners();
       this.stop_correlations();
@@ -1136,6 +1122,15 @@ var Act = class {
   _es;
   /** Correlate/drain pipeline ops, optionally wrapped with trace decorators */
   _cd;
+  /**
+   * Event-name → owning state, computed at build time. The duplicate-event
+   * guard in merge.ts ensures one event name maps to at most one state, so
+   * this lookup is unambiguous. Used by `close()` to pick the right reducer
+   * set when seeding a `restart` snapshot in multi-state apps.
+   */
+  _event_to_state = /* @__PURE__ */ new Map();
+  /** Logger resolved at construction time (after user port configuration) */
+  _logger = log();
   /**
    * Executes an action on a state instance, committing resulting events.
    *
@@ -1357,7 +1352,7 @@ var Act = class {
     if (payloads.length === 0) return { lease, handled: 0, at: lease.at };
     const stream = lease.stream;
     let at = payloads.at(0).event.id, handled = 0;
-    lease.retry > 0 && logger4.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
+    lease.retry > 0 && this._logger.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
     const doAction = this.do.bind(this);
     const scopedApp = {
       do: doAction,
@@ -1379,9 +1374,11 @@ var Act = class {
         at = event.id;
         handled++;
       } catch (error) {
-        logger4.error(error);
+        this._logger.error(error);
         const block2 = lease.retry >= options.maxRetries && options.blockOnError;
-        block2 && logger4.error(`Blocking ${stream} after ${lease.retry} retries.`);
+        block2 && this._logger.error(
+          `Blocking ${stream} after ${lease.retry} retries.`
+        );
         return {
           lease,
           handled,
@@ -1411,15 +1408,17 @@ var Act = class {
     const stream = lease.stream;
     const events = payloads.map((p) => p.event);
     const at = events.at(-1).id;
-    lease.retry > 0 && logger4.warn(`Retrying batch ${stream}@${events[0].id} (${lease.retry}).`);
+    lease.retry > 0 && this._logger.warn(
+      `Retrying batch ${stream}@${events[0].id} (${lease.retry}).`
+    );
     try {
       await batchHandler(events, stream);
       return { lease, handled: events.length, at };
     } catch (error) {
-      logger4.error(error);
+      this._logger.error(error);
       const { options } = payloads[0];
       const block2 = lease.retry >= options.maxRetries && options.blockOnError;
-      block2 && logger4.error(`Blocking ${stream} after ${lease.retry} retries.`);
+      block2 && this._logger.error(`Blocking ${stream} after ${lease.retry} retries.`);
       return {
         lease,
         handled: 0,
@@ -1545,7 +1544,7 @@ var Act = class {
           this._needs_drain = false;
         return result;
       } catch (error) {
-        logger4.error(error);
+        this._logger.error(error);
       } finally {
         this._drain_locked = false;
       }
@@ -1846,16 +1845,24 @@ var Act = class {
       streams.map(async (s) => {
         let maxId = -1;
         let version = -1;
+        let lastEventName;
         await store().query(
           (e) => {
-            if (e.name !== TOMBSTONE_EVENT) {
+            if (e.name === TOMBSTONE_EVENT) return;
+            if (maxId === -1) {
               maxId = e.id;
               version = e.version;
             }
+            if (e.name !== SNAP_EVENT && lastEventName === void 0) {
+              lastEventName = e.name;
+            }
           },
-          { stream: s, stream_exact: true, backward: true, limit: 1 }
+          // limit: 2 covers the typical snapshot-at-head case (snapshot is
+          // always preceded by the domain event it captured). Streams with
+          // unusual layouts fall back to no-seed via the lookup miss path.
+          { stream: s, stream_exact: true, backward: true, limit: 2 }
         );
-        if (maxId >= 0) streamInfo.set(s, { maxId, version });
+        if (maxId >= 0) streamInfo.set(s, { maxId, version, lastEventName });
       })
     );
     const skipped = [];
@@ -1864,16 +1871,14 @@ var Act = class {
       safe = [...streamInfo.keys()];
     } else {
       const pendingSet = /* @__PURE__ */ new Set();
-      const leases = await store().claim(1e3, 1e3, randomUUID2(), 1);
-      if (leases.length) await store().ack(leases);
-      for (const lease of leases) {
-        const sourceRe = lease.source ? RegExp(lease.source) : void 0;
+      await store().query_streams((position) => {
+        const sourceRe = position.source ? RegExp(position.source) : void 0;
         for (const [stream, info] of streamInfo) {
-          if ((!sourceRe || sourceRe.test(stream)) && lease.at < info.maxId) {
+          if ((!sourceRe || sourceRe.test(stream)) && position.at < info.maxId) {
             pendingSet.add(stream);
           }
         }
-      }
+      });
       safe = [];
       for (const [stream] of streamInfo) {
         if (pendingSet.has(stream)) {
@@ -1913,16 +1918,21 @@ var Act = class {
       this.emit("closed", result2);
       return result2;
     }
-    const mergedState = [...this._states.values()][0];
     const seedStates = /* @__PURE__ */ new Map();
-    if (mergedState) {
-      await Promise.all(
-        guarded.filter((s) => targetMap.get(s)?.restart).map(async (stream) => {
-          const snap2 = await this._es.load(mergedState, stream);
-          seedStates.set(stream, snap2.state);
-        })
-      );
-    }
+    await Promise.all(
+      guarded.filter((s) => targetMap.get(s)?.restart).map(async (stream) => {
+        const lastEventName = streamInfo.get(stream)?.lastEventName;
+        const ownerState = lastEventName ? this._event_to_state.get(lastEventName) : void 0;
+        if (!ownerState) {
+          this._logger.error(
+            `Cannot seed restart for "${stream}": no registered state owns event "${lastEventName ?? "<none>"}". Stream will be tombstoned instead.`
+          );
+          return;
+        }
+        const snap2 = await this._es.load(ownerState, stream);
+        seedStates.set(stream, snap2.state);
+      })
+    );
     for (const stream of guarded) {
       const archiveFn = targetMap.get(stream)?.archive;
       if (archiveFn) await archiveFn();
@@ -2025,7 +2035,7 @@ var Act = class {
           if (!made_progress) break;
         }
         if (lastDrain) this.emit("settled", lastDrain);
-      })().catch((err) => logger4.error(err)).finally(() => {
+      })().catch((err) => this._logger.error(err)).finally(() => {
         this._settling = false;
       });
     }, debounceMs);
@@ -2033,6 +2043,14 @@ var Act = class {
 };
 
 // src/act-builder.ts
+function registerBatchHandler(proj, batchHandlers) {
+  if (!proj.batchHandler || !proj.target) return;
+  const existing = batchHandlers.get(proj.target);
+  if (existing && existing !== proj.batchHandler) {
+    throw new Error(`Duplicate batch handler for target "${proj.target}"`);
+  }
+  batchHandlers.set(proj.target, proj.batchHandler);
+}
 function act(states = /* @__PURE__ */ new Map(), registry = {
   actions: {},
   events: {}
@@ -2067,9 +2085,7 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
     },
     withProjection: (proj) => {
       mergeProjection(proj, registry.events);
-      if (proj.batchHandler && proj.target) {
-        batchHandlers.set(proj.target, proj.batchHandler);
-      }
+      registerBatchHandler(proj, batchHandlers);
       return act(
         states,
         registry,
@@ -2115,9 +2131,7 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
     build: () => {
       for (const proj of pendingProjections) {
         mergeProjection(proj, registry.events);
-        if (proj.batchHandler && proj.target) {
-          batchHandlers.set(proj.target, proj.batchHandler);
-        }
+        registerBatchHandler(proj, batchHandlers);
       }
       return new Act(
         registry,
@@ -2272,8 +2286,9 @@ function state(entry) {
         emits(events) {
           const defaultPatch = Object.fromEntries(
             Object.keys(events).map((k) => {
-              const fn = ({ data }) => data;
-              fn._passthrough = true;
+              const fn = Object.assign(({ data }) => data, {
+                _passthrough: true
+              });
               return [k, fn];
             })
           );