@kalphq/core 0.1.0

package/dist/reactor-Brv_eUBE.d.ts

@@ -0,0 +1,742 @@
+import { IRNodeId, KalpAI, KalpActions, KalpAuth, KalpMemory, KalpVault, HandlerContext, IRGraph } from '@kalphq/sdk';
+
+/**
+ * Core runtime types for the Kalp v2 Orchestration Reactor.
+ *
+ * These types define the execution event model, task primitives, and runtime
+ * event contracts. They are intentionally infrastructure-agnostic — no
+ * Cloudflare, Durable Object, or platform-specific types appear here.
+ *
+ * @module
+ */
+
+/**
+ * Categories of untracked IO that Kalp can detect (best-effort).
+ *
+ * - `"network"` — bare `globalThis.fetch` or similar outside `actions.fetch`.
+ * - `"timer"` — `setTimeout` / `setInterval` outside `actions.wait`.
+ * - `"fs"` — Node `fs` access (not applicable in all runtimes; kept for portability).
+ * - `"unknown"` — anything else the heuristic can’t classify.
+ */
+type UntrackedIOSource = "network" | "timer" | "fs" | "unknown";
+/**
+ * Execution identity carried through every handler invocation.
+ *
+ * Hierarchy:
+ * ```
+ * thread = actor instance (identified by threadId)
+ *   +-- trace = one handleEvent() call into the actor
+ *         +-- execution = one handler invocation (step/tool/lifecycle run)
+ * ```
+ *
+ * `threadId` is opaque in Core. The adapter maps it to infrastructure
+ * (e.g. Durable Object id, in-memory key). Core never parses or assumes its format.
+ */
+interface ExecutionContext {
+    /** Unique per handler invocation (UUID). Distinguishes retries, loop iterations. */
+    executionId: string;
+    /** Per `handleEvent()` call. Groups all executions from one external stimulus. */
+    traceId: string;
+    /** Opaque actor identifier. Adapter maps to infrastructure (CF: DO id, tests: in-memory). */
+    threadId: string;
+    /** Total count of detected untracked IO operations. */
+    untrackedIOCount: number;
+    /** Breakdown of untracked IO by source type. */
+    untrackedIOByType: Record<UntrackedIOSource, number>;
+    /** Whether any plugin has been loaded (observability may be incomplete). */
+    hasUntrustedPlugins: boolean;
+}
+/**
+ * Union of all structured events emitted during agent execution.
+ *
+ * Every runtime operation MUST emit an event. If it doesn't emit an event,
+ * it doesn't exist in the system. This is the fundamental invariant.
+ *
+ * These events enable: replay, debugging, billing, observability, and
+ * deterministic re-execution.
+ */
+type ExecutionEvent = {
+    type: "node.started";
+    nodeId: IRNodeId;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "node.completed";
+    nodeId: IRNodeId;
+    result: unknown;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "primitive.invoked";
+    name: string;
+    params: unknown;
+    result: unknown;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.run";
+    target: string;
+    input: unknown;
+    idempotencyKey?: string;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.run.completed";
+    target: string;
+    result: unknown;
+    idempotencyKey?: string;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.wait";
+    duration: string | number;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.loop.start";
+    loopId: string;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.loop.iteration";
+    loopId: string;
+    iteration: number;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.loop.end";
+    loopId: string;
+    reason: string;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.fetch";
+    url: string;
+    method: string;
+    status: number;
+    durationMs: number;
+    idempotencyKey?: string;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.emit";
+    event: string;
+    payload: unknown;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.schedule";
+    at: number;
+    payload: unknown;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "state.write";
+    key: string;
+    value: unknown;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "state.read";
+    key: string;
+    value: unknown;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.ask";
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.approval";
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "action.call";
+    contract: string;
+    input: unknown;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "execution.untracked";
+    source: UntrackedIOSource;
+    location?: string;
+    nodeId?: IRNodeId;
+    action?: string;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "log";
+    level: "debug" | "info" | "warn" | "error";
+    msg: string;
+    data?: Record<string, unknown>;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+} | {
+    type: "error";
+    nodeId?: IRNodeId;
+    error: string;
+    executionId: string;
+    traceId: string;
+    threadId: string;
+    timestamp: number;
+};
+/**
+ * An external event that enters the reactor from the host adapter.
+ * Each event maps to an entry in the IR via `type` → `ir.entries[type]`.
+ */
+interface RuntimeEvent {
+    /** Event name matching an IR entry key (e.g. "onMessage", "route:GET:/health"). */
+    type: string;
+    /** Arbitrary payload associated with the event. */
+    payload: unknown;
+    /** Opaque thread identifier. Adapter sets this from infrastructure (DO id, etc.). */
+    threadId?: string;
+}
+/**
+ * A task in the reactor's internal execution queue.
+ * Created when a node needs to be processed (entry traversal, handler execution, etc.).
+ */
+interface ExecutionTask {
+    /** The IR node to process. */
+    nodeId: IRNodeId;
+    /** Context data passed to the handler. */
+    context: unknown;
+    /**
+     * Optional resolve callback for action.run intent pattern.
+     * When a handler calls `actions.run(step, input)`, the reactor creates a
+     * task with a resolve function. The handler's Promise awaits this resolve.
+     */
+    resolve?: (result: unknown) => void;
+}
+/**
+ * The runtime representation of a bundled handler module.
+ *
+ * Each handler is an isolated function that receives a {@link HandlerContext}
+ * (from `@kalphq/sdk`) and returns a result. The reactor executes these in a
+ * sandboxed context with intercepted primitives.
+ */
+interface HandlerModule {
+    /** The handler's entry function. */
+    default: (context: unknown, input?: unknown) => Promise<unknown>;
+}
+
+/**
+ * Adapter interfaces for the Kalp v2 Orchestration Reactor.
+ *
+ * These contracts decouple the runtime core from any specific infrastructure.
+ * The reactor never touches storage, scheduling, or transport directly —
+ * it always goes through these interfaces.
+ *
+ * Implementations:
+ * - Cloudflare DO adapter (DurableObjectStorage, Alarms, fetch)
+ * - InMemory adapter (Maps, timeouts) — local dev / tests
+ *
+ * @module
+ */
+
+/**
+ * KV-like state store for agent runtime data.
+ *
+ * Supports get/set/delete and atomic transactions. Co-located with the
+ * actor — adapters decide backing store (DO storage, Redis, in-memory).
+ */
+interface StateStore {
+    /**
+     * Reads a value from state.
+     *
+     * @param key - The state key.
+     * @returns The stored value, or `null` if not found.
+     */
+    get(key: string): Promise<unknown>;
+    /**
+     * Writes a value to state.
+     *
+     * @param key - The state key.
+     * @param value - The value to store (must be JSON-serializable).
+     */
+    set(key: string, value: unknown): Promise<void>;
+    /**
+     * Deletes a key from state.
+     *
+     * @param key - The state key to delete.
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Atomically increments a numeric value.
+     *
+     * @param key - The key to increment.
+     * @param amount - The amount to add.
+     * @returns The new value.
+     */
+    increment(key: string, amount: number): Promise<number>;
+    /**
+     * Executes a function within an atomic transaction.
+     *
+     * @param fn - The transactional function receiving a scoped store.
+     * @returns The transaction's return value.
+     */
+    transaction<T>(fn: (tx: StateStore) => Promise<T>): Promise<T>;
+}
+/**
+ * Append-only execution event log.
+ *
+ * All structured events flow through this store. It is the system's source
+ * of truth for replay, debugging, and observability.
+ */
+interface EventStore {
+    /**
+     * Appends a structured event to the execution log.
+     * Events are append-only and ordered by insertion time.
+     *
+     * @param event - The execution event to persist.
+     */
+    append(event: ExecutionEvent): Promise<void>;
+    /**
+     * Loads all events from the execution log, ordered by insertion.
+     * Used for replay, debugging, and rehydration.
+     *
+     * @returns An ordered array of all persisted execution events.
+     */
+    loadAll(): Promise<ExecutionEvent[]>;
+    /**
+     * Loads events filtered by thread ID.
+     *
+     * @param threadId - The thread to filter by.
+     * @returns Events belonging to the specified thread.
+     */
+    loadByThread(threadId: string): Promise<ExecutionEvent[]>;
+    /**
+     * Loads events filtered by trace ID.
+     *
+     * @param traceId - The trace to filter by.
+     * @returns Events belonging to the specified trace.
+     */
+    loadByTrace(traceId: string): Promise<ExecutionEvent[]>;
+}
+/**
+ * KV store with TTL for idempotency deduplication.
+ *
+ * Actor-scoped (not global). Stored via the adapter's backing store.
+ * Zero race conditions since the actor is single-threaded.
+ */
+interface IdempotencyStore {
+    /**
+     * Retrieves a cached result by idempotency key.
+     *
+     * @param key - The composite idempotency key.
+     * @returns The cached result, or `null` if not found or expired.
+     */
+    get(key: string): Promise<unknown | null>;
+    /**
+     * Stores a result with an optional TTL.
+     *
+     * @param key - The composite idempotency key.
+     * @param result - The result to cache.
+     * @param opts - Optional settings (TTL in milliseconds).
+     */
+    set(key: string, result: unknown, opts?: {
+        ttlMs?: number;
+    }): Promise<void>;
+}
+/**
+ * Thread metadata store.
+ *
+ * Stores and retrieves metadata associated with a thread (actor instance).
+ */
+interface ThreadStore {
+    /**
+     * Retrieves metadata for a thread.
+     *
+     * @param threadId - The thread identifier.
+     * @returns The thread metadata, or `null` if not set.
+     */
+    getMeta(threadId: string): Promise<Record<string, unknown> | null>;
+    /**
+     * Stores metadata for a thread.
+     *
+     * @param threadId - The thread identifier.
+     * @param meta - The metadata to store.
+     */
+    setMeta(threadId: string, meta: Record<string, unknown>): Promise<void>;
+}
+/**
+ * Composite persistence adapter decomposed into specialized sub-stores.
+ *
+ * This prevents a single monolithic adapter from hiding 4 different
+ * storage patterns behind one interface. Each sub-store has clear semantics.
+ */
+interface PersistenceAdapter {
+    /** KV-like state store (get/set/delete/transaction). */
+    state: StateStore;
+    /** Append-only execution event log. */
+    events: EventStore;
+    /** KV with TTL for idempotency deduplication. */
+    idempotency: IdempotencyStore;
+    /** Thread metadata store. */
+    threads: ThreadStore;
+}
+/**
+ * Scheduler adapter for deferred execution (alarms, timers).
+ *
+ * Used by `actions.wait`, `actions.loop`, and `actions.schedule` for future
+ * wake-ups. The adapter is responsible for persisting the alarm and re-entering
+ * the reactor when it fires.
+ *
+ * Adapters may have limitations (e.g. CF: 1 alarm per DO). Core handles
+ * multi-schedule queuing in {@link StateStore}; adapter fires one at a time.
+ *
+ * **Best-effort timing** — scheduled events are approximate, not guaranteed
+ * to fire at the exact requested time.
+ */
+interface SchedulerAdapter {
+    /**
+     * Schedules a wake-up at the given timestamp (ms since epoch).
+     * If an alarm already exists, it should be replaced.
+     *
+     * @param at - Unix timestamp in milliseconds for the wake-up.
+     */
+    schedule(at: number): Promise<void>;
+    /**
+     * Cancels any pending scheduled wake-up.
+     */
+    cancel(): Promise<void>;
+}
+/**
+ * Transport adapter for sending responses back to the caller.
+ *
+ * Used when the reactor needs to push data to a connected client
+ * (e.g. WebSocket message, streaming response).
+ */
+interface TransportAdapter {
+    /**
+     * Sends a response payload to the connected client.
+     *
+     * @param response - The data to send (will be JSON-serialized).
+     */
+    send(response: unknown): Promise<void>;
+}
+/**
+ * Adapter for cross-thread (cross-actor) messaging.
+ *
+ * Core never uses HTTP semantics directly. The adapter maps to the
+ * appropriate transport (CF: fetch to DO, Node: IPC, tests: direct call).
+ */
+interface CrossThreadAdapter {
+    /**
+     * Sends an event to another thread (actor).
+     *
+     * @param targetThreadId - The target thread's opaque identifier.
+     * @param event - The event name.
+     * @param payload - The event payload.
+     */
+    send(targetThreadId: string, event: string, payload: unknown): Promise<void>;
+}
+
+/**
+ * Structured execution log for the Kalp v2 Orchestration Reactor.
+ *
+ * The execution log is the system's source of truth. Every runtime operation
+ * emits a structured event that is persisted via the {@link PersistenceAdapter}.
+ * This enables replay, time-travel debugging, billing, and observability.
+ *
+ * Rule: **If it doesn't emit an event, it doesn't exist.**
+ *
+ * @module
+ */
+
+/**
+ * Append-only structured event log backed by an {@link EventStore}.
+ *
+ * All reactor operations flow through this class. It provides a unified
+ * interface for emitting and loading events regardless of the underlying
+ * storage mechanism.
+ */
+declare class ExecutionLog {
+    private eventStore;
+    /** In-memory buffer of events emitted during the current processing cycle. */
+    private buffer;
+    /**
+     * Creates a new execution log backed by the given event store.
+     *
+     * @param eventStore - The store used to persist and load events.
+     */
+    constructor(eventStore: EventStore);
+    /**
+     * 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.
+     */
+    emit(event: ExecutionEvent): Promise<void>;
+    /**
+     * Loads all previously persisted events from the adapter.
+     *
+     * Used for replay, rehydration, and debugging.
+     *
+     * @returns An ordered array of all persisted execution events.
+     */
+    load(): Promise<ExecutionEvent[]>;
+    /**
+     * Returns events emitted during the current processing cycle (in-memory only).
+     *
+     * @returns The in-memory event buffer.
+     */
+    getBuffer(): ReadonlyArray<ExecutionEvent>;
+    /**
+     * Clears the in-memory buffer. Called between processing cycles.
+     */
+    clearBuffer(): void;
+}
+
+/**
+ * AI primitive — intercepted LLM calls with event emission.
+ *
+ * Every generate/stream/classify call is logged to the execution log.
+ * The actual LLM provider call is delegated to the injected implementation.
+ *
+ * @module
+ */
+
+/**
+ * A concrete AI provider implementation that performs the actual LLM calls.
+ * This is injected by the host adapter (e.g. Cloudflare AI, OpenAI fetch, etc.).
+ */
+type AIProvider = KalpAI;
+/**
+ * Creates an intercepted AI primitive that wraps every call with event emission.
+ *
+ * The returned object matches the SDK's {@link KalpAI} interface exactly.
+ * Internally, each method:
+ * 1. Emits a `primitive.invoked` event before calling the provider.
+ * 2. Calls the actual provider implementation.
+ * 3. Emits a `primitive.invoked` event with the result.
+ *
+ * @param provider - The concrete AI provider implementation.
+ * @param log - The execution log for event emission.
+ * @param execCtx - Optional execution context for event identity.
+ * @returns An intercepted {@link KalpAI} matching the SDK interface.
+ */
+declare function createAIPrimitive(provider: AIProvider, log: ExecutionLog, execCtx?: ExecutionContext): KalpAI;
+
+/**
+ * Actions primitive — intercepted orchestration intents with event emission.
+ *
+ * This is the core of the event-sourced runtime model. Every action is an
+ * **intent**, not a direct execution. The handler emits the intent, and the
+ * reactor resolves it.
+ *
+ * - `actions.run(step, input)` → emits `action.run`, suspends, reactor enqueues handler, resolves with result
+ * - `actions.wait(duration)` → emits `action.wait`, schedules alarm, terminates execution
+ * - `actions.loop(body)` → emits `action.loop.start`, reactor drives iterations
+ * - `actions.fetch(url, init)` → emits `action.fetch`, delegates to http primitive
+ *
+ * @module
+ */
+
+/** Callback to dispatch a handler task into the reactor queue. */
+type DispatchAction = (moduleRef: string, input: unknown) => Promise<unknown>;
+/**
+ * Creates the intercepted actions primitive for handler context.
+ *
+ * Each method emits structured events and interacts with the reactor
+ * via the `dispatch` callback (for run) and the `scheduler` adapter
+ * (for wait).
+ *
+ * @param log - The execution log for event emission.
+ * @param scheduler - The scheduler adapter for deferred execution.
+ * @param dispatch - Callback to enqueue a handler task in the reactor.
+ * @param execCtx - Optional execution context for event identity.
+ * @returns A {@link KalpActions} matching the SDK interface exactly.
+ */
+declare function createActionsPrimitive(log: ExecutionLog, scheduler: SchedulerAdapter, dispatch: DispatchAction, execCtx?: ExecutionContext): KalpActions;
+
+/**
+ * Handler context builder for the Kalp v2 Orchestration Reactor.
+ *
+ * Assembles the {@link HandlerContext} that is passed to every handler function.
+ * Each primitive in the context is intercepted — all operations emit structured
+ * events to the execution log.
+ *
+ * The context shape matches the SDK's `HandlerContext` interface exactly,
+ * preserving DX:
+ *
+ * ```ts
+ * const { fetch, loop, run, wait } = actions;
+ * const { delete: deleteKey, get, put } = storage;
+ * const { classify, generate, stream } = ai;
+ * ```
+ *
+ * @module
+ */
+
+/**
+ * External provider implementations injected by the host adapter.
+ * These are NOT part of the reactor core — they come from infrastructure.
+ */
+interface RuntimeProviders {
+    /** AI provider implementation (e.g. OpenAI, Anthropic, Cloudflare AI). */
+    ai: AIProvider;
+    /** Authentication context for the current request. */
+    auth: KalpAuth;
+    /** Memory (conversation history) provider. */
+    memory: KalpMemory;
+    /** Secrets vault provider. */
+    vault: KalpVault;
+}
+/**
+ * Builds a {@link HandlerContext} with fully intercepted primitives.
+ *
+ * Every operation on the returned context (ai.generate, storage.put,
+ * actions.run, etc.) is intercepted to emit structured events to the
+ * execution log. The handler never touches infrastructure directly.
+ *
+ * @param log - The execution log for event emission.
+ * @param stateStore - The state sub-store for KV operations.
+ * @param scheduler - The scheduler adapter for deferred execution.
+ * @param dispatch - Callback to enqueue handler tasks in the reactor.
+ * @param providers - External providers (ai, auth, memory, vault).
+ * @param execCtx - Optional execution context for event identity.
+ * @param agentConfig - Optional agent configuration for metadata.
+ * @returns A complete {@link HandlerContext} matching the SDK interface.
+ */
+declare function buildHandlerContext(log: ExecutionLog, stateStore: StateStore, scheduler: SchedulerAdapter, dispatch: DispatchAction, providers: RuntimeProviders, execCtx?: ExecutionContext, agentConfig?: {
+    name: string;
+    systemPrompt: string;
+    metadata?: Record<string, unknown>;
+}): HandlerContext;
+
+/**
+ * Orchestration Reactor — the Kalp v2 event-sourced execution engine.
+ *
+ * The reactor is **infrastructure-agnostic**. It receives events, processes
+ * tasks from an internal queue, and delegates all IO to adapter interfaces.
+ * When the queue is empty, control returns to the host adapter (Durable Object,
+ * Node process, test harness, etc.) which waits for the next external event.
+ *
+ * Key invariants:
+ * - The reactor never imports Cloudflare, Node, or any platform API.
+ * - Every operation emits structured events to the {@link ExecutionLog}.
+ * - Handler execution is sandboxed via intercepted primitives.
+ * - `actions.run` is an intent + suspend, not a direct call.
+ *
+ * @module
+ */
+
+/**
+ * The Kalp v2 Orchestration Reactor.
+ *
+ * Processes external events by looking up the corresponding IR entry,
+ * executing the handler chain, and emitting structured events for every
+ * operation. The reactor is portable — it works in Durable Objects, Node,
+ * or any environment that provides the adapter interfaces.
+ */
+declare class OrchestrationReactor {
+    /** The execution log (single source of truth). */
+    readonly log: ExecutionLog;
+    /** The IR graph (structural index only). */
+    readonly ir: IRGraph;
+    /** Internal task queue. */
+    private queue;
+    /** Bundled handler modules keyed by moduleRef. */
+    private bundles;
+    /** Composite persistence adapter (state, events, idempotency, threads). */
+    private persistence;
+    /** Scheduler adapter (alarms). */
+    private scheduler;
+    /** External providers (ai, auth, memory, vault). */
+    private providers;
+    /** Result of the last completed handler. */
+    private lastResult;
+    /** Opaque thread identifier (set by adapter via RuntimeEvent.threadId). */
+    private 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: IRGraph, bundles: Map<string, HandlerModule>, persistence: PersistenceAdapter, scheduler: SchedulerAdapter, providers: RuntimeProviders);
+    /**
+     * 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.
+     */
+    handleEvent(event: RuntimeEvent): Promise<unknown>;
+    /**
+     * 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.
+     */
+    processUntilIdle(): Promise<void>;
+    /**
+     * Processes a single task from the queue.
+     *
+     * - **Entry nodes**: traverse sequential edges to find the handler.
+     * - **Handler nodes**: build context, execute handler, emit events.
+     */
+    private processTask;
+    /**
+     * 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.
+     */
+    private enqueueSuccessors;
+    /**
+     * 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.
+     */
+    private createDispatch;
+}
+
+export { type AIProvider as A, type CrossThreadAdapter as C, type DispatchAction as D, ExecutionLog as E, type HandlerModule as H, type IdempotencyStore as I, OrchestrationReactor as O, type PersistenceAdapter as P, type RuntimeProviders as R, type SchedulerAdapter as S, type ThreadStore as T, type UntrackedIOSource as U, type StateStore as a, type ExecutionContext as b, type EventStore as c, type ExecutionEvent as d, type ExecutionTask as e, type RuntimeEvent as f, type TransportAdapter as g, buildHandlerContext as h, createAIPrimitive as i, createActionsPrimitive as j };