@pogodisco/zephyr 1.4.2 → 1.5.0

package/dist/types.d.ts

@@ -27,5 +27,8 @@ export type WorkflowObserver<Reg extends ActionRegistry = any> = {
     }, next: () => Promise<any>): Promise<any>;
 };
 export interface Executor {
-    run: (wfId: string, input: Record<string, any>, context: Record<string, any>, obververs?: WorkflowObserver[]) => Promise<any>;
+    run: (wfId: string, input: Record<string, any>, services: ServiceRegistry, obsververs?: WorkflowObserver[]) => Promise<any>;
 }
+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]>>;

package/dist/workflow-composer.d.ts

@@ -1,4 +1,4 @@
-import { ActionParams, ActionRegistry, ActionReturn, Simplify } from "./types.js";
+import { ActionParams, ActionRegistry, ActionReturn, ServiceParams, ServiceRegistry, ServiceReturn, Simplify } from "./types.js";
 type NormalizedCall = {
     kind: "none";
 } | {
@@ -40,14 +40,18 @@ type WorkflowOutput<T> = T extends WorkflowDef<any, any, any, any, infer O> ? un
 export type StepResultFromResolve<Reg extends ActionRegistry, ActionName extends keyof Reg, R extends ResolvedStepInput> = R extends {
     kind: "loop";
 } ? ActionReturn<Reg, ActionName>[] : ActionReturn<Reg, ActionName>;
+export type ServiceStepResultFromResolve<S extends ServiceRegistry, SK extends keyof S, MK extends keyof S[SK], R extends ResolvedStepInput> = R extends {
+    kind: "loop";
+} ? ServiceReturn<S, SK, MK>[] : ServiceReturn<S, SK, MK>;
 export type StepDef<Reg extends ActionRegistry, ID extends string = string, ActionName extends keyof Reg = any> = {
     id: ID;
-    action: ActionName;
+    action: ActionName | "__service__";
     dependsOn: string[];
     resolve: (ctx: any) => ResolvedStepInput;
     when?: (ctx: any) => boolean;
-    options?: StepOptions<any, any, any>;
+    options?: StepOptions<any, any>;
     __subflowId?: string;
+    serviceCall?: ServiceCall;
 };
 export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
     name: string;
@@ -59,27 +63,30 @@ export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extend
     results: Results;
     outputResolver?: (ctx: any) => Output;
 };
-type StepRuntimeCtx<I, R, C> = {
+type StepRuntimeCtx<I, R> = {
     input: I;
     results: R;
-    context: C;
 };
-type StepOptions<Input, Results, Context> = {
+type StepOptions<Input, Results> = {
     retry?: number;
     retryDelay?: number | ((attempt: number) => number);
     timeout?: number;
     continueOnError?: boolean;
-    onError?: (err: unknown, ctx: StepRuntimeCtx<Input, Results, Context>) => any;
+    onError?: (err: unknown, ctx: StepRuntimeCtx<Input, Results>) => any;
     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, any, infer R> ? R : {})> : Acc;
+type ServiceCall = {
+    service: string;
+    method: string;
+};
+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 S, any> ? S : [])
+    ...(Head extends WorkflowBuilder<any, any, any, any, infer Steps, any> ? Steps : [])
 ]> : Acc;
