@hexabot-ai/agentic 3.0.1-alpha.0

package/dist/esm/bindings/base-binding.js

@@ -0,0 +1,273 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+const TASK_KIND = 'task';
+const resolveValidationOptions = (options) => {
+    if (!options) {
+        return {};
+    }
+    if ('bindingKinds' in options || 'actions' in options) {
+        return options;
+    }
+    return { bindingKinds: options };
+};
+const hasBindingsConfigured = (workflow) => {
+    const defs = workflow.defs ?? {};
+    const hasNonTaskDefs = Object.values(defs).some((definition) => definition.kind !== TASK_KIND);
+    const hasNestedBindings = Object.values(defs).some((definition) => definition.bindings && Object.keys(definition.bindings).length > 0);
+    return hasNonTaskDefs || hasNestedBindings;
+};
+const formatZodIssues = (issues, prefix) => issues.map((issue) => {
+    const path = issue.path.join('.') || '<root>';
+    return `${prefix}.${path}: ${issue.message}`;
+});
+const collectDuplicateReferences = (refs) => {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const ref of refs) {
+        if (seen.has(ref)) {
+            duplicates.add(ref);
+            continue;
+        }
+        seen.add(ref);
+    }
+    return Array.from(duplicates).sort();
+};
+const toBindingRefs = (refs) => Array.isArray(refs) ? refs : [refs];
+const collectBindingRefs = (bindings) => {
+    if (!bindings) {
+        return [];
+    }
+    const refs = [];
+    for (const [bindingKind, bindingRefs] of Object.entries(bindings)) {
+        for (const ref of toBindingRefs(bindingRefs)) {
+            refs.push({ kind: bindingKind, ref });
+        }
+    }
+    return refs;
+};
+const detectBindingCycles = (defs) => {
+    const errors = [];
+    const reportedCycles = new Set();
+    const states = new Map();
+    const stack = [];
+    const defNames = Object.keys(defs);
+    const visit = (defName) => {
+        const state = states.get(defName);
+        if (state === 'visited') {
+            return;
+        }
+        if (state === 'visiting') {
+            const cycleStart = stack.indexOf(defName);
+            if (cycleStart === -1) {
+                return;
+            }
+            const cyclePath = [...stack.slice(cycleStart), defName];
+            const cycleKey = cyclePath.join('->');
+            if (!reportedCycles.has(cycleKey)) {
+                reportedCycles.add(cycleKey);
+                errors.push(`defs.${defName}.bindings: Circular binding reference detected (${cyclePath.join(' -> ')}).`);
+            }
+            return;
+        }
+        states.set(defName, 'visiting');
+        stack.push(defName);
+        const definition = defs[defName];
+        for (const { ref } of collectBindingRefs(definition?.bindings)) {
+            if (!Object.prototype.hasOwnProperty.call(defs, ref)) {
+                continue;
+            }
+            visit(ref);
+        }
+        stack.pop();
+        states.set(defName, 'visited');
+    };
+    for (const defName of defNames) {
+        visit(defName);
+    }
+    return errors;
+};
+const resolveSupportedBindingKinds = (definition, defName, kinds, actions, errors) => {
+    if (definition.action) {
+        if (!actions) {
+            return null;
+        }
+        const action = actions[definition.action];
+        if (!action) {
+            errors.push(`defs.${defName}.action: No action implementation provided for "${definition.action}".`);
+            return [];
+        }
+        return action.supportedBindings ?? [];
+    }
+    if (definition.kind === TASK_KIND) {
+        return [];
+    }
+    return kinds[definition.kind]?.supportedBindings ?? [];
+};
+export const validateAndResolveBindings = (workflow, options) => {
+    const errors = [];
+    const resolvedDefs = {};
+    const defs = workflow.defs ?? {};
+    const resolvedOptions = resolveValidationOptions(options);
+    const kinds = resolvedOptions.bindingKinds ?? {};
+    const actions = resolvedOptions.actions;
+    const kindNames = Object.keys(kinds);
+    const hasBindingUsage = hasBindingsConfigured(workflow);
+    const parsedSettingsByDefName = new Map();
+    if (hasBindingUsage && kindNames.length === 0) {
+        errors.push('Workflows that declare non-task defs or nested bindings require a non-empty "bindingKinds" registry.');
+    }
+    for (const [defName, defDefinition] of Object.entries(defs)) {
+        if (defDefinition.kind === TASK_KIND) {
+            if (defDefinition.action && actions && !actions[defDefinition.action]) {
+                errors.push(`defs.${defName}.action: No action implementation provided for "${defDefinition.action}".`);
+            }
+            continue;
+        }
+        const kindDefinition = kinds[defDefinition.kind];
+        if (!kindDefinition) {
+            errors.push(`defs.${defName}.kind: Unknown binding kind "${defDefinition.kind}".`);
+            continue;
+        }
+        const actionPolicy = kindDefinition.actionPolicy ?? 'optional';
+        if (actionPolicy === 'required' && !defDefinition.action) {
+            errors.push(`defs.${defName}.action: Binding kind "${defDefinition.kind}" requires an action.`);
+        }
+        if (actionPolicy === 'forbidden' && defDefinition.action) {
+            errors.push(`defs.${defName}.action: Binding kind "${defDefinition.kind}" does not allow action declarations.`);
+        }
+        if (defDefinition.action && actions && !actions[defDefinition.action]) {
+            errors.push(`defs.${defName}.action: No action implementation provided for "${defDefinition.action}".`);
+        }
+        const { schema } = kindDefinition;
+        const parsedPayload = schema.safeParse(defDefinition.settings);
+        if (!parsedPayload.success) {
+            errors.push(...formatZodIssues(parsedPayload.error.issues, `defs.${defName}.settings`));
+            continue;
+        }
+        parsedSettingsByDefName.set(defName, parsedPayload.data);
+    }
+    for (const [defName, defDefinition] of Object.entries(defs)) {
+        const defBindings = defDefinition.bindings;
+        if (!defBindings) {
+            continue;
+        }
+        const supportedKinds = resolveSupportedBindingKinds(defDefinition, defName, kinds, actions, errors);
+        const shouldValidateSupportedKinds = Array.isArray(supportedKinds);
+        for (const [bindingKind, bindingRefs] of Object.entries(defBindings)) {
+            const kindDefinition = kinds[bindingKind];
+            if (!kindDefinition) {
+                errors.push(`defs.${defName}.bindings.${bindingKind}: Unknown binding kind "${bindingKind}".`);
+                continue;
+            }
+            const { multiple } = kindDefinition;
+            if (multiple && !Array.isArray(bindingRefs)) {
+                errors.push(`defs.${defName}.bindings.${bindingKind}: Expected an array of def references for binding kind "${bindingKind}".`);
+                continue;
+            }
+            if (!multiple && typeof bindingRefs !== 'string') {
+                errors.push(`defs.${defName}.bindings.${bindingKind}: Expected a single def reference string for binding kind "${bindingKind}".`);
+                continue;
+            }
+            if (shouldValidateSupportedKinds &&
+                supportedKinds &&
+                !supportedKinds.includes(bindingKind)) {
+                const supportedKindsLabel = supportedKinds.length > 0 ? supportedKinds.join(', ') : '<none>';
+                errors.push(`defs.${defName}.bindings.${bindingKind}: "${defDefinition.action ?? defDefinition.kind}" does not support binding kind "${bindingKind}". Supported binding kinds: ${supportedKindsLabel}.`);
+            }
+            const refs = toBindingRefs(bindingRefs);
+            const duplicateRefs = collectDuplicateReferences(refs);
+            if (duplicateRefs.length > 0) {
+                errors.push(`defs.${defName}.bindings.${bindingKind}: Duplicate def reference(s): ${duplicateRefs.join(', ')}`);
+            }
+            for (const ref of refs) {
+                const definition = defs[ref];
+                if (!definition) {
+                    errors.push(`defs.${defName}.bindings.${bindingKind}: Unknown def reference "${ref}".`);
+                    continue;
+                }
+                if (definition.kind !== bindingKind) {
+                    errors.push(`defs.${defName}.bindings.${bindingKind}: Def "${ref}" has kind "${definition.kind}" and cannot be mounted as "${bindingKind}".`);
+                }
+            }
+        }
+    }
+    errors.push(...detectBindingCycles(defs));
+    const inProgress = new Set();
+    const mountResolvedDef = (defName) => {
+        const existing = resolvedDefs[defName];
+        if (existing) {
+            return existing.payload;
+        }
+        const definition = defs[defName];
+        if (!definition || definition.kind === TASK_KIND) {
+            return undefined;
+        }
+        const parsedSettings = parsedSettingsByDefName.get(defName);
+        if (parsedSettings === undefined) {
+            return undefined;
+        }
+        if (inProgress.has(defName)) {
+            return undefined;
+        }
+        inProgress.add(defName);
+        const nestedBindings = mountTaskBindings(definition.bindings, resolvedDefs, kinds, mountResolvedDef);
+        const payload = {
+            settings: parsedSettings,
+            ...(definition.action ? { action: definition.action } : {}),
+            ...(Object.keys(nestedBindings).length > 0
+                ? { bindings: nestedBindings }
+                : {}),
+        };
+        resolvedDefs[defName] = {
+            kind: definition.kind,
+            payload,
+        };
+        inProgress.delete(defName);
+        return payload;
+    };
+    for (const [defName, definition] of Object.entries(defs)) {
+        if (definition.kind === TASK_KIND) {
+            continue;
+        }
+        mountResolvedDef(defName);
+    }
+    return { errors, resolvedDefs };
+};
+export const mountTaskBindings = (taskBindings, resolvedDefs, bindingKinds, resolveDef) => {
+    if (!taskBindings) {
+        return {};
+    }
+    const mounted = {};
+    const kinds = bindingKinds ?? {};
+    for (const [bindingKind, bindingRefs] of Object.entries(taskBindings)) {
+        const refs = toBindingRefs(bindingRefs);
+        const isMultiple = kinds[bindingKind]?.multiple ?? Array.isArray(bindingRefs);
+        if (!isMultiple) {
+            const ref = refs[0];
+            if (!ref) {
+                continue;
+            }
+            const resolvedDefPayload = resolvedDefs[ref]?.payload ?? resolveDef?.(ref) ?? undefined;
+            if (!resolvedDefPayload) {
+                continue;
+            }
+            mounted[bindingKind] = resolvedDefPayload;
+            continue;
+        }
+        const mountedKindDefs = {};
+        for (const ref of refs) {
+            const resolvedDefPayload = resolvedDefs[ref]?.payload ?? resolveDef?.(ref) ?? undefined;
+            if (!resolvedDefPayload) {
+                continue;
+            }
+            mountedKindDefs[ref] = resolvedDefPayload;
+        }
+        if (Object.keys(mountedKindDefs).length > 0) {
+            mounted[bindingKind] = mountedKindDefs;
+        }
+    }
+    return mounted;
+};

