@hexabot-ai/agentic 3.0.1-alpha.0

package/dist/types/dsl.types.d.ts

@@ -0,0 +1,220 @@
+import { z } from 'zod';
+import type { BindingKindSchemas } from './bindings/base-binding';
+export declare const ExpressionStringSchema: z.ZodString;
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare const DEFAULT_TIMEOUT_MS = 0;
+export declare const DEFAULT_RETRY_SETTINGS: {
+    readonly enabled: false;
+    readonly max_attempts: 3;
+    readonly backoff_ms: 25;
+    readonly max_delay_ms: 10000;
+    readonly jitter: 0;
+    readonly multiplier: 1;
+};
+export type InputField = {
+    type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+    description?: string;
+    enum?: Array<string | number | boolean>;
+    items?: InputField;
+    properties?: Record<string, InputField>;
+};
+export type ConditionalBranch = {
+    condition: string;
+    steps: FlowStep[];
+} | {
+    else?: unknown;
+    steps: FlowStep[];
+};
+export type ConditionalBlock = {
+    description?: string;
+    when: ConditionalBranch[];
+};
+export type ParallelBlock = {
+    description?: string;
+    strategy?: 'wait_all' | 'wait_any';
+    steps: FlowStep[];
+};
+export type LoopAccumulate = {
+    as: string;
+    initial: JsonValue;
+    merge: string;
+};
+type BaseLoopStep = {
+    name?: string;
+    description?: string;
+    accumulate?: LoopAccumulate;
+    steps: FlowStep[];
+};
+export type ForEachLoopStep = BaseLoopStep & {
+    type: 'for_each';
+    for_each: {
+        item: string;
+        in: string;
+    };
+    max_concurrency?: number;
+    until?: string;
+};
+export type WhileLoopStep = BaseLoopStep & {
+    type: 'while';
+    while: string;
+};
+export type LoopStep = ForEachLoopStep | WhileLoopStep;
+export type FlowStep = {
+    do: string;
+} | {
+    parallel: ParallelBlock;
+} | {
+    conditional: ConditionalBlock;
+} | {
+    loop: LoopStep;
+};
+export declare const JsonValueSchema: z.ZodType<JsonValue>;
+export declare const BaseSettingsSchema: z.ZodObject<{
+    timeout_ms: z.ZodOptional<z.ZodInt>;
+    retries: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        max_attempts: z.ZodDefault<z.ZodInt>;
+        backoff_ms: z.ZodDefault<z.ZodInt>;
+        max_delay_ms: z.ZodDefault<z.ZodInt>;
+        jitter: z.ZodDefault<z.ZodNumber>;
+        multiplier: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const SettingsSchema: z.ZodObject<{
+    timeout_ms: z.ZodOptional<z.ZodInt>;
+    retries: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        max_attempts: z.ZodDefault<z.ZodInt>;
+        backoff_ms: z.ZodDefault<z.ZodInt>;
+        max_delay_ms: z.ZodDefault<z.ZodInt>;
+        jitter: z.ZodDefault<z.ZodNumber>;
+        multiplier: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$catchall<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+export declare const TASK_KIND: "task";
+export declare const TaskDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"task">;
+    description: z.ZodOptional<z.ZodString>;
+    action: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    bindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        timeout_ms: z.ZodOptional<z.ZodInt>;
+        retries: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            max_attempts: z.ZodDefault<z.ZodInt>;
+            backoff_ms: z.ZodDefault<z.ZodInt>;
+            max_delay_ms: z.ZodDefault<z.ZodInt>;
+            jitter: z.ZodDefault<z.ZodNumber>;
+            multiplier: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$catchall<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+}, z.core.$strict>;
+export declare const DefDefinitionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"task">;
+    description: z.ZodOptional<z.ZodString>;
+    action: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    bindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        timeout_ms: z.ZodOptional<z.ZodInt>;
+        retries: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            max_attempts: z.ZodDefault<z.ZodInt>;
+            backoff_ms: z.ZodDefault<z.ZodInt>;
+            max_delay_ms: z.ZodDefault<z.ZodInt>;
+            jitter: z.ZodDefault<z.ZodNumber>;
+            multiplier: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$catchall<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    action: z.ZodOptional<z.ZodString>;
+    settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    bindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+}, z.core.$strict>]>;
+declare const ConditionalSchema: z.ZodType<{
+    description?: string;
+    when: ConditionalBranch[];
+}>;
+export declare const FlowStepSchema: z.ZodType<FlowStep>;
+export declare const WorkflowMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const WorkflowDefinitionSchema: z.ZodObject<{
+    inputs: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<InputField, unknown, z.core.$ZodTypeInternals<InputField, unknown>>>>;
+    }, z.core.$strict>>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        settings: z.ZodOptional<z.ZodObject<{
+            timeout_ms: z.ZodOptional<z.ZodInt>;
+            retries: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                max_attempts: z.ZodDefault<z.ZodInt>;
+                backoff_ms: z.ZodDefault<z.ZodInt>;
+                max_delay_ms: z.ZodDefault<z.ZodInt>;
+                jitter: z.ZodDefault<z.ZodNumber>;
+                multiplier: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$catchall<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+    }, z.core.$strict>>;
+    defs: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"task">;
+        description: z.ZodOptional<z.ZodString>;
+        action: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        bindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+        settings: z.ZodOptional<z.ZodObject<{
+            timeout_ms: z.ZodOptional<z.ZodInt>;
+            retries: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                max_attempts: z.ZodDefault<z.ZodInt>;
+                backoff_ms: z.ZodDefault<z.ZodInt>;
+                max_delay_ms: z.ZodDefault<z.ZodInt>;
+                jitter: z.ZodDefault<z.ZodNumber>;
+                multiplier: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$catchall<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        action: z.ZodOptional<z.ZodString>;
+        settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        bindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+    }, z.core.$strict>]>>;
+    flow: z.ZodArray<z.ZodType<FlowStep, unknown, z.core.$ZodTypeInternals<FlowStep, unknown>>>;
+    outputs: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>;
+export type Settings = z.infer<typeof SettingsSchema>;
+export type Conditional = z.infer<typeof ConditionalSchema>;
+export type TaskDefinition = z.infer<typeof TaskDefinitionSchema>;
+export type DefDefinition = z.infer<typeof DefDefinitionSchema>;
+export type DefDefinitions = z.infer<typeof WorkflowDefinitionSchema>['defs'];
+export type TaskDefinitions = Record<string, TaskDefinition>;
+export type WorkflowMetadata = z.infer<typeof WorkflowMetadataSchema>;
+export type WorkflowDefinition = z.infer<typeof WorkflowDefinitionSchema>;
+export type WorkflowValidationActionMetadata = {
+    supportedBindings?: readonly string[];
+};
+export type ValidateWorkflowOptions = {
+    bindingKinds?: BindingKindSchemas;
+    actions?: Record<string, WorkflowValidationActionMetadata>;
+};
+export type WorkflowValidationResult = {
+    success: true;
+    data: WorkflowDefinition;
+} | {
+    success: false;
+    errors: string[];
+};
+export declare const isTaskDefinition: (definition: DefDefinition) => definition is TaskDefinition;
+export declare const extractTaskDefinitions: (defs: DefDefinitions) => TaskDefinitions;
+export declare function validateWorkflow(input: string | unknown, options?: ValidateWorkflowOptions): WorkflowValidationResult;
+export {};
+//# sourceMappingURL=dsl.types.d.ts.map

