@rotorsoft/act 0.7.0 → 0.8.0

package/dist/index.js

@@ -564,6 +564,9 @@ process.once("unhandledRejection", async (arg) => {
   await disposeAndExit("ERROR");
 });
 
+// src/act-builder.ts
+import { ZodObject as ZodObject2 } from "zod";
+
 // src/act.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import EventEmitter from "events";
@@ -811,47 +814,15 @@ var Act = class {
     this.emit("committed", snapshots);
     return snapshots;
   }
-  /**
-   * Loads the current state snapshot for a specific stream.
-   *
-   * Reconstructs the current state by replaying events from the event store.
-   * Uses snapshots when available to optimize loading performance.
-   *
-   * @template SX - State schema type
-   * @template EX - Event schemas type
-   * @template AX - Action schemas type
-   * @param state - The state definition to load
-   * @param stream - The stream ID (state instance identifier)
-   * @param callback - Optional callback invoked with the loaded snapshot
-   * @returns The current state snapshot for the stream
-   *
-   * @example Load current state
-   * ```typescript
-   * const snapshot = await app.load(Counter, "counter-1");
-   * console.log(snapshot.state.count);    // Current count
-   * console.log(snapshot.version);        // Number of events applied
-   * console.log(snapshot.patches);        // Events since last snapshot
-   * ```
-   *
-   * @example With callback
-   * ```typescript
-   * const snapshot = await app.load(User, "user-123", (snap) => {
-   *   console.log("Loaded user:", snap.state.name);
-   * });
-   * ```
-   *
-   * @example Load multiple states
-   * ```typescript
-   * const [user, account] = await Promise.all([
-   *   app.load(User, "user-123"),
-   *   app.load(BankAccount, "account-456")
-   * ]);
-   * ```
-   *
-   * @see {@link Snapshot} for snapshot structure
-   */
-  async load(state2, stream, callback) {
-    const merged = this._states.get(state2.name) || state2;
+  async load(stateOrName, stream, callback) {
+    let merged;
+    if (typeof stateOrName === "string") {
+      const found = this._states.get(stateOrName);
+      if (!found) throw new Error(`State "${stateOrName}" not found`);
+      merged = found;
+    } else {
+      merged = this._states.get(stateOrName.name) || stateOrName;
+    }
     return await load(merged, stream, callback);
   }
   /**
@@ -1077,7 +1048,8 @@ var Act = class {
           );
           fetched.forEach(({ stream, lagging: lagging2, events }) => {
             const payloads = events.flatMap((event) => {
-              const register = this.registry.events[event.name] || [];
+              const register = this.registry.events[event.name];
+              if (!register) return [];
               return [...register.reactions.values()].filter((reaction) => {
                 const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
                 return resolved && resolved.target === stream;
@@ -1310,6 +1282,35 @@ var Act = class {
 };
 
 // src/act-builder.ts
+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() });
+}
 var _this_ = ({ stream }) => ({
   source: stream,
   target: stream
@@ -1344,6 +1345,8 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
         }
         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: { ...existing.patch, ...state2.patch },