package/dist/esm/context.js

@@ -0,0 +1,75 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+/**
+ * Base context that is threaded through every workflow execution.
+ *
+ * Extend this class in user-land to expose shared services such as loggers,
+ * event emitters, database connections, or feature flags.
+ */
+export class BaseWorkflowContext {
+    /**
+     * Sets up the context and copies any initial state onto the instance.
+     *
+     * @param initialState - Optional properties to assign to the context instance.
+     * @param eventEmitter - Optional workflow event emitter to expose to actions.
+     */
+    constructor(initialState) {
+        this.state = (initialState ?? {});
+    }
+    /**
+     * Snapshot the context state for telemetry or UI rendering.
+     * Override to filter or reshape the exposed state.
+     */
+    snapshot() {
+        return safeCloneRecord(this.state);
+    }
+    /**
+     * Provides access to the workflow runtime API for the current execution.
+     *
+     * @returns Runtime control methods that allow suspension and inspection.
+     * @throws Error when the context is not currently attached to a runner.
+     */
+    get workflow() {
+        if (!this._workflowControl) {
+            throw new Error('Workflow runtime is not attached to this context.');
+        }
+        return this._workflowControl;
+    }
+    /**
+     * Attaches or detaches the runtime control object.
+     *
+     * @param control - Runtime control instance or `undefined` to detach.
+     * @returns Nothing; the method mutates internal state.
+     */
+    attachWorkflowRuntime(control) {
+        this._workflowControl = control;
+    }
+}
+const safeCloneRecord = (value) => {
+    if (!value) {
+        return {};
+    }
+    if (typeof structuredClone === 'function') {
+        try {
+            return structuredClone(value);
+        }
+        catch {
+            // Fall through to JSON clone below.
+        }
+    }
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        const shallow = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (typeof entry !== 'function') {
+                shallow[key] = entry;
+            }
+        }
+        return shallow;
+    }
+};