package/dist/types/dsl.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsl.types.d.ts","sourceRoot":"","sources":["../../src/dsl.types.ts"],"names":[],"mappings":"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"}

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+export { AbstractAction } from './action/abstract-action';
+export { defineAction } from './action/action';
+export type { DefineActionParams } from './action/action';
+export type { Action, ActionExecutionArgs, ActionExecutionOutcome, ActionMetadata, Actions, InferActionArgs, InferActionBindings, InferActionContext, InferActionInput, InferActionOutput, InferActionSettings, SuspensionNotice, } from './action/action.types';
+export { BaseWorkflowContext, type ActionSnapshot, type ActionStatus, type StepExecutionRecord, type SuspensionOptions, type WorkflowRunStatus, type WorkflowRuntimeControl, type WorkflowSnapshot, } from './context';
+export * from './dsl.types';
+export type { BindingKindDescriptor, BindingKindSchemas, InferMountedBindingValue, InferWorkflowBindings, } from './bindings/base-binding';
+export { compileWorkflow, Workflow as Workflow, WorkflowEventEmitter, WorkflowRunner, type FlowStepPath, type WorkflowCompileOptions, type WorkflowResumeResult, type WorkflowRunOptions, type WorkflowStartResult, } from './workflow';
+export { StepType } from './workflow-event-emitter';
+export type { StepInfo, WorkflowEventEmitterLike, WorkflowEventMap, } from './workflow-event-emitter';
+export type { BaseStep as CompiledBaseStep, ConditionalBranch as CompiledConditionalBranch, ConditionalStep as CompiledConditionalStep, LoopStep as CompiledLoopStep, CompiledMapping, ParallelStep as CompiledParallelStep, CompiledStep, CompiledTask, CompiledTaskBindings, TaskStep as CompiledTaskStep, CompiledValue, CompiledWorkflow, EvaluationScope, ExecutionState, PersistedSuspension, RunnerResumeArgs, RunnerStartArgs, Suspension, ResumeResult as WorkflowResumeOutcome, StartResult as WorkflowStartOutcome, } from './workflow-types';
+export { NonDeterministicWorkflowError } from './runner-runtime-control';
+export { compileValue, evaluateMapping, evaluateValue, mergeSettings, type CompileValueOptions, type JsonataFunctionConfig, type JsonataFunctionImplementation, type JsonataFunctionRegistry, } from './workflow-values';
+export { createDeferred } from './utils/deferred';
+export type { Deferred } from './utils/deferred';
+export { assertSnakeCaseName, isSnakeCaseName, toSnakeCase, } from './utils/naming';
+export { sleep, withTimeout } from './utils/timeout';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,YAAY,EACV,MAAM,EACN,mBAAmB,EACnB,sBAAsB,EACtB,cAAc,EACd,OAAO,EACP,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,mBAAmB,EACnB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,GACtB,MAAM,WAAW,CAAC;AAEnB,cAAc,aAAa,CAAC;AAE5B,YAAY,EACV,qBAAqB,EACrB,kBAAkB,EAClB,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,eAAe,EACf,QAAQ,IAAI,QAAQ,EACpB,oBAAoB,EACpB,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,GACzB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,YAAY,EACV,QAAQ,EACR,wBAAwB,EACxB,gBAAgB,GACjB,MAAM,0BAA0B,CAAC;AAElC,YAAY,EACV,QAAQ,IAAI,gBAAgB,EAC5B,iBAAiB,IAAI,yBAAyB,EAC9C,eAAe,IAAI,uBAAuB,EAC1C,QAAQ,IAAI,gBAAgB,EAC5B,eAAe,EACf,YAAY,IAAI,oBAAoB,EACpC,YAAY,EACZ,YAAY,EACZ,oBAAoB,EACpB,QAAQ,IAAI,gBAAgB,EAC5B,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,YAAY,IAAI,qBAAqB,EACrC,WAAW,IAAI,oBAAoB,GACpC,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AAEzE,OAAO,EACL,YAAY,EACZ,eAAe,EACf,aAAa,EACb,aAAa,EACb,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,KAAK,uBAAuB,GAC7B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,YAAY,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,WAAW,GACZ,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/types/runner-runtime-control.d.ts

