@rotorsoft/act 0.32.0 → 0.32.2

package/dist/index.js

@@ -648,63 +648,6 @@ function dispose(disposer) {
 }
 var SNAP_EVENT = "__snapshot__";
 var TOMBSTONE_EVENT = "__tombstone__";
-function build_tracer(logLevel2) {
-  if (logLevel2 === "trace") {
-    const logger4 = log();
-    return {
-      fetched: (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];
-          })
-        );
-        logger4.trace(data, ">> fetch");
-      },
-      correlated: (streams) => {
-        const data = streams.map(({ stream }) => stream).join(" ");
-        logger4.trace(`>> correlate ${data}`);
-      },
-      leased: (leases) => {
-        const data = Object.fromEntries(
-          leases.map(({ stream, at, retry }) => [stream, { at, retry }])
-        );
-        logger4.trace(data, ">> lease");
-      },
-      acked: (leases) => {
-        const data = Object.fromEntries(
-          leases.map(({ stream, at, retry }) => [stream, { at, retry }])
-        );
-        logger4.trace(data, ">> ack");
-      },
-      blocked: (leases) => {
-        const data = Object.fromEntries(
-          leases.map(({ stream, at, retry, error }) => [
-            stream,
-            { at, retry, error }
-          ])
-        );
-        logger4.trace(data, ">> block");
-      }
-    };
-  } else {
-    return {
-      fetched: () => {
-      },
-      correlated: () => {
-      },
-      leased: () => {
-      },
-      acked: () => {
-      },
-      blocked: () => {
-      }
-    };
-  }
-}
 
 // src/signals.ts
 var logger = log();
