npm - @pogodisco/zephyr - Versions diffs - 1.3.9 → 1.3.11 - Mend

@pogodisco/zephyr 1.3.9 → 1.3.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/types.d.ts +4 -1
package/dist/utils.d.ts +11 -0
package/dist/utils.js +12 -0
package/dist/workflow-composer.d.ts +26 -6
package/dist/workflow-composer.js +55 -369
package/dist/workflow-executor.js +46 -2
package/package.json +1 -1

package/dist/types.d.ts CHANGED Viewed

@@ -1,7 +1,7 @@
 import { createWorkflow } from "./workflow-composer.js";
 export type Action<F extends (...args: any[]) => any = (...args: any[]) => any> = F;
 export type ActionRegistry = Record<string, (...args: any[]) => any>;
-export type MergeActionRegistries<A extends ActionRegistry, B extends ActionRegistry> = Omit<A, keyof B> & B;
+export type MergeActionRegistries<A extends ActionRegistry, B extends ActionRegistry> = Simplify<Omit<A, keyof B> & B>;
 export type ExecutionFrame = {
     stepId: string;
     attempts: number;
@@ -12,6 +12,9 @@ export type ExecutionFrame = {
     error?: any;
     skipped?: boolean;
 };
+export type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 export type ActionParams<Reg, K extends keyof Reg> = Reg[K] extends (...args: infer P) => any ? P : never;
 export type ActionReturn<Reg, K extends keyof Reg> = Reg[K] extends (...args: any[]) => infer R ? Awaited<R> : never;
 export type WorkflowObserver<Reg extends ActionRegistry = any> = {

package/dist/utils.d.ts CHANGED Viewed

@@ -14,4 +14,15 @@ export declare function createRunner<Reg extends ActionRegistry>(registry: Reg):
     results: W extends WorkflowDef<Reg, any, infer R, any, any> ? R : never;
     extras: Record<string, any>;
 }>;
+/**
+ * Create a typed runner for a specific module
+ * @example
+ * const run = createModuleRunner(modWithLoop, regOne);
+ * const result = await run("loopWorkflow", { items: ["APPLE"] });
+ */
+export declare function createModuleRunner<M extends Record<string, WorkflowDef<any, any, any, any, any>>, Reg extends ActionRegistry>(module: M, registry: Reg): <K extends keyof M>(key: K, input: M[K] extends WorkflowDef<Reg, infer I, any, any, any> ? I : never, observers?: any[]) => Promise<{
+    output: M[K] extends WorkflowDef<Reg, any, any, any, infer O> ? O : never;
+    results: M[K] extends WorkflowDef<Reg, any, infer R, any, any> ? R : never;
+    extras: Record<string, any>;
+}>;
 export {};

package/dist/utils.js CHANGED Viewed

@@ -21,3 +21,15 @@ export function createRunner(registry) {
         return executeWorkflow(workflow, registry, input, observers ?? []);
     };
 }
+/**
+ * Create a typed runner for a specific module
+ * @example
+ * const run = createModuleRunner(modWithLoop, regOne);
+ * const result = await run("loopWorkflow", { items: ["APPLE"] });
+ */
+export function createModuleRunner(module, registry) {
+    return async (key, input, observers) => {
+        const workflow = module[key];
+        return executeWorkflow(workflow, registry, input, observers ?? []);
+    };
+}

package/dist/workflow-composer.d.ts CHANGED Viewed

@@ -48,6 +48,7 @@ export type StepDef<Reg extends ActionRegistry, ID extends string = string, Acti
     dependsOn: string[];
     resolve: (ctx: any) => ResolvedStepInput;
     when?: (ctx: any) => boolean;
+    options?: StepOptions<any, any, any>;
 };
 export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
     name: string;
@@ -59,6 +60,20 @@ export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extend
     outputResolver?: (ctx: any) => Output;
     __context?: any;
 };