-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> {
+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;
     private steps;
     private frontier;
@@ -90,8 +97,7 @@ Input = unknown, Context = unknown, Steps extends StepDef<Reg, any, any>[] = [],
     step<ID extends string, ActionName extends keyof Reg & string, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-        context: Context;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, WFReg, Input, Context, [
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Simplify<Results & {
@@ -100,41 +106,67 @@ Input = unknown, Context = unknown, Steps extends StepDef<Reg, any, any>[] = [],
     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;
-        context: Context;
-    } & 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> & {
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
+    service<ID extends string, SK extends keyof Services & string, MK extends keyof Services[SK] & string, ResolveOut extends NormalizedCall = NormalizedCall>(id: ID, service: SK, method: MK, resolve?: (ctx: {
+        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): WorkflowBuilder<Reg, Services, WFReg, Input, [
+        ...Steps,
+        StepDef<Reg, ID, any>
+    ], Simplify<Results & {
+        [K in ID]: ServiceStepResultFromResolve<Services, SK, MK, ResolveOut>;
+    }>>;
+    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>;
-    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>>>;
+    parallel<Branches extends readonly WorkflowBuilder<Reg, Services, WFReg, Input, any, any>[]>(...branches: {
+        [K in keyof Branches]: (builder: WorkflowBuilder<Reg, Services, WFReg, Input, [], Results>) => Branches[K];
+    }): WorkflowBuilder<Reg, Services, WFReg, Input, MergeBranchSteps<Branches, Steps>, Simplify<MergeBranchResults<Branches, Results>>>;
     join<ID extends string = string, ActionName extends keyof Reg & string = any, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-        context: Context;
-    } & 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>;
+    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
     subflow<Prefix extends string, K extends keyof WFReg & string>(prefix: Prefix, workflowKey: K, resolveInput: (ctx: {
         input: Input;
         results: Results;
-        context: Context;
-    }) => WorkflowInput<WFReg[K]>, options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, WFReg, Input, Context, Steps, Results & {
+    }) => WorkflowInput<WFReg[K]>, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results & {
         [P in Prefix]: WorkflowOutput<WFReg[K]>;
     }>;
     when(predicate: (ctx: {
         input: Input;
         results: Results;
-        context: Context;
-    }) => boolean): WorkflowBuilder<Reg, WFReg, Input, Context, Steps, Results, Output>;
+    }) => boolean): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results, Output>;
     endWhen(): this;
     output<Output>(fn: (ctx: {
         input: Input;
         results: Results;
-        context: Context;
     }) => Output): WorkflowDef<Reg, Input, Results, Steps, Output>;
     build(): WorkflowDef<Reg, Input, Results, Steps>;
     private validateDependencies;
     private getEndSteps;
 }
 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>;
+Services extends ServiceRegistry>(): <Input = unknown>(name: string) => WorkflowBuilder<Reg, Services, WFReg, Input, [], {}, undefined>;
 export {};

package/dist/workflow-composer.js

