@pogodisco/zephyr 1.5.4 → 1.5.6

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./registry.js";
 export * from "./workflow-executor.js";
 export * from "./workflow-composer.js";
 export * from "./workflow-module.js";
+export { exposeAll, exposeAllAs } from "./utils.js";
 export * from "./types.js";
 export * from "./session.js";
 export { useMetrics, useLog } from "./observer.js";

package/dist/index.js

@@ -3,6 +3,7 @@ export * from "./registry.js";
 export * from "./workflow-executor.js";
 export * from "./workflow-composer.js";
 export * from "./workflow-module.js";
+export { exposeAll, exposeAllAs } from "./utils.js";
 export * from "./types.js";
 export * from "./session.js";
 export { useMetrics, useLog } from "./observer.js";

package/dist/types.d.ts

@@ -40,6 +40,11 @@ export type NormalizedCall = {
 } | {
     kind: "object";
     args: any;
+} | {
+    kind: "pipe_source";
+    args: any;
+} | {
+    kind: "pipe_collect";
 };
 export type CallHelpers<Reg extends ActionRegistry, ActionName extends keyof Reg> = {
     args: (...args: ActionParams<Reg, ActionName>) => {

package/dist/utils.d.ts

@@ -1 +1,4 @@
+import { Module } from "./workflow-module.js";
 export declare function generateWorkflowId(name: string): string;
+export declare function exposeAll<Name extends string, M extends Module<any, any, any, any>>(name: Name, mod: M): Record<`${Name}.${keyof M["workflows"] & string}`, `${Name}.${keyof M["workflows"] & string}`>;
+export declare function exposeAllAs<Name extends string, M extends Module<any, any, any, any>>(name: Name, mod: M): Record<keyof M["workflows"] & string, `${Name}.${keyof M["workflows"] & string}`>;

package/dist/utils.js

@@ -3,3 +3,18 @@ export function generateWorkflowId(name) {
     const time = Date.now().toString(36);
     return `${name}-${time}-${random}`;
 }
+export function exposeAll(name, mod) {
+    const result = {};
+    for (const key in mod.workflows) {
+        const full = `${name}.${key}`;
+        result[full] = full;
+    }
+    return result;
+}
+export function exposeAllAs(name, mod) {
+    const result = {};
+    for (const key in mod.workflows) {
+        result[key] = `${name}.${key}`;
+    }
+    return result;
+}

package/dist/workflow-composer.d.ts

@@ -1,5 +1,4 @@
 import { ActionRegistry, ActionReturn, CallHelpers, NormalizedCall, ServiceParams, ServiceRegistry, ServiceReturn, Simplify } from "./types.js";
-import { PipeBuilder, PipeDef, PipeFinalType, StepsOfPipeBuilder } from "./workflow-composer-pipe.js";
 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 StepDef<Reg extends ActionRegistry, ID extends string = string, ActionName extends keyof Reg = any> = {
@@ -11,7 +10,9 @@ export type StepDef<Reg extends ActionRegistry, ID extends string = string, Acti
     options?: StepOptions<any, any>;
     __subflowId?: string;
     serviceCall?: ServiceCall;
-    pipe?: PipeDef;
+    pipe?: {
+        workflow: WorkflowDef<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;
@@ -33,6 +34,9 @@ type StepOptions<Input, Results> = {
     timeout?: number;
     continueOnError?: boolean;
     onError?: (err: unknown, ctx: StepRuntimeCtx<Input, Results>) => any;
+    pipe?: {
+        parallel?: boolean;
+    };
     label?: string;
     meta?: Record<string, any>;
 };
@@ -45,6 +49,7 @@ type MergeBranchSteps<Branches extends readonly any[], Acc extends any[]> = Bran
     ...Acc,
     ...(Head extends WorkflowBuilder<any, any, any, any, infer Steps, any> ? Steps : [])
 ]> : Acc;
+type LastStepOfBranch<B> = B extends WorkflowBuilder<any, any, any, any, any, infer Results> ? Results extends Record<string, infer Last> ? Last : never : never;
 export declare 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 name;
@@ -88,14 +93,11 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
     ], Simplify<Results & {
         [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: {
+    pipe<ID extends string, Arr extends any[], Branch extends WorkflowBuilder<Reg, Services, WFReg, Arr[number], any, 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>[];
+    } & Results) => Arr, builder: (b: WorkflowBuilder<Reg, Services, WFReg, Arr[number], [], Results>) => Branch, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Simplify<Results & {
+        [K in ID]: LastStepOfBranch<Branch>[];
     }>>;
     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;

package/dist/workflow-composer.js

@@ -1,8 +1,4 @@
 import { generateWorkflowId } from "./utils.js";
-import { PipeBuilder, } from "./workflow-composer-pipe.js";
-/* ------------------------------------------------ */
-/* FLUENT WORKFLOW BUILDER                          */
-/* ------------------------------------------------ */
 export class WorkflowBuilder {
     clearPendingWhen() {
         this.pendingWhen = undefined;
@@ -50,24 +46,47 @@ 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();
+        const branchBuilder = new WorkflowBuilder(this.name);
+        branchBuilder.frontier = [];
+        branchBuilder.pendingWhen = this.pendingWhen;
+        const built = builder(branchBuilder);
+        const wfId = generateWorkflowId(id);
+        const entrySteps = built.steps.filter((s) => s.dependsOn.length === 0);
+        const hasDependents = new Set();
+        for (const step of built.steps) {
+            for (const dep of step.dependsOn)
+                hasDependents.add(dep);
+        }
+        const endSteps = built.steps.filter((s) => !hasDependents.has(s.id));
+        const subWf = {
+            _id: wfId,
+            input: {},
+            results: {},
+            name: `${id}_pipe`,
+            steps: built.steps,
+            // steps: built.steps,
+            entrySteps,
+            endSteps,
+            outputResolver: (ctx) => {
+                return built.frontier.length === 1
+                    ? ctx[built.frontier[0]]
+                    : built.frontier.map((f) => ctx[f]);
+            },
+        };
         this.steps.push({
             id,
-            action: "__pipe__",
-            pipe: {
-                input,
-                steps,
-            },
+            action: "__pipe_map__",
             dependsOn: deps,
             when: this.pendingWhen,
-            resolve: () => ({ kind: "none" }),
+            resolve: (ctx) => ({
+                kind: "pipe_source",
+                args: input(ctx),
+            }),
+            pipe: {
+                workflow: subWf,
+            },
             options,
         });
         this.frontier = [id];

package/dist/workflow-executor.js

@@ -1,3 +1,474 @@
+// import { composeObserver } from "./observer.js";
+// import {
+//   ActionRegistry,
+//   ExecutionFrame,
+//   Executor,
+//   NormalizedCall,
+//   ServiceRegistry,
+//   WorkflowObserver,
+// } from "./types.js";
+// import { StepDef, WorkflowDef } from "./workflow-composer.js";
+//
+// export function createCallHelpers() {
+//   return {
+//     args: (...args: any[]) => ({ kind: "positional", args }),
+//     obj: (arg: any) => ({ kind: "object", args: arg }),
+//     none: () => ({ kind: "none" }),
+//   };
+// }
+//
+// async function withTimeout<T>(promise: Promise<T>, ms?: number): Promise<T> {
+//   if (!ms) return promise;
+//   return Promise.race([
+//     promise,
+//     new Promise<T>((_, reject) =>
+//       setTimeout(() => reject(new Error("Timeout")), ms),
+//     ),
+//   ]);
+// }
+//
+// function createStepCtx(input: any, results: any) {
+//   const helpers = createCallHelpers();
+//
+//   return new Proxy(
+//     {
+//       input,
+//       results,
+//       ...helpers,
+//     },
+//     {
+//       get(target, prop) {
+//         // 1. explicit keys first
+//         if (prop in target) return target[prop as keyof typeof target];
+//
+//         // 2. fallback to results
+//         if (prop in results) return results[prop as keyof typeof target];
+//
+//         return undefined;
+//       },
+//     },
+//   );
+// }
+//
+// // Helper to run action with retry support
+// async function runWithRetry(
+//   actionFn: () => Promise<any>,
+//   stepOptions?: {
+//     retry?: number;
+//     retryDelay?: number | ((attempt: number) => number);
+//   },
+// ): Promise<any> {
+//   const maxRetries = stepOptions?.retry ?? 0;
+//   let lastError: any;
+//
+//   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<Reg extends ActionRegistry, I, R, O = R>({
+//   workflow,
+//   actionRegistry,
+//   services,
+//   input,
+//
+//   depsExecutors,
+//   observers = [],
+// }: {
+//   workflow: WorkflowDef<Reg, I, any, any, O>;
+//
+//   actionRegistry: Reg;
+//   services: ServiceRegistry;
+//   input: I;
+//
+//   depsExecutors: Record<string, Executor>;
+//   observers: WorkflowObserver<Reg>[];
+// }): Promise<{
+//   // results: WorkflowResults<WR[K]>;
+//   output: O;
+//   extras: Record<string, any>;
+// }> {
+//   const results: Record<string, any> = {};
+//   const extras: Record<string, any> = {};
+//   extras.frames = {} as Record<string, ExecutionFrame>;
+//
+//   // -----------------------------
+//   // Fully typed step map
+//   // -----------------------------
+//   // const stepById: Map<string, StepDef<Reg, any, any>> = new Map(
+//   //   workflow.steps.map((s: StepDef<Reg, any, any>) => [s.id, s]),
+//   // );
+//   const stepById = new Map(
+//     workflow.steps.map((s: StepDef<Reg, any, any>) => [s.id, s]),
+//   );
+//   console.log("SERVICES", services);
+//   console.log("WF STEPS", workflow.steps);
+//   // return;
+//
+//   const remainingDeps = new Map<string, number>();
+//   const dependents = new Map<string, string[]>();
+//   const ready: string[] = [];
+//
+//   for (const step of workflow.steps) {
+//     remainingDeps.set(step.id, step.dependsOn.length);
+//     if (step.dependsOn.length === 0) ready.push(step.id);
+//
+//     for (const dep of step.dependsOn) {
+//       if (!dependents.has(dep)) dependents.set(dep, []);
+//       dependents.get(dep)!.push(step.id);
+//     }
+//   }
+//
+//   let completed = 0;
+//
+//   // -----------------------------
+//   // Normalized runner
+//   // -----------------------------
+//   const runAction = async (
+//     input: NormalizedCall | undefined,
+//     action: any,
+//   ): Promise<any> => {
+//     if (!input) return await action();
+//
+//     switch (input.kind) {
+//       case "none":
+//         return await action();
+//       case "positional":
+//         return await action(...input.args);
+//       case "object":
+//         return await action(input.args);
+//       default:
+//         throw new Error(
+//           `Unknown ResolvedStepInput kind: ${(input as any).kind}`,
+//         );
+//     }
+//   };
+//
+//   // -----------------------------
+//   // Execution loop
+//   // -----------------------------
+//
+//   while (ready.length > 0) {
+//     const batch = ready.splice(0);
+//
+//     await Promise.all(
+//       batch.map(async (stepId) => {
+//         const step = stepById.get(stepId)! as StepDef<Reg, any, any>;
+//
+//         const frame: ExecutionFrame = {
+//           stepId,
+//           attempts: 0,
+//           start: Date.now(),
+//         };
+//         extras.frames[stepId] = frame;
+//
+//         const ctx = {
+//           stepId,
+//           input,
+//           results,
+//
+//           actionRegistry,
+//           extras,
+//           frame,
+//         };
+//
+//         const stepCtx = createStepCtx(input, results);
+//         // const stepCtx = {
+//         //   input,
+//         //   results,
+//         //
+//         //   ...createCallHelpers(),
+//         // };
+//
+//         const resolvedArgs = step.resolve?.(stepCtx);
+//
+//         frame.input = resolvedArgs;
+//
+//         const core = async () => {
+//           frame.attempts++;
+//
+//           // -----------------------------
+//           // ✅ SINGLE when evaluation
+//           // -----------------------------
+//           if (step.when && !step.when(stepCtx)) {
+//             frame.input = undefined; // 👈 important for observer consistency
+//             frame.output = undefined;
+//             frame.end = Date.now();
+//             frame.skipped = true;
+//             results[step.id] = undefined;
+//             return undefined;
+//           }
+//
+//           // -----------------------------
+//           // Pipe V2 handling
+//           // -----------------------------
+//
+//           if (step.action === "__pipe_source__") {
+//             // The source step produces the array
+//             const args = step.resolve!(stepCtx);
+//             results[step.id] = args.args;
+//             frame.output = args;
+//             frame.end = Date.now();
+//             return args.args;
+//           }
+//
+//           if (step.action === "__pipe_collect__") {
+//             // Collect outputs of branch steps
+//             const pipeSourceId = (step as any).__pipeSource;
+//             const sourceItems: any[] = results[pipeSourceId] ?? [];
+//
+//             const branchStepIds = step.dependsOn; // prefixed branch step IDs
+//
+//             const collected = sourceItems.map((_, index) => {
+//               // Last step for each item in the branch
+//               const lastStepId =
+//                 branchStepIds[
+//                   branchStepIds.length - sourceItems.length + index
+//                 ];
+//               return results[lastStepId];
+//             });
+//
+//             results[step.id] = collected;
+//             frame.output = collected;
+//             frame.end = Date.now();
+//             return collected;
+//           }
+//
+//           // Branch steps inside pipeV2
+//           //
+//           //
+//           // Branch steps inside pipeV2
+//           if (step.__pipeSource) {
+//             const pipeSourceId = step.__pipeSource;
+//             const sourceItems: any[] = results[pipeSourceId] ?? [];
+//
+//             // Determine the branch index
+//             const branchSteps = workflow.steps.filter(
+//               (s) => s.__pipeSource === pipeSourceId,
+//             );
+//
+//             // For each source item, run sequential branch steps
+//             for (let i = 0; i < sourceItems.length; i++) {
+//               const item = sourceItems[i];
+//               let current = item;
+//
+//               for (const branchStep of branchSteps) {
+//                 const branchCtx = createStepCtx(current, results);
+//
+//                 // check step.when
+//                 if (branchStep.when && !branchStep.when(branchCtx)) {
+//                   results[branchStep.id] = undefined;
+//                   continue;
+//                 }
+//
+//                 let actionFn;
+//                 if (branchStep.__subflowId) {
+//                   const [modId, subWfId] = branchStep.__subflowId.split(".");
+//                   actionFn = async () =>
+//                     depsExecutors[modId]
+//                       .run(subWfId, branchCtx, services, observers)
+//                       .then((r) => r.output);
+//                 } else if (branchStep.action === "__service__") {
+//                   const { service, method } = branchStep.serviceCall!;
+//                   actionFn = async () =>
+//                     services[service][method](
+//                       ...branchStep.resolve!(branchCtx).args,
+//                     );
+//                 } else {
+//                   actionFn = async () =>
+//                     actionRegistry[branchStep.action](
+//                       ...branchStep.resolve!(branchCtx).args,
+//                     );
+//                 }
+//
+//                 current = await runWithRetry(actionFn, branchStep.options);
+//                 results[branchStep.id] = current;
+//               }
+//             }
+//
+//             // collector step just gathers last step of each item
+//             return (results[step.id] = branchSteps.length
+//               ? branchSteps[branchSteps.length - 1].map((s) => results[s.id])
+//               : []);
+//           }
+//
+//           // -----------------------------
+//           // 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 = new Proxy(
+//                     {
+//                       current,
+//                       results,
+//                       ...createCallHelpers(),
+//                     },
+//                     {
+//                       get(target, prop) {
+//                         if (prop in target)
+//                           return target[prop as keyof typeof target];
+//
+//                         if (prop in results)
+//                           return results[prop as keyof typeof target];
+//
+//                         return undefined;
+//                       },
+//                     },
+//                   );
+//
+//                   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,
+//             );
+//
+//             frame.output = subExecution.output;
+//             frame.end = Date.now();
+//             results[step.id] = subExecution.output;
+//
+//             Object.assign(extras, subExecution.extras);
+//
+//             return subExecution.output;
+//           }
+//
+//           // -----------------------------
+//           // Normal action
+//           // -----------------------------
+//           const actionFn = async () => {
+//             let action = null;
+//             if (step.action === "__service__") {
+//               const { service, method } = step.serviceCall!;
+//
+//               action = services[service][method];
+//             } else {
+//               action = actionRegistry[step.action];
+//             }
+//
+//             console.log("action", 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;
+//             return result;
+//           } 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;
+//           }
+//         };
+//
+//         const composed = composeObserver(observers, ctx, core);
+//         await composed();
+//
+//         for (const childId of dependents.get(stepId) ?? []) {
+//           const remaining = remainingDeps.get(childId)! - 1;
+//           remainingDeps.set(childId, remaining);
+//           if (remaining === 0) ready.push(childId);
+//         }
+//
+//         completed++;
+//       }),
+//     );
+//   }
+//
+//   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(outputCtx)
+//     : results;
+//
+//   return {
+//     // results: results as WorkflowResults<WR[K]>,
+//     output: output as O,
+//     extras,
+//   };
+// }
+//
 import { composeObserver } from "./observer.js";
 export function createCallHelpers() {
     return {
@@ -16,23 +487,16 @@ async function withTimeout(promise, ms) {
 }
 function createStepCtx(input, results) {
     const helpers = createCallHelpers();
-    return new Proxy({
-        input,
-        results,
-        ...helpers,
-    }, {
+    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;
     let lastError;
@@ -45,26 +509,19 @@ async function runWithRetry(actionFn, stepOptions) {
             if (attempt === maxRetries)
                 break;
             const delay = stepOptions?.retryDelay;
-            if (typeof delay === "number") {
+            if (typeof delay === "number")
                 await new Promise((r) => setTimeout(r, delay));
-            }
-            else if (typeof delay === "function") {
+            else if (typeof delay === "function")
                 await new Promise((r) => setTimeout(r, delay(attempt)));
-            }
         }
     }
     throw lastError;
 }
 export async function executeWorkflow({ workflow, actionRegistry, services, input, depsExecutors, observers = [], }) {
     const results = {};
-    const extras = {};
-    extras.frames = {};
-    // -----------------------------
-    // Fully typed step map
-    // -----------------------------
-    // const stepById: Map<string, StepDef<Reg, any, any>> = new Map(
-    //   workflow.steps.map((s: StepDef<Reg, any, any>) => [s.id, s]),
-    // );
+    const extras = {
+        frames: {},
+    };
     const stepById = new Map(workflow.steps.map((s) => [s.id, s]));
     const remainingDeps = new Map();
     const dependents = new Map();
@@ -79,10 +536,6 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
             dependents.get(dep).push(step.id);
         }
     }
-    let completed = 0;
-    // -----------------------------
-    // Normalized runner
-    // -----------------------------
     const runAction = async (input, action) => {
         if (!input)
             return await action();
@@ -97,9 +550,7 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                 throw new Error(`Unknown ResolvedStepInput kind: ${input.kind}`);
         }
     };
-    // -----------------------------
-    // Execution loop
-    // -----------------------------
+    let completed = 0;
     while (ready.length > 0) {
         const batch = ready.splice(0);
         await Promise.all(batch.map(async (stepId) => {
@@ -110,75 +561,50 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                 start: Date.now(),
             };
             extras.frames[stepId] = frame;
-            const ctx = {
-                stepId,
-                input,
-                results,
-                actionRegistry,
-                extras,
-                frame,
-            };
+            const ctx = { stepId, input, results, actionRegistry, extras, frame };
             const stepCtx = createStepCtx(input, results);
-            // const stepCtx = {
-            //   input,
-            //   results,
-            //
-            //   ...createCallHelpers(),
-            // };
             const resolvedArgs = step.resolve?.(stepCtx);
             frame.input = resolvedArgs;
             const core = async () => {
                 frame.attempts++;
-                // -----------------------------
-                // ✅ SINGLE when evaluation
-                // -----------------------------
+                // Skip if .when is false
                 if (step.when && !step.when(stepCtx)) {
-                    frame.input = undefined; // 👈 important for observer consistency
+                    frame.input = undefined;
                     frame.output = undefined;
                     frame.end = Date.now();
                     frame.skipped = true;
                     results[step.id] = undefined;
                     return undefined;
                 }
-                // -----------------------------
-                // 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;
+                if (step.action === "__pipe_map__") {
+                    const isParallel = step?.options?.pipe?.parallel;
+                    const items = step.resolve(stepCtx).args ?? [];
+                    const { workflow } = step.pipe;
+                    const executions = items.map((item, index) => executeWorkflow({
+                        workflow,
+                        input: item,
+                        services,
+                        actionRegistry,
+                        depsExecutors,
+                        observers,
+                    }).then((res) => ({
+                        index,
+                        output: res.output,
+                        extras: res.extras,
+                    })));
+                    const settled = await Promise.all(executions);
+                    console.log("SETTLED", settled);
+                    // ✅ preserve order (IMPORTANT)
+                    const outputs = settled
+                        .sort((a, b) => a.index - b.index)
+                        .map((r) => r.output);
+                    results[step.id] = outputs;
+                    frame.output = outputs;
                     frame.end = Date.now();
-                    return pipeResults;
+                    return outputs;
                 }
+                // ---------------- Subflow ----------------
                 if (step.__subflowId) {
-                    // -----------------------------
-                    // Subflow handling
-                    // -----------------------------
                     const [modId, subWfId] = step.__subflowId.split(".");
                     const exec = depsExecutors[modId];
                     const subExecution = await exec.run(subWfId, resolvedArgs, services, observers);
@@ -188,11 +614,9 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                     Object.assign(extras, subExecution.extras);
                     return subExecution.output;
                 }
-                // -----------------------------
-                // Normal action
-                // -----------------------------
+                // ---------------- Normal action ----------------
                 const actionFn = async () => {
-                    let action = null;
+                    let action;
                     if (step.action === "__service__") {
                         const { service, method } = step.serviceCall;
                         action = services[service][method];
@@ -200,8 +624,7 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                     else {
                         action = actionRegistry[step.action];
                     }
-                    console.log("action", action);
-                    return await runAction(resolvedArgs, action);
+                    return runAction(resolvedArgs, action);
                 };
                 try {
                     const result = await withTimeout(runWithRetry(actionFn, step.options), step.options?.timeout);
@@ -236,16 +659,11 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
             completed++;
         }));
     }
-    if (completed !== workflow.steps.length) {
+    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(outputCtx)
         : results;
-    return {
-        // results: results as WorkflowResults<WR[K]>,
-        output: output,
-        extras,
-    };
+    return { output: output, extras };
 }

package/dist/workflow-module.d.ts

@@ -9,7 +9,6 @@ type DepWorkflows<Deps extends ModuleMap> = keyof Deps extends never ? {} : Simp
         [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>;
 type AnyWorkflow = WorkflowDef<any, any, any, any, any>;
 type ModuleShape = Record<string, AnyWorkflow>;
 type ModuleMap = Record<string, Module<any, any, any, any>>;
@@ -22,14 +21,14 @@ type ServicesFromDepsRecursive<Deps extends ModuleMap> = [keyof Deps] extends [
 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;
-type Module<Reg extends ActionRegistry, S extends ServiceRegistry, Own extends ModuleShape, Deps extends ModuleMap> = {
+export type Module<Reg extends ActionRegistry, S extends ServiceRegistry, Own extends ModuleShape, Deps extends ModuleMap, Public extends ModuleShape = Own> = {
     workflows: Own;
     __getExecutor: () => Executor;
     createRuntime: (config: {
         services: FinalServices<S, Deps>;
     }) => {
-        run: <K extends keyof WorkflowRegistry<Own, Deps>>(workflow: K, input: WorkflowInput<WorkflowRegistry<Own, Deps>[K]>, observers?: WorkflowObserver<Reg>[]) => Promise<{
-            output: WorkflowOutput<WorkflowRegistry<Own, Deps>[K]>;
+        run: <K extends keyof Public>(workflow: K, input: WorkflowInput<Public[K]>, observers?: WorkflowObserver<Reg>[]) => Promise<{
+            output: WorkflowOutput<Public[K]>;
             extras: Record<string, any>;
         }>;
         getServices: () => FinalServices<S, Deps>;
@@ -39,9 +38,13 @@ type ModuleContext<Reg extends ActionRegistry, WFReg extends Record<string, Work
     wf: ReturnType<typeof createWorkflow<Reg, WFReg, S>>;
     services: S;
 };
-export declare function createModuleFactory<S extends ServiceRegistry>(): <Reg extends ActionRegistry = Record<string, any>, Use extends ModuleMap = {}, Own extends ModuleShape = {}>(config: {
+type ExposedWorkflows<Own extends ModuleShape, Use extends ModuleMap, Expose extends Record<string, keyof DepWorkflows<Use>> | undefined> = Own & (Expose extends Record<string, keyof DepWorkflows<Use>> ? {
+    [K in keyof Expose]: DepWorkflows<Use>[Expose[K]];
+} : {});
+export declare function createModuleFactory<S extends ServiceRegistry>(): <Reg extends ActionRegistry = Record<string, any>, Use extends ModuleMap = {}, Own extends ModuleShape = {}, Expose extends Record<string, keyof DepWorkflows<Use>> | undefined = undefined>(config: {
     actionRegistry: Reg;
     use?: Use;
+    expose?: Expose;
     define: (ctx: ModuleContext<typeof config.actionRegistry, DepWorkflows<Use>, S>) => Own;
-}) => Module<Reg, S, Own, Use>;
+}) => Module<Reg, S, Own, Use, ExposedWorkflows<Own, Use, Expose>>;
 export {};

package/dist/workflow-module.js

@@ -1,21 +1,316 @@
-import { createWorkflow } from "./workflow-composer.js";
+// import {
+//   ActionRegistry,
+//   ServiceRegistry,
+//   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 FinalServices<S extends ServiceRegistry, Deps extends ModuleMap> = S &
+//   ServicesFromDepsRecursive<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 ServicesFromDepsRecursive<Deps extends ModuleMap> = [keyof Deps] extends [
+//   never,
+// ]
+//   ? {} // no deps
+//   : UnionToIntersection<
+//       {
+//         [K in keyof Deps]: Deps[K] extends Module<
+//           any,
+//           infer S,
+//           any,
+//           infer SubDeps
+//         >
+//           ? S & ServicesFromDepsRecursive<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,
+//   S extends ServiceRegistry,
+//   Own extends ModuleShape,
+//   Deps extends ModuleMap,
+// > = {
+//   workflows: Own;
+//   __getExecutor: () => Executor;
+//
+//   createRuntime: (config: { services: FinalServices<S, 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>;
+//     }>;
+//
+//     getServices: () => FinalServices<S, Deps>;
+//   };
+// };
+//
+// /* ------------------------------------------------ */
+// /* MODULE CONTEXT (FIXED)                           */
+// /* ------------------------------------------------ */
+//
+// type ModuleContext<
+//   Reg extends ActionRegistry,
+//   WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>,
+//   S extends ServiceRegistry,
+// > = {
+//   wf: ReturnType<typeof createWorkflow<Reg, WFReg, S>>;
+//   services: S;
+// };
+//
+// function createModule<
+//   Reg extends ActionRegistry,
+//   S extends ServiceRegistry,
+//   Use extends ModuleMap,
+//   Own extends ModuleShape,
+// >(config: {
+//   actionRegistry: Reg;
+//   use?: Use;
+//   define: (ctx: ModuleContext<Reg, DepWorkflows<Use>, S>) => Own;
+// }): Module<Reg, S, Own, Use> {
+//   const deps = (config.use ?? {}) as Use;
+//
+//   const wf = createWorkflow<Reg, DepWorkflows<Use>, S>();
+//
+//   const own = config.define({
+//     wf,
+//     services: {} as S,
+//   });
+//
+//   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, services, observers = []) {
+//       const workflow = workflowMap[wfId];
+//
+//       if (!workflow) {
+//         throw new Error(`Workflow not found: ${String(wfId)}`);
+//       }
+//
+//       return executeWorkflow({
+//         workflow,
+//         actionRegistry: config.actionRegistry,
+//         depsExecutors,
+//         input,
+//         services,
+//         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, services, observers);
+//         },
+//         // make it same, practically nothing changes but naming, and what context holds
+//         getServices: () => ({ ...services }) as FinalServices<S, 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,
+//   S extends ServiceRegistry,
+// >() {
+//   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>, S>,
+//     ) => Own;
+//   }): Module<Reg, S, Own, Use> {
+//     return createModule<Reg, S, Use, Own>(config);
+//   };
+// }
+import { createWorkflow, } from "./workflow-composer.js";
 import { executeWorkflow } from "./workflow-executor.js";
 function createModule(config) {
     const deps = (config.use ?? {});
     const wf = createWorkflow();
+    // const macro = createMacro<Reg, S, DepWorkflows<Use>>();
     const own = config.define({
         wf,
         services: {},
     });
+    // 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]),
+    //     ),
+    //   );
+    //
+    //   const internal = { ...own, ...depWFs } as WorkflowRegistry<Own, Use>;
+    //
+    //   const publicMap = own;
+    //   return { internal, publicMap };
+    // }
     function buildWorkflowMap() {
         const depWFs = Object.fromEntries(Object.entries(deps).flatMap(([name, mod]) => Object.entries(mod.workflows).map(([k, wf]) => [`${name}.${k}`, wf])));
-        return { ...own, ...depWFs };
+        // const internal = { ...own, ...depWFs } as WorkflowRegistry<Own, Use>;
+        // const exposed = Object.fromEntries(
+        //   Object.entries(config.expose ?? {}).map(([alias, key]) => [
+        //     alias,
+        //     internal[key], // reuse already resolved workflow
+        //   ]),
+        // );
+        //
+        const internalBase = { ...own, ...depWFs };
+        const exposed = {};
+        if (config.expose) {
+            for (const alias in config.expose) {
+                const key = config.expose[alias];
+                exposed[alias] = internalBase[key];
+            }
+        }
+        const internal = {
+            ...internalBase,
+            ...exposed,
+        };
+        // if (config.expose) {
+        //   for (const alias in config.expose) {
+        //     const key = config.expose[alias];
+        //     exposed[alias] = internal[key];
+        //   }
+        // }
+        const publicMap = { ...own, ...exposed };
+        return { internal, publicMap };
     }
-    const workflowMap = buildWorkflowMap();
+    const { internal, publicMap } = buildWorkflowMap();
     const depsExecutors = Object.fromEntries(Object.entries(deps).map(([name, mod]) => [name, mod.__getExecutor()]));
     const executor = {
         run(wfId, input, services, observers = []) {
-            const workflow = workflowMap[wfId];
+            if (!(wfId in publicMap)) {
+                throw new Error(`Workflow not in public: ${wfId}`);
+            }
+            const workflow = internal[wfId];
             if (!workflow) {
                 throw new Error(`Workflow not found: ${String(wfId)}`);
             }
@@ -36,7 +331,12 @@ function createModule(config) {
             let runtimeActions = config.actionRegistry;
             // const runtimeService = createServiceRegisty(services)
             return {
-                run: async (workflowId, input, observers = []) => {
+                run: async (
+                // run: async <K extends keyof WorkflowRegistry<Own, Use>>(
+                workflowId, input, 
+                // input: WorkflowInput<WorkflowRegistry<Own, Use>[K]>,
+                // input: WorkflowInput<WorkflowRegistry<Own, Use>[K]>,
+                observers = []) => {
                     return executor.run(workflowId, input, services, observers);
                 },
                 // make it same, practically nothing changes but naming, and what context holds

package/package.json

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