package/dist/esm/dsl.types.js

@@ -0,0 +1,309 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import jsonata from 'jsonata';
+import { parse as parseYaml } from 'yaml';
+import { z } from 'zod';
+import { validateAndResolveBindings } from './bindings/base-binding';
+export const ExpressionStringSchema = z
+    .string()
+    .regex(/^=/, 'Expression strings must start with "="')
+    .superRefine((value, ctx) => {
+    try {
+        jsonata(value.slice(1));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown JSONata parse error';
+        ctx.addIssue({
+            code: 'custom',
+            message: `Invalid JSONata expression: ${message}`,
+        });
+    }
+});
+// Per-action timeout in milliseconds; 0 disables the timeout wrapper.
+export const DEFAULT_TIMEOUT_MS = 0;
+// Retry defaults: disabled with 3 attempts and exponential backoff starting at 25ms, capped at 10s, no jitter.
+export const DEFAULT_RETRY_SETTINGS = {
+    enabled: false,
+    max_attempts: 3,
+    backoff_ms: 25,
+    max_delay_ms: 10000,
+    jitter: 0,
+    multiplier: 1,
+};
+export const JsonValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonValueSchema),
+    z.record(z.string(), JsonValueSchema),
+]));
+const InputFieldSchema = z.lazy(() => z
+    .strictObject({
+    type: z.enum([
+        'string',
+        'number',
+        'integer',
+        'boolean',
+        'array',
+        'object',
+    ]),
+    description: z.string().optional(),
+    enum: z.array(z.union([z.string(), z.number(), z.boolean()])).optional(),
+    items: InputFieldSchema.optional(),
+    properties: z.record(z.string(), InputFieldSchema).optional(),
+})
+    .superRefine((value, ctx) => {
+    if (value.type === 'array' && !value.items) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Array inputs must declare "items"',
+            path: ['items'],
+        });
+    }
+    if (value.type !== 'array' && value.items) {
+        ctx.addIssue({
+            code: 'custom',
+            message: '"items" is only valid when type is "array"',
+            path: ['items'],
+        });
+    }
+    if (value.type !== 'object' && value.properties) {
+        ctx.addIssue({
+            code: 'custom',
+            message: '"properties" is only valid when type is "object"',
+            path: ['properties'],
+        });
+    }
+}));
+// Retry policy: exponential backoff per attempt, capped by max_delay_ms, with optional jitter multiplier.
+const RetriesSchema = z.strictObject({
+    enabled: z.boolean().optional().meta({
+        title: 'Enabled',
+        description: 'Enable retry attempts when an action fails (disabled = no retries).',
+    }),
+    max_attempts: z
+        .int()
+        .min(1)
+        .default(DEFAULT_RETRY_SETTINGS.max_attempts)
+        .meta({
+        title: 'Max Attempts',
+        description: 'Total number of attempts before giving up.',
+    }),
+    backoff_ms: z.int().min(0).default(DEFAULT_RETRY_SETTINGS.backoff_ms).meta({
+        title: 'Initial Backoff (ms)',
+        description: 'Delay in milliseconds before the first retry.',
+    }),
+    max_delay_ms: z
+        .int()
+        .min(0)
+        .default(DEFAULT_RETRY_SETTINGS.max_delay_ms)
+        .meta({
+        title: 'Max Delay (ms)',
+        description: 'Maximum delay cap in milliseconds between retries.',
+    }),
+    jitter: z.number().min(0).default(DEFAULT_RETRY_SETTINGS.jitter).meta({
+        title: 'Jitter',
+        description: 'Randomization factor applied to retry delays (0 = none).',
+    }),
+    multiplier: z
+        .number()
+        .min(1)
+        .default(DEFAULT_RETRY_SETTINGS.multiplier)
+        .meta({
+        title: 'Backoff Multiplier',
+        description: 'Multiplier applied to the delay after each retry.',
+    }),
+});
+// Shared execution settings applied to every action invocation.
+export const BaseSettingsSchema = z.strictObject({
+    timeout_ms: z.int().nonnegative().optional().meta({
+        title: 'Timeout (ms)',
+        description: 'Maximum runtime in milliseconds for a single action invocation (0 = disabled).',
+    }),
+    retries: RetriesSchema.optional().meta({
+        title: 'Retries',
+        description: 'Retry policy applied when an action fails.',
+    }),
+});
+export const SettingsSchema = BaseSettingsSchema.catchall(JsonValueSchema);
+const TaskBindingReferenceSchema = z.union([z.string(), z.array(z.string())]);
+const TaskBindingsSchema = z.record(z.string(), TaskBindingReferenceSchema);
+export const TASK_KIND = 'task';
+export const TaskDefinitionSchema = z.strictObject({
+    kind: z.literal(TASK_KIND),
+    description: z.string().optional(),
+    action: z.string(),
+    inputs: z.record(z.string(), JsonValueSchema).optional(),
+    bindings: TaskBindingsSchema.optional(),
+    settings: SettingsSchema.optional(),
+});
+const NonTaskDefinitionSchema = z.strictObject({
+    kind: z
+        .string()
+        .refine((kind) => kind !== TASK_KIND, `kind "${TASK_KIND}" must follow the task definition shape.`),
+    description: z.string().optional(),
+    action: z.string().optional(),
+    settings: z.record(z.string(), z.unknown()),
+    bindings: TaskBindingsSchema.optional(),
+});
+export const DefDefinitionSchema = z.union([
+    TaskDefinitionSchema,
+    NonTaskDefinitionSchema,
+]);
+const ConditionalWhenSchema = z.lazy(() => z.strictObject({
+    condition: ExpressionStringSchema,
+    steps: z.array(FlowStepSchema),
+}));
+const ConditionalElseSchema = z.lazy(() => z.strictObject({
+    else: z.unknown().optional(),
+    steps: z.array(FlowStepSchema),
+}));
+const ConditionalSchema = z.strictObject({
+    description: z.string().optional(),
+    when: z.array(z.union([ConditionalWhenSchema, ConditionalElseSchema])).min(1),
+});
+const ParallelSchema = z.strictObject({
+    description: z.string().optional(),
+    strategy: z.enum(['wait_all', 'wait_any']).optional(),
+    steps: z.array(z.lazy(() => FlowStepSchema)),
+});
+const LoopAccumulateSchema = z.strictObject({
+    as: z.string(),
+    initial: JsonValueSchema,
+    merge: ExpressionStringSchema,
+});
+const ForEachLoopSchema = z.strictObject({
+    type: z.literal('for_each'),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    for_each: z.strictObject({
+        item: z.string(),
+        in: ExpressionStringSchema,
+    }),
+    max_concurrency: z.int().positive().optional(),
+    until: ExpressionStringSchema.optional(),
+    accumulate: LoopAccumulateSchema.optional(),
+    steps: z.array(z.lazy(() => FlowStepSchema)),
+});
+const WhileLoopSchema = z.strictObject({
+    type: z.literal('while'),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    while: ExpressionStringSchema,
+    accumulate: LoopAccumulateSchema.optional(),
+    steps: z.array(z.lazy(() => FlowStepSchema)),
+});
+const LoopSchema = z.lazy(() => z.union([ForEachLoopSchema, WhileLoopSchema]));
+export const FlowStepSchema = z.lazy(() => z.union([
+    z.strictObject({
+        do: z.string(),
+    }),
+    z.strictObject({
+        parallel: ParallelSchema,
+    }),
+    z.strictObject({
+        conditional: ConditionalSchema,
+    }),
+    z.strictObject({
+        loop: LoopSchema,
+    }),
+]));
+export const WorkflowMetadataSchema = z.strictObject({
+    name: z.string().min(1),
+    version: z.string().min(1),
+    description: z.string().optional(),
+});
+const InputsSchema = z.strictObject({
+    schema: z.record(z.string(), InputFieldSchema).optional(),
+});
+const DefaultsSchema = z.strictObject({
+    settings: SettingsSchema.optional(),
+});
+export const WorkflowDefinitionSchema = z.strictObject({
+    inputs: InputsSchema.optional(),
+    context: z.record(z.string(), JsonValueSchema).optional(),
+    defaults: DefaultsSchema.optional(),
+    defs: z.record(z.string(), DefDefinitionSchema),
+    flow: z.array(FlowStepSchema),
+    outputs: z.record(z.string(), ExpressionStringSchema),
+});
+const collectTaskReferences = (steps) => {
+    const refs = [];
+    for (const step of steps) {
+        if ('do' in step) {
+            refs.push(step.do);
+            continue;
+        }
+        if ('parallel' in step) {
+            refs.push(...collectTaskReferences(step.parallel.steps));
+            continue;
+        }
+        if ('conditional' in step) {
+            for (const branch of step.conditional.when) {
+                if ('condition' in branch) {
+                    refs.push(...collectTaskReferences(branch.steps));
+                }
+                else if ('else' in branch) {
+                    refs.push(...collectTaskReferences(branch.steps));
+                }
+            }
+            continue;
+        }
+        if ('loop' in step) {
+            refs.push(...collectTaskReferences(step.loop.steps));
+        }
+    }
+    return refs;
+};
+export const isTaskDefinition = (definition) => definition.kind === TASK_KIND;
+export const extractTaskDefinitions = (defs) => Object.entries(defs).reduce((tasks, [defName, def]) => {
+    if (isTaskDefinition(def)) {
+        tasks[defName] = def;
+    }
+    return tasks;
+}, {});
+const formatZodErrors = (issues) => issues.map((issue) => {
+    const path = issue.path.join('.') || '<root>';
+    return `${path}: ${issue.message}`;
+});
+export function validateWorkflow(input, options) {
+    let candidate = input;
+    if (typeof input === 'string') {
+        try {
+            candidate = parseYaml(input);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown YAML parse error';
+            return {
+                success: false,
+                errors: ['Unable to parse workflow YAML', message],
+            };
+        }
+    }
+    const parsed = WorkflowDefinitionSchema.safeParse(candidate);
+    if (!parsed.success) {
+        return { success: false, errors: formatZodErrors(parsed.error.issues) };
+    }
+    const errors = [];
+    const taskDefinitions = extractTaskDefinitions(parsed.data.defs);
+    const referencedTasks = new Set(collectTaskReferences(parsed.data.flow));
+    const missingTasks = Array.from(referencedTasks).filter((task) => !Object.prototype.hasOwnProperty.call(taskDefinitions, task));
+    if (missingTasks.length > 0) {
+        errors.push(`Unknown task(s) referenced in flow: ${missingTasks.join(', ')}`);
+    }
+    const bindingValidation = validateAndResolveBindings(parsed.data, {
+        bindingKinds: options?.bindingKinds,
+        actions: options?.actions,
+    });
+    if (bindingValidation.errors.length > 0) {
+        errors.push(...bindingValidation.errors);
+    }
+    if (errors.length > 0) {
+        return { success: false, errors };
+    }
+    return { success: true, data: parsed.data };
+}

package/dist/esm/index.js

@@ -0,0 +1,16 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+export { AbstractAction } from './action/abstract-action';
+export { defineAction } from './action/action';
+export { BaseWorkflowContext, } from './context';
+export * from './dsl.types';
+export { compileWorkflow, Workflow as Workflow, WorkflowEventEmitter, WorkflowRunner, } from './workflow';
+export { StepType } from './workflow-event-emitter';
+export { NonDeterministicWorkflowError } from './runner-runtime-control';
+export { compileValue, evaluateMapping, evaluateValue, mergeSettings, } from './workflow-values';
+export { createDeferred } from './utils/deferred';
+export { assertSnakeCaseName, isSnakeCaseName, toSnakeCase, } from './utils/naming';
+export { sleep, withTimeout } from './utils/timeout';