@@ -0,0 +1,64 @@
+import type { SuspensionOptions, WorkflowRunStatus, WorkflowRuntimeControl } from './context';
+import type { Deferred } from './utils/deferred';
+import type { WorkflowRunner } from './workflow-runner';
+export type RuntimeSuspensionRequest = {
+    stepId: string;
+    stepExecId: string;
+    suspendIndex: number;
+    suspendKey: string;
+    reason?: string;
+    data?: unknown;
+    awaitResults: Record<string, unknown>;
+    resume: Deferred<unknown>;
+};
+export type RuntimeStepReplaySeed = {
+    stepId: string;
+    stepExecId: string;
+    awaitResults?: Record<string, unknown>;
+    activeSuspension?: {
+        suspendIndex?: number;
+        suspendKey?: string;
+        reason?: string;
+    };
+};
+export type RuntimeResolvedSuspension = {
+    stepId: string;
+    resumeData: unknown;
+    stepExecId?: string;
+    suspendIndex?: number;
+    suspendKey?: string;
+};
+export declare class NonDeterministicWorkflowError extends Error {
+    constructor(message: string);
+}
+/** Minimal wrapper that exposes runner controls to actions via the context. */
+export declare class RunnerRuntimeControl implements WorkflowRuntimeControl {
+    private readonly runner;
+    private readonly pendingSuspensions;
+    private readonly suspensionWaiters;
+    private readonly primedResumeData;
+    private readonly stepAttempts;
+    private readonly activeStepExecutions;
+    private readonly replaySeeds;
+    constructor(runner: WorkflowRunner);
+    get status(): WorkflowRunStatus;
+    get resumeData(): unknown;
+    suspend<T = unknown>(options?: SuspensionOptions): Promise<T>;
+    resume(data?: unknown): void;
+    waitForStepSuspension(stepId: string): Promise<RuntimeSuspensionRequest>;
+    beginStepExecution(stepId: string): string;
+    prepareStepReplay(seed: RuntimeStepReplaySeed): void;
+    recordStepSuspendResult(params: RuntimeResolvedSuspension): void;
+    clearStepSuspensions(stepId: string, error?: unknown): void;
+    primeStepResumeData(stepId: string, resumeData: unknown): void;
+    getSnapshot(): import("./context").WorkflowSnapshot;
+    private enqueueSuspension;
+    private dequeueStepSuspension;
+    private dequeuePrimedResumeData;
+    private ensureStepExecution;
+    private assertReplayExpectation;
+    private normalizeAwaitResults;
+    private serializeAwaitResults;
+    private bumpStepAttemptCounter;
+}
+//# sourceMappingURL=runner-runtime-control.d.ts.map

