@pogodisco/zephyr 1.5.2 → 1.5.4

package/dist/utils.js

@@ -1,5 +1,4 @@
 export function generateWorkflowId(name) {
-    // Short random + timestamp for practically unique ID
     const random = Math.random().toString(36).slice(2, 10);
     const time = Date.now().toString(36);
     return `${name}-${time}-${random}`;

package/dist/workflow-composer-pipe.d.ts

@@ -25,7 +25,7 @@ export declare class PipeBuilder<Current, Reg extends ActionRegistry, Services e
     action<A extends keyof Reg & string>(action: A, resolve: (ctx: {
         current: Current;
         results: Results;
-    } & CallHelpers<Reg, A>) => NormalizedCall): PipeBuilder<ActionReturn<Reg, A>, Reg, Services, Results, [
+    } & Results & CallHelpers<Reg, A>) => NormalizedCall): PipeBuilder<ActionReturn<Reg, A>, Reg, Services, Results, [
         ...Steps,
         {
             type: "action";
@@ -35,7 +35,7 @@ export declare class PipeBuilder<Current, Reg extends ActionRegistry, Services e
     service<SK extends keyof Services & string, MK extends keyof Services[SK] & string>(id: string, service: SK, method: MK, resolve: (ctx: {
         current: Current;
         results: Results;
-    } & {
+    } & Results & {
         args: (...args: ServiceParams<Services, SK, MK>) => {
             kind: "positional";
             args: ServiceParams<Services, SK, MK>;
@@ -47,16 +47,6 @@ export declare class PipeBuilder<Current, Reg extends ActionRegistry, Services e
         none: () => {
             kind: "none";
         };
-        loop: (items: {
-            kind: "positional";
-            args: ServiceParams<Services, SK, MK>;
-        }[] | {
-            kind: "object";
-            args: ServiceParams<Services, SK, MK>[0];
-        }[]) => {
-            kind: "loop";
-            items: typeof items;
-        };
     }) => NormalizedCall): PipeBuilder<ServiceReturn<Services, SK, MK>, Reg, Services, Results, [
         ...Steps,
         {

package/dist/workflow-composer.d.ts

@@ -1,22 +1,12 @@
 import { ActionRegistry, ActionReturn, CallHelpers, NormalizedCall, ServiceParams, ServiceRegistry, ServiceReturn, Simplify } from "./types.js";
 import { PipeBuilder, PipeDef, PipeFinalType, StepsOfPipeBuilder } from "./workflow-composer-pipe.js";
-export type ResolvedStepInput = NormalizedCall | {
-    kind: "loop";
-    items: NormalizedCall[];
-};
 type WorkflowInput<T> = T extends WorkflowDef<any, infer I, any, any, any> ? I : never;
 type WorkflowOutput<T> = T extends WorkflowDef<any, any, any, any, infer O> ? unknown extends O ? undefined : O : undefined;
-export type StepResultFromResolve<Reg extends ActionRegistry, ActionName extends keyof Reg, R extends ResolvedStepInput> = R extends {
-    kind: "loop";
-} ? ActionReturn<Reg, ActionName>[] : ActionReturn<Reg, ActionName>;
-export type ServiceStepResultFromResolve<S extends ServiceRegistry, SK extends keyof S, MK extends keyof S[SK], R extends ResolvedStepInput> = R extends {
-    kind: "loop";
-} ? ServiceReturn<S, SK, MK>[] : ServiceReturn<S, SK, MK>;
 export type StepDef<Reg extends ActionRegistry, ID extends string = string, ActionName extends keyof Reg = any> = {
     id: ID;
     action: ActionName | "__service__";
     dependsOn: string[];
-    resolve: (ctx: any) => ResolvedStepInput;
+    resolve: (ctx: any) => NormalizedCall;
     when?: (ctx: any) => boolean;
     options?: StepOptions<any, any>;
     __subflowId?: string;
@@ -64,23 +54,23 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
     private outputResolver?;
     private clearPendingWhen;
     constructor(name: string);
-    step<ID extends string, ActionName extends keyof Reg & string, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
+    step<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
+    } & Results & CallHelpers<Reg, ActionName>) => NormalizedCall, dependsOn?: string[], options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Simplify<Results & {
-        [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>;
+        [K in ID]: ActionReturn<Reg, ActionName>;
     }>>;
-    seq<ID extends string = string, ActionName extends keyof Reg & string = any, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
+    seq<ID extends string = string, ActionName extends keyof Reg & string = any>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
-    service<ID extends string, SK extends keyof Services & string, MK extends keyof Services[SK] & string, ResolveOut extends NormalizedCall = NormalizedCall>(id: ID, service: SK, method: MK, resolve?: (ctx: {
+    } & Results & CallHelpers<Reg, ActionName>) => NormalizedCall, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: ActionReturn<Reg, ActionName>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
+    service<ID extends string, SK extends keyof Services & string, MK extends keyof Services[SK] & string>(id: ID, service: SK, method: MK, resolve?: (ctx: {
         input: Input;
         results: Results;
-    } & {
+    } & Results & {
         args: (...args: ServiceParams<Services, SK, MK>) => {
             kind: "positional";
             args: ServiceParams<Services, SK, MK>;
@@ -92,11 +82,11 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
         none: () => {
             kind: "none";
         };
-    }) => ResolveOut, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
+    }) => NormalizedCall, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
         ...Steps,
         StepDef<Reg, ID, any>
     ], Simplify<Results & {
-        [K in ID]: ServiceStepResultFromResolve<Services, SK, MK, ResolveOut>;
+        [K in ID]: ServiceReturn<Services, SK, MK>;
     }>>;
     pipe<ID extends string, Arr extends any[], PB extends PipeBuilder<any, Reg, Services, Results, any>>(id: ID, input: (ctx: {
         input: Input;
@@ -113,25 +103,27 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
     parallel<Branches extends readonly WorkflowBuilder<Reg, Services, WFReg, Input, any, any>[]>(...branches: {
         [K in keyof Branches]: (builder: WorkflowBuilder<Reg, Services, WFReg, Input, [], Results>) => Branches[K];
     }): WorkflowBuilder<Reg, Services, WFReg, Input, MergeBranchSteps<Branches, Steps>, Simplify<MergeBranchResults<Branches, Results>>>;
-    join<ID extends string = string, ActionName extends keyof Reg & string = any, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
+    join<ID extends string = string, ActionName extends keyof Reg & string = any>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
+    } & Results & CallHelpers<Reg, ActionName>) => NormalizedCall, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: ActionReturn<Reg, ActionName>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
     subflow<Prefix extends string, K extends keyof WFReg & string>(prefix: Prefix, workflowKey: K, resolveInput: (ctx: {
         input: Input;
         results: Results;
     }) => WorkflowInput<WFReg[K]>, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results & {
         [P in Prefix]: WorkflowOutput<WFReg[K]>;
     }>;
+    private _subflow;
+    sub: this["subflow"];
     when(predicate: (ctx: {
         input: Input;
         results: Results;
-    }) => boolean): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results, Output>;
+    } & Results) => boolean): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results, Output>;
     endWhen(): this;
     output<Output>(fn: (ctx: {
         input: Input;
         results: Results;
-    }) => Output): WorkflowDef<Reg, Input, Results, Steps, Output>;
+    } & Results) => Output): WorkflowDef<Reg, Input, Results, Steps, Output>;
     build(): WorkflowDef<Reg, Input, Results, Steps>;
     private validateDependencies;
     private getEndSteps;

package/dist/workflow-composer.js

@@ -1,547 +1,3 @@
-// import {
-//   ActionParams,
-//   ActionRegistry,
-//   ActionReturn,
-//   ServiceParams,
-//   ServiceRegistry,
-//   ServiceReturn,
-//   Simplify,
-// } from "./types.js";
-// import { generateWorkflowId } from "./utils.js";
-//
-// /* ------------------------------------------------ */
-// /* STEP INPUT NORMALIZATION TYPES                  */
-// /* ------------------------------------------------ */
-//
-// type NormalizedCall =
-//   | { kind: "none" }
-//   | { kind: "positional"; args: any[] }
-//   | { kind: "object"; args: any };
-//
-// export type ResolvedStepInput =
-//   | NormalizedCall
-//   | { kind: "loop"; items: NormalizedCall[] };
-//
-// type CallHelpers<Reg extends ActionRegistry, ActionName extends keyof Reg> = {
-//   args: (...args: ActionParams<Reg, ActionName>) => {
-//     kind: "positional";
-//     args: ActionParams<Reg, ActionName>;
-//   };
-//
-//   obj: ActionParams<Reg, ActionName> extends [infer A]
-//     ? (arg: A) => { kind: "object"; args: A }
-//     : never;
-//
-//   none: () => { kind: "none" };
-//   loop: (
-//     items:
-//       | { kind: "positional"; args: ActionParams<Reg, ActionName> }[]
-//       | { kind: "object"; args: ActionParams<Reg, ActionName>[0] }[],
-//   ) => {
-//     kind: "loop";
-//     items: typeof items;
-//   };
-// };
-//
-// /* ------------------------------------------------ */
-// /* STEP RESULT TYPES                               */
-// /* ------------------------------------------------ */
-//
-// type WorkflowInput<T> =
-//   T extends WorkflowDef<any, infer I, any, any, any> ? I : never;
-//
-// // type WorkflowOutput<T> =
-// //   T extends WorkflowDef<any, any, any, any, infer O> ? O : never;
-//
-// type WorkflowOutput<T> =
-//   T extends WorkflowDef<any, any, any, any, infer O>
-//     ? unknown extends O
-//       ? undefined
-//       : O
-//     : undefined;
-//
-// export type StepResultFromResolve<
-//   Reg extends ActionRegistry,
-//   ActionName extends keyof Reg,
-//   R extends ResolvedStepInput,
-// > = R extends { kind: "loop" }
-//   ? ActionReturn<Reg, ActionName>[]
-//   : ActionReturn<Reg, ActionName>;
-//
-// export type ServiceStepResultFromResolve<
-//   S extends ServiceRegistry,
-//   SK extends keyof S,
-//   MK extends keyof S[SK],
-//   R extends ResolvedStepInput,
-// > = R extends { kind: "loop" }
-//   ? ServiceReturn<S, SK, MK>[]
-//   : ServiceReturn<S, SK, MK>;
-//
-// /* ------------------------------------------------ */
-// /* STEP DEFINITION                                 */
-// /* ------------------------------------------------ */
-//
-// export type StepDef<
-//   Reg extends ActionRegistry,
-//   ID extends string = string,
-//   ActionName extends keyof Reg = any,
-// > = {
-//   id: ID;
-//   action: ActionName | "__service__";
-//   dependsOn: string[];
-//   resolve: (ctx: any) => ResolvedStepInput;
-//   when?: (ctx: any) => boolean;
-//   options?: StepOptions<any, any>;
-//   __subflowId?: string;
-//
-//   serviceCall?: ServiceCall;
-// };
-//
-// /* ------------------------------------------------ */
-// /* WORKFLOW DEFINITION                             */
-// /* ------------------------------------------------ */
-//
-// export type WorkflowDef<
-//   Reg extends ActionRegistry,
-//   Input,
-//   Results,
-//   Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[],
-//   Output = undefined,
-// > = {
-//   name: string;
-//   _id: string;
-//   steps: Steps;
-//   entrySteps: StepDef<Reg>[];
-//   endSteps: StepDef<Reg>[];
-//   input: Input;
-//   results: Results;
-//   outputResolver?: (ctx: any) => Output;
-//   // __context?: any;
-// };
-// type StepRuntimeCtx<I, R> = {
-//   input: I;
-//   results: R;
-// };
-// type StepOptions<Input, Results> = {
-//   retry?: number;
-//   retryDelay?: number | ((attempt: number) => number);
-//   timeout?: number;
-//
-//   continueOnError?: boolean;
-//
-//   onError?: (err: unknown, ctx: StepRuntimeCtx<Input, Results>) => any;
-//
-//   // optional later:
-//   label?: string;
-//   meta?: Record<string, any>;
-// };
-//
-// type ServiceCall = {
-//   service: string;
-//   method: string;
-// };
-//
-// /* ------------------------------------------------ */
-// /* HELPER TYPES                                    */
-// /* ------------------------------------------------ */
-//
-// type MergeBranchResults<
-//   Branches extends readonly any[],
-//   Acc,
-// > = Branches extends readonly [infer Head, ...infer Tail]
-//   ? MergeBranchResults<
-//       Tail,
-//       Acc &
-//         (Head extends WorkflowBuilder<any, any, any, any, any, infer Results>
-//           ? Results
-//           : {})
-//     >
-//   : Acc;
-//
-// type MergeBranchSteps<
-//   Branches extends readonly any[],
-//   Acc extends any[],
-// > = Branches extends readonly [infer Head, ...infer Tail]
-//   ? MergeBranchSteps<
-//       Tail,
-//       [
-//         ...Acc,
-//         ...(Head extends WorkflowBuilder<any, any, any, any, infer Steps, any>
-//           ? Steps
-//           : []),
-//       ]
-//     >
-//   : Acc;
-//
-// /* ------------------------------------------------ */
-// /* FLUENT WORKFLOW BUILDER                          */
-// /* ------------------------------------------------ */
-// export class WorkflowBuilder<
-//   Reg extends ActionRegistry,
-//   Services extends ServiceRegistry,
-//   WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>, //
-//   Input = unknown,
-//   Steps extends StepDef<Reg, any, any>[] = [],
-//   Results = {},
-//   Output = undefined,
-// > {
-//   private steps: StepDef<Reg, any, any>[] = [];
-//   private frontier: string[] = [];
-//
-//   private pendingWhen?: (ctx: { input: Input; results: Results }) => boolean;
-//   private outputResolver?: (ctx: any) => any;
-//   private clearPendingWhen() {
-//     this.pendingWhen = undefined;
-//   }
-//
-//   constructor(private name: string) {}
-//
-//   step<
-//     ID extends string,
-//     ActionName extends keyof Reg & string,
-//     ResolveOut extends ResolvedStepInput = ResolvedStepInput,
-//   >(
-//     id: ID,
-//     action: ActionName,
-//     resolve?: (
-//       ctx: {
-//         input: Input;
-//         results: Results;
-//       } & CallHelpers<Reg, ActionName>,
-//     ) => ResolveOut,
-//     dependsOn?: string[],
-//     options?: StepOptions<Input, Results>,
-//   ): WorkflowBuilder<
-//     Reg,
-//     Services,
-//     WFReg,
-//     Input,
-//     [...Steps, StepDef<Reg, ID, ActionName>],
-//     Simplify<
-//       Results & {
-//         [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>;
-//       }
-//     >
-//   > {
-//     const deps = dependsOn ?? [...this.frontier];
-//
-//     this.steps.push({
-//       id,
-//       action,
-//       resolve: resolve ?? (() => ({ kind: "none" })),
-//       dependsOn: deps,
-//       when: this.pendingWhen,
-//       options,
-//     });
-//
-//     this.frontier = [id];
-//
-//     return this as any;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Sequential shortcut                             */
-//   /* ------------------------------------------------ */
-//   seq<
-//     ID extends string = string,
-//     ActionName extends keyof Reg & string = any,
-//     ResolveOut extends ResolvedStepInput = ResolvedStepInput,
-//   >(
-//     id: ID,
-//     action: ActionName,
-//     resolve?: (
-//       ctx: {
-//         input: Input;
-//         results: Results;
-//       } & CallHelpers<Reg, ActionName>,
-//     ) => ResolveOut,
-//     options?: StepOptions<Input, Results>,
-//   ) {
-//     return this.step<ID, ActionName, ResolveOut>(
-//       id,
-//       action,
-//       resolve,
-//       undefined,
-//       options,
-//     );
-//   }
-//
-//   service<
-//     ID extends string,
-//     SK extends keyof Services & string,
-//     MK extends keyof Services[SK] & string,
-//     ResolveOut extends NormalizedCall = NormalizedCall,
-//   >(
-//     id: ID,
-//     service: SK,
-//     method: MK,
-//     resolve?: (
-//       ctx: {
-//         input: Input;
-//         results: Results;
-//       } & {
-//         args: (...args: ServiceParams<Services, SK, MK>) => {
-//           kind: "positional";
-//           args: ServiceParams<Services, SK, MK>;
-//         };
-//         obj: ServiceParams<Services, SK, MK> extends [infer A]
-//           ? (arg: A) => { kind: "object"; args: A }
-//           : never;
-//         none: () => { kind: "none" };
-//         loop: (
-//           items:
-//             | { kind: "positional"; args: ServiceParams<Services, SK, MK> }[]
-//             | { kind: "object"; args: ServiceParams<Services, SK, MK>[0] }[],
-//         ) => {
-//           kind: "loop";
-//           items: typeof items;
-//         };
-//       },
-//     ) => ResolveOut,
-//     options?: StepOptions<Input, Results>,
-//   ): WorkflowBuilder<
-//     Reg,
-//     Services,
-//     WFReg,
-//     Input,
-//     [...Steps, StepDef<Reg, ID, any>],
-//     // Simplify<
-//     //   Results & {
-//     //     [K in ID]: ResolveOut extends { kind: "loop" }
-//     //       ? ServiceReturn<Services, SK, MK>[]
-//     //       : ServiceReturn<Services, SK, MK>;
-//     //   }
-//     // >
-//     Simplify<
-//       Results & {
-//         [K in ID]: ServiceStepResultFromResolve<Services, SK, MK, ResolveOut>;
-//       }
-//     >
-//   > {
-//     const deps = [...this.frontier];
-//
-//     this.steps.push({
-//       id,
-//       action: "__service__",
-//       serviceCall: {
-//         service,
-//         method,
-//       },
-//       resolve: resolve ?? (() => ({ kind: "none" })),
-//       dependsOn: deps,
-//       when: this.pendingWhen,
-//       options,
-//     });
-//
-//     this.frontier = [id];
-//
-//     return this as any;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Override the result of the last step            */
-//   /* ------------------------------------------------ */
-//   as<NewType>(): WorkflowBuilder<
-//     Reg,
-//     Services,
-//     WFReg,
-//     Input,
-//     Steps,
-//     // Override the result of the last step only
-//     Steps extends [...infer Rest, infer Last]
-//       ? Last extends StepDef<Reg, infer ID, any>
-//         ? Simplify<Omit<Results, ID> & { [K in ID]: NewType }>
-//         : Results
-//       : Results,
-//     Output
-//   > {
-//     return this as any;
-//   }
-//
-//   parallel<
-//     Branches extends readonly WorkflowBuilder<
-//       Reg,
-//       Services,
-//       WFReg,
-//       Input,
-//       any,
-//       any
-//     >[],
-//   >(
-//     ...branches: {
-//       [K in keyof Branches]: (
-//         builder: WorkflowBuilder<Reg, Services, WFReg, Input, [], Results>,
-//       ) => Branches[K];
-//     }
-//   ): WorkflowBuilder<
-//     Reg,
-//     Services,
-//     WFReg,
-//     Input,
-//     MergeBranchSteps<Branches, Steps>,
-//     // [
-//     //   ...Steps,
-//     //   ...(Branches[number] extends WorkflowBuilder<Reg, any, any, infer S, any>
-//     //     ? S
-//     //     : never),
-//     // ],
-//     Simplify<MergeBranchResults<Branches, Results>>
-//   > {
-//     const parentFrontier = [...this.frontier];
-//     const branchEnds: string[] = [];
-//
-//     branches.forEach((branch) => {
-//       const b = new WorkflowBuilder<Reg, Services, WFReg, Input, [], Results>(
-//         this.name,
-//       );
-//
-//       b.frontier = parentFrontier;
-//       b.pendingWhen = this.pendingWhen;
-//       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 = string,
-//     ActionName extends keyof Reg & string = any,
-//     ResolveOut extends ResolvedStepInput = ResolvedStepInput,
-//   >(
-//     id: ID,
-//     action: ActionName,
-//     resolve?: (
-//       ctx: {
-//         input: Input;
-//         results: Results;
-//       } & CallHelpers<Reg, ActionName>,
-//     ) => ResolveOut,
-//     options?: StepOptions<Input, Results>,
-//   ) {
-//     const result = this.step<ID, ActionName, ResolveOut>(
-//       id,
-//       action,
-//       resolve,
-//       [...this.frontier],
-//       options,
-//     );
-//
-//     this.clearPendingWhen();
-//     return result;
-//   }
-//
-//   subflow<Prefix extends string, K extends keyof WFReg & string>(
-//     prefix: Prefix,
-//     workflowKey: K,
-//     resolveInput: (ctx: {
-//       input: Input;
-//       results: Results;
-//     }) => WorkflowInput<WFReg[K]>,
-//     options?: StepOptions<Input, Results>,
-//   ): WorkflowBuilder<
-//     Reg,
-//     Services,
-//     WFReg,
-//     Input,
-//     Steps,
-//     Results & { [P in Prefix]: WorkflowOutput<WFReg[K]> }
-//   > {
-//     this.steps.push({
-//       id: prefix,
-//       action: "__subflow__",
-//       dependsOn: [...this.frontier],
-//       when: this.pendingWhen,
-//       resolve: (ctx: any) => resolveInput(ctx),
-//       options,
-//       __subflowId: workflowKey, // 👈 STRING ONLY
-//     });
-//
-//     this.frontier = [prefix];
-//     return this as any;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Conditional                                      */
-//   /* ------------------------------------------------ */
-//
-//   when(
-//     predicate: (ctx: { input: Input; results: Results }) => boolean,
-//   ): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results, Output> {
-//     this.pendingWhen = predicate;
-//     return this;
-//   }
-//
-//   endWhen(): this {
-//     this.clearPendingWhen();
-//
-//     return this;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Workflow output                                  */
-//   /* ------------------------------------------------ */
-//   output<Output>(
-//     fn: (ctx: { input: Input; results: Results }) => 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 {
-//       _id: generateWorkflowId(this.name),
-//       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,
-//     };
-//   }
-//
-//   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));
-//   }
-// }
-//
-// export function createWorkflow<
-//   Reg extends ActionRegistry,
-//   WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>, // 👈 NEW
-//   Services extends ServiceRegistry,
-// >() {
-//   return function workflow<Input = unknown>(name: string) {
-//     return new WorkflowBuilder<Reg, Services, WFReg, Input>(name);
-//   };
-// }
-//
-//
-//
-//
-//
 import { generateWorkflowId } from "./utils.js";
 import { PipeBuilder, } from "./workflow-composer-pipe.js";
 /* ------------------------------------------------ */
@@ -555,6 +11,8 @@ export class WorkflowBuilder {
         this.name = name;
         this.steps = [];
         this.frontier = [];
+        this._subflow = this.subflow.bind(this);
+        this.sub = ((...args) => this._subflow(...args));
     }
     step(id, action, resolve, dependsOn, options) {
         const deps = dependsOn ?? [...this.frontier];

package/dist/workflow-executor.d.ts

@@ -12,10 +12,6 @@ export declare function createCallHelpers(): {
     none: () => {
         kind: string;
     };
-    loop: (items: any[]) => {
-        kind: string;
-        items: any[];
-    };
 };
 export declare function executeWorkflow<Reg extends ActionRegistry, I, R, O = R>({ workflow, actionRegistry, services, input, depsExecutors, observers, }: {
     workflow: WorkflowDef<Reg, I, any, any, O>;

package/dist/workflow-executor.js

@@ -4,10 +4,8 @@ export function createCallHelpers() {
         args: (...args) => ({ kind: "positional", args }),
         obj: (arg) => ({ kind: "object", args: arg }),
         none: () => ({ kind: "none" }),
-        loop: (items) => ({ kind: "loop", items }),
     };
 }
-// Helper to wrap action execution with timeout
 async function withTimeout(promise, ms) {
     if (!ms)
         return promise;
@@ -16,6 +14,24 @@ async function withTimeout(promise, ms) {
         new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), ms)),
     ]);
 }
