@pogodisco/zephyr 1.3.20 → 1.4.0

package/dist/types.d.ts

@@ -21,7 +21,7 @@ export type WorkflowObserver<Reg extends ActionRegistry = any> = {
         stepId: string;
         input: any;
         results: Record<string, any>;
-        registry: Reg;
+        actionRegistry: Reg;
         extras: Record<string, any>;
         frame: ExecutionFrame;
     }, next: () => Promise<any>): Promise<any>;

package/dist/workflow-composer.d.ts

@@ -35,10 +35,8 @@ type CallHelpers<Reg extends ActionRegistry, ActionName extends keyof Reg> = {
         items: typeof items;
     };
 };
-type SubflowResult<SubResults, SubOutput> = SubOutput extends undefined ? SubResults : SubOutput;
 type WorkflowInput<T> = T extends WorkflowDef<any, infer I, any, any, any> ? I : never;
-type WorkflowResults<T> = T extends WorkflowDef<any, any, infer R, any, any> ? R : 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>;
@@ -49,6 +47,7 @@ export type StepDef<Reg extends ActionRegistry, ID extends string = string, Acti
     resolve: (ctx: any) => ResolvedStepInput;
     when?: (ctx: any) => boolean;
     options?: StepOptions<any, any, any>;
+    __subflowId?: string;
 };
 export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
     name: string;
@@ -73,12 +72,13 @@ type StepOptions<Input, Results, Context> = {
     label?: string;
     meta?: Record<string, any>;
 };
-type MergeBranchResults<Branches extends readonly any[], Acc> = Branches extends readonly [infer Head, ...infer Tail] ? MergeBranchResults<Tail, Acc & (Head extends WorkflowBuilder<any, any, any, any, infer R> ? R : {})> : Acc;
+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 R> ? R : {})> : 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, infer S, any> ? S : [])
+    ...(Head extends WorkflowBuilder<any, any, any, any, infer S, any> ? S : [])
 ]> : Acc;
