@codemation/core 0.0.19 → 0.2.1

package/dist/{InMemoryLiveWorkflowRepository-orY1VsWG.d.cts → RunIntentService-CV8izV8t.d.cts}

@@ -1,5 +1,5 @@
 import { ReadableStream } from "node:stream/web";
-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, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
 
 //#region src/contracts/retryPolicySpec.types.d.ts
 
@@ -318,10 +318,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;
@@ -353,6 +361,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>;
 }
@@ -703,6 +712,10 @@ interface NodeActivationReceipt {
   mode?: "local" | "worker";
   queue?: string;
 }
+interface PreparedNodeActivationDispatch {
+  readonly receipt: NodeActivationReceipt;
+  dispatch(): Promise<void>;
+}
 interface NodeActivationContinuation {
   markNodeRunning(args: {
     runId: RunId;
@@ -725,8 +738,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 {
@@ -800,8 +812,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;
@@ -1160,6 +1173,140 @@ declare class CredentialUnboundError extends Error {
   private static createMessage;
 }
 //#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/runtime/InMemoryLiveWorkflowRepository.d.ts
 declare class InMemoryLiveWorkflowRepository implements LiveWorkflowRepository {
   private readonly workflowsById;
@@ -1168,5 +1315,65 @@ declare class InMemoryLiveWorkflowRepository implements LiveWorkflowRepository {
   get(workflowId: WorkflowId): WorkflowDefinition | undefined;
 }
 //#endregion
-export { OutputPortKey as $, RunCurrentState as $n, NodeActivationRequestBase as $t, ExecutionMode as A, WebhookTriggerRoutingDiagnostics as An, CoreTokens as Ar, runnableNodeInputType as At, NodeActivationId as B, NodeExecutionSnapshot as Bn, RetryPolicySpec as Br, BinaryStorageWriteResult as Bt, CredentialTypeRegistry as C, WorkflowSnapshotResolver as Cn, injectAll as Cr, WorkflowPolicyRuntimeDefaults as Ct, BinaryAttachment as D, WebhookInvocationMatch as Dn, predicateAwareClassFactory as Dr, WorkflowStoragePolicyResolver as Dt, ActivationIdFactory as E, WebhookControlSignal as En, instancePerContainerCachingFactory as Er, WorkflowStoragePolicyMode as Et, JsonArray as F, ConnectionInvocationRecord as Fn, RunEventBus as Fr, BinaryBody as Ft, NodeErrorHandlerArgs as G, PersistedMutableRunState as Gn, ExecutionContext as Gt, NodeConnectionName as H, NodeInputsByPort as Hn, EngineHost as Ht, JsonObject as I, CurrentStateExecutionRequest as In, RunEventSubscription as Ir, BinaryStorage as It, NodeKind as J, PersistedWorkflowSnapshot as Jn, MultiInputNode as Jt, NodeErrorHandlerSpec as K, PersistedRunControlState as Kn, ExecutionContextFactory as Kt, JsonPrimitive as L, EngineRunCounters as Ln, ExponentialRetryPolicySpec as Lr, BinaryStorageReadResult as Lt, Item as M, WorkflowActivationPolicy as Mn, EngineExecutionLimitsPolicy as Mr, triggerNodeOutputType as Mt, ItemBinary as N, ConnectionInvocationAppendArgs as Nn, EngineExecutionLimitsPolicyConfig as Nr, triggerNodeSetupStateType as Nt, BinaryPreviewKind as O, WebhookTriggerMatcher as On, registry as Or, WorkflowStoragePolicySpec as Ot, Items as P, ConnectionInvocationId as Pn, RunEvent as Pr, BinaryAttachmentCreateRequest as Pt, NodeSchedulerDecision as Q, RunCompletionNotifier as Qn, NodeActivationRequest as Qt, JsonValue as R, ExecutionFrontierPlan as Rn, FixedRetryPolicySpec as Rr, BinaryStorageStatResult as Rt, CredentialTypeId as S, WorkflowSnapshotFactory as Sn, inject as Sr, WorkflowNodeConnection as St, OAuth2ProviderFromPublicConfig as T, TriggerInstanceId as Tn, instanceCachingFactory as Tr, WorkflowStoragePolicyDecisionArgs as Tt, NodeDefinition as U, PendingNodeExecution as Un, ExecutableTriggerNode as Ut, NodeConfigBase as V, NodeExecutionStatus as Vn, EngineDeps as Vt, NodeErrorHandler as W, PersistedMutableNodeState as Wn, ExecutionBinaryService as Wt, NodeOutputs as X, PersistedWorkflowTokenRegistryLike as Xn, NodeActivationContinuation as Xt, NodeOffloadPolicy as Y, PersistedWorkflowSnapshotNode as Yn, Node as Yt, NodeRef as Z, PinnedNodeOutputsByPort as Zn, NodeActivationReceipt as Zt, CredentialSessionFactoryArgs as _, TriggerTestItemsContext as _n, Lifecycle as _r, WorkflowErrorHandler as _t, CredentialBindingKey as a, NodeExecutionScheduler as an, RunStateResetRequest as ar, RunDataSnapshot as at, CredentialType as b, WorkflowRunnerResolver as bn, container as br, WorkflowGraphFactory as bt, CredentialHealthStatus as c, NodeResolver as cn, RunSummary as cr, RunnableNodeConfig as ct, CredentialInstanceRecord as d, TriggerCleanupHandle as dn, WorkflowExecutionPruneRepository as dr, TriggerNodeConfig as dt, NodeActivationScheduler as en, RunEventPublisherDeps as er, PairedItemRef as et, CredentialJsonRecord as f, TriggerNode as fn, WorkflowExecutionRepository as fr, TriggerNodeOutputJson as ft, CredentialSessionFactory as g, TriggerSetupStateRepository as gn, InjectionToken as gr, WorkflowErrorContext as gt, CredentialRequirement as h, TriggerSetupStateFor as hn, Disposable as hr, WorkflowDefinition as ht, CredentialBinding as i, NodeExecutionRequestHandler as in, RunResult as ir, RunDataFactory as it, InputPortKey as j, AllWorkflowsActiveWorkflowActivationPolicy as jn, ENGINE_EXECUTION_LIMITS_DEFAULTS as jr, runnableNodeOutputType as jt, Edge as k, WebhookTriggerResolution as kn, singleton as kr, branchRef as kt, CredentialHealthTester as l, PersistedTriggerSetupState as ln, WebhookRunResult as lr, RunnableNodeInputJson as lt, CredentialOAuth2AuthDefinition as m, TriggerSetupContext as mn, DependencyContainer as mr, UpstreamRefPlaceholder as mt, AnyCredentialType as n, NodeExecutionContext as nn, RunPruneCandidate as nr, PersistedRunPolicySnapshot as nt, CredentialFieldSchema as o, NodeExecutionStatePublisher as on, RunStatus as or, RunId as ot, CredentialMaterialSourceKind as p, TriggerRuntimeDiagnostics as pn, Container as pr, TriggerNodeSetupState as pt, NodeId as q, PersistedRunState as qn, LiveWorkflowRepository as qt, CredentialAuthDefinition as r, NodeExecutionRequest as rn, RunQueueEntry as rr, PersistedTokenId as rt, CredentialHealth as s, NodeExecutor as sn, RunStopCondition as sr, RunIdFactory as st, InMemoryLiveWorkflowRepository as t, NodeBinaryAttachmentService as tn, RunExecutionOptions as tr, ParentExecutionRef as tt, CredentialInstanceId as u, TestableTriggerNode as un, WorkflowExecutionListingRepository as ur, RunnableNodeOutputJson as ut, CredentialSessionService as v, WorkflowNodeInstanceFactory as vn, RegistrationOptions as vr, WorkflowErrorHandlerSpec as vt, CredentialUnboundError as w, HttpMethod as wn, injectable as wr, WorkflowPrunePolicySpec as wt, CredentialTypeDefinition as x, WorkflowRunnerService as xn, delay as xr, WorkflowId as xt, CredentialSetupStatus as y, WorkflowRepository as yn, TypeToken as yr, WorkflowGraph as yt, MutableRunData as z, NodeExecutionError as zn, NoneRetryPolicySpec as zr, BinaryStorageWriteRequest as zt };
-//# sourceMappingURL=InMemoryLiveWorkflowRepository-orY1VsWG.d.cts.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 { NodeRef as $, PersistedWorkflowSnapshotNode as $n, NodeActivationReceipt as $t, BinaryPreviewKind as A, WebhookInvocationMatch as An, instancePerContainerCachingFactory as Ar, WorkflowStoragePolicySpec as At, JsonValue as B, EngineRunCounters as Bn, RunEventSubscription as Br, BinaryStorageStatResult as Bt, CredentialTypeDefinition as C, WorkflowRunnerResolver as Cn, TypeToken as Cr, WorkflowId as Ct, OAuth2ProviderFromPublicConfig as D, HttpMethod as Dn, injectAll as Dr, WorkflowStoragePolicyDecisionArgs as Dt, CredentialUnboundError as E, WorkflowSnapshotResolver as En, inject as Er, WorkflowPrunePolicySpec as Et, ItemBinary as F, WorkflowActivationPolicy as Fn, ENGINE_EXECUTION_LIMITS_DEFAULTS as Fr, triggerNodeSetupStateType as Ft, NodeDefinition as G, NodeInputsByPort as Gn, ExecutableTriggerNode as Gt, NodeActivationId as H, NodeExecutionError as Hn, FixedRetryPolicySpec as Hr, BinaryStorageWriteResult as Ht, Items as I, ConnectionInvocationAppendArgs as In, EngineExecutionLimitsPolicy as Ir, BinaryAttachmentCreateRequest as It, NodeErrorHandlerSpec as J, PersistedMutableRunState as Jn, ExecutionContextFactory as Jt, NodeErrorHandler as K, PendingNodeExecution as Kn, ExecutionBinaryService as Kt, JsonArray as L, ConnectionInvocationId as Ln, EngineExecutionLimitsPolicyConfig as Lr, BinaryBody as Lt, ExecutionMode as M, WebhookTriggerResolution as Mn, registry as Mr, runnableNodeInputType as Mt, InputPortKey as N, WebhookTriggerRoutingDiagnostics as Nn, singleton as Nr, runnableNodeOutputType as Nt, ActivationIdFactory as O, TriggerInstanceId as On, injectable as Or, WorkflowStoragePolicyMode as Ot, Item as P, AllWorkflowsActiveWorkflowActivationPolicy as Pn, CoreTokens as Pr, triggerNodeOutputType as Pt, NodeOutputs as Q, PersistedWorkflowSnapshot as Qn, NodeActivationContinuation as Qt, JsonObject as R, ConnectionInvocationRecord as Rn, RunEvent as Rr, BinaryStorage as Rt, CredentialType as S, WorkflowRepository as Sn, RegistrationOptions as Sr, WorkflowGraphFactory as St, CredentialTypeRegistry as T, WorkflowSnapshotFactory as Tn, delay as Tr, WorkflowPolicyRuntimeDefaults as Tt, NodeConfigBase as U, NodeExecutionSnapshot as Un, NoneRetryPolicySpec as Ur, EngineDeps as Ut, MutableRunData as V, ExecutionFrontierPlan as Vn, ExponentialRetryPolicySpec as Vr, BinaryStorageWriteRequest as Vt, NodeConnectionName as W, NodeExecutionStatus as Wn, RetryPolicySpec as Wr, EngineHost as Wt, NodeKind as X, PersistedRunSchedulingState as Xn, MultiInputNode as Xt, NodeId as Y, PersistedRunControlState as Yn, LiveWorkflowRepository as Yt, NodeOffloadPolicy as Z, PersistedRunState as Zn, Node as Zt, CredentialRequirement as _, TriggerSetupContext as _n, Container as _r, WorkflowDefinition as _t, CredentialAuthDefinition as a, NodeExecutionRequest as an, RunExecutionOptions as ar, PersistedTokenId as at, CredentialSessionService as b, TriggerTestItemsContext as bn, InjectionToken$1 as br, WorkflowErrorHandlerSpec as bt, CredentialFieldSchema as c, NodeExecutionStatePublisher as cn, RunResult as cr, RunId as ct, CredentialHealthTester as d, PersistedTriggerSetupState as dn, RunStopCondition as dr, RunnableNodeInputJson as dt, NodeActivationRequest as en, PersistedWorkflowTokenRegistryLike as er, NodeSchedulerDecision as et, CredentialInstanceId as f, PreparedNodeActivationDispatch as fn, RunSummary as fr, RunnableNodeOutputJson as ft, CredentialOAuth2AuthDefinition as g, TriggerRuntimeDiagnostics as gn, WorkflowExecutionRepository as gr, UpstreamRefPlaceholder as gt, CredentialMaterialSourceKind as h, TriggerNode as hn, WorkflowExecutionPruneRepository as hr, TriggerNodeSetupState as ht, AnyCredentialType as i, NodeExecutionContext as in, RunEventPublisherDeps as ir, PersistedRunPolicySnapshot as it, Edge as j, WebhookTriggerMatcher as jn, predicateAwareClassFactory as jr, branchRef as jt, BinaryAttachment as k, WebhookControlSignal as kn, instanceCachingFactory as kr, WorkflowStoragePolicyResolver as kt, CredentialHealth as l, NodeExecutor as ln, RunStateResetRequest as lr, RunIdFactory as lt, CredentialJsonRecord as m, TriggerCleanupHandle as mn, WorkflowExecutionListingRepository as mr, TriggerNodeOutputJson as mt, InMemoryLiveWorkflowRepository as n, NodeActivationScheduler as nn, RunCompletionNotifier as nr, PairedItemRef as nt, CredentialBinding as o, NodeExecutionRequestHandler as on, RunPruneCandidate as or, RunDataFactory as ot, CredentialInstanceRecord as p, TestableTriggerNode as pn, WebhookRunResult as pr, TriggerNodeConfig as pt, NodeErrorHandlerArgs as q, PersistedMutableNodeState as qn, ExecutionContext as qt, Engine as r, NodeBinaryAttachmentService as rn, RunCurrentState as rr, ParentExecutionRef as rt, CredentialBindingKey as s, NodeExecutionScheduler as sn, RunQueueEntry as sr, RunDataSnapshot as st, RunIntentService as t, NodeActivationRequestBase as tn, PinnedNodeOutputsByPort as tr, OutputPortKey as tt, CredentialHealthStatus as u, NodeResolver as un, RunStatus as ur, RunnableNodeConfig as ut, CredentialSessionFactory as v, TriggerSetupStateFor as vn, DependencyContainer$1 as vr, WorkflowErrorContext as vt, CredentialTypeId as w, WorkflowRunnerService as wn, container as wr, WorkflowNodeConnection as wt, CredentialSetupStatus as x, WorkflowNodeInstanceFactory as xn, Lifecycle as xr, WorkflowGraph as xt, CredentialSessionFactoryArgs as y, TriggerSetupStateRepository as yn, Disposable as yr, WorkflowErrorHandler as yt, JsonPrimitive as z, CurrentStateExecutionRequest as zn, RunEventBus as zr, BinaryStorageReadResult as zt };
+//# sourceMappingURL=RunIntentService-CV8izV8t.d.cts.map