@codemation/core 0.0.1

package/dist/RunIntentService-DEo6GTTo.d.cts

@@ -0,0 +1,289 @@
+import { B as NodeActivationId, Bt as BinaryStorageWriteResult, Cn as HttpMethod, D as BinaryAttachment, Dn as WebhookTriggerMatcher, En as WebhookInvocationMatch, Fn as CurrentStateExecutionRequest, Fr as RetryPolicySpec, Ft as BinaryBody, Gt as ExecutionContext, It as BinaryStorage, Kt as ExecutionContextFactory, Lt as BinaryStorageReadResult, On as WebhookTriggerResolution, P as Items, Qn as RunCurrentState, Rt as BinaryStorageStatResult, Sn as WorkflowSnapshotResolver, Vn as NodeInputsByPort, Wt as ExecutionBinaryService, X as NodeOutputs, Yn as PersistedWorkflowTokenRegistryLike, Yt as NodeActivationContinuation, ar as RunResult, at as RunDataSnapshot, dr as WebhookRunResult, en as NodeBinaryAttachmentService, er as RunExecutionOptions, gn as WorkflowCatalog, ht as WorkflowDefinition, in as NodeExecutionStatePublisher, it as RunDataFactory, lr as RunStopCondition, ot as RunId, q as NodeId, sr as RunStateStore, tn as NodeExecutionContext, tt as ParentExecutionRef, v as CredentialSessionService, vn as WorkflowRepository, xt as WorkflowId, z as MutableRunData } from "./InMemoryWorkflowCatalog-C_ACeLyW.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<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["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 EngineFacadeDeps {
+  workflowCatalog: WorkflowCatalog;
+  tokenRegistry: PersistedWorkflowTokenRegistryLike;
+  webhookTriggerMatcher: WebhookTriggerMatcher;
+  workflowSnapshotResolver: WorkflowSnapshotResolver;
+  triggerRuntime: EngineTriggerRuntime;
+  runStartService: EngineRunStartService;
+  runContinuationService: EngineRunContinuationService;
+}
+/**
+ * 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 {
+  private readonly deps;
+  constructor(deps: EngineFacadeDeps);
+  loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  getTokenRegistry(): EngineFacadeDeps["tokenRegistry"];
+  resolveWorkflowSnapshot(args: {
+    workflowId: WorkflowId;
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["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<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["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>;
+}
+//#endregion
+//#region src/policies/EngineExecutionLimitsPolicy.d.ts
+interface EngineExecutionLimitsPolicyConfig {
+  readonly defaultMaxNodeActivations: number;
+  readonly hardMaxNodeActivations: number;
+  readonly defaultMaxSubworkflowDepth: number;
+  readonly hardMaxSubworkflowDepth: number;
+}
+/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
+declare const ENGINE_EXECUTION_LIMITS_DEFAULTS: EngineExecutionLimitsPolicyConfig;
+/**
+ * Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
+ */
+declare class EngineExecutionLimitsPolicy {
+  private readonly config;
+  constructor(config?: EngineExecutionLimitsPolicyConfig);
+  /**
+   * Effective options for a new root run (depth 0): defaults merged with engine ceilings.
+   * Replaces a separate one-method factory for root-run bootstrap.
+   */
+  createRootExecutionOptions(): RunExecutionOptions;
+  mergeExecutionOptionsForNewRun(parent: ParentExecutionRef | undefined, user: RunExecutionOptions | undefined): RunExecutionOptions;
+  private capNumber;
+}
+//#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/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/executionContext/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/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/executionContext/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/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/runtime/RunIntentService.d.ts
+declare class RunIntentService {
+  private readonly engine;
+  private readonly workflowRepository;
+  constructor(engine: Engine, workflowRepository: WorkflowRepository);
+  startWorkflow(args: {
+    workflow: WorkflowDefinition;
+    startAt?: string;
+    items: Items;
+    parent?: CurrentStateExecutionRequest["parent"];
+    executionOptions?: RunExecutionOptions;
+    workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
+    mutableState?: CurrentStateExecutionRequest["mutableState"];
+    currentState?: RunCurrentState;
+    stopCondition?: RunStopCondition;
+    reset?: CurrentStateExecutionRequest["reset"];
+  }): Promise<RunResult>;
+  rerunFromNode(args: {
+    workflow: WorkflowDefinition;
+    nodeId: string;
+    currentState: RunCurrentState;
+    items?: Items;
+    parent?: CurrentStateExecutionRequest["parent"];
+    executionOptions?: RunExecutionOptions;
+    workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
+    mutableState?: CurrentStateExecutionRequest["mutableState"];
+  }): Promise<RunResult>;
+  resolveWebhookTrigger(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookTriggerResolution;
+  runMatchedWebhook(args: {
+    endpointPath: string;
+    method: HttpMethod;
+    requestItem: Items[number];
+  }): Promise<WebhookRunResult>;
+  runWebhookMatch(args: {
+    match: WebhookInvocationMatch;
+    requestItem: Items[number];
+  }): Promise<WebhookRunResult>;
+}
+//#endregion
+export { DefaultExecutionBinaryService as a, InProcessRetryRunner as c, ENGINE_EXECUTION_LIMITS_DEFAULTS as d, EngineExecutionLimitsPolicy as f, DefaultExecutionContextFactory as i, DefaultAsyncSleeper as l, Engine as m, InMemoryRunDataFactory as n, UnavailableBinaryStorage as o, EngineExecutionLimitsPolicyConfig as p, InMemoryBinaryStorage as r, CredentialResolverFactory as s, RunIntentService as t, AsyncSleeper as u };
+//# sourceMappingURL=RunIntentService-DEo6GTTo.d.cts.map