@@ -729,14 +672,162 @@ process.once("unhandledRejection", async (arg) => {
 import { randomUUID as randomUUID2 } from "crypto";
 import EventEmitter from "events";
 
-// src/event-sourcing.ts
+// 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) {
+  return Promise.all(
+    leased.map(async ({ stream, source, at, lagging }) => {
+      const events = [];
+      await store().query((e) => events.push(e), {
+        stream: source,
+        after: at,
+        limit: eventLimit
+      });
+      return { stream, source, at, lagging, events };
+    })
+  );
+}
+var ack = (leases) => store().ack(leases);
+var block = (leases) => store().block(leases);
+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;
-    const snapped = await store().commit(
+    await store().commit(
       stream,
       [{ name: SNAP_EVENT, data: snapshot.state }],
       {
@@ -746,19 +837,18 @@ async function snap(snapshot) {
       version
       // IMPORTANT! - state events are committed right after the snapshot event
     );
-    logger2.trace(snapped, "\u{1F7E0} snap");
   } 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;
   let snaps = cached?.snaps ?? 0;
   let event;
-  const count = await store().query(
+  await store().query(
     (e) => {
       event = e;
       if (e.name === SNAP_EVENT) {
@@ -777,10 +867,6 @@ async function load(me, stream, callback, asOf) {
       ...cached ? { after: cached.event_id } : { with_snaps: true, ...asOf }
     }
   );
-  logger2.trace(
-    state2,
-    `\u{1F7E2} load ${stream}${cached && count === 0 ? " (cached)" : ""}${timeTravel ? " (as-of)" : ""}`
-  );
   return { event, state: state2, patches, snaps };
 }
 async function action(me, action2, target, payload, reactingTo, skipValidation = false) {
@@ -791,10 +877,6 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   if (snapshot.event?.name === TOMBSTONE_EVENT)
     throw new StreamClosedError(stream);
   const expected = expectedVersion ?? snapshot.event?.version;
-  logger2.trace(
-    payload,
-    `\u{1F535} ${stream}.${action2}${typeof expected === "number" ? `.${expected}` : ""}`
-  );
   if (me.given) {
     const invariants = me.given[action2] || [];
     invariants.forEach(({ valid, description }) => {
@@ -834,10 +916,6 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
       } : void 0
     }
   };
-  logger2.trace(
-    emitted.map((e) => e.data),
-    `\u{1F534} commit ${stream}.${emitted.map((e) => e.name).join(", ")}`
-  );
   let committed;
   try {
     committed = await store().commit(
@@ -848,7 +926,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;
@@ -862,25 +940,121 @@ 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/tracing.ts
+var traced = (inner, exit, entry) => (async (...args) => {
+  entry?.(...args);
+  const result = await inner(...args);
+  exit?.(result, ...args);
+  return result;
+});
+function buildEs(logger2) {
+  if (logger2.level !== "trace") {
+    return { snap, load, action };
+  }
+  return {
+    snap: traced(snap, void 0, (snapshot) => {
+      logger2.trace(
+        `\u{1F7E0} snap ${snapshot.event.stream}@${snapshot.event.version}`
+      );
+    }),
+    load: traced(load, void 0, (_me, stream, _cb, asOf) => {
+      logger2.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) {
+          logger2.trace(
+            committed.map((s) => s.event.data),
+            `\u{1F534} commit ${target.stream}.${committed.map((s) => s.event.name).join(", ")}`
+          );
+        }
+      },
+      (_me, action2, target, payload) => {
+        logger2.trace(payload, `\u{1F535} ${target.stream}.${action2}`);
+      }
+    )
+  };
+}
+function buildDrain(logger2) {
+  if (logger2.level !== "trace") {
+    return {
+      claim,
+      fetch,
+      ack,
+      block,
+      subscribe
+    };
+  }
+  return {
+    claim: traced(claim, (leased) => {
+      if (leased.length) {
+        const data = Object.fromEntries(
+          leased.map(({ stream, at, retry }) => [stream, { at, retry }])
+        );
+        logger2.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];
+        })
+      );
+      logger2.trace(data, ">> fetch");
+    }),
+    ack: traced(ack, (acked) => {
+      if (acked.length) {
+        const data = Object.fromEntries(
+          acked.map(({ stream, at, retry }) => [stream, { at, retry }])
+        );
+        logger2.trace(data, ">> ack");
+      }
+    }),
+    block: traced(block, (blocked) => {
+      if (blocked.length) {
+        const data = Object.fromEntries(
+          blocked.map(({ stream, at, retry, error }) => [
+            stream,
+            { at, retry, error }
+          ])
+        );
+        logger2.trace(data, ">> block");
+      }
+    }),
+    subscribe: traced(subscribe, (result, streams) => {
+      if (result.subscribed) {
+        const data = streams.map(({ stream }) => stream).join(" ");
+        logger2.trace(`>> correlate ${data}`);
+      }
+    })
+  };
+}
+
 // src/act.ts
-var logger3 = log();
-var tracer = build_tracer(config().logLevel);
 var Act = class {
   constructor(registry, _states = /* @__PURE__ */ new Map(), batchHandlers = /* @__PURE__ */ new Map()) {
     this.registry = registry;
     this._states = _states;
     this._batch_handlers = batchHandlers;
+    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) {
@@ -940,6 +1114,12 @@ var Act = class {
   _static_targets;
   /** Batch handlers for static-target projections (target → handler) */
   _batch_handlers;
+  /** Event-sourcing handlers, optionally wrapped with trace decorators */
+  _es;
+  /** Correlate/drain pipeline ops, optionally wrapped with trace decorators */
+  _cd;
+  /** Logger resolved at construction time (after user port configuration) */
+  _logger = log();
   /**
    * Executes an action on a state instance, committing resulting events.
    *
@@ -1022,7 +1202,7 @@ var Act = class {
    * @see {@link ValidationError}, {@link InvariantError}, {@link ConcurrencyError}
    */
   async do(action2, target, payload, reactingTo, skipValidation = false) {
-    const snapshots = await action(
+    const snapshots = await this._es.action(
       this.registry.actions[action2],
       action2,
       target,
@@ -1048,7 +1228,7 @@ var Act = class {
     } else {
       merged = this._states.get(stateOrName.name) || stateOrName;
     }
-    return await load(merged, stream, callback, asOf);
+    return await this._es.load(merged, stream, callback, asOf);
   }
   /**
    * Queries the event store for events matching a filter.
@@ -1161,7 +1341,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 && logger3.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,
@@ -1183,16 +1363,18 @@ var Act = class {
         at = event.id;
         handled++;
       } catch (error) {
-        logger3.error(error);
-        const block = lease.retry >= options.maxRetries && options.blockOnError;
-        block && logger3.error(`Blocking ${stream} after ${lease.retry} retries.`);
+        this._logger.error(error);
+        const block2 = lease.retry >= options.maxRetries && options.blockOnError;
+        block2 && this._logger.error(
+          `Blocking ${stream} after ${lease.retry} retries.`
+        );
         return {
           lease,
           handled,
           at,
           // only report error when nothing was handled
           error: handled === 0 ? error.message : void 0,
-          block
+          block: block2
         };
       }
     }
@@ -1215,21 +1397,23 @@ var Act = class {
     const stream = lease.stream;
     const events = payloads.map((p) => p.event);
     const at = events.at(-1).id;
-    lease.retry > 0 && logger3.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) {
-      logger3.error(error);
+      this._logger.error(error);
       const { options } = payloads[0];
-      const block = lease.retry >= options.maxRetries && options.blockOnError;
-      block && logger3.error(`Blocking ${stream} after ${lease.retry} retries.`);
+      const block2 = lease.retry >= options.maxRetries && options.blockOnError;
+      block2 && this._logger.error(`Blocking ${stream} after ${lease.retry} retries.`);
       return {
         lease,
         handled: 0,
         at: lease.at,
         error: error.message,
-        block
+        block: block2
       };
     }
   }
@@ -1285,7 +1469,7 @@ var Act = class {
         this._drain_locked = true;
         const lagging = Math.ceil(streamLimit * this._drain_lag2lead_ratio);
         const leading = streamLimit - lagging;
-        const leased = await store().claim(
+        const leased = await this._cd.claim(
           lagging,
           leading,
           randomUUID2(),
@@ -1295,17 +1479,7 @@ var Act = class {
           this._needs_drain = false;
           return { fetched: [], leased: [], acked: [], blocked: [] };
         }
-        const fetched = await Promise.all(
-          leased.map(async ({ stream, source, at, lagging: lagging2 }) => {
-            const events = await this.query_array({
-              stream: source,
-              after: at,
-              limit: eventLimit
-            });
-            return { stream, source, at, lagging: lagging2, events };
-          })
-        );
-        tracer.fetched(fetched);
+        const fetched = await this._cd.fetch(leased, eventLimit);
         const payloadsMap = /* @__PURE__ */ new Map();
         const fetch_window_at = fetched.reduce(
           (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
@@ -1322,7 +1496,6 @@ var Act = class {
           });
           payloadsMap.set(stream, payloads);
         });
-        tracer.leased(leased);
         const handled = await Promise.all(
           leased.map((lease) => {
             const streamFetch = fetched.find((f) => f.stream === lease.stream);
@@ -1346,27 +1519,21 @@ var Act = class {
         const leading_avg = leading > 0 ? leading_handled / leading : 0;
         const total = lagging_avg + leading_avg;
         this._drain_lag2lead_ratio = total > 0 ? Math.max(0.2, Math.min(0.8, lagging_avg / total)) : 0.5;
-        const acked = await store().ack(
+        const acked = await this._cd.ack(
           handled.filter(({ error }) => !error).map(({ at, lease }) => ({ ...lease, at }))
         );
-        if (acked.length) {
-          tracer.acked(acked);
-          this.emit("acked", acked);
-        }
-        const blocked = await store().block(
-          handled.filter(({ block }) => block).map(({ lease, error }) => ({ ...lease, error }))
+        if (acked.length) this.emit("acked", acked);
+        const blocked = await this._cd.block(
+          handled.filter(({ block: block2 }) => block2).map(({ lease, error }) => ({ ...lease, error }))
         );
-        if (blocked.length) {
-          tracer.blocked(blocked);
-          this.emit("blocked", blocked);
-        }
+        if (blocked.length) this.emit("blocked", blocked);
         const result = { fetched, leased, acked, blocked };
         const hasErrors = handled.some(({ error }) => error);
         if (!acked.length && !blocked.length && !hasErrors)
           this._needs_drain = false;
         return result;
       } catch (error) {
-        logger3.error(error);
+        this._logger.error(error);
       } finally {
         this._drain_locked = false;
       }
@@ -1472,10 +1639,9 @@ var Act = class {
         stream,
         source
       }));
-      const { subscribed } = await store().subscribe(streams);
+      const { subscribed } = await this._cd.subscribe(streams);
       this._correlation_checkpoint = last_id;
       if (subscribed) {
-        tracer.correlated(streams);
         for (const { stream } of streams) {
           this._subscribed_statics.add(stream);
         }
@@ -1740,7 +1906,7 @@ var Act = class {
     if (mergedState) {
       await Promise.all(
         guarded.filter((s) => targetMap.get(s)?.restart).map(async (stream) => {
-          const snap2 = await load(mergedState, stream);
+          const snap2 = await this._es.load(mergedState, stream);
           seedStates.set(stream, snap2.state);
         })
       );
@@ -1847,139 +2013,13 @@ var Act = class {
           if (!made_progress) break;
         }
         if (lastDrain) this.emit("settled", lastDrain);
-      })().catch((err) => logger3.error(err)).finally(() => {
+      })().catch((err) => this._logger.error(err)).finally(() => {
         this._settling = false;
       });
     }, debounceMs);
   }
 };
 
-// src/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/act-builder.ts
 function act(states = /* @__PURE__ */ new Map(), registry = {
   actions: {},
@@ -2220,8 +2260,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];
             })
           );
@@ -2322,7 +2363,6 @@ export {
   ValidationError,
   ZodEmpty,
   act,
-  build_tracer,
   cache,
   config,
   dispose,