import { a as PersistedValue, o as RetryConfig } from "./types-nm947ViN.mjs";
import { StandardSchemaV1 } from "@standard-schema/spec";

//#region src/core/workflow.d.ts
/** Context passed to every step handler. */
interface StepContext<TInput extends PersistedValue, TPrev extends PersistedValue, TStepsSoFar extends Record<string, PersistedValue> = Record<string, PersistedValue>> {
  /** The validated workflow input (same for every step in the run). */
  input: TInput;
  /** The return value of the previous step (`undefined` for the first step). */
  prev: TPrev;
  /** Aborted on cancellation, lease loss, or step timeout. */
  signal: AbortSignal;
  /** Complete the workflow early, skipping remaining steps. Optionally persist a value as the final result. */
  complete: (value?: PersistedValue) => never;
  /** Results of all previously completed steps, keyed by step name. */
  steps: TStepsSoFar;
}
/** Internal representation of a step used by the engine. */
interface StepDefinition {
  name: string;
  handler: (ctx: StepContext<PersistedValue, PersistedValue, Record<string, PersistedValue>>) => Promise<PersistedValue | void>;
  retry?: RetryConfig;
  timeoutMs?: number;
}
/** A single execution unit: either a sequential step or a parallel group. */
type ExecutionUnit = {
  readonly kind: 'step';
  readonly definition: StepDefinition;
} | {
  readonly kind: 'parallel';
  readonly branches: readonly StepDefinition[];
};
/** Configuration object form for `.step()` when you need retry or timeout options. */
interface StepConfig<TInput extends PersistedValue, TPrev extends PersistedValue, TOutput extends PersistedValue | void, TStepsSoFar extends Record<string, PersistedValue> = Record<string, PersistedValue>> {
  retry?: RetryConfig;
  /** Timeout per attempt in milliseconds. Takes precedence over `retry.timeoutMs`. */
  timeoutMs?: number;
  handler: (ctx: StepContext<TInput, TPrev, TStepsSoFar>) => Promise<TOutput>;
}
/** A parallel branch: either a bare handler or a StepConfig with retry/timeout. */
type ParallelBranch<TInput extends PersistedValue, TPrev extends PersistedValue, TOutput extends PersistedValue | void = PersistedValue | void, TStepsSoFar extends Record<string, PersistedValue> = Record<string, PersistedValue>> = ((ctx: StepContext<TInput, TPrev, TStepsSoFar>) => Promise<TOutput>) | StepConfig<TInput, TPrev, TOutput, TStepsSoFar>;
/** Extract the output type from a ParallelBranch. */
type InferBranchOutput<B> = B extends ((ctx: never) => Promise<infer O>) ? O : B extends {
  handler: (ctx: never) => Promise<infer O>;
} ? O : never;
/** Context passed to the `onFailure` handler when a workflow run fails. */
interface FailureContext<TInput extends PersistedValue = PersistedValue> {
  /** The error that caused the failure. */
  error: Error;
  /** The name of the step that failed. */
  stepName: string;
  /** The original validated workflow input. */
  input: TInput;
}
/**
 * A typed workflow definition.
 *
 * @typeParam TName - Literal string name of the workflow (e.g. `'order-fulfillment'`)
 * @typeParam TInput - The validated input schema type
 * @typeParam TPrev - The output type of the most recently added step (used for chaining)
 * @typeParam TSteps - Accumulated map of `{ stepName: outputType }` across `.step()` calls
 */
interface Workflow<TName extends string = string, TInput extends PersistedValue = PersistedValue, TPrev extends PersistedValue = PersistedValue, TSteps extends Record<string, PersistedValue> = Record<string, PersistedValue>> {
  readonly name: TName;
  readonly inputSchema: StandardSchemaV1<TInput>;
  readonly executionUnits: readonly ExecutionUnit[];
  readonly failureHandler?: (ctx: FailureContext<TInput>) => Promise<void>;
  step<TStepName extends string, TOutput extends PersistedValue | void>(name: TStepName, handler: (ctx: StepContext<TInput, TPrev, TSteps>) => Promise<TOutput>): Workflow<TName, TInput, NormalizeOutput<TOutput>, TSteps & Record<TStepName, NormalizeOutput<TOutput>>>;
  step<TStepName extends string, TOutput extends PersistedValue | void>(name: TStepName, config: StepConfig<TInput, TPrev, TOutput, TSteps>): Workflow<TName, TInput, NormalizeOutput<TOutput>, TSteps & Record<TStepName, NormalizeOutput<TOutput>>>;
  parallel<TBranches extends Record<string, ParallelBranch<TInput, TPrev, PersistedValue | void, TSteps>>>(branches: TBranches): Workflow<TName, TInput, Prettify<{ [K in keyof TBranches & string]: NormalizeOutput<InferBranchOutput<TBranches[K]>> }>, TSteps & { [K in keyof TBranches & string]: NormalizeOutput<InferBranchOutput<TBranches[K]>> }>;
  onFailure(handler: (ctx: FailureContext<TInput>) => Promise<void>): Workflow<TName, TInput, TPrev, TSteps>;
  parseInput(input: unknown): TInput;
}
type AnyWorkflow = Workflow<string, any, any, any>;
/** Extract the input type from a Workflow */
type InferInput<W> = W extends Workflow<any, infer I, any, any> ? I : never;
/** Extract the accumulated steps map from a Workflow */
type InferSteps<W> = W extends Workflow<any, any, any, infer S> ? S : never;
/** Map a workflow tuple/array to `{ workflowName: inputType }` */
type WorkflowInputMap<T extends readonly AnyWorkflow[]> = { [W in T[number] as W extends Workflow<infer N, any, any, any> ? N : never]: InferInput<W> };
/** Map a workflow tuple/array to `{ workflowName: stepsRecord }` */
type WorkflowStepsMap<T extends readonly AnyWorkflow[]> = { [W in T[number] as W extends Workflow<infer N, any, any, any> ? N : never]: InferSteps<W> };
/** Flatten intersection types for readable IDE tooltips */
type Prettify<T> = { [K in keyof T]: T[K] } & {};
type NormalizeOutput<T extends PersistedValue | void> = Exclude<T, void> | (void extends T ? undefined : never);
/**
 * Create a new workflow definition.
 *
 * @example
 * ```ts
 * const workflow = createWorkflow({
 *   name: 'process-content',
 *   input: z.object({ url: z.string() }),
 * })
 *   .step('scrape', async ({ input }) => { ... })
 *   .step('summarize', async ({ prev }) => { ... })
 * ```
 */
declare function createWorkflow<TName extends string, TInput extends PersistedValue>(config: {
  name: TName;
  input: StandardSchemaV1<TInput>;
}): Workflow<TName, TInput, undefined, {}>;
//#endregion
export { InferInput as a, StepConfig as c, Workflow as d, WorkflowInputMap as f, InferBranchOutput as i, StepContext as l, createWorkflow as m, ExecutionUnit as n, InferSteps as o, WorkflowStepsMap as p, FailureContext as r, ParallelBranch as s, AnyWorkflow as t, StepDefinition as u };
//# sourceMappingURL=workflow-Cic2yHNB.d.mts.map