package/dist/types/runner-runtime-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-runtime-control.d.ts","sourceRoot":"","sources":["../../src/runner-runtime-control.ts"],"names":[],"mappings":"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"}

package/dist/types/step-executors/conditional-executor.d.ts

@@ -0,0 +1,13 @@
+import type { ConditionalStep, ExecutionState, Suspension } from '../workflow-types';
+import type { StepExecutorEnv } from './types';
+/**
+ * Evaluate a conditional step by checking branches in order and executing the first match.
+ *
+ * @param env Executor environment providing helpers and workflow context.
+ * @param step The conditional step definition.
+ * @param state Mutable workflow execution state.
+ * @param path Path tokens locating this step within the workflow tree.
+ * @returns A suspension if a branch pauses execution, otherwise void.
+ */
+export declare function executeConditional(env: StepExecutorEnv, step: ConditionalStep, state: ExecutionState, path: Array<number | string>): Promise<Suspension | void>;
+//# sourceMappingURL=conditional-executor.d.ts.map

package/dist/types/step-executors/conditional-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-executor.d.ts","sourceRoot":"","sources":["../../../src/step-executors/conditional-executor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,UAAU,EACX,MAAM,mBAAmB,CAAC;AAI3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAC3B,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAoD5B"}

package/dist/types/step-executors/loop-executor.d.ts

@@ -0,0 +1,33 @@
+import type { EvaluationScope, ExecutionState, LoopStep, Suspension } from '../workflow-types';
+import type { StepExecutorEnv } from './types';
+type LoopScope = EvaluationScope;
+/**
+ * Execute a loop step by iterating over input items and executing child steps.
+ *
+ * @param env Executor environment with helpers and workflow context.
+ * @param step The loop step configuration.
+ * @param state Mutable workflow execution state.
+ * @param path Path tokens locating this loop within the workflow.
+ * @param startIndex Index to resume iteration from when continuing.
+ * @returns A suspension if a child step pauses execution, otherwise void.
+ */
+export declare function executeLoop(env: StepExecutorEnv, step: LoopStep, state: ExecutionState, path: Array<number | string>, startIndex?: number): Promise<Suspension | void>;
+/**
+ * Update the loop accumulator using the configured merge expression.
+ *
+ * @param step The loop step containing accumulation settings.
+ * @param scope Current evaluation scope for expressions.
+ * @param previous Previous accumulator value to merge with.
+ * @returns The updated accumulator value.
+ */
+export declare function updateAccumulator(step: LoopStep, scope: LoopScope, previous: unknown): Promise<unknown>;
+/**
+ * Determine whether loop execution should stop based on the `until` condition.
+ *
+ * @param step The loop step configuration.
+ * @param scope Current evaluation scope for expressions.
+ * @returns True if the loop should stop, otherwise false.
+ */
+export declare function shouldStopLoop(step: LoopStep, scope: LoopScope): Promise<boolean>;
+export {};
+//# sourceMappingURL=loop-executor.d.ts.map