-export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown, Context = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Output = undefined> {
+export declare class WorkflowBuilder<Reg extends ActionRegistry, WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>, //
+Input = unknown, Context = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Output = undefined> {
     private name;
     private steps;
     private frontier;
@@ -90,7 +90,7 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
         input: Input;
         results: Results;
         context: Context;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, Input, Context, [
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, WFReg, Input, Context, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Simplify<Results & {
@@ -100,34 +100,30 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
         input: Input;
         results: Results;
         context: Context;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, Input, Context, [...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>;
-    as<NewType>(): WorkflowBuilder<Reg, Input, Context, Steps, Steps extends [...infer Rest, infer Last] ? Last extends StepDef<Reg, infer ID, any> ? Simplify<Omit<Results, ID> & {
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, WFReg, Input, Context, [...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>;
+    as<NewType>(): WorkflowBuilder<Reg, WFReg, Input, Context, 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>;
-    parallel<Branches extends readonly WorkflowBuilder<Reg, Input, Context, any, any>[]>(...branches: {
-        [K in keyof Branches]: (builder: WorkflowBuilder<Reg, Input, Context, [], Results>) => Branches[K];
-    }): WorkflowBuilder<Reg, Input, Context, MergeBranchSteps<Branches, Steps>, Simplify<MergeBranchResults<Branches, Results>>>;
+    parallel<Branches extends readonly WorkflowBuilder<Reg, WFReg, Input, Context, any, any>[]>(...branches: {
+        [K in keyof Branches]: (builder: WorkflowBuilder<Reg, WFReg, Input, Context, [], Results>) => Branches[K];
+    }): WorkflowBuilder<Reg, WFReg, Input, Context, 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: {
         input: Input;
         results: Results;
         context: Context;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, Input, Context, [...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>;
-    subflow<Prefix extends string, SubSteps extends StepDef<Reg, any, any>[], WF extends WorkflowDef<Reg, any, any, SubSteps, any>>(prefix: Prefix, workflow: WF, resolveInput: WorkflowInput<WF> extends undefined ? ((ctx: {
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, WFReg, Input, Context, [...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>;
+    subflow<Prefix extends string, K extends keyof WFReg & string>(prefix: Prefix, workflowKey: K, resolveInput: (ctx: {
         input: Input;
         results: Results;
         context: Context;
-    }) => WorkflowInput<WF>) | undefined : (ctx: {
-        input: Input;
-        results: Results;
-        context: Context;
-    }) => WorkflowInput<WF>, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, Input, Context, Steps, Results & {
-        [K in Prefix]: SubflowResult<WorkflowResults<WF>, WorkflowOutput<WF>>;
+    }) => WorkflowInput<WFReg[K]>, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, WFReg, Input, Context, Steps, Results & {
+        [P in Prefix]: WorkflowOutput<WFReg[K]>;
     }>;
     when(predicate: (ctx: {
         input: Input;
         results: Results;
         context: Context;
-    }) => boolean): WorkflowBuilder<Reg, Input, Context, Steps, Results, Output>;
+    }) => boolean): WorkflowBuilder<Reg, WFReg, Input, Context, Steps, Results, Output>;
     endWhen(): this;
     output<Output>(fn: (ctx: {
         input: Input;
@@ -138,5 +134,6 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
     private validateDependencies;
     private getEndSteps;
 }
-export declare function createWorkflow<Reg extends ActionRegistry, Context extends Record<string, any> = {}>(): <Input = unknown>(name: string) => WorkflowBuilder<Reg, Input, Context, [], {}, undefined>;
+export declare function createWorkflow<Reg extends ActionRegistry, WFReg extends Record<string, WorkflowDef<any, any, any, any, any>>, // 👈 NEW
+Context extends Record<string, any> = {}>(): <Input = unknown>(name: string) => WorkflowBuilder<Reg, WFReg, Input, Context, [], {}, undefined>;
 export {};

package/dist/workflow-composer.js

@@ -562,34 +562,19 @@ export class WorkflowBuilder {
         this.clearPendingWhen();
         return result;
     }
-    /* ------------------------------------------------ */
-    /* Subflow                                         */
-    /* ------------------------------------------------ */
-    subflow(prefix, workflow, resolveInput, options) {
-        const idMap = new Map();
-        workflow.steps.forEach((step) => {
-            idMap.set(step.id, `${prefix}.${step.id}`);
-        });
-        workflow.steps.forEach((step) => {
-            const newStep = {
-                ...step,
-                id: idMap.get(step.id),
-                dependsOn: step.dependsOn.map((d) => idMap.get(d)),
-                resolve: (ctx) => {
-                    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.steps.push(newStep);
+    subflow(prefix, workflowKey, resolveInput, options) {
+        this.steps.push({
+            id: prefix,
+            action: "__subflow__",
+            dependsOn: [...this.frontier],
+            resolve: (ctx) => ({
+                kind: "object",
+                args: resolveInput(ctx),
+            }),
+            options,
+            __subflowId: workflowKey, // 👈 STRING ONLY
         });
-        this.frontier = workflow.endSteps.map((e) => idMap.get(e.id));
+        this.frontier = [prefix];
         return this;
     }
     /* ------------------------------------------------ */

package/dist/workflow-executor.d.ts

@@ -1,7 +1,24 @@
 import { ActionRegistry, WorkflowObserver } from "./types.js";
-import { StepDef, WorkflowDef } from "./workflow-composer.js";
-export declare function executeWorkflow<Reg extends ActionRegistry, I, R, O = R, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[]>(workflow: WorkflowDef<Reg, I, R, Steps, O>, registry: Reg, input: I, context: any, observers?: WorkflowObserver<Reg>[]): Promise<{
-    results: R;
-    output: O;
+import { WorkflowDef } from "./workflow-composer.js";
+import { WorkflowInput, WorkflowOutput } from "./workflow-module.js";
+export declare function createCallHelpers(): {
+    args: (...args: any[]) => {
+        kind: string;
+        args: any[];
+    };
+    obj: (arg: any) => {
+        kind: string;
+        args: any;
+    };
+    none: () => {
+        kind: string;
+    };
+    loop: (items: any[]) => {
+        kind: string;
+        items: any[];
+    };
+};
+export declare function executeWorkflow<Reg extends ActionRegistry, WR extends Record<string, WorkflowDef<any, any, any, any, any>>, K extends keyof WR>(workflowId: K, workflowRegistry: WR, actionRegistry: Reg, input: WorkflowInput<WR[K]>, context: any, observers?: WorkflowObserver<Reg>[]): Promise<{
+    output: WorkflowOutput<WR[K]>;
     extras: Record<string, any>;
 }>;

package/dist/workflow-executor.js

@@ -1,5 +1,236 @@
+// import { composeObserver } from "./observer.js";
+// import { ActionRegistry, ExecutionFrame, WorkflowObserver } from "./types.js";
+// import {
+//   StepDef,
+//   WorkflowDef,
+//   ResolvedStepInput,
+// } from "./workflow-composer.js";
+//
+// export function createCallHelpers() {
+//   return {
+//     args: (...args: any[]) => ({ kind: "positional", args }),
+//     obj: (arg: any) => ({ kind: "object", args: arg }),
+//     none: () => ({ kind: "none" }),
+//     loop: (items: any[]) => ({ kind: "loop", items }),
+//   };
+// }
+//
+// // Helper to wrap action execution with timeout
+// 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),
+//     ),
+//   ]);
+// }
+//
+// // 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,
+//   Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[],
+// >(
+//   workflow: WorkflowDef<Reg, I, R, Steps, O>,
+//   registry: Reg,
+//   input: I,
+//   context: any,
+//   observers: WorkflowObserver<Reg>[] = [],
+// ): Promise<{ results: R; 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 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: ResolvedStepInput | 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);
+//       case "loop":
+//         return await Promise.all(
+//           input.items.map((item) => runAction(item, action)),
+//         );
+//       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)!;
+//
+//         const frame: ExecutionFrame = {
+//           stepId,
+//           attempts: 0,
+//           start: Date.now(),
+//         };
+//         extras.frames[stepId] = frame;
+//
+//         const ctx = {
+//           stepId,
+//           input,
+//           results,
+//           context,
+//           registry,
+//           extras,
+//           frame,
+//         };
+//
+//         const core = async () => {
+//           frame.attempts++;
+//           const stepCtx = { input, results, context, ...createCallHelpers() };
+//
+//           // Conditional skip
+//           if (step.when && !step.when(stepCtx)) {
+//             frame.output = undefined;
+//             frame.end = Date.now();
+//             frame.skipped = true;
+//             results[step.id] = undefined;
+//             return undefined;
+//           }
+//
+//           const resolvedArgs = step.resolve?.(stepCtx);
+//           frame.input = resolvedArgs;
+//
+//           const actionFn = async () => {
+//             const action = registry[step.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 output: O = workflow.outputResolver
+//     ? workflow.outputResolver({
+//         input,
+//         results: results as R,
+//         context: (workflow as any).__context,
+//       })
+//     : (results as unknown as O);
+//
+//   return { results: results as R, output, extras };
+// }
 import { composeObserver } from "./observer.js";
-function createCallHelpers() {
+export function createCallHelpers() {
     return {
         args: (...args) => ({ kind: "positional", args }),
         obj: (arg) => ({ kind: "object", args: arg }),
@@ -39,13 +270,20 @@ async function runWithRetry(actionFn, stepOptions) {
     }
     throw lastError;
 }
-export async function executeWorkflow(workflow, registry, input, context, observers = []) {
+export async function executeWorkflow(workflowId, workflowRegistry, actionRegistry, input, context, observers = []) {
+    const workflow = workflowRegistry[workflowId];
+    if (!workflow) {
+        throw new Error(`Workflow not found: ${String(workflowId)}`);
+    }
     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 stepById = new Map(workflow.steps.map((s) => [s.id, s]));
     const remainingDeps = new Map();
     const dependents = new Map();
@@ -98,7 +336,7 @@ export async function executeWorkflow(workflow, registry, input, context, observ
                 input,
                 results,
                 context,
-                registry,
+                actionRegistry,
                 extras,
                 frame,
             };
@@ -115,8 +353,22 @@ export async function executeWorkflow(workflow, registry, input, context, observ
                 }
                 const resolvedArgs = step.resolve?.(stepCtx);
                 frame.input = resolvedArgs;
+                // -----------------------------
+                // Subflow handling
+                // -----------------------------
+                if (step.__subflowId) {
+                    const subWorkflow = step.__subflow;
+                    const subInput = resolvedArgs;
+                    const subExecution = await executeWorkflow(step.__subflowId, workflowRegistry, actionRegistry, resolvedArgs, context, observers);
+                    // Assign output to this step
+                    frame.output = subExecution.output;
+                    results[step.id] = subExecution.output;
+                    // Merge extras
+                    Object.assign(extras, subExecution.extras);
+                    return subExecution.output;
+                }
                 const actionFn = async () => {
-                    const action = registry[step.action];
+                    const action = actionRegistry[step.action];
                     return await runAction(resolvedArgs, action);
                 };
                 try {
@@ -158,9 +410,13 @@ export async function executeWorkflow(workflow, registry, input, context, observ
     const output = workflow.outputResolver
         ? workflow.outputResolver({
             input,
-            results: results,
+            results,
             context: workflow.__context,
         })
         : results;
-    return { results: results, output, extras };
+    return {
+        // results: results as WorkflowResults<WR[K]>,
+        output: output,
+        extras,
+    };
 }

package/dist/workflow-module.d.ts

@@ -1,59 +1,40 @@
 import { ActionRegistry, WorkflowObserver } from "./types.js";
 import { createWorkflow, WorkflowDef } from "./workflow-composer.js";
-type ModuleWFRegistry<Own extends ModuleShape, Deps extends ModuleMap> = OwnWFs<Own> & DepsWFs<Deps>;
-type OwnWFs<Own extends ModuleShape> = {
-    [K in keyof Own & string]: Own[K];
-};
-type NamespacedDepWFs<DepName extends string, M extends Module<any, any, any, any>> = {
-    [K in keyof M["own"] & string as `${DepName}.${K}`]: M["own"][K];
-};
-type DepsWFs<Deps extends ModuleMap> = [keyof Deps] extends [never] ? {} : {
-    [DepName in keyof Deps & string]: NamespacedDepWFs<DepName, Deps[DepName]>;
+type DepWorkflows<Deps extends ModuleMap> = keyof Deps extends never ? {} : {
+    [D in keyof Deps & string]: {
+        [K in keyof Deps[D]["workflows"] & string as `${D}.${K}`]: Deps[D]["workflows"][K];
+    };
 }[keyof Deps & string];
-type ModuleDepsPublic<Use> = {
-    [K in keyof Use]: Use[K] extends Module<any, infer Ctx, infer Own, any> ? ModulePublic<Ctx, Own> : never;
-};
-type ModulePublic<Context extends Record<string, any>, Own extends ModuleShape> = {
-    own: Own;
-    __ctx: Context;
-};
+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>>;
 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<Reg extends ActionRegistry, Context extends Record<string, any>, Deps extends ModuleMap> = Context & ContextFromDeps<Deps>;
-type ModuleMap = Record<string, Module<any, any, any, any>>;
 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, Context extends Record<string, any>, Own extends ModuleShape = {}, Deps extends ModuleMap = {}> = {
-    own: Own;
-    deps: ModuleDepsPublic<Deps>;
+type Module<Reg extends ActionRegistry, Context extends Record<string, any>, Own extends ModuleShape, Deps extends ModuleMap> = {
+    workflows: Own;
     createRuntime: (config: {
         registry: Reg;
         context: FinalContext<Reg, Context, Deps>;
     }) => {
-        run: <K extends keyof ModuleWFRegistry<Own, Deps>>(workflow: K, input: WorkflowInput<ModuleWFRegistry<Own, Deps>[K]>, observers?: WorkflowObserver<Reg>[]) => Promise<{
-            results: WorkflowResults<ModuleWFRegistry<Own, Deps>[K]>;
-            output: WorkflowOutput<ModuleWFRegistry<Own, Deps>[K]>;
+        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]>;
             extras: Record<string, any>;
         }>;
         getContext: () => FinalContext<Reg, Context, Deps>;
     };
 };
-export type ModuleContext<Reg extends ActionRegistry, Context extends Record<string, any>, Deps extends ModuleMap> = {
-    wf: ReturnType<typeof createWorkflow<Reg, Context>>;
-    deps: Deps;
+export 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;
-    tools: <T>(factory: (ctx: {
-        wf: ModuleContext<Reg, Context, Deps>["wf"];
-        deps: Deps;
-        context: Context;
-    }) => T) => T;
 };
 export declare function createModuleFactory<Reg extends ActionRegistry, Context extends Record<string, any>>(): <Use extends ModuleMap = {}, Own extends ModuleShape = {}>(config: {
     use?: Use;
-    define: (ctx: ModuleContext<Reg, Context, Use>) => Own;
+    define: (ctx: ModuleContext<Reg, DepWorkflows<Use>, Context>) => Own;
 }) => Module<Reg, Context, Own, Use>;
 export {};

package/dist/workflow-module.js

@@ -145,40 +145,37 @@
 //
 import { createWorkflow } from "./workflow-composer.js";
 import { executeWorkflow } from "./workflow-executor.js";
-function toPublicDeps(deps) {
-    return deps;
-}
+/* ------------------------------------------------ */
+/* CREATE MODULE (FIXED)                            */
+/* ------------------------------------------------ */
 function createModule(config) {
     const deps = (config.use ?? {});
+    // ✅ CRITICAL: wf only sees DEP workflows
+    const wf = createWorkflow();
     const own = config.define({
-        wf: createWorkflow(),
-        deps,
+        wf,
         context: {},
-        tools: (factory) => factory({
-            wf: createWorkflow(),
-            deps,
-            context: {},
-        }),
     });
-    function mergeWFs() {
-        const depWFs = Object.fromEntries(Object.entries(deps).flatMap(([depName, depModule]) => Object.entries(depModule.own).map(([k, wf]) => [`${depName}.${k}`, wf])));
+    function buildRegistry() {
+        const depWFs = Object.fromEntries(Object.entries(deps).flatMap(([name, mod]) => Object.entries(mod.workflows).map(([k, wf]) => [`${name}.${k}`, wf])));
         return { ...own, ...depWFs };
     }
     return {
-        own,
-        deps: toPublicDeps(deps),
+        workflows: own,
         createRuntime({ registry, context }) {
-            const workflowRegistry = mergeWFs();
+            const workflowRegistry = buildRegistry();
             return {
                 run: async (workflowId, input, observers = []) => {
-                    const wfObj = workflowRegistry[workflowId]; // <-- concrete WorkflowDef
-                    return executeWorkflow(wfObj, registry, input, context, observers);
+                    return executeWorkflow(workflowId, workflowRegistry, registry, input, context, observers);
                 },
                 getContext: () => ({ ...context }),
             };
         },
     };
 }
+/* ------------------------------------------------ */
+/* FACTORY (FIXED)                                  */
+/* ------------------------------------------------ */
 export function createModuleFactory() {
     return function (config) {
         return createModule(config);

package/package.json

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