@codemation/core 0.0.19 → 0.2.0

package/dist/{InMemoryLiveWorkflowRepository-DxoualoC.d.ts → RunIntentService-BCvGdOSY.d.ts}

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { DependencyContainer, DependencyContainer as Container, Disposable, InjectionToken, InjectionToken as TypeToken, Lifecycle, RegistrationOptions, container, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
+import { DependencyContainer as Container, DependencyContainer as DependencyContainer$1, Disposable, InjectionToken as InjectionToken$1, InjectionToken as TypeToken, Lifecycle, RegistrationOptions, container as container$1, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
 import { ReadableStream } from "node:stream/web";
 
 //#region src/contracts/retryPolicySpec.types.d.ts
@@ -347,10 +347,18 @@ interface PendingNodeExecution {
   batchId?: string;
   enqueuedAt: string;
 }
+interface PersistedRunSchedulingState {
+  pending?: PendingNodeExecution;
+  queue: RunQueueEntry[];
+}
 interface PersistedRunState {
   runId: RunId;
   workflowId: WorkflowId;
   startedAt: string;
+  /** Canonical terminal time for listings and retention when persisted on the run root. */
+  finishedAt?: string;
+  /** Optimistic concurrency / CAS on the run aggregate (repository may increment on save). */
+  revision?: number;
   parent?: ParentExecutionRef;
   executionOptions?: RunExecutionOptions;
   control?: PersistedRunControlState;
@@ -382,6 +390,7 @@ interface WorkflowExecutionRepository {
     engineCounters?: EngineRunCounters;
   }): Promise<void>;
   load(runId: RunId): Promise<PersistedRunState | undefined>;
+  loadSchedulingState(runId: RunId): Promise<PersistedRunSchedulingState | undefined>;
   save(state: PersistedRunState): Promise<void>;
   deleteRun?(runId: RunId): Promise<void>;
 }
@@ -732,6 +741,10 @@ interface NodeActivationReceipt {
   mode?: "local" | "worker";
   queue?: string;
 }
+interface PreparedNodeActivationDispatch {
+  readonly receipt: NodeActivationReceipt;
+  dispatch(): Promise<void>;
+}
 interface NodeActivationContinuation {
   markNodeRunning(args: {
     runId: RunId;
@@ -754,8 +767,7 @@ interface NodeActivationContinuation {
 }
 interface NodeActivationScheduler {
   setContinuation?(continuation: NodeActivationContinuation): void;
-  enqueue(request: NodeActivationRequest): Promise<NodeActivationReceipt>;
-  notifyPendingStatePersisted?(runId: RunId): void;
+  prepareDispatch(request: NodeActivationRequest): Promise<PreparedNodeActivationDispatch>;
   cancel?(receiptId: string): Promise<void>;
 }
 interface WorkflowNodeInstanceFactory {
@@ -829,8 +841,9 @@ interface Edge {
 }
 type NodeConnectionName = string;
 /**
- * Named connection from an executable parent node to child nodes that exist in {@link WorkflowDefinition.nodes}
- * but are not traversed by the main execution graph.
+ * Named connection from a parent node to child nodes that exist in {@link WorkflowDefinition.nodes}
+ * but are not traversed by the main execution graph. Parents are commonly executable nodes, but may
+ * also be connection-owned nodes for recursive agent attachments.
  */
 interface WorkflowNodeConnection {
   readonly parentNodeId: NodeId;
@@ -1189,9 +1202,168 @@ declare class CredentialUnboundError extends Error {
   private static createMessage;
 }
 //#endregion
+//#region src/contracts/executionPersistenceContracts.d.ts
+/** Canonical id for persisted execution rows (activation or connection invocation). */
+type ExecutionInstanceId = string;
+/** Stable id for persisted work-queue rows. */
+type WorkItemId = string;
+/** Batch grouping for planner activations. */
+type BatchId = string;
+/** Optimistic concurrency on the run root. */
+type RunRevision = number;
+type PersistedRunWorkItemKind = "queue" | "pending";
+type WorkItemStatus = "queued" | "claimed" | "completed" | "failed" | "cancelled";
+type PersistedExecutionInstanceKind = "workflowNodeActivation" | "connectionInvocation";
+type ConnectionInvocationKind = "languageModel" | "tool" | "nestedAgent";
+type PayloadStorageKind = "inline" | "external" | "omitted";
+/**
+ * Persisted run-work-queue row (queue entry or pending activation).
+ * Serialized to {@link RunWorkItem} in Prisma; engine still uses {@link PersistedRunState} queue + pending.
+ */
+interface PersistedRunWorkItemRecord {
+  readonly workItemId: WorkItemId;
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly kind: PersistedRunWorkItemKind;
+  readonly orderIndex: number;
+  readonly status: WorkItemStatus;
+  readonly queueName?: string;
+  readonly claimToken?: string;
+  readonly claimedBy?: string;
+  readonly claimedAt?: string;
+  readonly availableAt: string;
+  readonly enqueuedAt: string;
+  readonly completedAt?: string;
+  readonly failedAt?: string;
+  readonly sourceInstanceId?: ExecutionInstanceId;
+  readonly parentInstanceId?: ExecutionInstanceId;
+  readonly itemsIn: number;
+  /** Queue entry when kind is queue; pending activation when kind is pending. */
+  readonly payloadJson: string;
+  readonly error?: Readonly<NodeExecutionError>;
+}
+/**
+ * Payload policy fields for large-batch externalization (optional on first rollout).
+ */
+interface ExecutionPayloadPolicyFields {
+  readonly inputStorageKind: PayloadStorageKind;
+  readonly outputStorageKind: PayloadStorageKind;
+  readonly inputBytes?: number;
+  readonly outputBytes?: number;
+  readonly inputPreviewJson?: unknown;
+  readonly outputPreviewJson?: unknown;
+  readonly inputPayloadRef?: string;
+  readonly outputPayloadRef?: string;
+  readonly inputTruncated?: boolean;
+  readonly outputTruncated?: boolean;
+}
+/**
+ * One persisted execution row (workflow node activation or connection invocation).
+ */
+interface PersistedExecutionInstanceRecord {
+  readonly instanceId: ExecutionInstanceId;
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly slotNodeId: NodeId;
+  readonly workflowNodeId: NodeId;
+  readonly kind: PersistedExecutionInstanceKind;
+  readonly connectionKind?: ConnectionInvocationKind;
+  readonly activationId?: NodeActivationId;
+  readonly batchId: BatchId;
+  readonly runIndex: number;
+  readonly parentInstanceId?: ExecutionInstanceId;
+  readonly parentRunId?: RunId;
+  readonly workerClaimToken?: string;
+  readonly status: NodeExecutionStatus;
+  readonly queuedAt?: string;
+  readonly startedAt?: string;
+  readonly finishedAt?: string;
+  readonly updatedAt: string;
+  readonly itemCount: number;
+  readonly inputJson?: string;
+  readonly outputJson?: string;
+  readonly errorJson?: string;
+  readonly inputItemIndicesJson?: string;
+  readonly outputItemCount?: number;
+  readonly successfulItemCount?: number;
+  readonly failedItemCount?: number;
+  readonly truncatedInputPreviewJson?: string;
+  readonly truncatedOutputPreviewJson?: string;
+  readonly inputTruncated?: boolean;
+  readonly outputTruncated?: boolean;
+  readonly usedPinnedOutput?: boolean;
+  readonly payloadPolicy?: ExecutionPayloadPolicyFields;
+}
+/**
+ * Cached slot projection for planner/debugger/UI (not canonical history).
+ */
+interface RunSlotProjectionState {
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly revision: RunRevision;
+  readonly slotStatesByNodeId: Record<NodeId, Readonly<{
+    latestInstanceId?: ExecutionInstanceId;
+    latestTerminalInstanceId?: ExecutionInstanceId;
+    latestRunningInstanceId?: ExecutionInstanceId;
+    latestStatus?: NodeExecutionStatus;
+    invocationCount: number;
+    runCount: number;
+  }>>;
+}
+interface PersistedRunSlotProjectionRecord {
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly revision: RunRevision;
+  readonly updatedAt: string;
+  readonly slotStatesJson: string;
+}
+interface WorkflowRunDetailDto {
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly startedAt: string;
+  readonly finishedAt?: string;
+  readonly status: RunStatus;
+  readonly workflowSnapshot?: PersistedWorkflowSnapshot;
+  readonly mutableState?: PersistedMutableRunState;
+  readonly slotStates: ReadonlyArray<SlotExecutionStateDto>;
+  readonly executionInstances: ReadonlyArray<ExecutionInstanceDto>;
+}
+interface SlotExecutionStateDto {
+  readonly slotNodeId: NodeId;
+  readonly latestInstanceId?: ExecutionInstanceId;
+  readonly latestTerminalInstanceId?: ExecutionInstanceId;
+  readonly latestRunningInstanceId?: ExecutionInstanceId;
+  readonly status?: NodeExecutionStatus;
+  readonly invocationCount: number;
+  readonly runCount: number;
+}
+interface ExecutionInstanceDto {
+  readonly instanceId: ExecutionInstanceId;
+  readonly slotNodeId: NodeId;
+  readonly workflowNodeId: NodeId;
+  readonly parentInstanceId?: ExecutionInstanceId;
+  readonly kind: PersistedExecutionInstanceKind;
+  readonly connectionKind?: ConnectionInvocationKind;
+  readonly runIndex: number;
+  readonly batchId: BatchId;
+  readonly activationId?: NodeActivationId;
+  readonly status: NodeExecutionStatus;
+  readonly queuedAt?: string;
+  readonly startedAt?: string;
+  readonly finishedAt?: string;
+  readonly itemCount: number;
+  readonly inputJson?: JsonValue;
+  readonly outputJson?: JsonValue;
+  readonly error?: Readonly<NodeExecutionError>;
+}
+interface WorkflowDetailSelectionState {
+  readonly selectedSlotNodeId: NodeId | null;
+  readonly selectedInstanceId: ExecutionInstanceId | null;
+}
+//#endregion
 //#region src/contracts/runFinishedAtFactory.d.ts
-type RunFinishedAtSource = Pick<PersistedRunState, "status" | "nodeSnapshotsByNodeId">;
-/** Derives workflow end time from node snapshots for run listings. */
+type RunFinishedAtSource = Pick<PersistedRunState, "status" | "nodeSnapshotsByNodeId" | "finishedAt">;
+/** Derives workflow end time from persisted run root or node snapshots for run listings. */
 declare class RunFinishedAtFactory {
   static resolveIso(state: RunFinishedAtSource): string | undefined;
 }
@@ -1279,6 +1451,13 @@ declare class ConnectionNodeIdFactory {
   static toolConnectionNodeId(parentNodeId: NodeId, toolName: string): NodeId;
   static isLanguageModelConnectionNodeId(nodeId: NodeId): boolean;
   static isToolConnectionNodeId(nodeId: NodeId): boolean;
+  static parseLanguageModelConnectionNodeId(nodeId: NodeId): Readonly<{
+    parentNodeId: NodeId;
+  }> | undefined;
+  static parseToolConnectionNodeId(nodeId: NodeId): Readonly<{
+    parentNodeId: NodeId;
+    normalizedToolName: string;
+  }> | undefined;
   /** True when `nodeId` is a connection-owned child of `parentNodeId` (LLM or tool slot). */
   static isConnectionOwnedDescendantOf(parentNodeId: NodeId, nodeId: NodeId): boolean;
   /** Normalizes a tool display name to a stable id segment. */
@@ -1314,6 +1493,140 @@ declare class DefaultWorkflowGraphFactory implements WorkflowGraphFactory {
   create(def: WorkflowDefinition): WorkflowGraph;
 }
 //#endregion
+//#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/WorkflowSnapshotCodec.d.ts
 declare class WorkflowSnapshotCodec {
   private readonly tokenRegistry;
@@ -1332,6 +1645,62 @@ declare class WorkflowSnapshotCodec {
   private asRecord;
 }
 //#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/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/InMemoryLiveWorkflowRepository.d.ts
 declare class InMemoryLiveWorkflowRepository implements LiveWorkflowRepository {
   private readonly workflowsById;
@@ -1340,5 +1709,65 @@ declare class InMemoryLiveWorkflowRepository implements LiveWorkflowRepository {
   get(workflowId: WorkflowId): WorkflowDefinition | undefined;
 }
 //#endregion
-export { JsonArray as $, ConnectionInvocationRecord as $n, RunEventBus as $r, BinaryBody as $t, CredentialJsonRecord as A, TriggerNode as An, WorkflowExecutionRepository as Ar, TriggerNodeOutputJson as At, CredentialTypeId as B, WorkflowSnapshotFactory as Bn, inject as Br, WorkflowNodeConnection as Bt, CredentialBindingKey as C, NodeExecutionScheduler as Cn, RunStateResetRequest as Cr, RunDataSnapshot as Ct, CredentialHealthTester as D, PersistedTriggerSetupState as Dn, WebhookRunResult as Dr, RunnableNodeInputJson as Dt, CredentialHealthStatus as E, NodeResolver as En, RunSummary as Er, RunnableNodeConfig as Et, CredentialSessionFactoryArgs as F, TriggerTestItemsContext as Fn, Lifecycle as Fr, WorkflowErrorHandler as Ft, BinaryAttachment as G, WebhookInvocationMatch as Gn, predicateAwareClassFactory as Gr, WorkflowStoragePolicyResolver as Gt, CredentialUnboundError as H, HttpMethod as Hn, injectable as Hr, WorkflowPrunePolicySpec as Ht, CredentialSessionService as I, WorkflowNodeInstanceFactory as In, RegistrationOptions as Ir, WorkflowErrorHandlerSpec as It, ExecutionMode as J, WebhookTriggerRoutingDiagnostics as Jn, CoreTokens as Jr, runnableNodeInputType as Jt, BinaryPreviewKind as K, WebhookTriggerMatcher as Kn, registry as Kr, WorkflowStoragePolicySpec as Kt, CredentialSetupStatus as L, WorkflowRepository as Ln, TypeToken as Lr, WorkflowGraph as Lt, CredentialOAuth2AuthDefinition as M, TriggerSetupContext as Mn, DependencyContainer as Mr, UpstreamRefPlaceholder as Mt, CredentialRequirement as N, TriggerSetupStateFor as Nn, Disposable as Nr, WorkflowDefinition as Nt, CredentialInstanceId as O, TestableTriggerNode as On, WorkflowExecutionListingRepository as Or, RunnableNodeOutputJson as Ot, CredentialSessionFactory as P, TriggerSetupStateRepository as Pn, InjectionToken as Pr, WorkflowErrorContext as Pt, Items as Q, ConnectionInvocationId as Qn, RunEvent as Qr, BinaryAttachmentCreateRequest as Qt, CredentialType as R, WorkflowRunnerResolver as Rn, container as Rr, WorkflowGraphFactory as Rt, CredentialBinding as S, NodeExecutionRequestHandler as Sn, RunResult as Sr, RunDataFactory as St, CredentialHealth as T, NodeExecutor as Tn, RunStopCondition as Tr, RunIdFactory as Tt, OAuth2ProviderFromPublicConfig as U, TriggerInstanceId as Un, instanceCachingFactory as Ur, WorkflowStoragePolicyDecisionArgs as Ut, CredentialTypeRegistry as V, WorkflowSnapshotResolver as Vn, injectAll as Vr, WorkflowPolicyRuntimeDefaults as Vt, ActivationIdFactory as W, WebhookControlSignal as Wn, instancePerContainerCachingFactory as Wr, WorkflowStoragePolicyMode as Wt, Item as X, WorkflowActivationPolicy as Xn, EngineExecutionLimitsPolicy as Xr, triggerNodeOutputType as Xt, InputPortKey as Y, AllWorkflowsActiveWorkflowActivationPolicy as Yn, ENGINE_EXECUTION_LIMITS_DEFAULTS as Yr, runnableNodeOutputType as Yt, ItemBinary as Z, ConnectionInvocationAppendArgs as Zn, EngineExecutionLimitsPolicyConfig as Zr, triggerNodeSetupStateType as Zt, StepSequenceOutput as _, NodeActivationRequestBase as _n, RunCurrentState as _r, OutputPortKey as _t, WorkflowExecutableNodeClassifier as a, FixedRetryPolicySpec as ai, EngineDeps as an, NodeExecutionStatus as ar, NodeConfigBase as at, AnyCredentialType as b, NodeExecutionContext as bn, RunPruneCandidate as br, PersistedRunPolicySnapshot as bt, WorkflowBuilder as c, ExecutionBinaryService as cn, PersistedMutableNodeState as cr, NodeErrorHandler as ct, AnyRunnableNodeConfig as d, LiveWorkflowRepository as dn, PersistedRunState as dr, NodeId as dt, RunEventSubscription as ei, BinaryStorage as en, CurrentStateExecutionRequest as er, JsonObject as et, AnyTriggerNodeConfig as f, MultiInputNode as fn, PersistedWorkflowSnapshot as fr, NodeKind as ft, BranchStepsArg as g, NodeActivationRequest as gn, RunCompletionNotifier as gr, NodeSchedulerDecision as gt, BranchOutputGuard as h, NodeActivationReceipt as hn, PinnedNodeOutputsByPort as hr, NodeRef as ht, WorkflowExecutableNodeClassifierFactory as i, ExponentialRetryPolicySpec as ii, BinaryStorageWriteResult as in, NodeExecutionSnapshot as ir, NodeActivationId as it, CredentialMaterialSourceKind as j, TriggerRuntimeDiagnostics as jn, Container as jr, TriggerNodeSetupState as jt, CredentialInstanceRecord as k, TriggerCleanupHandle as kn, WorkflowExecutionPruneRepository as kr, TriggerNodeConfig as kt, ChainCursor as l, ExecutionContext as ln, PersistedMutableRunState as lr, NodeErrorHandlerArgs as lt, BranchMoreArgs as m, NodeActivationContinuation as mn, PersistedWorkflowTokenRegistryLike as mr, NodeOutputs as mt, WorkflowSnapshotCodec as n, RetryPolicy as ni, BinaryStorageStatResult as nn, ExecutionFrontierPlan as nr, JsonValue as nt, ConnectionNodeIdFactory as o, NoneRetryPolicySpec as oi, EngineHost as on, NodeInputsByPort as or, NodeConnectionName as ot, BooleanWhenOverloads as p, Node as pn, PersistedWorkflowSnapshotNode as pr, NodeOffloadPolicy as pt, Edge as q, WebhookTriggerResolution as qn, singleton as qr, branchRef as qt, DefaultWorkflowGraphFactory as r, NoRetryPolicy as ri, BinaryStorageWriteRequest as rn, NodeExecutionError as rr, MutableRunData as rt, ConnectionInvocationIdFactory as s, RetryPolicySpec as si, ExecutableTriggerNode as sn, PendingNodeExecution as sr, NodeDefinition as st, InMemoryLiveWorkflowRepository as t, ExpRetryPolicy as ti, BinaryStorageReadResult as tn, EngineRunCounters as tr, JsonPrimitive as tt, WhenBuilder as u, ExecutionContextFactory as un, PersistedRunControlState as ur, NodeErrorHandlerSpec as ut, ValidStepSequence as v, NodeActivationScheduler as vn, RunEventPublisherDeps as vr, PairedItemRef as vt, CredentialFieldSchema as w, NodeExecutionStatePublisher as wn, RunStatus as wr, RunId as wt, CredentialAuthDefinition as x, NodeExecutionRequest as xn, RunQueueEntry as xr, PersistedTokenId as xt, RunFinishedAtFactory as y, NodeBinaryAttachmentService as yn, RunExecutionOptions as yr, ParentExecutionRef as yt, CredentialTypeDefinition as z, WorkflowRunnerService as zn, delay as zr, WorkflowId as zt };
-//# sourceMappingURL=InMemoryLiveWorkflowRepository-DxoualoC.d.ts.map
+//#region src/runtime/RunIntentService.d.ts
+type StartWorkflowIntent = {
+  workflow: WorkflowDefinition;
+  startAt?: string;
+  items: Items;
+  synthesizeTriggerItems?: boolean;
+  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;
+  synthesizeTriggerItems?: boolean;
+  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>;
+  private resolveStartWorkflowItems;
+  private resolveRerunItems;
+  private resolveStartWorkflowTriggerNodeId;
+  private resolveRerunTriggerNodeId;
+  private firstTriggerNodeId;
+  private isTriggerNode;
+  private hasNonEmptyItems;
+  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
+export { CredentialHealthTester as $, PersistedTriggerSetupState as $n, RunStopCondition as $r, RunnableNodeInputJson as $t, ExecutionInstanceDto as A, RetryPolicy as Ai, BinaryStorageWriteResult as An, NodeExecutionError as Ar, NodeActivationId as At, RunSlotProjectionState as B, NodeActivationContinuation as Bn, PersistedWorkflowSnapshot as Br, NodeOutputs as Bt, BranchOutputGuard as C, ENGINE_EXECUTION_LIMITS_DEFAULTS as Ci, triggerNodeSetupStateType as Cn, WorkflowActivationPolicy as Cr, ItemBinary as Ct, RunFinishedAtFactory as D, RunEventBus as Di, BinaryStorageReadResult as Dn, CurrentStateExecutionRequest as Dr, JsonPrimitive as Dt, ValidStepSequence as E, RunEvent as Ei, BinaryStorage as En, ConnectionInvocationRecord as Er, JsonObject as Et, PersistedExecutionInstanceRecord as F, RetryPolicySpec as Fi, ExecutionContext as Fn, PersistedMutableNodeState as Fr, NodeErrorHandlerArgs as Ft, WorkflowRunDetailDto as G, NodeBinaryAttachmentService as Gn, RunCurrentState as Gr, ParentExecutionRef as Gt, WorkItemId as H, NodeActivationRequest as Hn, PersistedWorkflowTokenRegistryLike as Hr, NodeSchedulerDecision as Ht, PersistedRunSlotProjectionRecord as I, ExecutionContextFactory as In, PersistedMutableRunState as Ir, NodeErrorHandlerSpec as It, CredentialBinding as J, NodeExecutionRequestHandler as Jn, RunPruneCandidate as Jr, RunDataFactory as Jt, AnyCredentialType as K, NodeExecutionContext as Kn, RunEventPublisherDeps as Kr, PersistedRunPolicySnapshot as Kt, PersistedRunWorkItemKind as L, LiveWorkflowRepository as Ln, PersistedRunControlState as Lr, NodeId as Lt, ExecutionPayloadPolicyFields as M, ExponentialRetryPolicySpec as Mi, EngineHost as Mn, NodeExecutionStatus as Mr, NodeConnectionName as Mt, PayloadStorageKind as N, FixedRetryPolicySpec as Ni, ExecutableTriggerNode as Nn, NodeInputsByPort as Nr, NodeDefinition as Nt, BatchId as O, RunEventSubscription as Oi, BinaryStorageStatResult as On, EngineRunCounters as Or, JsonValue as Ot, PersistedExecutionInstanceKind as P, NoneRetryPolicySpec as Pi, ExecutionBinaryService as Pn, PendingNodeExecution as Pr, NodeErrorHandler as Pt, CredentialHealthStatus as Q, NodeResolver as Qn, RunStatus as Qr, RunnableNodeConfig as Qt, PersistedRunWorkItemRecord as R, MultiInputNode as Rn, PersistedRunSchedulingState as Rr, NodeKind as Rt, BranchMoreArgs as S, CoreTokens as Si, triggerNodeOutputType as Sn, AllWorkflowsActiveWorkflowActivationPolicy as Sr, Item as St, StepSequenceOutput as T, EngineExecutionLimitsPolicyConfig as Ti, BinaryBody as Tn, ConnectionInvocationId as Tr, JsonArray as Tt, WorkItemStatus as U, NodeActivationRequestBase as Un, PinnedNodeOutputsByPort as Ur, OutputPortKey as Ut, SlotExecutionStateDto as V, NodeActivationReceipt as Vn, PersistedWorkflowSnapshotNode as Vr, NodeRef as Vt, WorkflowDetailSelectionState as W, NodeActivationScheduler as Wn, RunCompletionNotifier as Wr, PairedItemRef as Wt, CredentialFieldSchema as X, NodeExecutionStatePublisher as Xn, RunResult as Xr, RunId as Xt, CredentialBindingKey as Y, NodeExecutionScheduler as Yn, RunQueueEntry as Yr, RunDataSnapshot as Yt, CredentialHealth as Z, NodeExecutor as Zn, RunStateResetRequest as Zr, RunIdFactory as Zt, ChainCursor as _, instanceCachingFactory as _i, WorkflowStoragePolicyResolver as _n, WebhookControlSignal as _r, BinaryAttachment as _t, RunTerminalPersistenceCoordinator as a, Container as ai, WorkflowDefinition as an, TriggerSetupContext as ar, CredentialRequirement as at, AnyTriggerNodeConfig as b, registry as bi, runnableNodeInputType as bn, WebhookTriggerResolution as br, ExecutionMode as bt, EngineExecutionLimitsPolicyFactory as c, InjectionToken$1 as ci, WorkflowErrorHandlerSpec as cn, TriggerTestItemsContext as cr, CredentialSessionService as ct, DefaultWorkflowGraphFactory as d, TypeToken as di, WorkflowId as dn, WorkflowRunnerResolver as dr, CredentialTypeDefinition as dt, RunSummary as ei, RunnableNodeOutputJson as en, PreparedNodeActivationDispatch as er, CredentialInstanceId as et, WorkflowExecutableNodeClassifierFactory as f, container$1 as fi, WorkflowNodeConnection as fn, WorkflowRunnerService as fr, CredentialTypeId as ft, WorkflowBuilder as g, injectable as gi, WorkflowStoragePolicyMode as gn, TriggerInstanceId as gr, ActivationIdFactory as gt, ConnectionInvocationIdFactory as h, injectAll as hi, WorkflowStoragePolicyDecisionArgs as hn, HttpMethod as hr, OAuth2ProviderFromPublicConfig as ht, WorkflowPolicyErrorServices as i, WorkflowExecutionRepository as ii, UpstreamRefPlaceholder as in, TriggerRuntimeDiagnostics as ir, CredentialOAuth2AuthDefinition as it, ExecutionInstanceId as j, NoRetryPolicy as ji, EngineDeps as jn, NodeExecutionSnapshot as jr, NodeConfigBase as jt, ConnectionInvocationKind as k, ExpRetryPolicy as ki, BinaryStorageWriteRequest as kn, ExecutionFrontierPlan as kr, MutableRunData as kt, WorkflowSnapshotCodec as l, Lifecycle as li, WorkflowGraph as ln, WorkflowNodeInstanceFactory as lr, CredentialSetupStatus as lt, ConnectionNodeIdFactory as m, inject as mi, WorkflowPrunePolicySpec as mn, WorkflowSnapshotResolver as mr, CredentialUnboundError as mt, InMemoryLiveWorkflowRepository as n, WorkflowExecutionListingRepository as ni, TriggerNodeOutputJson as nn, TriggerCleanupHandle as nr, CredentialJsonRecord as nt, WorkflowStoragePolicyEvaluator as o, DependencyContainer$1 as oi, WorkflowErrorContext as on, TriggerSetupStateFor as or, CredentialSessionFactory as ot, WorkflowExecutableNodeClassifier as p, delay as pi, WorkflowPolicyRuntimeDefaults as pn, WorkflowSnapshotFactory as pr, CredentialTypeRegistry as pt, CredentialAuthDefinition as q, NodeExecutionRequest as qn, RunExecutionOptions as qr, PersistedTokenId as qt, EngineWorkflowRunnerService as r, WorkflowExecutionPruneRepository as ri, TriggerNodeSetupState as rn, TriggerNode as rr, CredentialMaterialSourceKind as rt, RunPolicySnapshotFactory as s, Disposable as si, WorkflowErrorHandler as sn, TriggerSetupStateRepository as sr, CredentialSessionFactoryArgs as st, RunIntentService as t, WebhookRunResult as ti, TriggerNodeConfig as tn, TestableTriggerNode as tr, CredentialInstanceRecord as tt, Engine as u, RegistrationOptions as ui, WorkflowGraphFactory as un, WorkflowRepository as ur, CredentialType as ut, WhenBuilder as v, instancePerContainerCachingFactory as vi, WorkflowStoragePolicySpec as vn, WebhookInvocationMatch as vr, BinaryPreviewKind as vt, BranchStepsArg as w, EngineExecutionLimitsPolicy as wi, BinaryAttachmentCreateRequest as wn, ConnectionInvocationAppendArgs as wr, Items as wt, BooleanWhenOverloads as x, singleton as xi, runnableNodeOutputType as xn, WebhookTriggerRoutingDiagnostics as xr, InputPortKey as xt, AnyRunnableNodeConfig as y, predicateAwareClassFactory as yi, branchRef as yn, WebhookTriggerMatcher as yr, Edge as yt, RunRevision as z, Node as zn, PersistedRunState as zr, NodeOffloadPolicy as zt };
+//# sourceMappingURL=RunIntentService-BCvGdOSY.d.ts.map