package/dist/types/step-executors/loop-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-executor.d.ts","sourceRoot":"","sources":["../../../src/step-executors/loop-executor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EAEd,QAAQ,EACR,UAAU,EAEX,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,KAAK,SAAS,GAAG,eAAe,CAAC;AAEjC;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EAC5B,UAAU,SAAI,GACb,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAM5B;AA+LD;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,OAAO,CAAC,CASlB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,OAAO,CAAC,CAQlB"}

package/dist/types/step-executors/parallel-executor.d.ts

@@ -0,0 +1,14 @@
+import type { ExecutionState, ParallelStep, Suspension } from '../workflow-types';
+import type { StepExecutorEnv } from './types';
+/**
+ * Execute a set of steps in parallel order, respecting the configured strategy.
+ *
+ * @param env Executor environment providing helpers and workflow context.
+ * @param step The parallel step definition including strategy and children.
+ * @param state Mutable workflow execution state.
+ * @param path Path tokens locating this parallel block in the workflow.
+ * @param startIndex Index to resume execution from when continuing.
+ * @returns A suspension if a child pauses execution, otherwise void.
+ */
+export declare function executeParallel(env: StepExecutorEnv, step: ParallelStep, state: ExecutionState, path: Array<number | string>, startIndex?: number): Promise<Suspension | void>;
+//# sourceMappingURL=parallel-executor.d.ts.map

package/dist/types/step-executors/parallel-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-executor.d.ts","sourceRoot":"","sources":["../../../src/step-executors/parallel-executor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,UAAU,EACX,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EAC5B,UAAU,SAAI,GACb,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA6C5B"}

package/dist/types/step-executors/skip-helpers.d.ts

@@ -0,0 +1,12 @@
+import type { ActionSnapshot } from '../context';
+import { type StepInfo, type WorkflowEventMap } from '../workflow-event-emitter';
+import type { CompiledStep } from '../workflow-types';
+type SkipStepEnv = {
+    runId?: string;
+    buildInstanceStepInfo: (step: CompiledStep, iterationStack: number[]) => StepInfo;
+    markSnapshot: (step: StepInfo, status: ActionSnapshot['status'], reason?: string) => void;
+    emit: <K extends keyof WorkflowEventMap>(event: K, payload: WorkflowEventMap[K]) => void;
+};
+export declare const markStepsSkipped: (env: SkipStepEnv, steps: CompiledStep[], iterationStack: number[], reason?: string) => void;
+export {};
+//# sourceMappingURL=skip-helpers.d.ts.map

package/dist/types/step-executors/skip-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skip-helpers.d.ts","sourceRoot":"","sources":["../../../src/step-executors/skip-helpers.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,KAAK,WAAW,GAAG;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qBAAqB,EAAE,CACrB,IAAI,EAAE,YAAY,EAClB,cAAc,EAAE,MAAM,EAAE,KACrB,QAAQ,CAAC;IACd,YAAY,EAAE,CACZ,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,EAChC,MAAM,CAAC,EAAE,MAAM,KACZ,IAAI,CAAC;IACV,IAAI,EAAE,CAAC,CAAC,SAAS,MAAM,gBAAgB,EACrC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,KACzB,IAAI,CAAC;CACX,CAAC;AA+BF,eAAO,MAAM,gBAAgB,GAC3B,KAAK,WAAW,EAChB,OAAO,YAAY,EAAE,EACrB,gBAAgB,MAAM,EAAE,EACxB,SAAS,MAAM,SAGhB,CAAC"}

