@codemation/core 0.11.0 → 0.12.0

package/dist/RunIntentService-BOSGwmqn.d.ts

@@ -0,0 +1,299 @@
+import { $t as PersistedRunState, Ar as RunId, Bt as CurrentStateExecutionRequest, Di as LiveWorkflowRepository, Dr as PersistedRunPolicySnapshot, Er as ParentExecutionRef, Gi as ResumeContext, Hn as EngineExecutionLimitsPolicyConfig, Hr as WorkflowErrorHandlerSpec, Ii as NodeExecutionRequest, Jr as WorkflowStoragePolicyDecisionArgs, Kr as WorkflowPolicyRuntimeDefaults, Kt as NodeInputsByPort, Li as NodeExecutionRequestHandler, Oo as WorkflowId, Sr as NodeOutputs, To as NodeId, Vi as NodeResolver, Vn as EngineExecutionLimitsPolicy, Vr as WorkflowErrorHandler, ca as WorkflowSnapshotResolver, cn as RunExecutionOptions, dr as NodeActivationId, fa as WebhookInvocationMatch, fn as RunResult, fr as NodeConfigBase, gr as NodeErrorHandlerSpec, hn as RunStopCondition, ia as WorkflowRepository, ir as Items, ki as NodeActivationContinuation, la as HttpMethod, ma as WebhookTriggerResolution, mr as NodeErrorHandler, nn as PersistedWorkflowSnapshotNode, on as RunCurrentState, pa as WebhookTriggerMatcher, rn as PersistedWorkflowTokenRegistryLike, tn as PersistedWorkflowSnapshot, vn as WebhookRunResult, xn as WorkflowExecutionRepository, zr as WorkflowDefinition } from "./index-CSKKuK60.js";
+
+//#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" | "halted";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+  resumeRun(args: {
+    runId: RunId;
+    taskId: string;
+    resumeContext: ResumeContext;
+  }): Promise<RunResult>;
+}
+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" | "halted";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+  /**
+   * Re-activate a suspended run item with a human decision (HITL).
+   * The HTTP resume endpoint calls this; this method exposes the engine primitive.
+   */
+  resumeRun(args: {
+    runId: RunId;
+    taskId: string;
+    resumeContext: ResumeContext;
+  }): Promise<RunResult>;
+  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
+}
+//#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/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/workflowSnapshots/WorkflowSnapshotCodec.d.ts
+declare class WorkflowSnapshotCodec {
+  private readonly tokenRegistry;
+  constructor(tokenRegistry: PersistedWorkflowTokenRegistryLike);
+  create(workflow: WorkflowDefinition): PersistedWorkflowSnapshot;
+  hydrate(snapshotNode: PersistedWorkflowSnapshotNode, liveConfig: NodeConfigBase): NodeConfigBase;
+  private serializeConfig;
+  /**
+   * Safely call `config.inspectorSummary()` and return a plain JSON-safe array, or undefined.
+   * Returns undefined if the method is absent, throws, or produces no valid rows.
+   */
+  private safeInspectorSummary;
+  private injectTokenIds;
+  private mergeValue;
+  private mergeNestedValue;
+  private restoreNonSerializableProperties;
+  private restoreTypeProperty;
+  private resolveTokenId;
+  private resolveTokenName;
+  private asTypeToken;
+  private asRecord;
+}
+//#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;
+  setWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  list(): ReadonlyArray<WorkflowDefinition>;
+  get(workflowId: WorkflowId): WorkflowDefinition | undefined;
+}
+//#endregion
+//#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 { RunPolicySnapshotFactory as a, RunTerminalPersistenceCoordinator as c, WorkflowSnapshotCodec as i, WorkflowStoragePolicyEvaluator as l, InMemoryLiveWorkflowRepository as n, EngineExecutionLimitsPolicyFactory as o, EngineWorkflowRunnerService as r, WorkflowPolicyErrorServices as s, RunIntentService as t, Engine as u };
+//# sourceMappingURL=RunIntentService-BOSGwmqn.d.ts.map

package/dist/RunIntentService-CWMMrAP4.d.cts

@@ -0,0 +1,220 @@
+import { Ar as HttpMethod, D as RunCurrentState, Fr as WebhookTriggerResolution, H as WorkflowExecutionRepository, I as RunStopCondition, Jn as LiveWorkflowRepository, Ki as NodeId, Mt as NodeActivationId, N as RunResult, Nr as WebhookInvocationMatch, Pr as WebhookTriggerMatcher, Tr as WorkflowRepository, Tt as Items, Ut as NodeOutputs, Xn as NodeActivationContinuation, Yi as WorkflowId, Zt as RunId, fr as ResumeContext, ir as NodeExecutionRequestHandler, k as RunExecutionOptions, kr as WorkflowSnapshotResolver, on as WorkflowDefinition, p as NodeInputsByPort, qt as ParentExecutionRef, rr as NodeExecutionRequest, s as CurrentStateExecutionRequest, w as PersistedWorkflowTokenRegistryLike, z as WebhookRunResult } from "./agentMcpTypes-DUmniLOY.cjs";
+
+//#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" | "halted";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+  resumeRun(args: {
+    runId: RunId;
+    taskId: string;
+    resumeContext: ResumeContext;
+  }): Promise<RunResult>;
+}
+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" | "halted";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+  /**
+   * Re-activate a suspended run item with a human decision (HITL).
+   * The HTTP resume endpoint calls this; this method exposes the engine primitive.
+   */
+  resumeRun(args: {
+    runId: RunId;
+    taskId: string;
+    resumeContext: ResumeContext;
+  }): Promise<RunResult>;
+  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
+}
+//#endregion
+//#region src/runtime/InMemoryLiveWorkflowRepository.d.ts
+declare class InMemoryLiveWorkflowRepository implements LiveWorkflowRepository {
+  private readonly workflowsById;
+  setWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  list(): ReadonlyArray<WorkflowDefinition>;
+  get(workflowId: WorkflowId): WorkflowDefinition | undefined;
+}
+//#endregion
+//#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 { InMemoryLiveWorkflowRepository as n, Engine as r, RunIntentService as t };
+//# sourceMappingURL=RunIntentService-CWMMrAP4.d.cts.map