@pogodisco/zephyr 1.5.1 → 1.5.2

package/dist/types.d.ts

@@ -32,3 +32,25 @@ export interface Executor {
 export type ServiceRegistry = Record<string, Record<string, (...args: any[]) => any>>;
 export type ServiceParams<S extends ServiceRegistry, K extends keyof S, M extends keyof S[K]> = Parameters<S[K][M]>;
 export type ServiceReturn<S extends ServiceRegistry, K extends keyof S, M extends keyof S[K]> = Awaited<ReturnType<S[K][M]>>;
+export type NormalizedCall = {
+    kind: "none";
+} | {
+    kind: "positional";
+    args: any[];
+} | {
+    kind: "object";
+    args: any;
+};
+export 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";
+    };
+};

package/dist/types.js

@@ -1 +1,2 @@
 export {};
+/// pipe

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

@@ -0,0 +1,71 @@
+import { ActionRegistry, ActionReturn, CallHelpers, NormalizedCall, ServiceParams, ServiceRegistry, ServiceReturn } from "./types.js";
+type PipeStep = {
+    type: "action" | "service";
+    action?: string;
+    service?: string;
+    method?: string;
+    resolve: (ctx: any) => NormalizedCall;
+};
+export type PipeDef = {
+    input: (ctx: any) => any[];
+    steps: PipeStep[];
+};
+type InferStepReturn<Step, Reg extends ActionRegistry, Services extends ServiceRegistry> = Step extends {
+    type: "action";
+    action: infer A;
+} ? A extends keyof Reg ? ActionReturn<Reg, A> : never : Step extends {
+    type: "service";
+    service: infer SK;
+    method: infer MK;
+} ? SK extends keyof Services ? MK extends keyof Services[SK] ? ServiceReturn<Services, SK, MK> : never : never : never;
+export type PipeFinalType<Steps, Reg extends ActionRegistry, Services extends ServiceRegistry> = Steps extends [...any[], infer Last] ? InferStepReturn<Last, Reg, Services> : never;
+export type StepsOfPipeBuilder<PB> = PB extends PipeBuilder<any, any, any, any, infer S> ? S : never;
+export declare class PipeBuilder<Current, Reg extends ActionRegistry, Services extends ServiceRegistry, Results, Steps extends any[] = []> {
+    private steps;
+    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, [
+        ...Steps,
+        {
+            type: "action";
+            action: A;
+        }
+    ]>;
+    service<SK extends keyof Services & string, MK extends keyof Services[SK] & string>(id: string, service: SK, method: MK, resolve: (ctx: {
+        current: Current;
+        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;
+        };
+    }) => NormalizedCall): PipeBuilder<ServiceReturn<Services, SK, MK>, Reg, Services, Results, [
+        ...Steps,
+        {
+            type: "service";
+            service: SK;
+            method: MK;
+        }
+    ]>;
+    getSteps(): Steps;
+    build(): PipeStep[];
+}
+export {};

package/dist/workflow-composer-pipe.js

@@ -0,0 +1,28 @@
+export class PipeBuilder {
+    constructor() {
+        this.steps = [];
+    }
+    action(action, resolve) {
+        this.steps.push({
+            type: "action",
+            action,
+            resolve,
+        });
+        return this;
+    }
+    service(id, service, method, resolve) {
+        this.steps.push({
+            type: "service",
+            service,
+            method,
+            resolve,
+        });
+        return this;
+    }
+    getSteps() {
+        return this.steps;
+    }
+    build() {
+        return this.steps;
+    }
+}

package/dist/workflow-composer.d.ts

@@ -1,40 +1,9 @@
-import { ActionParams, ActionRegistry, ActionReturn, ServiceParams, ServiceRegistry, ServiceReturn, Simplify } from "./types.js";
-type NormalizedCall = {
-    kind: "none";
-} | {
-    kind: "positional";
-    args: any[];
-} | {
-    kind: "object";
-    args: any;
-};
+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 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;
-    };
-};
 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 {
@@ -52,6 +21,7 @@ export type StepDef<Reg extends ActionRegistry, ID extends string = string, Acti
     options?: StepOptions<any, any>;
     __subflowId?: string;
     serviceCall?: ServiceCall;
+    pipe?: PipeDef;
 };
 export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
     name: string;
@@ -122,22 +92,21 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
         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]: ServiceStepResultFromResolve<Services, SK, MK, ResolveOut>;
     }>>;
+    pipe<ID extends string, Arr extends any[], PB extends PipeBuilder<any, Reg, Services, Results, any>>(id: ID, input: (ctx: {
+        input: Input;
+        results: Results;
+    }) => Arr, builder: (p: PipeBuilder<Arr[number], Reg, Services, Results>) => PB, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
+        ...Steps,
+        StepDef<Reg, ID, any>
+    ], Simplify<Results & {
+        [K in ID]: PipeFinalType<StepsOfPipeBuilder<PB>, Reg, Services>[];
+    }>>;
     as<NewType>(): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Steps extends [...infer Rest, infer Last] ? Last extends StepDef<Reg, infer ID, any> ? Simplify<Omit<Results, ID> & {
         [K in ID]: NewType;
     }> : Results : Results, Output>;

package/dist/workflow-composer.js

@@ -1,66 +1,469 @@
+// 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;
+//   }
+//
 //   /* ------------------------------------------------ */
-//   /* Subflow                                         */
+//   /* 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,
+//     );
+//   }
 //