package/dist/types/step-executors/task-executor.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutionState, Suspension, TaskStep } from '../workflow-types';
+import type { StepExecutorEnv } from './types';
+/**
+ * Execute a task step by running its task and handling suspension or output mapping.
+ *
+ * @param env Executor environment with compiled workflow and helpers.
+ * @param step The compiled task step to execute.
+ * @param state Mutable workflow execution state.
+ * @param _path Location of the step within the workflow (unused in this executor).
+ * @returns A suspension if the task pauses execution, otherwise void.
+ */
+export declare function executeTaskStep(env: StepExecutorEnv, step: TaskStep, state: ExecutionState, _path: Array<number | string>): Promise<Suspension | void>;
+//# sourceMappingURL=task-executor.d.ts.map

package/dist/types/step-executors/task-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-executor.d.ts","sourceRoot":"","sources":["../../../src/step-executors/task-executor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAGV,cAAc,EACd,UAAU,EACV,QAAQ,EACT,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAO/C;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAC5B,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAiE5B"}

package/dist/types/step-executors/types.d.ts

@@ -0,0 +1,24 @@
+import type { ActionSnapshot, BaseWorkflowContext, StepExecutionRecord } from '../context';
+import type { RuntimeResolvedSuspension, RuntimeStepReplaySeed, RuntimeSuspensionRequest } from '../runner-runtime-control';
+import type { StepInfo, WorkflowEventMap } from '../workflow-event-emitter';
+import type { CompiledStep, CompiledTask, CompiledWorkflow, ExecutionState, Suspension } from '../workflow-types';
+export type StepExecutorEnv = {
+    compiled: CompiledWorkflow;
+    context: BaseWorkflowContext;
+    runId?: string;
+    buildInstanceStepInfo: (step: CompiledStep, iterationStack: number[]) => StepInfo;
+    markSnapshot: (step: StepInfo, status: ActionSnapshot['status'], reason?: string) => void;
+    recordStepExecution: (step: StepInfo, update: Partial<StepExecutionRecord>) => void;
+    emit: <K extends keyof WorkflowEventMap>(event: K, payload: WorkflowEventMap[K]) => void;
+    setCurrentStep: (step?: StepInfo) => void;
+    beginStepExecution?: (stepId: string) => string;
+    waitForStepSuspension: (stepId: string) => Promise<RuntimeSuspensionRequest>;
+    clearStepSuspensions: (stepId: string, error?: unknown) => void;
+    primeStepResumeData: (stepId: string, resumeData: unknown) => void;
+    prepareStepReplay?: (seed: RuntimeStepReplaySeed) => void;
+    recordStepSuspendResult?: (params: RuntimeResolvedSuspension) => void;
+    captureTaskOutput: (task: CompiledTask, state: ExecutionState, result: unknown) => Promise<void>;
+    executeFlow: (steps: CompiledStep[], state: ExecutionState, path: Array<number | string>, startIndex?: number) => Promise<Suspension | void>;
+    executeStep: (step: CompiledStep, state: ExecutionState, path: Array<number | string>) => Promise<Suspension | void>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types/step-executors/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/step-executors/types.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EACV,yBAAyB,EACzB,qBAAqB,EACrB,wBAAwB,EACzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,UAAU,EACX,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,OAAO,EAAE,mBAAmB,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qBAAqB,EAAE,CACrB,IAAI,EAAE,YAAY,EAClB,cAAc,EAAE,MAAM,EAAE,KACrB,QAAQ,CAAC;IACd,YAAY,EAAE,CACZ,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,EAChC,MAAM,CAAC,EAAE,MAAM,KACZ,IAAI,CAAC;IACV,mBAAmB,EAAE,CACnB,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,OAAO,CAAC,mBAAmB,CAAC,KACjC,IAAI,CAAC;IACV,IAAI,EAAE,CAAC,CAAC,SAAS,MAAM,gBAAgB,EACrC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,KACzB,IAAI,CAAC;IACV,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC1C,kBAAkB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IAChD,qBAAqB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC7E,oBAAoB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAChE,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;IACnE,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAC1D,uBAAuB,CAAC,EAAE,CAAC,MAAM,EAAE,yBAAyB,KAAK,IAAI,CAAC;IACtE,iBAAiB,EAAE,CACjB,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,OAAO,KACZ,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,WAAW,EAAE,CACX,KAAK,EAAE,YAAY,EAAE,EACrB,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EAC5B,UAAU,CAAC,EAAE,MAAM,KAChB,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAChC,WAAW,EAAE,CACX,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,KACzB,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;CACjC,CAAC"}

package/dist/types/suspension-rebuilder.d.ts

@@ -0,0 +1,67 @@
+import type { ActionSnapshot, BaseWorkflowContext } from './context';
+import type { StepExecutorEnv } from './step-executors/types';
+import { type StepInfo, type WorkflowEventMap } from './workflow-event-emitter';
+import type { CompiledStep, CompiledTask, CompiledWorkflow, ExecutionState, Suspension } from './workflow-types';
+export type SuspensionRebuilderDeps = {
+    compiled: CompiledWorkflow;
+    context?: BaseWorkflowContext;
+    runId?: string;
+    createExecutorEnv: () => StepExecutorEnv;
+    buildInstanceStepInfo: (step: CompiledStep, iterationStack: number[]) => StepInfo;
+    captureTaskOutput: (task: CompiledTask, state: ExecutionState, result: unknown) => Promise<void>;
+    markSnapshot: (step: StepInfo, status: ActionSnapshot['status'], reason?: string) => void;
+    emit: <K extends keyof WorkflowEventMap>(event: K, payload: WorkflowEventMap[K]) => void;
+    executeFlow: (steps: CompiledStep[], state: ExecutionState, path: Array<number | string>, startIndex?: number) => Promise<Suspension | void>;
+};
+type RebuildSuspensionMetadata = {
+    stepExecId?: string;
+    suspendIndex?: number;
+    suspendKey?: string;
+    reason?: string;
+    awaitResults?: Record<string, unknown>;
+};
+/**
+ * Parse a suspended step id into its execution path and iteration stack.
+ *
+ * @param stepId The serialized step identifier stored in snapshots.
+ * @returns The decoded path tokens and iteration stack.
+ */
+export declare function parseSuspendedStepId(stepId: string): {
+    path: Array<number | string>;
+    iterationStack: number[];
+};
+/**
+ * Rebuild a suspension object based on persisted state and step identifiers.
+ *
+ * @param deps Dependencies needed to reconstruct executors and events.
+ * @param param0 Persisted state and metadata about the suspended step.
+ * @param param0.state Execution state captured at suspension time.
+ * @param param0.stepId Serialized step id used to locate the suspension point.
+ * @param param0.reason Optional reason supplied when the workflow suspended.
+ * @param param0.data Arbitrary payload provided with the suspension.
+ * @returns A suspension ready to be resumed, or null if reconstruction fails.
+ */
+export declare function rebuildSuspension(deps: SuspensionRebuilderDeps, { state, stepId, reason, data, stepExecId, suspendIndex, suspendKey, awaitResults, }: {
+    state?: ExecutionState;
+    stepId: string;
+    reason?: string;
+    data?: unknown;
+    stepExecId?: string;
+    suspendIndex?: number;
+    suspendKey?: string;
+    awaitResults?: Record<string, unknown>;
+}): Suspension | null;
+/**
+ * Walk the compiled flow to rebuild the continuation matching a target path.
+ *
+ * @param deps Dependencies for executor creation and event emission.
+ * @param steps The steps to search for the suspended step.
+ * @param state Mutable execution state to thread through the traversal.
+ * @param targetPath Path tokens identifying the suspended step location.
+ * @param pathPrefix Prefix accumulated while descending the tree.
+ * @param iterationDepth Current loop depth to match iteration stacks.
+ * @returns A rebuilt suspension or null if the path cannot be matched.
+ */
+export declare function buildSuspensionForPath(deps: SuspensionRebuilderDeps, steps: CompiledStep[], state: ExecutionState, targetPath: Array<number | string>, pathPrefix: Array<number | string>, iterationDepth?: number, suspensionMetadata?: RebuildSuspensionMetadata): Suspension | null;
+export {};
+//# sourceMappingURL=suspension-rebuilder.d.ts.map

package/dist/types/suspension-rebuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspension-rebuilder.d.ts","sourceRoot":"","sources":["../../src/suspension-rebuilder.ts"],"names":[],"mappings":"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"}

package/dist/types/utils/deferred.d.ts

@@ -0,0 +1,7 @@
+export type Deferred<T> = {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason?: unknown) => void;
+};
+export declare function createDeferred<T>(): Deferred<T>;
+//# sourceMappingURL=deferred.d.ts.map

