npm - @pogodisco/zephyr - Versions diffs - 1.5.1 → 1.5.3 - Mend

@pogodisco/zephyr 1.5.1 → 1.5.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/types.d.ts +22 -0
package/dist/types.js +1 -0
package/dist/workflow-composer-pipe.d.ts +71 -0
package/dist/workflow-composer-pipe.js +28 -0
package/dist/workflow-composer.d.ts +23 -64
package/dist/workflow-composer.js +24 -70
package/dist/workflow-executor.d.ts +0 -4
package/dist/workflow-executor.js +36 -13
package/dist/workflow-module.js +0 -257
package/package.json +1 -1

package/dist/types.d.ts CHANGED Viewed

@@ -32,3 +32,25 @@ export interface Executor {
 export type ServiceRegistry = Record<string, Record<string, (...args: any[]) => any>>;
 export type ServiceParams<S extends ServiceRegistry, K extends keyof S, M extends keyof S[K]> = Parameters<S[K][M]>;
 export type ServiceReturn<S extends ServiceRegistry, K extends keyof S, M extends keyof S[K]> = Awaited<ReturnType<S[K][M]>>;
+export type NormalizedCall = {
+    kind: "none";
+} | {
+    kind: "positional";
+    args: any[];
+} | {
+    kind: "object";
+    args: any;
+};
+export type CallHelpers<Reg extends ActionRegistry, ActionName extends keyof Reg> = {
+    args: (...args: ActionParams<Reg, ActionName>) => {
+        kind: "positional";
+        args: ActionParams<Reg, ActionName>;
+    };
+    obj: ActionParams<Reg, ActionName> extends [infer A] ? (arg: A) => {
+        kind: "object";
+        args: A;
+    } : never;
+    none: () => {
+        kind: "none";
+    };
+};

package/dist/types.js CHANGED Viewed

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

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

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

package/dist/workflow-composer-pipe.js ADDED Viewed

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

package/dist/workflow-composer.d.ts CHANGED Viewed

@@ -1,57 +1,17 @@
-import { ActionParams, ActionRegistry, ActionReturn, ServiceParams, ServiceRegistry, ServiceReturn, Simplify } from "./types.js";
-type NormalizedCall = {
-    kind: "none";
-} | {
-    kind: "positional";
-    args: any[];
-} | {
-    kind: "object";
-    args: any;
-};
-export type ResolvedStepInput = NormalizedCall | {
-    kind: "loop";
-    items: NormalizedCall[];
-};
-type CallHelpers<Reg extends ActionRegistry, ActionName extends keyof Reg> = {
-    args: (...args: ActionParams<Reg, ActionName>) => {
-        kind: "positional";
-        args: ActionParams<Reg, ActionName>;
-    };
-    obj: ActionParams<Reg, ActionName> extends [infer A] ? (arg: A) => {
-        kind: "object";
-        args: A;
-    } : never;
-    none: () => {
-        kind: "none";
-    };
-    loop: (items: {
-        kind: "positional";
-        args: ActionParams<Reg, ActionName>;
-    }[] | {
-        kind: "object";
-        args: ActionParams<Reg, ActionName>[0];
-    }[]) => {
-        kind: "loop";
-        items: typeof items;
-    };
-};
+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 StepResultFromResolve<Reg extends ActionRegistry, ActionName extends keyof Reg, R extends ResolvedStepInput> = R extends {
-    kind: "loop";
-} ? ActionReturn<Reg, ActionName>[] : ActionReturn<Reg, ActionName>;
-export type ServiceStepResultFromResolve<S extends ServiceRegistry, SK extends keyof S, MK extends keyof S[SK], R extends ResolvedStepInput> = R extends {
-    kind: "loop";
-} ? ServiceReturn<S, SK, MK>[] : ServiceReturn<S, SK, MK>;
 export type StepDef<Reg extends ActionRegistry, ID extends string = string, ActionName extends keyof Reg = any> = {
     id: ID;
     action: ActionName | "__service__";
     dependsOn: string[];
-    resolve: (ctx: any) => ResolvedStepInput;
+    resolve: (ctx: any) => NormalizedCall;
     when?: (ctx: any) => boolean;
     options?: StepOptions<any, any>;
     __subflowId?: string;
     serviceCall?: ServiceCall;
+    pipe?: PipeDef;
 };
 export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
     name: string;
@@ -94,20 +54,20 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
     private outputResolver?;
     private clearPendingWhen;
     constructor(name: string);
-    step<ID extends string, ActionName extends keyof Reg & string, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
+    step<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
+    } & CallHelpers<Reg, ActionName>) => NormalizedCall, dependsOn?: string[], options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Simplify<Results & {
-        [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>;
+        [K in ID]: ActionReturn<Reg, ActionName>;
     }>>;
-    seq<ID extends string = string, ActionName extends keyof Reg & string = any, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
+    seq<ID extends string = string, ActionName extends keyof Reg & string = any>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
-    service<ID extends string, SK extends keyof Services & string, MK extends keyof Services[SK] & string, ResolveOut extends NormalizedCall = NormalizedCall>(id: ID, service: SK, method: MK, resolve?: (ctx: {
+    } & CallHelpers<Reg, ActionName>) => NormalizedCall, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: ActionReturn<Reg, ActionName>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
+    service<ID extends string, SK extends keyof Services & string, MK extends keyof Services[SK] & string>(id: ID, service: SK, method: MK, resolve?: (ctx: {
         input: Input;
         results: Results;
     } & {
@@ -122,21 +82,20 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
         none: () => {
             kind: "none";
         };
-        loop: (items: {
-            kind: "positional";
-            args: ServiceParams<Services, SK, MK>;
-        }[] | {
-            kind: "object";
-            args: ServiceParams<Services, SK, MK>[0];
-        }[]) => {
-            kind: "loop";
-            items: typeof items;
-        };
-    }) => ResolveOut, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
+    }) => NormalizedCall, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
+        ...Steps,
+        StepDef<Reg, ID, any>
+    ], 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: {
+        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]: ServiceStepResultFromResolve<Services, SK, MK, ResolveOut>;
+        [K in ID]: PipeFinalType<StepsOfPipeBuilder<PB>, Reg, Services>[];
     }>>;
     as<NewType>(): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Steps extends [...infer Rest, infer Last] ? Last extends StepDef<Reg, infer ID, any> ? Simplify<Omit<Results, ID> & {
         [K in ID]: NewType;
@@ -144,10 +103,10 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
     parallel<Branches extends readonly WorkflowBuilder<Reg, Services, WFReg, Input, any, any>[]>(...branches: {
         [K in keyof Branches]: (builder: WorkflowBuilder<Reg, Services, WFReg, Input, [], Results>) => Branches[K];
     }): WorkflowBuilder<Reg, Services, WFReg, Input, MergeBranchSteps<Branches, Steps>, Simplify<MergeBranchResults<Branches, Results>>>;
-    join<ID extends string = string, ActionName extends keyof Reg & string = any, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
+    join<ID extends string = string, ActionName extends keyof Reg & string = any>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-    } & CallHelpers<Reg, ActionName>) => ResolveOut, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
+    } & CallHelpers<Reg, ActionName>) => NormalizedCall, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K_1 in ID]: ActionReturn<Reg, ActionName>; } extends infer T ? { [K in keyof T]: T[K]; } : never, undefined>;
     subflow<Prefix extends string, K extends keyof WFReg & string>(prefix: Prefix, workflowKey: K, resolveInput: (ctx: {
         input: Input;
         results: Results;

package/dist/workflow-composer.js CHANGED Viewed

@@ -1,74 +1,5 @@
-//   /* ------------------------------------------------ */
-//   /* Subflow                                         */
-//   /* ------------------------------------------------ */
-//
-//   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: {
-//               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, ...WF["steps"]],
-//     Results & {
-//       [K in Prefix]: SubflowResult<WorkflowResults<WF>, WorkflowOutput<WF>>;
-//     }
-//   > {
-//     const idMap = new Map<string, string>();
-//
-//     workflow.steps.forEach((step) => {
-//       idMap.set(step.id, `${prefix}.${step.id}`);
-//     });
-//
-//     workflow.steps.forEach((step) => {
-//       const newStep: StepDef<Reg, any, any> = {
-//         ...step,
-//         id: idMap.get(step.id)!,
-//         dependsOn: step.dependsOn.map((d) => idMap.get(d)!),
-//         resolve: (ctx: any) => {
-//           const subInput = resolveInput ? resolveInput(ctx) : undefined;
-//           return step.resolve({
-//             input: subInput,
-//             results: ctx.results,
-//             context: ctx.context,
-//           });
-//         },
-//       };
-//
-//       if (workflow.entrySteps.find((e) => e.id === step.id)) {
-//         newStep.dependsOn = [...this.frontier];
-//       }
-//
-//       this.steps.push(newStep);
-//     });
-//
-//     this.frontier = workflow.endSteps.map((e) => idMap.get(e.id)!);
-//     return this as any;
-//   }
-//
-//   /* ------------------------------------------------ */
-//   /* Conditional                                      */
-//   /* ------------------------------------------------ */
-//
 import { generateWorkflowId } from "./utils.js";
+import { PipeBuilder, } from "./workflow-composer-pipe.js";
 /* ------------------------------------------------ */
 /* FLUENT WORKFLOW BUILDER                          */
 /* ------------------------------------------------ */
@@ -117,6 +48,29 @@ export class WorkflowBuilder {
         this.frontier = [id];
         return this;
     }
+    /* ----------------------- */
+    /* Pipe                    */
+    /* ----------------------- */
+    pipe(id, input, builder, options) {
+        const deps = [...this.frontier];
+        const pb = new PipeBuilder();
+        const built = builder(pb);
+        const steps = built.getSteps();
+        this.steps.push({
+            id,
+            action: "__pipe__",
+            pipe: {
+                input,
+                steps,
+            },
+            dependsOn: deps,
+            when: this.pendingWhen,
+            resolve: () => ({ kind: "none" }),
+            options,
+        });
+        this.frontier = [id];
+        return this;
+    }
     /* ------------------------------------------------ */
     /* Override the result of the last step            */
     /* ------------------------------------------------ */

package/dist/workflow-executor.d.ts CHANGED Viewed

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

package/dist/workflow-executor.js CHANGED Viewed

@@ -4,10 +4,8 @@ export function createCallHelpers() {
         args: (...args) => ({ kind: "positional", args }),
         obj: (arg) => ({ kind: "object", args: arg }),
         none: () => ({ kind: "none" }),
-        loop: (items) => ({ kind: "loop", items }),
     };
 }
-// Helper to wrap action execution with timeout
 async function withTimeout(promise, ms) {
     if (!ms)
         return promise;
@@ -77,8 +75,6 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                 return await action(...input.args);
             case "object":
                 return await action(input.args);
-            case "loop":
-                return await Promise.all(input.items.map((item) => runAction(item, action)));
             default:
                 throw new Error(`Unknown ResolvedStepInput kind: ${input.kind}`);
         }
@@ -125,20 +121,47 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                     return undefined;
                 }
                 // -----------------------------
-                // Subflow handling
+                // Pipe handling
                 // -----------------------------
+                if (step.pipe && step.pipe.steps) {
+                    const items = step.pipe.input(stepCtx);
+                    const pipeResults = await Promise.all(items.map(async (item) => {
+                        let current = item;
+                        for (const pipeStep of step.pipe.steps) {
+                            const pipeCtx = {
+                                current,
+                                results,
+                                ...createCallHelpers(),
+                            };
+                            const resolved = pipeStep.resolve(pipeCtx);
+                            let action;
+                            if (pipeStep.type === "action") {
+                                action = actionRegistry[pipeStep.action];
+                            }
+                            else {
+                                action = services[pipeStep.service][pipeStep.method];
+                            }
+                            if (!action) {
+                                throw new Error(`Unknown ${pipeStep.type} in pipe step: ${pipeStep.type === "action"
+                                    ? pipeStep.action
+                                    : `${pipeStep.service}.${pipeStep.method}`}`);
+                            }
+                            current = await runAction(resolved, action);
+                        }
+                        return current;
+                    }));
+                    results[step.id] = pipeResults;
+                    frame.output = pipeResults;
+                    frame.end = Date.now();
+                    return pipeResults;
+                }
                 if (step.__subflowId) {
+                    // -----------------------------
+                    // Subflow handling
+                    // -----------------------------
                     const [modId, subWfId] = step.__subflowId.split(".");
                     const exec = depsExecutors[modId];
                     const subExecution = await exec.run(subWfId, resolvedArgs, services, observers);
-                    // const subExecution = await executeWorkflow(
-                    //   step.__subflowId,
-                    //   workflowRegistry,
-                    //   actionRegistry,
-                    //   resolvedArgs as any,
-                    //   context,
-                    //   observers,
-                    // );
                     frame.output = subExecution.output;
                     frame.end = Date.now();
                     results[step.id] = subExecution.output;

package/dist/workflow-module.js CHANGED Viewed

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

package/package.json CHANGED Viewed

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