-//   subflow<
-//     Prefix extends string,
-//     SubSteps extends StepDef<Reg, any, any>[],
-//     WF extends WorkflowDef<Reg, any, any, SubSteps, any>,
+//   service<
+//     ID extends string,
+//     SK extends keyof Services & string,
+//     MK extends keyof Services[SK] & string,
+//     ResolveOut extends NormalizedCall = NormalizedCall,
 //   >(
-//     prefix: Prefix,
-//     workflow: WF,
-//     resolveInput: WorkflowInput<WF> extends undefined
-//       ?
-//           | ((ctx: {
-//               input: Input;
-//               results: Results;
-//               context: Context;
-//             }) => WorkflowInput<WF>)
-//           | undefined
-//       : (ctx: {
-//           input: Input;
-//           results: Results;
-//           context: Context;
-//         }) => WorkflowInput<WF>,
-//     options?: StepOptions<Input, Results, Context>,
+//     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,
-//     Context,
-//     [...Steps, ...WF["steps"]],
-//     Results & {
-//       [K in Prefix]: SubflowResult<WorkflowResults<WF>, WorkflowOutput<WF>>;
+//     [...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 idMap = new Map<string, string>();
+//     const parentFrontier = [...this.frontier];
+//     const branchEnds: string[] = [];
+//
+//     branches.forEach((branch) => {
+//       const b = new WorkflowBuilder<Reg, Services, WFReg, Input, [], Results>(
+//         this.name,
+//       );
 //
-//     workflow.steps.forEach((step) => {
-//       idMap.set(step.id, `${prefix}.${step.id}`);
+//       b.frontier = parentFrontier;
+//       b.pendingWhen = this.pendingWhen;
+//       branch(b);
+//       branchEnds.push(...b.frontier);
+//       this.steps.push(...(b as any).steps);
 //     });
 //
-//     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,
-//           });
-//         },
-//       };
-//
-//       if (workflow.entrySteps.find((e) => e.id === step.id)) {
-//         newStep.dependsOn = [...this.frontier];
-//       }
+//     this.frontier = branchEnds;
+//
+//     return this as any;
+//   }
 //
-//       this.steps.push(newStep);
+//   /* ------------------------------------------------ */
+//   /* 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 = workflow.endSteps.map((e) => idMap.get(e.id)!);
+//     this.frontier = [prefix];
 //     return this as any;
 //   }
 //
@@ -68,7 +471,79 @@
 //   /* 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";
 /* ------------------------------------------------ */
 /* FLUENT WORKFLOW BUILDER                          */
 /* ------------------------------------------------ */
@@ -117,6 +592,29 @@ export class WorkflowBuilder {
         this.frontier = [id];
         return this;
     }
+    /* ----------------------- */
+    /* Pipe                    */
+    /* ----------------------- */
+    pipe(id, input, builder, options) {
+        const deps = [...this.frontier];
+        const pb = new PipeBuilder();
+        const built = builder(pb);
+        const steps = built.getSteps();
+        this.steps.push({
+            id,
+            action: "__pipe__",
+            pipe: {
+                input,
+                steps,
+            },
+            dependsOn: deps,
+            when: this.pendingWhen,
+            resolve: () => ({ kind: "none" }),
+            options,
+        });
+        this.frontier = [id];
+        return this;
+    }
     /* ------------------------------------------------ */
     /* Override the result of the last step            */
     /* ------------------------------------------------ */

package/dist/workflow-executor.js

@@ -77,8 +77,10 @@ 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)));
+            // case "loop":
+            //   return await Promise.all(
+            //     input.items.map((item) => runAction(item, action)),
+            //   );
             default:
                 throw new Error(`Unknown ResolvedStepInput kind: ${input.kind}`);
         }
@@ -125,9 +127,44 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                     return undefined;
                 }
                 // -----------------------------
-                // Subflow handling
+                // Pipe handling
                 // -----------------------------
+                if (step.pipe && step.pipe.steps) {
+                    const items = step.pipe.input(stepCtx);
+                    const pipeResults = await Promise.all(items.map(async (item) => {
+                        let current = item;
+                        for (const pipeStep of step.pipe.steps) {
+                            const pipeCtx = {
+                                current,
+                                results,
+                                ...createCallHelpers(),
+                            };
+                            const resolved = pipeStep.resolve(pipeCtx);
+                            let action;
+                            if (pipeStep.type === "action") {
+                                action = actionRegistry[pipeStep.action];
+                            }
+                            else {
+                                action = services[pipeStep.service][pipeStep.method];
+                            }
+                            if (!action) {
+                                throw new Error(`Unknown ${pipeStep.type} in pipe step: ${pipeStep.type === "action"
+                                    ? pipeStep.action
+                                    : `${pipeStep.service}.${pipeStep.method}`}`);
+                            }
+                            current = await runAction(resolved, action);
+                        }
+                        return current;
+                    }));
+                    results[step.id] = pipeResults;
+                    frame.output = pipeResults;
+                    frame.end = Date.now();
+                    return pipeResults;
+                }
                 if (step.__subflowId) {
+                    // -----------------------------
+                    // Subflow handling
+                    // -----------------------------
                     const [modId, subWfId] = step.__subflowId.split(".");
                     const exec = depsExecutors[modId];
                     const subExecution = await exec.run(subWfId, resolvedArgs, services, observers);

package/package.json

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