@rotorsoft/act 0.31.1 → 0.32.1

package/dist/index.js

@@ -1,3 +1,20 @@
+import {
+  ActorSchema,
+  CausationEventSchema,
+  CommittedMetaSchema,
+  ConcurrencyError,
+  Environments,
+  Errors,
+  EventMetaSchema,
+  InvariantError,
+  LogLevels,
+  QuerySchema,
+  StreamClosedError,
+  TargetSchema,
+  ValidationError,
+  ZodEmpty
+} from "./chunk-JBKZJXQZ.js";
+
 // src/adapters/ConsoleLogger.ts
 var LEVEL_VALUES = {
   fatal: 60,
@@ -136,141 +153,29 @@ var InMemoryCache = class {
   }
 };
 
-// src/types/errors.ts
-var Errors = {
-  ValidationError: "ERR_VALIDATION",
-  InvariantError: "ERR_INVARIANT",
-  ConcurrencyError: "ERR_CONCURRENCY",
-  StreamClosedError: "ERR_STREAM_CLOSED"
-};
-var ValidationError = class extends Error {
-  constructor(target, payload, details) {
-    super(`Invalid ${target} payload`);
-    this.target = target;
-    this.payload = payload;
-    this.details = details;
-    this.name = Errors.ValidationError;
-  }
-};
-var InvariantError = class extends Error {
-  constructor(action2, payload, target, snapshot, description) {
-    super(`${action2} failed invariant: ${description}`);
-    this.action = action2;
-    this.payload = payload;
-    this.target = target;
-    this.snapshot = snapshot;
-    this.description = description;
-    this.name = Errors.InvariantError;
-  }
-};
-var StreamClosedError = class extends Error {
-  constructor(stream) {
-    super(`Stream "${stream}" is closed (tombstoned)`);
-    this.stream = stream;
-    this.name = Errors.StreamClosedError;
-  }
-};
-var ConcurrencyError = class extends Error {
-  constructor(stream, lastVersion, events, expectedVersion) {
-    super(
-      `Concurrency error committing "${events.map((e) => `${stream}.${e.name}.${JSON.stringify(e.data)}`).join(
-        ", "
-      )}". Expected version ${expectedVersion} but found version ${lastVersion}.`
-    );
-    this.stream = stream;
-    this.lastVersion = lastVersion;
-    this.events = events;
-    this.expectedVersion = expectedVersion;
-    this.name = Errors.ConcurrencyError;
-  }
-};
-
 // src/utils.ts
 import { prettifyError } from "zod";
 
 // src/config.ts
 import * as fs from "fs";
-import { z as z2 } from "zod";
-
-// src/types/schemas.ts
 import { z } from "zod";
-var ZodEmpty = z.record(z.string(), z.never());
-var ActorSchema = z.object({
-  id: z.string(),
-  name: z.string()
-}).loose().readonly();
-var TargetSchema = z.object({
-  stream: z.string(),
-  actor: ActorSchema,
-  expectedVersion: z.number().optional()
-}).loose().readonly();
-var CausationEventSchema = z.object({
-  id: z.number(),
-  name: z.string(),
-  stream: z.string()
-});
-var EventMetaSchema = z.object({
-  correlation: z.string(),
-  causation: z.object({
-    action: TargetSchema.and(z.object({ name: z.string() })).optional(),
-    event: CausationEventSchema.optional()
-  })
-}).readonly();
-var CommittedMetaSchema = z.object({
-  id: z.number(),
-  stream: z.string(),
-  version: z.number(),
-  created: z.date(),
-  meta: EventMetaSchema
-}).readonly();
-var QuerySchema = z.object({
-  stream: z.string().optional(),
-  names: z.string().array().optional(),
-  before: z.number().optional(),
-  after: z.number().optional(),
-  limit: z.number().optional(),
-  created_before: z.date().optional(),
-  created_after: z.date().optional(),
-  backward: z.boolean().optional(),
-  correlation: z.string().optional(),
-  with_snaps: z.boolean().optional(),
-  stream_exact: z.boolean().optional()
-}).readonly();
-
-// src/types/index.ts
-var Environments = [
-  "development",
-  "test",
-  "staging",
-  "production"
-];
-var LogLevels = [
-  "fatal",
-  "error",
-  "warn",
-  "info",
-  "debug",
-  "trace"
-];
-
-// src/config.ts
-var PackageSchema = z2.object({
-  name: z2.string().min(1),
-  version: z2.string().min(1),
-  description: z2.string().min(1).optional(),
-  author: z2.object({ name: z2.string().min(1), email: z2.string().optional() }).optional().or(z2.string().min(1)).optional(),
-  license: z2.string().min(1).optional(),
-  dependencies: z2.record(z2.string(), z2.string()).optional()
+var PackageSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().min(1),
+  description: z.string().min(1).optional(),
+  author: z.object({ name: z.string().min(1), email: z.string().optional() }).optional().or(z.string().min(1)).optional(),
+  license: z.string().min(1).optional(),
+  dependencies: z.record(z.string(), z.string()).optional()
 });
 var getPackage = () => {
   const pkg2 = fs.readFileSync("package.json");
   return JSON.parse(pkg2.toString());
 };
 var BaseSchema = PackageSchema.extend({
-  env: z2.enum(Environments),
-  logLevel: z2.enum(LogLevels),
-  logSingleLine: z2.boolean(),
-  sleepMs: z2.number().int().min(0).max(5e3)
+  env: z.enum(Environments),
+  logLevel: z.enum(LogLevels),
+  logSingleLine: z.boolean(),
+  sleepMs: z.number().int().min(0).max(5e3)
 });
 var { NODE_ENV, LOG_LEVEL, LOG_SINGLE_LINE, SLEEP_MS } = process.env;
 var env = NODE_ENV || "development";