+type StepRuntimeCtx<I, R, C> = {
+    input: I;
+    results: R;
+    context: C;
+};
+type StepOptions<Input, Results, Context> = {
+    retry?: number;
+    retryDelay?: number | ((attempt: number) => number);
+    timeout?: number;
+    continueOnError?: boolean;
+    onError?: (err: unknown, ctx: StepRuntimeCtx<Input, Results, Context>) => any;
+    label?: string;
+    meta?: Record<string, any>;
+};
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown, Context extends Record<string, any> = {}, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Output = undefined> {
     private name;
@@ -66,13 +81,15 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
     private context;
     private steps;
     private frontier;
+    private pendingWhen?;
     private outputResolver?;
+    private clearPendingWhen;
     constructor(name: string, registry: Reg, context: Context);
     step<ID extends string, ActionName extends keyof Reg & string, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
         context: Context;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: {}): WorkflowBuilder<Reg, Input, Context, [
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Results & {
@@ -82,7 +99,7 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
         input: Input;
         results: Results;
         context: Context;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: {}): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; }, undefined>;
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; }, undefined>;
     as<NewType>(): WorkflowBuilder<Reg, Input, Context, Steps, Steps extends [...infer Rest, infer Last] ? Last extends StepDef<Reg, infer ID, any> ? Omit<Results, ID> & {
         [K in ID]: NewType;
     } : Results : Results, Output>;
@@ -91,12 +108,14 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
     }): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         ...(Branches[number] extends WorkflowBuilder<Reg, any, any, infer S, any> ? S : never)