+function createStepCtx(input, results) {
+    const helpers = createCallHelpers();
+    return new Proxy({
+        input,
+        results,
+        ...helpers,
+    }, {
+        get(target, prop) {
+            // 1. explicit keys first
+            if (prop in target)
+                return target[prop];
+            // 2. fallback to results
+            if (prop in results)
+                return results[prop];
+            return undefined;
+        },
+    });
+}
 // Helper to run action with retry support
 async function runWithRetry(actionFn, stepOptions) {
     const maxRetries = stepOptions?.retry ?? 0;
@@ -77,10 +93,6 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                 return await action(...input.args);
             case "object":
                 return await action(input.args);
-            // case "loop":
-            //   return await Promise.all(
-            //     input.items.map((item) => runAction(item, action)),
-            //   );
             default:
                 throw new Error(`Unknown ResolvedStepInput kind: ${input.kind}`);
         }
@@ -106,11 +118,13 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                 extras,
                 frame,
             };
-            const stepCtx = {
-                input,
-                results,
-                ...createCallHelpers(),
-            };
+            const stepCtx = createStepCtx(input, results);
+            // const stepCtx = {
+            //   input,
+            //   results,
+            //
+            //   ...createCallHelpers(),
+            // };
             const resolvedArgs = step.resolve?.(stepCtx);
             frame.input = resolvedArgs;
             const core = async () => {
@@ -168,14 +182,6 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                     const [modId, subWfId] = step.__subflowId.split(".");
                     const exec = depsExecutors[modId];
                     const subExecution = await exec.run(subWfId, resolvedArgs, services, observers);
-                    // const subExecution = await executeWorkflow(
-                    //   step.__subflowId,
-                    //   workflowRegistry,
-                    //   actionRegistry,
-                    //   resolvedArgs as any,
-                    //   context,
-                    //   observers,
-                    // );
                     frame.output = subExecution.output;
                     frame.end = Date.now();
                     results[step.id] = subExecution.output;
@@ -233,11 +239,9 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
     if (completed !== workflow.steps.length) {
         throw new Error("Workflow execution failed (cycle or missing dependency)");
     }
+    const outputCtx = createStepCtx(input, results);
     const output = workflow.outputResolver
-        ? workflow.outputResolver({
-            input,
-            results,
-        })
+        ? workflow.outputResolver(outputCtx)
         : results;
     return {
         // results: results as WorkflowResults<WR[K]>,

package/dist/workflow-module.js

@@ -1,260 +1,3 @@
-//   ActionRegistry,
-// import {
-//   Executor,
-//   Simplify,
-//   WorkflowObserver,
-// } from "./types.js";
-// import { createWorkflow, WorkflowDef } from "./workflow-composer.js";
-// import { executeWorkflow } from "./workflow-executor.js";
-// type UnionToIntersection<U> = (U extends any ? (x: U) => any : never) extends (
-//   x: infer I,
-// ) => any
-//   ? I
-//   : never;
-// /* ------------------------------------------------ */
-// /* WORKFLOW REGISTRY TYPES                          */
-// /* ------------------------------------------------ */
-// type EnsureWorkflowRecord<T> =
-//   T extends Record<string, WorkflowDef<any, any, any, any, any>>
-//     ? T
-//     : Record<string, WorkflowDef<any, any, any, any, any>>;
-//
-// type EnsureWorkflowShape<T> = {
-//   [K in keyof T]: T[K] extends WorkflowDef<any, any, any, any, any>
-//     ? T[K]
-//     : never;
-// };
-//
-// type DepWorkflows<Deps extends ModuleMap> = keyof Deps extends never
-//   ? {}
-//   : Simplify<
-//       EnsureWorkflowShape<
-//         UnionToIntersection<
-//           {
-//             [D in keyof Deps & string]: {
-//               [K in keyof Deps[D]["workflows"] &
-//                 string as `${D}.${K}`]: Deps[D]["workflows"][K];
-//             };
-//           }[keyof Deps & string]
-//         >
-//       >
-//     >;
-//
-// type WorkflowRegistry<Own extends ModuleShape, Deps extends ModuleMap> = Own &
-//   DepWorkflows<Deps>;
-//
-// /* ------------------------------------------------ */
-// /* MODULE TYPES                                     */
-// /* ------------------------------------------------ */
-//
-// type AnyWorkflow = WorkflowDef<any, any, any, any, any>;
-// type ModuleShape = Record<string, AnyWorkflow>;
-// type ModuleMap = Record<string, Module<any, any, any, any>>;
-//
-// // type ContextFromDeps<Deps> = [keyof Deps] extends [never]
-// //   ? {}
-// //   : {
-// //       [K in keyof Deps]: Deps[K] extends Module<any, infer Ctx, any, any>
-// //         ? Ctx
-// //         : never;
-// //     }[keyof Deps];
-//
-// type FinalContext<
-//   Context extends Record<string, any>,
-//   Deps extends ModuleMap,
-// > = Context & ContextFromDepsRecursive<Deps>;
-//
-// // type ContextFromDeps<Deps> = [keyof Deps] extends [never]
-// //   ? {}
-// //   : UnionToIntersection<
-// //       {
-// //         [K in keyof Deps]: Deps[K] extends Module<any, infer Ctx, any, any>
-// //           ? Ctx
-// //           : never;
-// //       }[keyof Deps]
-// //     >;
-//
-// type ContextFromDepsRecursive<Deps extends ModuleMap> = [keyof Deps] extends [
-//   never,
-// ]
-//   ? {} // no deps
-//   : UnionToIntersection<
-//       {
-//         [K in keyof Deps]: Deps[K] extends Module<
-//           any,
-//           infer Ctx,
-//           any,
-//           infer SubDeps
-//         >
-//           ? Ctx & ContextFromDepsRecursive<SubDeps>
-//           : never;
-//       }[keyof Deps]
-//     >;
-//
-// /* ------------------------------------------------ */
-// /* WORKFLOW IO TYPES                                */
-// /* ------------------------------------------------ */
-//
-// export type WorkflowInput<W> =
-//   W extends WorkflowDef<any, infer I, any, any, any> ? I : never;
-//
-// export type WorkflowResults<W> =
-//   W extends WorkflowDef<any, any, infer R, any, any> ? R : never;
-//
-// export type WorkflowOutput<W> =
-//   W extends WorkflowDef<any, any, any, any, infer O> ? O : never;
-//
-// /* ------------------------------------------------ */
-// /* MODULE RUNTIME                                   */
-// /* ------------------------------------------------ */
-//
-// type Module<
-//   Reg extends ActionRegistry,
-//   Context extends Record<string, any>,
-//   Own extends ModuleShape,
-//   Deps extends ModuleMap,
-// > = {
-//   workflows: Own;
-//   __getExecutor: () => Executor;
-//
-//   createRuntime: (config: { context: FinalContext<Context, Deps> }) => {
-//     run: <K extends keyof WorkflowRegistry<Own, Deps>>(
-//       workflow: K,
-//       input: WorkflowInput<WorkflowRegistry<Own, Deps>[K]>,
-//       observers?: WorkflowObserver<Reg>[],
-//     ) => Promise<{
-//       // results: WorkflowResults<WorkflowRegistry<Own, Deps>[K]>;
-//       output: WorkflowOutput<WorkflowRegistry<Own, Deps>[K]>;
-//       extras: Record<string, any>;
-//     }>;
-//
-//     getContext: () => FinalContext<Context, Deps>;
-//   };
-// };
-//
-// /* ------------------------------------------------ */
-// /* MODULE CONTEXT (FIXED)                           */
-// /* ------------------------------------------------ */
-//
-// type ModuleContext<
-//   Reg extends ActionRegistry,
-//   WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>,
-//   Context extends Record<string, any>,
-// > = {
-//   wf: ReturnType<typeof createWorkflow<Reg, WFReg, Context>>;
-//   context: Context;
-// };
-//
-// function createModule<
-//   Reg extends ActionRegistry,
-//   Context extends Record<string, any>,
-//   Use extends ModuleMap,
-//   Own extends ModuleShape,
-// >(config: {
-//   actionRegistry: Reg;
-//   use?: Use;
-//   define: (ctx: ModuleContext<Reg, DepWorkflows<Use>, Context>) => Own;
-// }): Module<Reg, Context, Own, Use> {
-//   const deps = (config.use ?? {}) as Use;
-//
-//   const wf = createWorkflow<Reg, DepWorkflows<Use>, Context>();
-//
-//   const own = config.define({
-//     wf,
-//     context: {} as Context,
-//   });
-//
-//   function buildWorkflowMap(): WorkflowRegistry<Own, Use> {
-//     const depWFs = Object.fromEntries(
-//       Object.entries(deps).flatMap(([name, mod]) =>
-//         Object.entries(mod.workflows).map(([k, wf]) => [`${name}.${k}`, wf]),
-//       ),
-//     );
-//
-//     return { ...own, ...depWFs } as WorkflowRegistry<Own, Use>;
-//   }
-//
-//   const workflowMap = buildWorkflowMap();
-//
-//   const depsExecutors = Object.fromEntries(
-//     Object.entries(deps).map(([name, mod]) => [name, mod.__getExecutor()]),
-//   );
-//
-//   const executor: Executor = {
-//     run(wfId, input, context, observers = []) {
-//       const workflow = workflowMap[wfId];
-//
-//       if (!workflow) {
-//         throw new Error(`Workflow not found: ${String(wfId)}`);
-//       }
-//
-//       return executeWorkflow({
-//         workflow,
-//         actionRegistry: config.actionRegistry,
-//         depsExecutors,
-//         input,
-//         context,
-//         observers,
-//       });
-//     },
-//   };
-//
-//   return {
-//     workflows: own,
-//     __getExecutor: () => executor,
-//
-//     createRuntime({ services }) {
-//       let runtimeActions = config.actionRegistry;
-//
-//       // const runtimeService = createServiceRegisty(services)
-//       return {
-//         run: async <K extends keyof WorkflowRegistry<Own, Use>>(
-//           workflowId: K,
-//           input: WorkflowInput<WorkflowRegistry<Own, Use>[K]>,
-//           observers: WorkflowObserver<Reg>[] = [],
-//         ) => {
-//           return executor.run(workflowId as string, input, context, observers);
-//         },
-//         // make it same, practically nothing changes but naming, and what context holds
-//         getContext: () => ({ ...context }) as FinalContext<Context, Use>,
-//
-//         setActionRegistry(reg: Reg) {
-//           runtimeActions = reg;
-//           // ⚠️ optional: if you REALLY want override, you'd need:
-//           // executor.actions = reg
-//           // but better keep actions immutable
-//         },
-//       };
-//     },
-//   };
-// }
-//
-// /* ------------------------------------------------ */
-// /* FACTORY (FIXED)                                  */
-// /* ------------------------------------------------ */
-//
-// export function createModuleFactory<
-//   // Reg extends ActionRegistry,
-//   Context extends Record<string, any>,
-// >() {
-//   return function <
-//     Reg extends ActionRegistry = Record<string, any>,
-//     Use extends ModuleMap = {},
-//     Own extends ModuleShape = {},
-//   >(config: {
-//     actionRegistry: Reg;
-//     use?: Use;
-//     define: (
-//       ctx: ModuleContext<
-//         typeof config.actionRegistry,
-//         DepWorkflows<Use>,
-//         Context
-//       >, // ✅ FIXED HERE
-//     ) => Own;
-//   }): Module<Reg, Context, Own, Use> {
-//     return createModule<Reg, Context, Use, Own>(config);
-//   };
-// }
 import { createWorkflow } from "./workflow-composer.js";
 import { executeWorkflow } from "./workflow-executor.js";
 function createModule(config) {

package/package.json

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