@@ -100,6 +100,22 @@ export class WorkflowBuilder {
     seq(id, action, resolve, options) {
         return this.step(id, action, resolve, undefined, options);
     }
+    service(id, service, method, resolve) {
+        const deps = [...this.frontier];
+        this.steps.push({
+            id,
+            action: "__service__",
+            serviceCall: {
+                service,
+                method,
+            },
+            resolve: resolve ?? (() => ({ kind: "none" })),
+            dependsOn: deps,
+            when: this.pendingWhen,
+        });
+        this.frontier = [id];
+        return this;
+    }
     /* ------------------------------------------------ */
     /* Override the result of the last step            */
     /* ------------------------------------------------ */

package/dist/workflow-executor.d.ts

@@ -1,4 +1,4 @@
-import { ActionRegistry, Executor, WorkflowObserver } from "./types.js";
+import { ActionRegistry, Executor, ServiceRegistry, WorkflowObserver } from "./types.js";
 import { WorkflowDef } from "./workflow-composer.js";
 export declare function createCallHelpers(): {
     args: (...args: any[]) => {
@@ -17,11 +17,11 @@ export declare function createCallHelpers(): {
         items: any[];
     };
 };
-export declare function executeWorkflow<Reg extends ActionRegistry, I, R, O = R>({ workflow, actionRegistry, input, context, depsExecutors, observers, }: {
+export declare 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;
-    context: any;
     depsExecutors: Record<string, Executor>;
     observers: WorkflowObserver<Reg>[];
 }): Promise<{

package/dist/workflow-executor.js

@@ -39,7 +39,7 @@ async function runWithRetry(actionFn, stepOptions) {
     }
     throw lastError;
 }
-export async function executeWorkflow({ workflow, actionRegistry, input, context, depsExecutors, observers = [], }) {
+export async function executeWorkflow({ workflow, actionRegistry, services, input, depsExecutors, observers = [], }) {
     const results = {};
     const extras = {};
     extras.frames = {};
@@ -100,7 +100,6 @@ export async function executeWorkflow({ workflow, actionRegistry, input, context
                 stepId,
                 input,
                 results,
-                context,
                 actionRegistry,
                 extras,
                 frame,
@@ -108,7 +107,6 @@ export async function executeWorkflow({ workflow, actionRegistry, input, context
             const stepCtx = {
                 input,
                 results,
-                context,
                 ...createCallHelpers(),
             };
             const resolvedArgs = step.resolve?.(stepCtx);
@@ -132,7 +130,7 @@ export async function executeWorkflow({ workflow, actionRegistry, input, context
                 if (step.__subflowId) {
                     const [modId, subWfId] = step.__subflowId.split(".");
                     const exec = depsExecutors[modId];
-                    const subExecution = await exec.run(subWfId, resolvedArgs, context, observers);
+                    const subExecution = await exec.run(subWfId, resolvedArgs, services, observers);
                     // const subExecution = await executeWorkflow(
                     //   step.__subflowId,
                     //   workflowRegistry,
@@ -151,7 +149,15 @@ export async function executeWorkflow({ workflow, actionRegistry, input, context
                 // Normal action
                 // -----------------------------
                 const actionFn = async () => {
-                    const action = actionRegistry[step.action];
+                    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 {
@@ -194,7 +200,6 @@ export async function executeWorkflow({ workflow, actionRegistry, input, context
         ? workflow.outputResolver({
             input,
             results,
-            context,
         })
         : results;
     return {

package/dist/workflow-module.d.ts

@@ -1,4 +1,4 @@
-import { ActionRegistry, Executor, Simplify, WorkflowObserver } from "./types.js";
+import { ActionRegistry, ServiceRegistry, Executor, Simplify, WorkflowObserver } from "./types.js";
 import { createWorkflow, WorkflowDef } from "./workflow-composer.js";
 type UnionToIntersection<U> = (U extends any ? (x: U) => any : never) extends (x: infer I) => any ? I : never;
 type EnsureWorkflowShape<T> = {
@@ -13,35 +13,35 @@ type WorkflowRegistry<Own extends ModuleShape, Deps extends ModuleMap> = Own & D
 type AnyWorkflow = WorkflowDef<any, any, any, any, any>;
 type ModuleShape = Record<string, AnyWorkflow>;
 type ModuleMap = Record<string, Module<any, any, any, any>>;
-type FinalContext<Context extends Record<string, any>, Deps extends ModuleMap> = Context & ContextFromDepsRecursive<Deps>;
-type ContextFromDepsRecursive<Deps extends ModuleMap> = [keyof Deps] extends [
+type FinalServices<S extends ServiceRegistry, Deps extends ModuleMap> = S & ServicesFromDepsRecursive<Deps>;
+type ServicesFromDepsRecursive<Deps extends ModuleMap> = [keyof Deps] extends [
     never
 ] ? {} : UnionToIntersection<{
-    [K in keyof Deps]: Deps[K] extends Module<any, infer Ctx, any, infer SubDeps> ? Ctx & ContextFromDepsRecursive<SubDeps> : never;
+    [K in keyof Deps]: Deps[K] extends Module<any, infer S, any, infer SubDeps> ? S & ServicesFromDepsRecursive<SubDeps> : never;
 }[keyof Deps]>;
 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> = {
+type Module<Reg extends ActionRegistry, S extends ServiceRegistry, Own extends ModuleShape, Deps extends ModuleMap> = {
     workflows: Own;
     __getExecutor: () => Executor;
     createRuntime: (config: {
-        context: FinalContext<Context, Deps>;
+        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]>;
             extras: Record<string, any>;
         }>;
-        getContext: () => FinalContext<Context, Deps>;
+        getServices: () => FinalServices<S, Deps>;
     };
 };
-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;
+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;
 };
-export declare function createModuleFactory<Context extends Record<string, any>>(): <Reg extends ActionRegistry = Record<string, any>, Use extends ModuleMap = {}, Own extends ModuleShape = {}>(config: {
+export declare function createModuleFactory<S extends ServiceRegistry>(): <Reg extends ActionRegistry = Record<string, any>, Use extends ModuleMap = {}, Own extends ModuleShape = {}>(config: {
     actionRegistry: Reg;
     use?: Use;
-    define: (ctx: ModuleContext<typeof config.actionRegistry, DepWorkflows<Use>, Context>) => Own;
-}) => Module<Reg, Context, Own, Use>;
+    define: (ctx: ModuleContext<typeof config.actionRegistry, DepWorkflows<Use>, S>) => Own;
+}) => Module<Reg, S, Own, Use>;
 export {};

package/dist/workflow-module.js

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

package/package.json

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