@kalphq/core 0.0.0-dev-20260507190243

package/dist/chunk-G4LOF3MT.js

@@ -0,0 +1,957 @@
+// src/engine/execution-log.ts
+var ExecutionLog = class {
+  /**
+   * Creates a new execution log backed by the given event store.
+   *
+   * @param eventStore - The store used to persist and load events.
+   */
+  constructor(eventStore) {
+    this.eventStore = eventStore;
+  }
+  /** In-memory buffer of events emitted during the current processing cycle. */
+  buffer = [];
+  /**
+   * Emits a structured execution event.
+   *
+   * The event is immediately persisted via the adapter and buffered in memory
+   * for the current processing cycle.
+   *
+   * @param event - The execution event to emit.
+   */
+  async emit(event) {
+    this.buffer.push(event);
+    await this.eventStore.append(event);
+  }
+  /**
+   * Loads all previously persisted events from the adapter.
+   *
+   * Used for replay, rehydration, and debugging.
+   *
+   * @returns An ordered array of all persisted execution events.
+   */
+  async load() {
+    return this.eventStore.loadAll();
+  }
+  /**
+   * Returns events emitted during the current processing cycle (in-memory only).
+   *
+   * @returns The in-memory event buffer.
+   */
+  getBuffer() {
+    return this.buffer;
+  }
+  /**
+   * Clears the in-memory buffer. Called between processing cycles.
+   */
+  clearBuffer() {
+    this.buffer = [];
+  }
+};
+
+// src/engine/primitives/ai.ts
+function createAIPrimitive(provider, log, execCtx) {
+  const ids = {
+    executionId: execCtx?.executionId ?? "",
+    traceId: execCtx?.traceId ?? "",
+    threadId: execCtx?.threadId ?? ""
+  };
+  return {
+    async generate(params) {
+      const result = await provider.generate(params);
+      await log.emit({
+        type: "primitive.invoked",
+        name: "ai.generate",
+        params: { model: params.model, prompt: params.prompt },
+        result,
+        ...ids,
+        timestamp: Date.now()
+      });
+      return result;
+    },
+    stream(params) {
+      void log.emit({
+        type: "primitive.invoked",
+        name: "ai.stream",
+        params: { model: params.model, prompt: params.prompt },
+        result: "[stream]",
+        ...ids,
+        timestamp: Date.now()
+      });
+      return provider.stream(params);
+    },
+    async classify(params) {
+      const result = await provider.classify(params);
+      await log.emit({
+        type: "primitive.invoked",
+        name: "ai.classify",
+        params: { input: params.input, labels: params.labels },
+        result,
+        ...ids,
+        timestamp: Date.now()
+      });
+      return result;
+    }
+  };
+}
+
+// src/engine/primitives/storage.ts
+function createStoragePrimitive(stateStore, log, execCtx) {
+  const ids = {
+    executionId: execCtx?.executionId ?? "",
+    traceId: execCtx?.traceId ?? "",
+    threadId: execCtx?.threadId ?? ""
+  };
+  return {
+    async get(key) {
+      const value = await stateStore.get(key);
+      await log.emit({
+        type: "state.read",
+        key,
+        value,
+        ...ids,
+        timestamp: Date.now()
+      });
+      return value;
+    },
+    async put(key, value) {
+      await stateStore.set(key, value);
+      await log.emit({
+        type: "state.write",
+        key,
+        value,
+        ...ids,
+        timestamp: Date.now()
+      });
+    },
+    async delete(key) {
+      await stateStore.delete(key);
+      await log.emit({
+        type: "state.write",
+        key,
+        value: void 0,
+        ...ids,
+        timestamp: Date.now()
+      });
+    },
+    async increment(key, amount = 1) {
+      const newValue = await stateStore.increment(key, amount);
+      await log.emit({
+        type: "state.write",
+        key,
+        value: newValue,
+        ...ids,
+        timestamp: Date.now()
+      });
+      return newValue;
+    },
+    async transaction(callback, _options) {
+      return stateStore.transaction(async (tx) => {
+        return callback(tx);
+      });
+    }
+  };
+}
+
+// src/engine/primitives/actions.ts
+function parseDuration(duration) {
+  if (typeof duration === "number") return duration;
+  const match = duration.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i);
+  if (!match) {
+    throw new Error(
+      `Invalid duration format: "${duration}". Expected e.g. "5m", "30s", "1h".`
+    );
+  }
+  const value = parseFloat(match[1]);
+  const unit = match[2].toLowerCase();
+  const multipliers = {
+    ms: 1,
+    s: 1e3,
+    m: 6e4,
+    h: 36e5,
+    d: 864e5
+  };
+  return value * (multipliers[unit] ?? 1);
+}
+function createActionsPrimitive(log, scheduler, dispatch, execCtx) {
+  let loopCounter = 0;
+  const ids = {
+    executionId: execCtx?.executionId ?? "",
+    traceId: execCtx?.traceId ?? "",
+    threadId: execCtx?.threadId ?? ""
+  };
+  return {
+    /**
+     * Emits an `action.run` intent and suspends until the reactor resolves it.
+     * The handler receives a Promise that resolves with the step/tool result.
+     */
+    async run(node, ...args) {
+      const target = `${node.kind}s.${node.id}`;
+      const input = args[0];
+      await log.emit({
+        type: "action.run",
+        target,
+        input,
+        ...ids,
+        timestamp: Date.now()
+      });
+      const result = await dispatch(target, input);
+      await log.emit({
+        type: "action.run.completed",
+        target,
+        result,
+        ...ids,
+        timestamp: Date.now()
+      });
+      return result;
+    },
+    /**
+     * Emits an `action.wait` event, schedules an alarm, and returns.
+     * The host adapter is responsible for re-entering the reactor when the alarm fires.
+     */
+    async wait(duration) {
+      const ms = parseDuration(duration);
+      await log.emit({
+        type: "action.wait",
+        duration,
+        ...ids,
+        timestamp: Date.now()
+      });
+      await scheduler.schedule(Date.now() + ms);
+      return { type: "timeout" };
+    },
+    /**
+     * Runtime-driven loop. Each iteration is a separate event, enabling
+     * persistence, rehydration, cut, pause, and per-iteration billing.
+     */
+    loop(body) {
+      const loopId = `loop_${++loopCounter}_${Date.now()}`;
+      void (async () => {
+        await log.emit({
+          type: "action.loop.start",
+          loopId,
+          ...ids,
+          timestamp: Date.now()
+        });
+        let iteration = 0;
+        while (true) {
+          await log.emit({
+            type: "action.loop.iteration",
+            loopId,
+            iteration,
+            ...ids,
+            timestamp: Date.now()
+          });
+          try {
+            await body();
+          } catch (err) {
+            await log.emit({
+              type: "action.loop.end",
+              loopId,
+              reason: err instanceof Error ? err.message : "error",
+              ...ids,
+              timestamp: Date.now()
+            });
+            break;
+          }
+          iteration++;
+        }
+      })();
+    },
+    /**
+     * Intercepted fetch — logs the request and delegates to globalThis.fetch.
+     */
+    async fetch(input, init) {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+      const start = Date.now();
+      const response = await globalThis.fetch(input, init);
+      const durationMs = Date.now() - start;
+      await log.emit({
+        type: "action.fetch",
+        url,
+        method,
+        status: response.status,
+        durationMs,
+        ...ids,
+        timestamp: Date.now()
+      });
+      return response;
+    },
+    async ask(_prompt, _schema, _options) {
+      await log.emit({
+        type: "action.ask",
+        ...ids,
+        timestamp: Date.now()
+      });
+      return { text: "stub response" };
+    },
+    async requestApproval(_reason, _options) {
+      await log.emit({
+        type: "action.approval",
+        ...ids,
+        timestamp: Date.now()
+      });
+      return true;
+    },
+    emit(eventName, payload, _options) {
+      void log.emit({
+        type: "action.emit",
+        event: eventName,
+        payload,
+        ...ids,
+        timestamp: Date.now()
+      });
+    },
+    async callAgent(contract, input) {
+      await log.emit({
+        type: "action.call",
+        contract: contract.agentId,
+        input,
+        ...ids,
+        timestamp: Date.now()
+      });
+      return {};
+    },
+    /**
+     * Pauses the agent until an external event occurs.
+     * Emits an action.wait event with duration and schedules a timeout alarm if specified.
+     */
+    async waitForEvent(eventName, timeout) {
+      const duration = timeout ? parseDuration(timeout) : 0;
+      await log.emit({
+        type: "action.wait",
+        duration,
+        ...ids,
+        timestamp: Date.now()
+      });
+      if (timeout) {
+        await scheduler.schedule(Date.now() + duration);
+      }
+      return { type: "event", eventName, payload: void 0 };
+    },
+    /**
+     * Pauses the agent until a specific date/time.
+     * Emits an action.wait event with the duration and schedules an alarm for the target time.
+     */
+    async waitUntil(date) {
+      const targetTime = typeof date === "number" ? date : typeof date === "string" ? new Date(date).getTime() : date.getTime();
+      const now = Date.now();
+      const duration = Math.max(0, targetTime - now);
+      await log.emit({
+        type: "action.wait",
+        duration,
+        ...ids,
+        timestamp: Date.now()
+      });
+      await scheduler.schedule(targetTime);
+      return {
+        type: "scheduled_time_reached",
+        scheduledAt: new Date(targetTime).toISOString()
+      };
+    },
+    /**
+     * Schedules a node for future non-blocking execution.
+     * Emits an action.schedule event and schedules the execution via the scheduler.
+     */
+    async schedule(node, date, ...args) {
+      const targetTime = typeof date === "number" ? date : typeof date === "string" ? new Date(date).getTime() : date.getTime();
+      const target = `${node.kind}s.${node.id}`;
+      const input = args[0];
+      const scheduleId = `schedule_${target}_${targetTime}`;
+      await log.emit({
+        type: "action.schedule",
+        at: targetTime,
+        payload: { scheduleId, target, input },
+        ...ids,
+        timestamp: Date.now()
+      });
+      await scheduler.schedule(targetTime);
+      return { scheduleId };
+    }
+  };
+}
+
+// src/engine/primitives/mcp.ts
+function createMcpPrimitive(log, execCtx) {
+  const ids = {
+    executionId: execCtx?.executionId ?? "",
+    traceId: execCtx?.traceId ?? "",
+    threadId: execCtx?.threadId ?? ""
+  };
+  return new Proxy({}, {
+    get(_target, serverName) {
+      return new Proxy(
+        {},
+        {
+          get(_target2, toolName) {
+            return async (input) => {
+              const timestamp = Date.now();
+              void log.emit({
+                type: "primitive.invoked",
+                name: "mcp." + serverName + "." + toolName,
+                params: input,
+                result: void 0,
+                ...ids,
+                timestamp
+              });
+              return { error: "MCP not implemented in core yet" };
+            };
+          }
+        }
+      );
+    }
+  });
+}
+
+// src/engine/primitives/date.ts
+function createDatePrimitive(log, execCtx) {
+  const ids = {
+    executionId: execCtx?.executionId ?? "",
+    traceId: execCtx?.traceId ?? "",
+    threadId: execCtx?.threadId ?? ""
+  };
+  const baseTime = Date.now();
+  return {
+    /**
+     * Get the current time (event timestamp).
+     */
+    now() {
+      return baseTime;
+    },
+    /**
+     * Format the current time as ISO string.
+     */
+    toISOString() {
+      return new Date(baseTime).toISOString();
+    },
+    /**
+     * Check if the original event occurred after the given date.
+     *
+     * @param isoString - ISO 8601 date string to compare against.
+     */
+    isAfter(isoString) {
+      const timestamp = Date.now();
+      void log.emit({
+        type: "primitive.invoked",
+        name: "date.isAfter",
+        params: isoString,
+        result: void 0,
+        ...ids,
+        timestamp
+      });
+      return baseTime > new Date(isoString).getTime();
+    },
+    /**
+     * Add a duration to the current time.
+     *
+     * @param duration - Duration string (e.g., "1h", "30m", "24h") or milliseconds.
+     */
+    add(duration) {
+      const timestamp = Date.now();
+      void log.emit({
+        type: "primitive.invoked",
+        name: "date.add",
+        params: duration,
+        result: void 0,
+        ...ids,
+        timestamp
+      });
+      if (typeof duration === "number") {
+        return baseTime + duration;
+      }
+      const match = duration.match(/^(\d+)([smhd])$/);
+      if (!match) {
+        throw new Error(`Invalid duration format: ${duration}`);
+      }
+      const value = parseInt(match[1], 10);
+      const unit = match[2];
+      if (!unit) {
+        throw new Error(`Invalid duration format: ${duration}`);
+      }
+      const multipliers = {
+        s: 1e3,
+        m: 6e4,
+        h: 36e5,
+        d: 864e5
+      };
+      const multiplier = multipliers[unit];
+      if (!multiplier) {
+        throw new Error(`Invalid duration unit: ${unit}`);
+      }
+      return baseTime + value * multiplier;
+    },
+    /**
+     * Convert the event timestamp to a specific timezone.
+     *
+     * @param tz - IANA timezone identifier.
+     * @returns TimezoneFormatter for the converted time.
+     */
+    timezone(tz) {
+      const formatter = {
+        format(format) {
+          const timestamp = Date.now();
+          void log.emit({
+            type: "primitive.invoked",
+            name: "date.timezone.format",
+            params: { tz, format },
+            result: void 0,
+            ...ids,
+            timestamp
+          });
+          const date = new Date(baseTime);
+          return date.toISOString().replace("T", " ").slice(0, 19);
+        },
+        toISOString() {
+          return new Date(baseTime).toISOString();
+        }
+      };
+      return formatter;
+    }
+  };
+}
+
+// src/engine/primitives/math.ts
+function createMathPrimitive(log, execCtx) {
+  const ids = {
+    executionId: execCtx?.executionId ?? "",
+    traceId: execCtx?.traceId ?? "",
+    threadId: execCtx?.threadId ?? ""
+  };
+  let seed = execCtx?.executionId.split("").reduce((a, c) => a + c.charCodeAt(0), 0) ?? Date.now();
+  return {
+    /**
+     * Deterministic pseudo-random number generator.
+     * Seeded by the execution runId (ULID) for replay consistency.
+     */
+    random() {
+      const timestamp = Date.now();
+      seed = (seed * 9301 + 49297) % 233280;
+      const result = seed / 233280;
+      void log.emit({
+        type: "primitive.invoked",
+        name: "math.random",
+        params: void 0,
+        result,
+        ...ids,
+        timestamp
+      });
+      return result;
+    },
+    /** Round down to nearest integer. */
+    floor(x) {
+      const result = Math.floor(x);
+      const timestamp = Date.now();
+      void log.emit({
+        type: "primitive.invoked",
+        name: "math.floor",
+        params: x,
+        result,
+        ...ids,
+        timestamp
+      });
+      return result;
+    },
+    /** Round up to nearest integer. */
+    ceil(x) {
+      const result = Math.ceil(x);
+      const timestamp = Date.now();
+      void log.emit({
+        type: "primitive.invoked",
+        name: "math.ceil",
+        params: x,
+        result,
+        ...ids,
+        timestamp
+      });
+      return result;
+    },
+    /** Round to nearest integer. */
+    round(x) {
+      const result = Math.round(x);
+      const timestamp = Date.now();
+      void log.emit({
+        type: "primitive.invoked",
+        name: "math.round",
+        params: x,
+        result,
+        ...ids,
+        timestamp
+      });
+      return result;
+    },
+    /** Return smallest of provided values. */
+    min(...values) {
+      const result = Math.min(...values);
+      const timestamp = Date.now();
+      void log.emit({
+        type: "primitive.invoked",
+        name: "math.min",
+        params: values,
+        result,
+        ...ids,
+        timestamp
+      });
+      return result;
+    },
+    /** Return largest of provided values. */
+    max(...values) {
+      const result = Math.max(...values);
+      const timestamp = Date.now();
+      void log.emit({
+        type: "primitive.invoked",
+        name: "math.max",
+        params: values,
+        result,
+        ...ids,
+        timestamp
+      });
+      return result;
+    },
+    /** Return absolute value. */
+    abs(x) {
+      const result = Math.abs(x);
+      const timestamp = Date.now();
+      void log.emit({
+        type: "primitive.invoked",
+        name: "math.abs",
+        params: x,
+        result,
+        ...ids,
+        timestamp
+      });
+      return result;
+    },
+    /** Return base to the power of exponent. */
+    pow(base, exponent) {
+      const result = Math.pow(base, exponent);
+      const timestamp = Date.now();
+      void log.emit({
+        type: "primitive.invoked",
+        name: "math.pow",
+        params: { base, exponent },
+        result,
+        ...ids,
+        timestamp
+      });
+      return result;
+    },
+    /** Return square root. */
+    sqrt(x) {
+      const result = Math.sqrt(x);
+      const timestamp = Date.now();
+      void log.emit({
+        type: "primitive.invoked",
+        name: "math.sqrt",
+        params: x,
+        result,
+        ...ids,
+        timestamp
+      });
+      return result;
+    }
+  };
+}
+
+// src/engine/primitives/agent-meta.ts
+function createAgentMetaPrimitive(log, execCtx, agentConfig) {
+  return {
+    agentId: execCtx?.executionId ?? "unknown",
+    runId: execCtx?.traceId ?? "unknown",
+    name: agentConfig?.name ?? "unknown",
+    systemPrompt: agentConfig?.systemPrompt ?? "",
+    metadata: agentConfig?.metadata
+  };
+}
+
+// src/engine/context-builder.ts
+function buildHandlerContext(log, stateStore, scheduler, dispatch, providers, execCtx, agentConfig) {
+  const ids = {
+    executionId: execCtx?.executionId ?? "",
+    traceId: execCtx?.traceId ?? "",
+    threadId: execCtx?.threadId ?? ""
+  };
+  return {
+    ai: createAIPrimitive(providers.ai, log),
+    storage: createStoragePrimitive(stateStore, log, execCtx),
+    actions: createActionsPrimitive(log, scheduler, dispatch, execCtx),
+    auth: providers.auth,
+    memory: providers.memory,
+    vault: providers.vault,
+    mcp: createMcpPrimitive(log, execCtx),
+    agent: createAgentMetaPrimitive(log, execCtx, agentConfig),
+    date: createDatePrimitive(log, execCtx),
+    math: createMathPrimitive(log, execCtx),
+    log: {
+      debug: (msg, data) => void log.emit({
+        type: "log",
+        level: "debug",
+        msg,
+        data,
+        ...ids,
+        timestamp: Date.now()
+      }),
+      info: (msg, data) => void log.emit({
+        type: "log",
+        level: "info",
+        msg,
+        data,
+        ...ids,
+        timestamp: Date.now()
+      }),
+      warn: (msg, data) => void log.emit({
+        type: "log",
+        level: "warn",
+        msg,
+        data,
+        ...ids,
+        timestamp: Date.now()
+      }),
+      error: (err, data) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        const errorData = err instanceof Error ? { ...data, stack: err.stack } : data;
+        void log.emit({
+          type: "log",
+          level: "error",
+          msg,
+          data: errorData,
+          ...ids,
+          timestamp: Date.now()
+        });
+      }
+    }
+  };
+}
+
+// src/engine/reactor.ts
+var OrchestrationReactor = class {
+  /** The execution log (single source of truth). */
+  log;
+  /** The IR graph (structural index only). */
+  ir;
+  /** Internal task queue. */
+  queue = [];
+  /** Bundled handler modules keyed by moduleRef. */
+  bundles;
+  /** Composite persistence adapter (state, events, idempotency, threads). */
+  persistence;
+  /** Scheduler adapter (alarms). */
+  scheduler;
+  /** External providers (ai, auth, memory, vault). */
+  providers;
+  /** Result of the last completed handler. */
+  lastResult = void 0;
+  /** Opaque thread identifier (set by adapter via RuntimeEvent.threadId). */
+  threadId = "";
+  /**
+   * Creates a new reactor instance.
+   *
+   * @param ir - The compiled IR graph.
+   * @param bundles - Map from moduleRef to bundled handler module.
+   * @param persistence - Persistence adapter for state and event log.
+   * @param scheduler - Scheduler adapter for deferred wake-ups.
+   * @param providers - External providers for ai, auth, memory, vault.
+   */
+  constructor(ir, bundles, persistence, scheduler, providers) {
+    this.ir = ir;
+    this.bundles = bundles;
+    this.persistence = persistence;
+    this.scheduler = scheduler;
+    this.providers = providers;
+    this.log = new ExecutionLog(persistence.events);
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+  // Public API (called by host adapter)
+  // ──────────────────────────────────────────────────────────────────────────
+  /**
+   * Handles an external event by resolving the IR entry and processing
+   * the handler chain until the queue is empty.
+   *
+   * @param event - The external runtime event.
+   * @returns The result of the last completed handler.
+   * @throws If no entry exists for the event type.
+   */
+  async handleEvent(event) {
+    const entryId = this.ir.entries[event.type];
+    if (!entryId) {
+      throw new Error(`No entry for event: ${event.type}`);
+    }
+    if (event.threadId) {
+      this.threadId = event.threadId;
+    }
+    const traceId = crypto.randomUUID();
+    await this.log.emit({
+      type: "node.started",
+      nodeId: entryId,
+      executionId: "",
+      traceId,
+      threadId: this.threadId,
+      timestamp: Date.now()
+    });
+    this.queue.push({ nodeId: entryId, context: event.payload });
+    await this.processUntilIdle();
+    return this.lastResult;
+  }
+  /**
+   * Drains the task queue. Called internally after handleEvent and recursively
+   * after actions.run dispatches. When the queue is empty, control returns to
+   * the host adapter.
+   */
+  async processUntilIdle() {
+    while (this.queue.length > 0) {
+      const task = this.queue.shift();
+      await this.processTask(task);
+    }
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+  // Internal task processing
+  // ──────────────────────────────────────────────────────────────────────────
+  /**
+   * Processes a single task from the queue.
+   *
+   * - **Entry nodes**: traverse sequential edges to find the handler.
+   * - **Handler nodes**: build context, execute handler, emit events.
+   */
+  async processTask(task) {
+    const node = this.ir.nodes[task.nodeId];
+    if (!node) {
+      await this.log.emit({
+        type: "error",
+        nodeId: task.nodeId,
+        error: `Node "${task.nodeId}" not found in IR.`,
+        executionId: "",
+        traceId: "",
+        threadId: this.threadId,
+        timestamp: Date.now()
+      });
+      return;
+    }
+    switch (node.kind) {
+      case "entry": {
+        this.enqueueSuccessors(task.nodeId, task.context);
+        break;
+      }
+      case "handler": {
+        const executionId = crypto.randomUUID();
+        await this.log.emit({
+          type: "node.started",
+          nodeId: node.id,
+          executionId,
+          traceId: "",
+          threadId: this.threadId,
+          timestamp: Date.now()
+        });
+        const handlerModule = this.bundles.get(node.moduleRef);
+        if (!handlerModule) {
+          await this.log.emit({
+            type: "error",
+            nodeId: node.id,
+            error: `Handler module "${node.moduleRef}" not found in bundles.`,
+            executionId,
+            traceId: "",
+            threadId: this.threadId,
+            timestamp: Date.now()
+          });
+          return;
+        }
+        const dispatch = this.createDispatch();
+        const ctx = buildHandlerContext(
+          this.log,
+          this.persistence.state,
+          this.scheduler,
+          dispatch,
+          this.providers,
+          {
+            executionId,
+            traceId: "",
+            threadId: this.threadId,
+            untrackedIOCount: 0,
+            untrackedIOByType: { network: 0, timer: 0, fs: 0, unknown: 0 },
+            hasUntrustedPlugins: false
+          }
+        );
+        try {
+          const result = await handlerModule.default(ctx, task.context);
+          await this.log.emit({
+            type: "node.completed",
+            nodeId: node.id,
+            result,
+            executionId,
+            traceId: "",
+            threadId: this.threadId,
+            timestamp: Date.now()
+          });
+          this.lastResult = result;
+          if (task.resolve) {
+            task.resolve(result);
+          }
+          this.enqueueSuccessors(task.nodeId, {
+            ...task.context,
+            result
+          });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          await this.log.emit({
+            type: "error",
+            nodeId: node.id,
+            error: message,
+            executionId,
+            traceId: "",
+            threadId: this.threadId,
+            timestamp: Date.now()
+          });
+          throw err;
+        }
+        break;
+      }
+    }
+  }
+  /**
+   * Enqueues all successor nodes connected by outgoing edges from the given node.
+   *
+   * @param nodeId - The source node ID.
+   * @param context - The context to pass to successor tasks.
+   */
+  enqueueSuccessors(nodeId, context) {
+    const outEdges = this.ir.edges.filter((e) => e.from === nodeId);
+    for (const edge of outEdges) {
+      this.queue.push({ nodeId: edge.to, context });
+    }
+  }
+  /**
+   * Creates a dispatch function for actions.run.
+   *
+   * When a handler calls `actions.run(step, input)`, this function:
+   * 1. Looks up the handler node by moduleRef in the IR.
+   * 2. Creates a task with a resolve callback.
+   * 3. Returns a Promise that resolves when the task completes.
+   */
+  createDispatch() {
+    return (moduleRef, input) => {
+      const handlerNodeId = this.ir.handlerIndex[moduleRef];
+      if (!handlerNodeId) {
+        return Promise.reject(
+          new Error(
+            `Cannot dispatch: handler "${moduleRef}" not found in IR. Ensure it is statically imported at the top level.`
+          )
+        );
+      }
+      return new Promise((resolve) => {
+        this.queue.push({
+          nodeId: handlerNodeId,
+          context: input,
+          resolve
+        });
+      });
+    };
+  }
+};
+
+export {
+  ExecutionLog,
+  createAIPrimitive,
+  createStoragePrimitive,
+  createActionsPrimitive,
+  buildHandlerContext,
+  OrchestrationReactor
+};
+//# sourceMappingURL=chunk-G4LOF3MT.js.map