package/dist/types/utils/deferred.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferred.d.ts","sourceRoot":"","sources":["../../../src/utils/deferred.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IACxB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC,CAAC;AAEF,wBAAgB,cAAc,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAU/C"}

package/dist/types/utils/naming.d.ts

@@ -0,0 +1,24 @@
+export type WorkflowEntity = 'action' | 'workflow' | 'predicate';
+/**
+ * Verifies that names follow the snake_case convention required by the system.
+ *
+ * @param name - Candidate name that should be validated.
+ * @param entity - Entity type used to customize the error message.
+ * @throws Error when the name is not snake_case.
+ */
+export declare function assertSnakeCaseName(name: string, entity: WorkflowEntity): void;
+/**
+ * Checks whether the provided string is snake_case compliant.
+ *
+ * @param value - Text to evaluate.
+ * @returns `true` when the value is snake_case; otherwise `false`.
+ */
+export declare const isSnakeCaseName: (value: string) => boolean;
+/**
+ * Converts arbitrary text into snake_case for use in workflow entities.
+ *
+ * @param value - Input text that should be converted.
+ * @returns Snake cased version of the input.
+ */
+export declare function toSnakeCase(value: string): string;
+//# sourceMappingURL=naming.d.ts.map

package/dist/types/utils/naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../../../src/utils/naming.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,UAAU,GAAG,WAAW,CAAC;AAEjE;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,cAAc,GACrB,IAAI,CAMN;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,KAAG,OAClB,CAAC;AAE/B;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWjD"}