@@ -743,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();
@@ -824,14 +672,33 @@ process.once("unhandledRejection", async (arg) => {
 import { randomUUID as randomUUID2 } from "crypto";
 import EventEmitter from "events";
 
-// src/event-sourcing.ts
+// 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 }],
       {
@@ -841,7 +708,6 @@ 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);
   }
@@ -853,7 +719,7 @@ async function load(me, stream, callback, asOf) {
   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) {
@@ -872,10 +738,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) {
@@ -886,10 +748,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 }) => {
@@ -929,10 +787,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(
@@ -968,14 +822,257 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   return snapshots;
 }
 
-// src/act.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) {
+  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 tracer = build_tracer(config().logLevel);
+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") {
+    return { snap, load, action };
+  }
+  return {
+    snap: withSnapTrace(snap),
+    load: withLoadTrace(load),
+    action: withActionTrace(action)
+  };
+}
+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") {
+    return {
+      claim,
+      fetch,
+      ack,
+      block,
+      subscribe
+    };
+  }
+  return {
+    claim: withClaimTrace(claim),
+    fetch: withFetchTrace(fetch),
+    ack: withAckTrace(ack),
+    block: withBlockTrace(block),
+    subscribe: withSubscribeTrace(subscribe)
+  };
+}
+
+// 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);
     const statics = [];
     for (const [name, register] of Object.entries(this.registry.events)) {
       if (register.reactions.size > 0) {
@@ -1035,6 +1132,10 @@ 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;
   /**
    * Executes an action on a state instance, committing resulting events.
    *
@@ -1117,7 +1218,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,
@@ -1143,7 +1244,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.
@@ -1256,7 +1357,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 && logger4.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
     const doAction = this.do.bind(this);
     const scopedApp = {
       do: doAction,
@@ -1278,16 +1379,16 @@ 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.`);
+        logger4.error(error);
+        const block2 = lease.retry >= options.maxRetries && options.blockOnError;
+        block2 && logger4.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
         };
       }
     }
@@ -1310,21 +1411,21 @@ 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 && logger4.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);
+      logger4.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 && logger4.error(`Blocking ${stream} after ${lease.retry} retries.`);
       return {
         lease,
         handled: 0,
         at: lease.at,
         error: error.message,
-        block
+        block: block2
       };
     }
   }
@@ -1380,7 +1481,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(),
@@ -1390,17 +1491,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),
@@ -1417,7 +1508,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);
@@ -1441,27 +1531,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);
+        logger4.error(error);
       } finally {
         this._drain_locked = false;
       }
@@ -1567,10 +1651,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);
         }
@@ -1835,7 +1918,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);
         })
       );
@@ -1942,139 +2025,13 @@ var Act = class {
           if (!made_progress) break;
         }
         if (lastDrain) this.emit("settled", lastDrain);
-      })().catch((err) => logger3.error(err)).finally(() => {
+      })().catch((err) => logger4.error(err)).finally(() => {
         this._settling = false;
       });
     }, debounceMs);
   }
 };
 
-// src/merge.ts
-import { ZodObject as ZodObject2 } 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 ZodObject2 && incoming instanceof ZodObject2) {
-    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: {},
@@ -2417,7 +2374,6 @@ export {
   ValidationError,
   ZodEmpty,
   act,
-  build_tracer,
   cache,
   config,
   dispose,