@codemation/core 0.0.5 → 0.0.7

package/dist/index-CTjfVHJh.d.ts

@@ -0,0 +1,694 @@
+import { $r as RunEventBus, $t as BinaryBody, Ar as WorkflowExecutionRepository, Cn as NodeExecutionScheduler, Ct as RunDataSnapshot, Dr as WebhookRunResult, En as NodeResolver, Er as RunSummary, Et as RunnableNodeConfig, Ft as WorkflowErrorHandler, G as BinaryAttachment, Gn as WebhookInvocationMatch, Hn as HttpMethod, I as CredentialSessionService, In as WorkflowNodeInstanceFactory, It as WorkflowErrorHandlerSpec, J as ExecutionMode, Jn as WebhookTriggerRoutingDiagnostics, Kn as WebhookTriggerMatcher, Ln as WorkflowRepository, Lr as TypeToken, N as CredentialRequirement, Nt as WorkflowDefinition, Or as WorkflowExecutionListingRepository, Q as Items, Qr as RunEvent, Sn as NodeExecutionRequestHandler, Sr as RunResult, St as RunDataFactory, Tr as RunStopCondition, Ut as WorkflowStoragePolicyDecisionArgs, Vn as WorkflowSnapshotResolver, Vt as WorkflowPolicyRuntimeDefaults, X as Item, Xn as WorkflowActivationPolicy, Xr as EngineExecutionLimitsPolicy, Zr as EngineExecutionLimitsPolicyConfig, _r as RunCurrentState, an as EngineDeps, at as NodeConfigBase, bn as NodeExecutionContext, br as RunPruneCandidate, bt as PersistedRunPolicySnapshot, cn as ExecutionBinaryService, ct as NodeErrorHandler, dn as LiveWorkflowRepository, dr as PersistedRunState, dt as NodeId, ei as RunEventSubscription, en as BinaryStorage, er as CurrentStateExecutionRequest, gn as NodeActivationRequest, gt as NodeSchedulerDecision, hn as NodeActivationReceipt, in as BinaryStorageWriteResult, ir as NodeExecutionSnapshot, it as NodeActivationId, kr as WorkflowExecutionPruneRepository, ln as ExecutionContext, mn as NodeActivationContinuation, mr as PersistedWorkflowTokenRegistryLike, mt as NodeOutputs, n as WorkflowSnapshotCodec, nn as BinaryStorageStatResult, or as NodeInputsByPort, pr as PersistedWorkflowSnapshotNode, pt as NodeOffloadPolicy, qn as WebhookTriggerResolution, rt as MutableRunData, si as RetryPolicySpec, st as NodeDefinition, tn as BinaryStorageReadResult, tr as EngineRunCounters, un as ExecutionContextFactory, ut as NodeErrorHandlerSpec, vn as NodeActivationScheduler, wn as NodeExecutionStatePublisher, wt as RunId, xn as NodeExecutionRequest, yn as NodeBinaryAttachmentService, yr as RunExecutionOptions, yt as ParentExecutionRef, zt as WorkflowId } from "./InMemoryLiveWorkflowRepository-DxoualoC.js";
+import { ZodType, input, output } from "zod";
+
+//#region src/orchestration/Engine.d.ts
+interface EngineTriggerRuntime {
+  startTriggers(): Promise<void>;
+  stop(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+}
+interface EngineRunStartService {
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+}
+interface EngineRunContinuationService {
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+interface EngineNodeExecutionRequestHandler {
+  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
+}
+interface EngineFacadeDeps {
+  liveWorkflowRepository: LiveWorkflowRepository;
+  tokenRegistry: PersistedWorkflowTokenRegistryLike;
+  webhookTriggerMatcher: WebhookTriggerMatcher;
+  workflowSnapshotResolver: WorkflowSnapshotResolver;
+  triggerRuntime: EngineTriggerRuntime;
+  runStartService: EngineRunStartService;
+  runContinuationService: EngineRunContinuationService;
+  nodeExecutionRequestHandler: EngineNodeExecutionRequestHandler;
+}
+/**
+ * Runtime facade for orchestration, continuation, triggers, and webhook routing.
+ * Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
+ * The class token is exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
+ */
+declare class Engine implements NodeActivationContinuation, NodeExecutionRequestHandler {
+  private readonly deps;
+  constructor(deps: EngineFacadeDeps);
+  loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  getTokenRegistry(): EngineFacadeDeps["tokenRegistry"];
+  resolveWorkflowSnapshot(args: {
+    workflowId: WorkflowId;
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
+  }): WorkflowDefinition | undefined;
+  startTriggers(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  start(workflows: WorkflowDefinition[]): Promise<void>;
+  stop(): Promise<void>;
+  resolveWebhookTrigger(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookTriggerResolution;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
+}
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeFallbacksFactory.d.ts
+declare class MissingRuntimeFallbacks {
+  createDefinition(snapshotNode: PersistedWorkflowSnapshotNode): NodeDefinition;
+}
+//#endregion
+//#region src/runtime/EngineFactory.d.ts
+/**
+ * {@link EngineDeps} plus optional overrides for workflow-snapshot materialization.
+ * Overrides keep default construction in this factory while allowing tests or advanced wiring to inject instances.
+ */
+type EngineCompositionDeps = EngineDeps & {
+  workflowSnapshotCodec?: WorkflowSnapshotCodec;
+  missingRuntimeFallbacks?: MissingRuntimeFallbacks;
+  /** When set, used for run-start, trigger, and continuation limit defaults. */
+  executionLimitsPolicy?: EngineExecutionLimitsPolicy;
+};
+/**
+ * Composes the {@link Engine} graph from {@link EngineCompositionDeps}. Production wiring usually goes through
+ * {@link import("../bootstrap/runtime/EngineRuntimeRegistrar").EngineRuntimeRegistrar}; this factory remains for tests and custom composition.
+ * Exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
+ */
+declare class EngineFactory {
+  create(deps: EngineCompositionDeps): Engine;
+}
+//#endregion
+//#region src/events/NodeEventPublisher.d.ts
+/** Publishes node lifecycle snapshots onto the run {@link RunEventBus}. */
+declare class NodeEventPublisher {
+  private readonly eventBus;
+  constructor(eventBus: RunEventBus | undefined);
+  publish(kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed", snapshot: NodeExecutionSnapshot): Promise<void>;
+}
+//#endregion
+//#region src/execution/CredentialResolverFactory.d.ts
+declare class CredentialResolverFactory {
+  private readonly credentialSessions;
+  constructor(credentialSessions: CredentialSessionService);
+  create(workflowId: WorkflowId, nodeId: NodeId, config?: NodeExecutionContext["config"]): NodeExecutionContext["getCredential"];
+}
+//#endregion
+//#region src/execution/asyncSleeper.types.d.ts
+interface AsyncSleeper {
+  sleep(ms: number): Promise<void>;
+}
+//#endregion
+//#region src/execution/DefaultAsyncSleeper.d.ts
+declare class DefaultAsyncSleeper implements AsyncSleeper {
+  sleep(ms: number): Promise<void>;
+}
+//#endregion
+//#region src/execution/DefaultExecutionContextFactory.d.ts
+declare class DefaultExecutionContextFactory implements ExecutionContextFactory {
+  private readonly binaryStorage;
+  private readonly currentDate;
+  constructor(binaryStorage?: BinaryStorage, currentDate?: () => Date);
+  create(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    parent?: ParentExecutionRef;
+    subworkflowDepth: number;
+    engineMaxNodeActivations: number;
+    engineMaxSubworkflowDepth: number;
+    data: RunDataSnapshot;
+    nodeState?: NodeExecutionStatePublisher;
+    getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+  }): ExecutionContext;
+}
+//#endregion
+//#region src/execution/InProcessRetryRunner.d.ts
+declare class InProcessRetryRunner {
+  private readonly sleeper;
+  constructor(sleeper: AsyncSleeper);
+  run<T>(policy: RetryPolicySpec | undefined, work: () => Promise<T>): Promise<T>;
+  private static delayAfterFailureMs;
+  private static normalizePolicy;
+  private static assertPositiveInt;
+  private static assertNonNegativeFinite;
+  private static assertMultiplier;
+}
+//#endregion
+//#region src/execution/NodeExecutor.d.ts
+declare class NodeExecutor {
+  private readonly nodeInstanceFactory;
+  private readonly retryRunner;
+  constructor(nodeInstanceFactory: WorkflowNodeInstanceFactory, retryRunner: InProcessRetryRunner);
+  execute(request: NodeActivationRequest): Promise<NodeOutputs>;
+  private executeMultiInputNode;
+  private executeSingleInputNode;
+}
+//#endregion
+//#region src/execution/NodeInstanceFactory.d.ts
+declare class NodeInstanceFactory implements WorkflowNodeInstanceFactory {
+  private readonly nodeResolver;
+  constructor(nodeResolver: NodeResolver);
+  createNodes(workflow: WorkflowDefinition): Map<NodeId, unknown>;
+  createNode(definition: WorkflowDefinition["nodes"][number]): unknown;
+  createByType(type: TypeToken<unknown>): unknown;
+}
+//#endregion
+//#region src/contracts/Clock.d.ts
+/** Port for time; inject `SystemClock` in production and a fake/test clock in tests. */
+interface Clock {
+  now(): Date;
+}
+declare class SystemClock implements Clock {
+  now(): Date;
+}
+//#endregion
+//#region src/ai/AiHost.d.ts
+interface AgentCanvasPresentation<TIcon extends string = string> {
+  readonly label?: string;
+  readonly icon?: TIcon;
+}
+type ZodSchemaAny = ZodType<any, any, any>;
+interface ToolConfig {
+  readonly type: TypeToken<Tool<ToolConfig, ZodSchemaAny, ZodSchemaAny>>;
+  readonly name: string;
+  readonly description?: string;
+  readonly presentation?: AgentCanvasPresentation;
+  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
+}
+type ToolExecuteArgs<TConfig extends ToolConfig = ToolConfig, TInput = unknown> = Readonly<{
+  config: TConfig;
+  input: TInput;
+  ctx: NodeExecutionContext<any>;
+  item: Item;
+  itemIndex: number;
+  items: Items;
+}>;
+interface Tool<TConfig extends ToolConfig = ToolConfig, TInputSchema extends ZodSchemaAny = ZodSchemaAny, TOutputSchema extends ZodSchemaAny = ZodSchemaAny> {
+  readonly defaultDescription: string;
+  readonly inputSchema: TInputSchema;
+  readonly outputSchema: TOutputSchema;
+  execute(args: ToolExecuteArgs<TConfig, input<TInputSchema>>): Promise<output<TOutputSchema>> | output<TOutputSchema>;
+}
+type AgentTool<TInputSchema extends ZodSchemaAny = ZodSchemaAny, TOutputSchema extends ZodSchemaAny = ZodSchemaAny> = Tool<ToolConfig, TInputSchema, TOutputSchema>;
+type AgentToolExecuteArgs<TInput = unknown> = ToolExecuteArgs<ToolConfig, TInput>;
+type AgentToolToken = TypeToken<Tool<ToolConfig, ZodSchemaAny, ZodSchemaAny>>;
+interface AgentToolDefinition {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: ZodSchemaAny;
+}
+type AgentToolCall = Readonly<{
+  id?: string;
+  name: string;
+  input: unknown;
+}>;
+type AgentToolCallPlanner<_TNodeConfig = unknown> = (item: Item, index: number, items: Items, ctx: NodeExecutionContext<any>) => ReadonlyArray<AgentToolCall>;
+interface ChatModelConfig {
+  readonly type: TypeToken<ChatModelFactory<ChatModelConfig>>;
+  readonly name: string;
+  readonly presentation?: AgentCanvasPresentation;
+  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
+}
+interface LangChainChatModelLike {
+  invoke(input: unknown, options?: unknown): Promise<unknown>;
+  bindTools?(tools: ReadonlyArray<unknown>): LangChainChatModelLike;
+}
+interface ChatModelFactory<TConfig extends ChatModelConfig = ChatModelConfig> {
+  create(args: Readonly<{
+    config: TConfig;
+    ctx: NodeExecutionContext<any>;
+  }>): Promise<LangChainChatModelLike> | LangChainChatModelLike;
+}
+interface AgentNodeConfig<TInputJson = unknown, TOutputJson = unknown> extends RunnableNodeConfig<TInputJson, TOutputJson> {
+  readonly systemMessage: string;
+  readonly userMessageFormatter: (item: Item<TInputJson>, index: number, items: Items<TInputJson>, ctx: NodeExecutionContext<any>) => string;
+  readonly chatModel: ChatModelConfig;
+  readonly tools?: ReadonlyArray<ToolConfig>;
+}
+declare class AgentConfigInspector {
+  static isAgentNodeConfig(config: NodeConfigBase | undefined): config is AgentNodeConfig<any, any>;
+}
+type AgentAttachmentRole = "languageModel" | "tool";
+//#endregion
+//#region src/events/InMemoryRunEventBusRegistry.d.ts
+declare class InMemoryRunEventBus implements RunEventBus {
+  private readonly globalListeners;
+  private readonly listenersByWorkflowId;
+  publish(event: RunEvent): Promise<void>;
+  subscribe(onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
+  subscribeToWorkflow(workflowId: WorkflowId, onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
+}
+//#endregion
+//#region src/events/EventPublishingWorkflowExecutionRepository.d.ts
+declare class EventPublishingWorkflowExecutionRepository implements WorkflowExecutionRepository, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository {
+  private readonly inner;
+  private readonly eventBus;
+  private readonly now;
+  constructor(inner: WorkflowExecutionRepository, eventBus: RunEventBus, now?: () => Date);
+  createRun(args: Parameters<WorkflowExecutionRepository["createRun"]>[0]): Promise<void>;
+  load(runId: RunId): Promise<PersistedRunState | undefined>;
+  save(state: PersistedRunState): Promise<void>;
+  deleteRun(runId: RunId): Promise<void>;
+  listRuns(args?: Readonly<{
+    workflowId?: WorkflowId;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunSummary>>;
+  listRunsOlderThan(args: Readonly<{
+    beforeIso: string;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+}
+//#endregion
+//#region src/runtime-types/persistedRuntimeTypeModelRegistry.d.ts
+type DecoratedRuntimeType = Readonly<{
+  name?: string;
+}> & object;
+/** Categories of runtime classes that can be discovered and rehydrated from persisted snapshots. */
+type PersistedRuntimeTypeKind = "node" | "tool" | "chatModel";
+interface PersistedRuntimeTypeDecoratorOptions {
+  readonly name?: string;
+  readonly packageName?: string;
+  readonly moduleUrl?: string;
+}
+/** Serialized metadata attached to a decorated runtime type. */
+interface PersistedRuntimeTypeMetadata {
+  readonly persistedName: string;
+  readonly kind: PersistedRuntimeTypeKind;
+  readonly packageName: string;
+  readonly sourceHint?: string;
+}
+//#endregion
+//#region src/runtime-types/InjectableRuntimeDecoratorComposerRegistry.d.ts
+/**
+ * Applies both tsyringe injectability and persisted runtime metadata in one decorator.
+ * This keeps runtime-type decorators thin while still recording enough data for snapshot hydration.
+ */
+declare class InjectableRuntimeDecoratorComposer {
+  static compose(kind: PersistedRuntimeTypeKind, options: PersistedRuntimeTypeDecoratorOptions, decoratorFileUrl: string): ClassDecorator;
+}
+//#endregion
+//#region src/runtime-types/PersistedRuntimeTypeMetadataStoreRegistry.d.ts
+/**
+ * Defines and retrieves persisted runtime metadata on decorated classes.
+ * The metadata is attached as a non-enumerable property so runtime objects stay serializable.
+ */
+declare class PersistedRuntimeTypeMetadataStore {
+  static define(target: DecoratedRuntimeType, kind: PersistedRuntimeTypeKind, options: PersistedRuntimeTypeDecoratorOptions, decoratorFileUrl: string): void;
+  static get(target: unknown): PersistedRuntimeTypeMetadata | undefined;
+}
+//#endregion
+//#region src/runtime-types/PersistedRuntimeTypeNameResolver.d.ts
+/** Resolves the persisted type name from either an explicit override or the class name itself. */
+declare class PersistedRuntimeTypeNameResolver {
+  static resolve(target: DecoratedRuntimeType, override: string | undefined): string;
+}
+//#endregion
+//#region src/runtime-types/StackTraceCallSitePathResolver.d.ts
+declare class StackTraceCallSitePathResolver {
+  static resolve(decoratorFileUrl: string): string | undefined;
+  private static extractPath;
+}
+//#endregion
+//#region src/runtime-types/runtimeTypeDecorators.types.d.ts
+/** Reads persisted runtime metadata from a decorated class or object. */
+declare function getPersistedRuntimeTypeMetadata(target: unknown): PersistedRuntimeTypeMetadata | undefined;
+/** Marks a class as a persisted node runtime type and an injectable tsyringe service. */
+declare function node(options?: PersistedRuntimeTypeDecoratorOptions): ClassDecorator;
+/** Marks a class as a persisted tool runtime type and an injectable tsyringe service. */
+declare function tool(options?: PersistedRuntimeTypeDecoratorOptions): ClassDecorator;
+/** Marks a class as a persisted chat-model runtime type and an injectable tsyringe service. */
+declare function chatModel(options?: PersistedRuntimeTypeDecoratorOptions): ClassDecorator;
+//#endregion
+//#region src/serialization/ItemsInputNormalizer.d.ts
+/**
+ * Normalizes external inputs into the engine's canonical `Items` shape.
+ * Used at host and builder boundaries where callers may provide either a raw value,
+ * a single item-like object, or an array of item-like values.
+ */
+declare class ItemsInputNormalizer {
+  normalize(raw: unknown): Items;
+  private normalizeItem;
+  private isItem;
+}
+//#endregion
+//#region src/binaries/UnavailableBinaryStorage.d.ts
+declare class UnavailableBinaryStorage implements BinaryStorage {
+  readonly driverName = "unavailable";
+  write(): Promise<never>;
+  openReadStream(): Promise<undefined>;
+  stat(): Promise<{
+    exists: false;
+  }>;
+  delete(): Promise<void>;
+}
+//#endregion
+//#region src/binaries/DefaultExecutionBinaryServiceFactory.d.ts
+declare class DefaultExecutionBinaryService implements ExecutionBinaryService {
+  private readonly storage;
+  private readonly workflowId;
+  private readonly runId;
+  private readonly now;
+  constructor(storage: BinaryStorage, workflowId: WorkflowId, runId: RunId, now: () => Date);
+  forNode(args: {
+    nodeId: NodeId;
+    activationId: NodeActivationId;
+  }): NodeBinaryAttachmentService;
+  openReadStream(attachment: BinaryAttachment): Promise<BinaryStorageReadResult | undefined>;
+}
+//#endregion
+//#region src/policies/executionLimits/EngineExecutionLimitsPolicyFactory.d.ts
+/**
+ * Builds {@link EngineExecutionLimitsPolicy} by merging {@link ENGINE_EXECUTION_LIMITS_DEFAULTS} with optional `overrides` (e.g. host `runtime.engineExecutionLimits`).
+ */
+declare class EngineExecutionLimitsPolicyFactory {
+  create(overrides?: Partial<EngineExecutionLimitsPolicyConfig>): EngineExecutionLimitsPolicy;
+}
+//#endregion
+//#region src/policies/storage/RunPolicySnapshotFactory.d.ts
+declare class RunPolicySnapshotFactory {
+  static create(workflow: WorkflowDefinition, defaults?: WorkflowPolicyRuntimeDefaults): PersistedRunPolicySnapshot;
+}
+//#endregion
+//#region src/policies/storage/WorkflowStoragePolicyEvaluator.d.ts
+declare class WorkflowStoragePolicyEvaluator {
+  private readonly nodeResolver;
+  constructor(nodeResolver: NodeResolver);
+  shouldPersist(workflow: WorkflowDefinition, snapshot: PersistedRunPolicySnapshot | undefined, args: WorkflowStoragePolicyDecisionArgs): Promise<boolean>;
+  private modeMatches;
+}
+//#endregion
+//#region src/policies/storage/RunTerminalPersistenceCoordinator.d.ts
+declare class RunTerminalPersistenceCoordinator {
+  private readonly runRepository;
+  private readonly storageEvaluator;
+  constructor(runRepository: WorkflowExecutionRepository, storageEvaluator: WorkflowStoragePolicyEvaluator);
+  maybeDeleteAfterTerminalState(args: {
+    workflow: WorkflowDefinition;
+    state: PersistedRunState;
+    finalStatus: "completed" | "failed";
+    finishedAt: string;
+  }): Promise<void>;
+}
+//#endregion
+//#region src/policies/WorkflowPolicyErrorServices.d.ts
+declare class WorkflowPolicyErrorServices {
+  private readonly nodeResolver;
+  constructor(nodeResolver: NodeResolver);
+  resolveNodeErrorHandler(spec: NodeErrorHandlerSpec | undefined): NodeErrorHandler | undefined;
+  resolveWorkflowErrorHandler(spec: WorkflowErrorHandlerSpec | undefined): WorkflowErrorHandler | undefined;
+}
+//#endregion
+//#region src/runStorage/InMemoryBinaryStorageRegistry.d.ts
+declare class InMemoryBinaryStorage implements BinaryStorage {
+  readonly driverName = "memory";
+  private readonly values;
+  write(args: {
+    storageKey: string;
+    body: BinaryBody;
+  }): Promise<BinaryStorageWriteResult>;
+  openReadStream(storageKey: string): Promise<BinaryStorageReadResult | undefined>;
+  stat(storageKey: string): Promise<BinaryStorageStatResult>;
+  delete(storageKey: string): Promise<void>;
+}
+//#endregion
+//#region src/runStorage/InMemoryRunDataFactory.d.ts
+declare class InMemoryRunDataFactory implements RunDataFactory {
+  create(initial?: Record<NodeId, NodeOutputs>): MutableRunData;
+}
+//#endregion
+//#region src/runStorage/InMemoryWorkflowExecutionRepository.d.ts
+declare class InMemoryWorkflowExecutionRepository implements WorkflowExecutionRepository, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository {
+  private readonly runs;
+  createRun(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    startedAt: string;
+    parent?: ParentExecutionRef;
+    executionOptions?: PersistedRunState["executionOptions"];
+    control?: PersistedRunState["control"];
+    workflowSnapshot?: PersistedRunState["workflowSnapshot"];
+    mutableState?: PersistedRunState["mutableState"];
+    policySnapshot?: PersistedRunState["policySnapshot"];
+    engineCounters?: EngineRunCounters;
+  }): Promise<void>;
+  load(runId: RunId): Promise<PersistedRunState | undefined>;
+  save(state: PersistedRunState): Promise<void>;
+  deleteRun(runId: RunId): Promise<void>;
+  listRuns(args?: Readonly<{
+    workflowId?: WorkflowId;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunSummary>>;
+  listRunsOlderThan(args: Readonly<{
+    beforeIso: string;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+}
+//#endregion
+//#region src/runStorage/RunSummaryMapper.d.ts
+/** Maps persisted run state to API run summaries for listings. */
+declare class RunSummaryMapper {
+  static fromPersistedState(state: PersistedRunState): RunSummary;
+}
+//#endregion
+//#region src/runtime/EngineWorkflowRunnerService.d.ts
+declare class EngineWorkflowRunnerService {
+  private readonly engine;
+  private readonly workflowRepository;
+  constructor(engine: Engine, workflowRepository: WorkflowRepository);
+  runById(args: {
+    workflowId: WorkflowId;
+    startAt?: NodeId;
+    items: Items;
+    parent?: ParentExecutionRef;
+  }): Promise<RunResult>;
+  private findDefaultStartNodeId;
+}
+//#endregion
+//#region src/runtime/RunIntentService.d.ts
+type StartWorkflowIntent = {
+  workflow: WorkflowDefinition;
+  startAt?: string;
+  items: Items;
+  parent?: CurrentStateExecutionRequest["parent"];
+  executionOptions?: RunExecutionOptions;
+  workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
+  mutableState?: CurrentStateExecutionRequest["mutableState"];
+  currentState?: RunCurrentState;
+  stopCondition?: RunStopCondition;
+  reset?: CurrentStateExecutionRequest["reset"];
+};
+type RerunFromNodeIntent = {
+  workflow: WorkflowDefinition;
+  nodeId: NodeId;
+  currentState: RunCurrentState;
+  items?: Items;
+  parent?: CurrentStateExecutionRequest["parent"];
+  executionOptions?: RunExecutionOptions;
+  workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
+  mutableState?: CurrentStateExecutionRequest["mutableState"];
+};
+type MatchedWebhookRunIntent = {
+  endpointPath: string;
+  method: HttpMethod;
+  requestItem: Items[number];
+};
+type WebhookMatchRunIntent = {
+  match: WebhookInvocationMatch;
+  requestItem: Items[number];
+};
+declare class RunIntentService {
+  private readonly engine;
+  private readonly workflowRepository;
+  constructor(engine: Engine, workflowRepository: WorkflowRepository);
+  startWorkflow(args: StartWorkflowIntent): Promise<RunResult>;
+  rerunFromNode(args: RerunFromNodeIntent): Promise<RunResult>;
+  resolveWebhookTrigger(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookTriggerResolution;
+  runMatchedWebhook(args: MatchedWebhookRunIntent): Promise<WebhookRunResult>;
+  runWebhookMatch(args: WebhookMatchRunIntent): Promise<WebhookRunResult>;
+  /**
+   * Webhook-triggered runs always force inline execution first.
+   * This is the highest-precedence scheduler override: it wins over node hints and container defaults.
+   */
+  private createWebhookExecutionOptions;
+}
+//#endregion
+//#region src/runtime/WorkflowRepositoryWebhookTriggerMatcher.d.ts
+/**
+ * Resolves webhook HTTP routes from the live workflow repository (no trigger setup / registration).
+ * Maintains an in-memory index keyed by user-defined endpoint path for O(1) lookups after reload.
+ */
+declare class WorkflowRepositoryWebhookTriggerMatcher implements WebhookTriggerMatcher {
+  private readonly workflowRepository;
+  private readonly workflowActivationPolicy;
+  private readonly diagnostics?;
+  private readonly routeByPath;
+  private engineRoutesActive;
+  constructor(workflowRepository: WorkflowRepository, workflowActivationPolicy: WorkflowActivationPolicy, diagnostics?: WebhookTriggerRoutingDiagnostics | undefined);
+  onEngineWorkflowsLoaded(): void;
+  onEngineStopped(): void;
+  reloadWebhookRoutes(): void;
+  lookup(endpointPath: string): WebhookInvocationMatch | undefined;
+  match(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookInvocationMatch | undefined;
+  private rebuildRouteIndex;
+  private collectWebhookEndpointPaths;
+  private tryMatchFromTriggerNode;
+  private normalizeEndpointPath;
+}
+//#endregion
+//#region src/scheduler/ConfigDrivenOffloadPolicy.d.ts
+declare class ConfigDrivenOffloadPolicy implements NodeOffloadPolicy {
+  private readonly defaultMode;
+  constructor(defaultMode?: ExecutionMode);
+  decide(args: {
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    config: NodeConfigBase;
+  }): NodeSchedulerDecision;
+}
+//#endregion
+//#region src/scheduler/InlineDrivingScheduler.d.ts
+declare class InlineDrivingScheduler implements NodeActivationScheduler {
+  private readonly nodeExecutor;
+  private continuation;
+  private readonly drainingRuns;
+  private readonly queuesByRunId;
+  private readonly scheduledRuns;
+  private seq;
+  constructor(nodeExecutor: NodeExecutor);
+  setContinuation(continuation: NodeActivationContinuation): void;
+  enqueue(request: NodeActivationRequest): Promise<NodeActivationReceipt>;
+  notifyPendingStatePersisted(runId: RunId): void;
+  private drainRun;
+  private scheduleDrain;
+  private resumeAfterExecutionResult;
+  private resumeAfterExecutionError;
+  private asError;
+  private rethrowUnlessIgnorableContinuationError;
+  private isIgnorableContinuationError;
+}
+//#endregion
+//#region src/scheduler/DefaultDrivingScheduler.d.ts
+declare class DefaultDrivingScheduler implements NodeActivationScheduler {
+  private readonly offloadPolicy;
+  private readonly workerScheduler;
+  private readonly inline;
+  constructor(offloadPolicy: NodeOffloadPolicy, workerScheduler: NodeExecutionScheduler, inline: InlineDrivingScheduler);
+  setContinuation(continuation: NodeActivationContinuation): void;
+  enqueue(request: NodeActivationRequest): Promise<NodeActivationReceipt>;
+  notifyPendingStatePersisted(runId: string): void;
+  /**
+   * Scheduler precedence is explicit:
+   * 1. run-intent override (`executionOptions.localOnly`)
+   * 2. node-level execution hint / queue policy
+   * 3. container-default scheduler policy fallback
+   */
+  private selectScheduler;
+  private hasNodeSchedulingPreference;
+  private enqueueInline;
+}
+//#endregion
+//#region src/scheduler/HintOnlyOffloadPolicy.d.ts
+declare class HintOnlyOffloadPolicy implements NodeOffloadPolicy {
+  decide(args: {
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    config: NodeConfigBase;
+  }): NodeSchedulerDecision;
+}
+//#endregion
+//#region src/scheduler/LocalOnlyScheduler.d.ts
+declare class LocalOnlyScheduler implements NodeExecutionScheduler {
+  enqueue(_request: NodeExecutionRequest): Promise<{
+    receiptId: string;
+  }>;
+}
+//#endregion
+export { NodeInstanceFactory as $, PersistedRuntimeTypeKind as A, AgentToolCallPlanner as B, node as C, PersistedRuntimeTypeMetadataStore as D, PersistedRuntimeTypeNameResolver as E, AgentCanvasPresentation as F, ChatModelFactory as G, AgentToolExecuteArgs as H, AgentConfigInspector as I, ToolConfig as J, LangChainChatModelLike as K, AgentNodeConfig as L, EventPublishingWorkflowExecutionRepository as M, InMemoryRunEventBus as N, InjectableRuntimeDecoratorComposer as O, AgentAttachmentRole as P, SystemClock as Q, AgentTool as R, getPersistedRuntimeTypeMetadata as S, StackTraceCallSitePathResolver as T, AgentToolToken as U, AgentToolDefinition as V, ChatModelConfig as W, ZodSchemaAny as X, ToolExecuteArgs as Y, Clock as Z, EngineExecutionLimitsPolicyFactory as _, ConfigDrivenOffloadPolicy as a, CredentialResolverFactory as at, ItemsInputNormalizer as b, EngineWorkflowRunnerService as c, EngineFactory as ct, InMemoryRunDataFactory as d, NodeExecutor as et, InMemoryBinaryStorage as f, RunPolicySnapshotFactory as g, WorkflowStoragePolicyEvaluator as h, InlineDrivingScheduler as i, AsyncSleeper as it, PersistedRuntimeTypeMetadata as j, PersistedRuntimeTypeDecoratorOptions as k, RunSummaryMapper as l, Engine as lt, RunTerminalPersistenceCoordinator as m, HintOnlyOffloadPolicy as n, DefaultExecutionContextFactory as nt, WorkflowRepositoryWebhookTriggerMatcher as o, NodeEventPublisher as ot, WorkflowPolicyErrorServices as p, Tool as q, DefaultDrivingScheduler as r, DefaultAsyncSleeper as rt, RunIntentService as s, EngineCompositionDeps as st, LocalOnlyScheduler as t, InProcessRetryRunner as tt, InMemoryWorkflowExecutionRepository as u, DefaultExecutionBinaryService as v, tool as w, chatModel as x, UnavailableBinaryStorage as y, AgentToolCall as z };
+//# sourceMappingURL=index-CTjfVHJh.d.ts.map