package/dist/types/utils/timeout.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolves after the specified duration; useful for retry delays.
+ *
+ * @param durationMs - Number of milliseconds to wait before resolving.
+ * @returns A promise that resolves once the duration elapses.
+ */
+export declare const sleep: (durationMs: number) => Promise<void>;
+/**
+ * Wraps a promise and rejects if it does not settle within the timeout.
+ *
+ * @param promise - Operation that may take longer than the allowed timeout.
+ * @param timeoutMs - Maximum time in milliseconds to wait before rejecting.
+ * @returns The result of the original promise when it resolves in time.
+ * @throws Error when the timeout is exceeded.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs?: number): Promise<T>;
+//# sourceMappingURL=timeout.d.ts.map

package/dist/types/utils/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../../src/utils/timeout.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,YAAY,MAAM,KAAG,OAAO,CAAC,IAAI,CACI,CAAC;AAE5D;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,CAAC,CAqBZ"}

package/dist/types/utils/workflow-definition.d.ts

@@ -0,0 +1,3 @@
+import { type WorkflowDefinition } from '../dsl.types';
+export declare const safeRenameTaskInDefinition: (definition: WorkflowDefinition, currentTaskName: string, nextTaskName: string) => WorkflowDefinition;
+//# sourceMappingURL=workflow-definition.d.ts.map

package/dist/types/utils/workflow-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-definition.d.ts","sourceRoot":"","sources":["../../../src/utils/workflow-definition.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,cAAc,CAAC;AA8HtB,eAAO,MAAM,0BAA0B,GACrC,YAAY,kBAAkB,EAC9B,iBAAiB,MAAM,EACvB,cAAc,MAAM,KACnB,kBAgCF,CAAC"}

package/dist/types/workflow-compiler.d.ts

@@ -0,0 +1,12 @@
+import type { Action } from './action/action.types';
+import type { BindingKindSchemas } from './bindings/base-binding';
+import type { WorkflowDefinition } from './dsl.types';
+import type { CompiledWorkflow } from './workflow-types';
+import { type CompileValueOptions } from './workflow-values';
+export type WorkflowCompileOptions = CompileValueOptions & {
+    actions: Record<string, Action>;
+    bindingKinds?: BindingKindSchemas;
+};
+/** Compile a workflow definition into structures consumable by the runtime. */
+export declare const compileWorkflow: (definition: WorkflowDefinition, options: WorkflowCompileOptions) => CompiledWorkflow;
+//# sourceMappingURL=workflow-compiler.d.ts.map