-    ], Results & (Branches[number] extends WorkflowBuilder<Reg, any, any, any, infer R> ? UnionToIntersection<R> : {})>;
+    ], Results & UnionToIntersection<{
+        [K in keyof Branches]: Branches[K] extends WorkflowBuilder<Reg, any, any, any, infer R> ? R : never;
+    }[number]>>;
     join<ID extends string = string, ActionName extends keyof Reg & string = any, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
         context: Context;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: {}): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; }, undefined>;
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; }, undefined>;
     subflow<Prefix extends string, SubSteps extends StepDef<Reg, any, any>[], WF extends WorkflowDef<Reg, any, any, SubSteps, any>>(prefix: Prefix, workflow: WF, resolveInput: WorkflowInput<WF> extends undefined ? ((ctx: {
         input: Input;
         results: Results;
@@ -105,7 +124,7 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
         input: Input;
         results: Results;
         context: Context;
-    }) => WorkflowInput<WF>, options?: {}): WorkflowBuilder<Reg, Input, Context, [
+    }) => WorkflowInput<WF>, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         ...WF["steps"]
     ], Results & {
@@ -115,7 +134,8 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
         input: Input;
         results: Results;
         context: Context;
-    }) => boolean): this;
+    }) => boolean): WorkflowBuilder<Reg, Input, Context, Steps, Results, Output>;
+    endWhen(): this;
     output<Output>(fn: (ctx: {
         input: Input;
         results: Results;

package/dist/workflow-composer.js CHANGED Viewed

@@ -1,371 +1,10 @@
-// import { ActionRegistry, ActionReturn } from "./types.js";
-//
-// /* ------------------------------------------------ */
-// /* STEP INPUT NORMALIZATION TYPES                  */
-// /* ------------------------------------------------ */
-//
-// export type NormalizedCall =
-//   | { kind: "none" }
-//   | { kind: "positional"; args: any[] }
-//   | { kind: "object"; args: any };
-//
-// export type ResolvedStepInput =
-//   | NormalizedCall
-//   | { kind: "loop"; items: NormalizedCall[] };
-//
-// /* ------------------------------------------------ */
-// /* STEP RESULT TYPES                               */
-// /* ------------------------------------------------ */
-//
-// type SubflowResult<SubResults, SubOutput> = SubOutput extends undefined
-//   ? SubResults
-//   : SubOutput;
-//
-// export type StepResult<
-//   Reg extends ActionRegistry,
-//   ActionName extends keyof Reg,
-//   Loop extends boolean | undefined = undefined,
-// > = Loop extends true
-//   ? ActionReturn<Reg, ActionName>[]
-//   : ActionReturn<Reg, ActionName>;
-//
-// /* ------------------------------------------------ */
-// /* STEP DEFINITION                                 */
-// /* ------------------------------------------------ */
-//
-// export type StepDef<
-//   Reg extends ActionRegistry,
-//   ID extends string = string,
-//   ActionName extends keyof Reg = any,
-// > = {
-//   id: ID;
-//   action: ActionName;
-//   dependsOn: string[];
-//   resolve: (ctx: any) => ResolvedStepInput;
-//   when?: (ctx: any) => boolean;
-//   loop?: boolean;
-// };
-//
-// /* ------------------------------------------------ */
-// /* WORKFLOW DEFINITION                             */
-// /* ------------------------------------------------ */
-//
-// export type WorkflowDef<
-//   Reg extends ActionRegistry,
-//   Input,
-//   Results,
-//   Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[],
-//   Output = undefined,
-// > = {
-//   name: string;
-//   steps: Steps;
-//   entrySteps: StepDef<Reg>[];
-//   endSteps: StepDef<Reg>[];
-//   input: Input;
-//   results: Results;
-//   outputResolver?: (ctx: any) => Output;
-//   __context?: any;
-// };
-//
-// /* ------------------------------------------------ */
-// /* HELPER TYPES                                    */
-// /* ------------------------------------------------ */
-//
-// type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
-//   k: infer I,
-// ) => void
-//   ? I
-//   : never;
-//
-// /* ------------------------------------------------ */
-// /* FLUENT WORKFLOW BUILDER                          */
-// /* ------------------------------------------------ */
-//
-// export class WorkflowBuilder<
-//   Reg extends ActionRegistry,
-//   Input = unknown,
-//   Context extends Record<string, any> = {},
-//   Steps extends StepDef<Reg, any, any>[] = [],
-//   Results = {},
-//   Output = undefined,
-// > {
-//   private steps: StepDef<Reg, any, any>[] = [];
-//   private frontier: string[] = [];
-//   private outputResolver?: (ctx: any) => any;
-//
-//   constructor(
-//     private name: string,
-//     private registry: Reg,
-//     private context: Context,
-//   ) {}
-//
-//   /* ------------------------------------------------ */
-//   /* Base Step                                       */
-//   /* ------------------------------------------------ */
-//   step<
-//     ID extends string,
-//     ActionName extends keyof Reg & string,
-//     Loop extends boolean | undefined = undefined,
-//   >(
-//     id: ID,
-//     action: ActionName,
-//     resolve?: (ctx: {
-//       input: Input;
-//       results: Results;
-//       context: Context;
-//     }) => ResolvedStepInput,
-//     dependsOn?: string[],
-//     options?: { loop?: Loop },
-//   ): WorkflowBuilder<
-//     Reg,
-//     Input,
-//     Context,
-//     [...Steps, StepDef<Reg, ID, ActionName>],
-//     Results & { [K in ID]: StepResult<Reg, ActionName, Loop> }
-//   > {
-//     const deps = dependsOn ?? [...this.frontier];
-//
-//     this.steps.push({
-//       id,
-//       action,
-//       resolve: resolve ?? (() => ({ kind: "none" })),
-//       dependsOn: deps,
-//       loop: options?.loop ?? false,
-//     });
-//
-//     this.frontier = [id];
-//
-//     return this as any;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Sequential shortcut                             */
-//   /* ------------------------------------------------ */
-//   seq<ID extends string, ActionName extends keyof Reg & string>(
-//     id: ID,
-//     action: ActionName,
-//     resolve?: (ctx: {
-//       input: Input;
-//       results: Results;
-//       context: Context;
-//     }) => ResolvedStepInput,
-//     options?: { loop?: boolean },
-//   ) {
-//     return this.step(id, action, resolve, undefined, options);
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Parallel branches                               */
-//   /* ------------------------------------------------ */
-//   parallel<Branches extends WorkflowBuilder<Reg, Input, Context, any, any>[]>(
-//     ...branches: {
-//       [K in keyof Branches]: (
-//         builder: WorkflowBuilder<Reg, Input, Context, [], Results>,
-//       ) => Branches[K];
-//     }
-//   ): WorkflowBuilder<
-//     Reg,
-//     Input,
-//     Context,
-//     [
-//       ...Steps,
-//       ...(Branches[number] extends WorkflowBuilder<Reg, any, any, infer S, any>
-//         ? S
-//         : never),
-//     ],
-//     Results &
-//       (Branches[number] extends WorkflowBuilder<Reg, any, any, any, infer R>
-//         ? UnionToIntersection<R>
-//         : {})
-//   > {
-//     const parentFrontier = [...this.frontier];
-//     const branchEnds: string[] = [];
-//
-//     branches.forEach((branch) => {
-//       const b = new WorkflowBuilder<Reg, Input, Context, [], Results>(
-//         this.name,
-//         this.registry,
-//         this.context,
-//       );
-//
-//       b.frontier = parentFrontier;
-//       branch(b);
-//       branchEnds.push(...b.frontier);
-//       this.steps.push(...(b as any).steps);
-//     });
-//
-//     this.frontier = branchEnds;
-//     return this as any;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Join helper                                     */
-//   /* ------------------------------------------------ */
-//   join<ID extends string, ActionName extends keyof Reg & string>(
-//     id: ID,
-//     action: ActionName,
-//     resolve?: (ctx: {
-//       input: Input;
-//       results: Results;
-//       context: Context;
-//     }) => ResolvedStepInput,
-//     options?: { loop?: boolean },
-//   ) {
-//     return this.step(id, action, resolve, [...this.frontier], options);
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Subflow                                         */
-//   /* ------------------------------------------------ */
-//   subflow<
-//     Prefix extends string,
-//     SubInput,
-//     SubResults,
-//     SubSteps extends StepDef<Reg, any, any>[],
-//     SubOutput,
-//   >(
-//     prefix: Prefix,
-//     workflow: WorkflowDef<Reg, SubInput, SubResults, SubSteps, SubOutput>,
-//     resolveInput?: (ctx: {
-//       input: Input;
-//       results: Results;
-//       context: Context;
-//     }) => SubInput,
-//     options?: { loop?: boolean },
-//   ): WorkflowBuilder<
-//     Reg,
-//     Input,
-//     Context,
-//     [...Steps, ...SubSteps],
-//     Results & { [K in Prefix]: SubflowResult<SubResults, SubOutput> }
-//   > {
-//     const idMap = new Map<string, string>();
-//
-//     workflow.steps.forEach((step) => {
-//       idMap.set(step.id, `${prefix}.${step.id}`);
-//     });
-//
-//     workflow.steps.forEach((step) => {
-//       const newStep: StepDef<Reg, any, any> = {
-//         ...step,
-//         id: idMap.get(step.id)!,
-//         dependsOn: step.dependsOn.map((d) => idMap.get(d)!),
-//         resolve: (ctx: any) => {
-//           const subInput = resolveInput ? resolveInput(ctx) : undefined;
-//           return step.resolve({
-//             input: subInput,
-//             results: ctx.results,
-//             context: ctx.context,
-//           });
-//         },
-//         ...(options ? { loop: options.loop ?? step.loop } : {}),
-//       };
-//
-//       if (workflow.entrySteps.find((e) => e.id === step.id)) {
-//         newStep.dependsOn = [...this.frontier];
-//       }
-//
-//       this.steps.push(newStep);
-//     });
-//
-//     this.frontier = workflow.endSteps.map((e) => idMap.get(e.id)!);
-//     return this as any;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Conditional                                      */
-//   /* ------------------------------------------------ */
-//   when(
-//     predicate: (ctx: {
-//       input: Input;
-//       results: Results;
-//       context: Context;
-//     }) => boolean,
-//   ): this {
-//     const lastStep = this.steps[this.steps.length - 1];
-//     if (!lastStep) throw new Error("when() must follow a step");
-//     lastStep.when = predicate;
-//     return this;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Workflow output                                  */
-//   /* ------------------------------------------------ */
-//   output<Output>(
-//     fn: (ctx: { input: Input; results: Results; context: Context }) => Output,
-//   ): WorkflowDef<Reg, Input, Results, Steps, Output> {
-//     this.outputResolver = fn;
-//     return this.build() as WorkflowDef<Reg, Input, Results, Steps, Output>;
-//   }
-//
-//   build(): WorkflowDef<Reg, Input, Results, Steps> {
-//     this.validateDependencies();
-//
-//     return {
-//       name: this.name,
-//       steps: this.steps as Steps,
-//       entrySteps: this.steps.filter((s) => s.dependsOn.length === 0),
-//       endSteps: this.getEndSteps(),
-//       input: {} as Input,
-//       results: {} as Results,
-//       outputResolver: this.outputResolver,
-//       __context: this.context,
-//     };
-//   }
-//
-//   private validateDependencies() {
-//     const stepIds = new Set(this.steps.map((s) => s.id));
-//     for (const step of this.steps) {
-//       for (const dep of step.dependsOn) {
-//         if (!stepIds.has(dep))
-//           throw new Error(`Step ${step.id} depends on unknown step ${dep}`);
-//       }
-//     }
-//   }
-//
-//   private getEndSteps() {
-//     const hasDependents = new Set<string>();
-//     for (const step of this.steps) {
-//       for (const dep of step.dependsOn) hasDependents.add(dep);
-//     }
-//     return this.steps.filter((s) => !hasDependents.has(s.id));
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* STATIC HELPERS FOR NORMALIZATION                */
-//   /* ------------------------------------------------ */
-//   static args = (...args: any[]): NormalizedCall => ({
-//     kind: "positional",
-//     args,
-//   });
-//   static obj = (args: any): NormalizedCall => ({ kind: "object", args });
-//   static none = (): NormalizedCall => ({ kind: "none" });
-//   static loop = (items: NormalizedCall[]): ResolvedStepInput => ({
-//     kind: "loop",
-//     items,
-//   });
-// }
-//
-// /* ------------------------------------------------ */
-// /* WORKFLOW CREATOR                                 */
-// /* ------------------------------------------------ */
-// export function createWorkflow<
-//   Reg extends ActionRegistry,
-//   Context extends Record<string, any> = {},
-// >(registry: Reg, context?: Context) {
-//   return function workflow<Input = unknown>(name: string) {
-//     return new WorkflowBuilder<Reg, Input, Context>(
-//       name,
-//       registry,
-//       context || ({} as Context),
-//     );
-//   };
-// }
-//
 /* ------------------------------------------------ */
 /* FLUENT WORKFLOW BUILDER                          */
 /* ------------------------------------------------ */
 export class WorkflowBuilder {
+    clearPendingWhen() {
+        this.pendingWhen = undefined;
+    }
     constructor(name, registry, context) {
         this.name = name;
         this.registry = registry;
@@ -380,6 +19,8 @@ export class WorkflowBuilder {
             action,
             resolve: resolve ?? (() => ({ kind: "none" })),
             dependsOn: deps,
+            when: this.pendingWhen,
+            options,
         });
         this.frontier = [id];
         return this;
@@ -399,6 +40,47 @@ export class WorkflowBuilder {
     /* ------------------------------------------------ */
     /* Parallel branches                               */
     /* ------------------------------------------------ */
+    // parallel<Branches extends WorkflowBuilder<Reg, Input, Context, any, any>[]>(
+    //   ...branches: {
+    //     [K in keyof Branches]: (
+    //       builder: WorkflowBuilder<Reg, Input, Context, [], Results>,
+    //     ) => Branches[K];
+    //   }
+    // ): WorkflowBuilder<
+    //   Reg,
+    //   Input,
+    //   Context,
+    //   [
+    //     ...Steps,
+    //     ...(Branches[number] extends WorkflowBuilder<Reg, any, any, infer S, any>
+    //       ? S
+    //       : never),
+    //   ],
+    //   Results &
+    //     (Branches[number] extends WorkflowBuilder<Reg, any, any, any, infer R>
+    //       ? UnionToIntersection<R>
+    //       : {})
+    // > {
+    //   const parentFrontier = [...this.frontier];
+    //   const branchEnds: string[] = [];
+    //
+    //   branches.forEach((branch) => {
+    //     const b = new WorkflowBuilder<Reg, Input, Context, [], Results>(
+    //       this.name,
+    //       this.registry,
+    //       this.context,
+    //     );
+    //
+    //     b.frontier = parentFrontier;
+    //     branch(b);
+    //     branchEnds.push(...b.frontier);
+    //     this.steps.push(...(b as any).steps);
+    //   });
+    //
+    //   this.frontier = branchEnds;
+    //   this.clearPendingWhen();
+    //   return this as any;
+    // }
     parallel(...branches) {
         const parentFrontier = [...this.frontier];
         const branchEnds = [];
@@ -410,13 +92,16 @@ export class WorkflowBuilder {
             this.steps.push(...b.steps);
         });
         this.frontier = branchEnds;
+        this.clearPendingWhen();
         return this;
     }
     /* ------------------------------------------------ */
     /* Join helper                                     */
     /* ------------------------------------------------ */
     join(id, action, resolve, options) {
-        return this.step(id, action, resolve, [...this.frontier], options);
+        const result = this.step(id, action, resolve, [...this.frontier], options);
+        this.clearPendingWhen();
+        return result;
     }
     /* ------------------------------------------------ */
     /* Subflow                                         */
@@ -452,10 +137,11 @@ export class WorkflowBuilder {
     /* Conditional                                      */
     /* ------------------------------------------------ */
     when(predicate) {
-        const lastStep = this.steps[this.steps.length - 1];
-        if (!lastStep)
-            throw new Error("when() must follow a step");
-        lastStep.when = predicate;
+        this.pendingWhen = predicate;
+        return this;
+    }
+    endWhen() {
+        this.clearPendingWhen();
         return this;
     }
     /* ------------------------------------------------ */

package/dist/workflow-executor.js CHANGED Viewed

@@ -7,6 +7,38 @@ function createCallHelpers() {
         loop: (items) => ({ kind: "loop", items }),
     };
 }
+// Helper to wrap action execution with timeout
+async function withTimeout(promise, ms) {
+    if (!ms)
+        return promise;
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), ms)),
+    ]);
+}
+// Helper to run action with retry support
+async function runWithRetry(actionFn, stepOptions) {
+    const maxRetries = stepOptions?.retry ?? 0;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await actionFn();
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt === maxRetries)
+                break;
+            const delay = stepOptions?.retryDelay;
+            if (typeof delay === "number") {
+                await new Promise((r) => setTimeout(r, delay));
+            }
+            else if (typeof delay === "function") {
+                await new Promise((r) => setTimeout(r, delay(attempt)));
+            }
+        }
+    }
+    throw lastError;
+}
 export async function executeWorkflow(workflow, registry, input, observers = []) {
     const results = {};
     const extras = {};
@@ -84,9 +116,12 @@ export async function executeWorkflow(workflow, registry, input, observers = [])
                 }
                 const resolvedArgs = step.resolve?.(stepCtx);
                 frame.input = resolvedArgs;
-                try {
+                const actionFn = async () => {
                     const action = registry[step.action];
-                    const result = await runAction(resolvedArgs, action);
+                    return await runAction(resolvedArgs, action);
+                };
+                try {
+                    const result = await withTimeout(runWithRetry(actionFn, step.options), step.options?.timeout);
                     frame.output = result;
                     frame.end = Date.now();
                     results[step.id] = result;
@@ -95,6 +130,15 @@ export async function executeWorkflow(workflow, registry, input, observers = [])
                 catch (err) {
                     frame.error = err;
                     frame.end = Date.now();
+                    if (step.options?.onError) {
+                        const fallback = step.options.onError(err, ctx);
+                        results[step.id] = fallback;
+                        return fallback;
+                    }
+                    if (step.options?.continueOnError) {
+                        results[step.id] = undefined;
+                        return undefined;
+                    }
                     throw err;
                 }
             };

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@pogodisco/zephyr",
-  "version": "1.3.9",
+  "version": "1.3.11",
   "publishConfig": {
     "access": "public"
   },