@pogodisco/zephyr 1.3.11 → 1.3.13

package/dist/session.d.ts

@@ -1,25 +1,20 @@
 import { ActionRegistry, WorkflowObserver } from "./types.js";
-import { WorkflowDef } from "./workflow-composer.js";
-type ModuleFlows<Reg extends ActionRegistry> = Record<string, WorkflowDef<Reg, any, any>>;
-export declare class WorkflowSession<Reg extends ActionRegistry, State extends Record<string, any>> {
-    private registry;
+export declare class WorkflowSession<Reg extends ActionRegistry, Ctx> {
+    runtime: {
+        run: any;
+        getContext: () => Ctx;
+    };
     private subscribers;
     private running;
     private queue;
-    state: State;
     observers: WorkflowObserver[];
-    private moduleFlows;
-    /**
-     * @param baseModule Module to extend (inherits workflows)
-     * @param registry Action registry
-     * @param initialContext Initial context (session state) — will be mutated in workflows
-     */
-    constructor(baseModule: ModuleFlows<Reg>, registry: Reg, initialContext: State, observers: WorkflowObserver[]);
-    getState(): State;
-    subscribe(fn: (state: Partial<State>) => void): () => boolean;
+    constructor(runtime: {
+        run: any;
+        getContext: () => Ctx;
+    });
+    subscribe(fn: (state: Partial<Ctx>) => void): () => boolean;
     private notify;
     /** Queue a workflow execution by key and input; state/context is automatically updated */
-    dispatch(key: keyof ModuleFlows<Reg>, input?: any): void;
+    dispatch(workflow: any, input: any): void;
     private processQueue;
 }
-export {};

package/dist/session.js

@@ -1,56 +1,32 @@
-import { executeWorkflow } from "./workflow-executor.js";
-import { createModule } from "./workflow-module.js";
 export class WorkflowSession {
-    /**
-     * @param baseModule Module to extend (inherits workflows)
-     * @param registry Action registry
-     * @param initialContext Initial context (session state) — will be mutated in workflows
-     */
-    constructor(baseModule, registry, initialContext, observers) {
-        this.registry = registry;
+    constructor(runtime) {
+        this.runtime = runtime;
         this.subscribers = new Set();
         this.running = false;
         this.queue = [];
+        // public state: State; // session state & workflow context are the same object
         this.observers = [];
-        // Use the same object for session state and module context
-        this.state = initialContext;
-        this.observers = observers;
-        // Per-session module: inherits workflows, shares the same state/context object
-        this.moduleFlows = createModule({
-            registry: this.registry,
-            context: this.state,
-            use: [baseModule],
-            define: () => ({}), // no new flows needed
-        });
-    }
-    getState() {
-        return this.state;
     }
     subscribe(fn) {
         this.subscribers.add(fn);
-        fn(this.state); // immediately notify
+        fn(this.runtime.getContext()); // immediately notify
         return () => this.subscribers.delete(fn);
     }
     notify() {
         for (const fn of this.subscribers)
-            fn(this.state);
+            fn(this.runtime.getContext());
     }
     /** Queue a workflow execution by key and input; state/context is automatically updated */
-    dispatch(key, input = {}) {
-        this.queue.push({ key, input });
+    dispatch(workflow, input) {
+        this.queue.push({ workflow, input });
         if (!this.running)
             this.processQueue();
     }
     async processQueue() {
         this.running = true;
         while (this.queue.length) {
-            const { key, input } = this.queue.shift();
-            const workflow = this.moduleFlows[key];
-            if (!workflow)
-                throw new Error(`Workflow ${String(key)} not found`);
-            // state/context already lives on the module; no need to pass a separate context
-            await executeWorkflow(workflow, this.registry, input, this.observers);
-            // Notify subscribers after workflow mutates state
+            const { workflow, input } = this.queue.shift();
+            await this.runtime.run(workflow, input);
             this.notify();
         }
         this.running = false;

package/dist/types.d.ts

@@ -1,4 +1,3 @@
-import { createWorkflow } from "./workflow-composer.js";
 export type Action<F extends (...args: any[]) => any = (...args: any[]) => any> = F;
 export type ActionRegistry = Record<string, (...args: any[]) => any>;
 export type MergeActionRegistries<A extends ActionRegistry, B extends ActionRegistry> = Simplify<Omit<A, keyof B> & B>;
@@ -27,4 +26,3 @@ export type WorkflowObserver<Reg extends ActionRegistry = any> = {
         frame: ExecutionFrame;
     }, next: () => Promise<any>): Promise<any>;
 };
-export type WF<Reg extends ActionRegistry, Context extends Record<string, any>> = ReturnType<typeof createWorkflow<Reg, Context>>;

package/dist/utils.d.ts

@@ -1,5 +1,3 @@
-import { ActionRegistry } from "./types.js";
-import { WorkflowDef } from "./workflow-composer.js";
 type AnyFn = (...args: any[]) => any;
 /**
  * For generic actions - preserves the generic parameter
@@ -9,20 +7,4 @@ export declare function genericAction<F extends AnyFn>(fn: F): <T>() => ((...arg
  * For fixed actions
  */
 export declare function fixedAction<F extends AnyFn>(fn: F): () => ((...args: Parameters<F>) => ReturnType<F>);
-export declare function createRunner<Reg extends ActionRegistry>(registry: Reg): <W extends WorkflowDef<Reg, any, any, any, any>>(workflow: W, input: W extends WorkflowDef<Reg, infer I, any, any, any> ? I : never, observers?: any[]) => Promise<{
-    output: W extends WorkflowDef<Reg, any, any, any, infer O> ? O : never;
-    results: W extends WorkflowDef<Reg, any, infer R, any, any> ? R : never;
-    extras: Record<string, any>;
-}>;
-/**
- * Create a typed runner for a specific module
- * @example
- * const run = createModuleRunner(modWithLoop, regOne);
- * const result = await run("loopWorkflow", { items: ["APPLE"] });
- */
-export declare function createModuleRunner<M extends Record<string, WorkflowDef<any, any, any, any, any>>, Reg extends ActionRegistry>(module: M, registry: Reg): <K extends keyof M>(key: K, input: M[K] extends WorkflowDef<Reg, infer I, any, any, any> ? I : never, observers?: any[]) => Promise<{
-    output: M[K] extends WorkflowDef<Reg, any, any, any, infer O> ? O : never;
-    results: M[K] extends WorkflowDef<Reg, any, infer R, any, any> ? R : never;
-    extras: Record<string, any>;
-}>;
 export {};

package/dist/utils.js

@@ -1,4 +1,3 @@
-import { executeWorkflow } from "./workflow-executor.js";
 /**
  * For generic actions - preserves the generic parameter
  */
@@ -16,20 +15,21 @@ export function fixedAction(fn) {
         return fn;
     };
 }
-export function createRunner(registry) {
-    return async (workflow, input, observers) => {
-        return executeWorkflow(workflow, registry, input, observers ?? []);
-    };
-}
-/**
- * Create a typed runner for a specific module
- * @example
- * const run = createModuleRunner(modWithLoop, regOne);
- * const result = await run("loopWorkflow", { items: ["APPLE"] });
- */
-export function createModuleRunner(module, registry) {
-    return async (key, input, observers) => {
-        const workflow = module[key];
-        return executeWorkflow(workflow, registry, input, observers ?? []);
-    };
-}
+// export function createRuntime<Reg extends ActionRegistry, Context>(
+//   registry: Reg,
+//   context: Context,
+// ) {
+//   return {
+//     run: async <W extends WorkflowDef<Reg, any, any, any, any>>(
+//       workflow: W,
+//       input: W extends WorkflowDef<Reg, infer I, any, any, any> ? I : never,
+//       observers?: WorkflowObserver[],
+//     ): Promise<{
+//       output: W extends WorkflowDef<Reg, any, any, any, infer O> ? O : never;
+//       results: W extends WorkflowDef<Reg, any, infer R, any, any> ? R : never;
+//       extras: Record<string, any>;
+//     }> => {
+//       return executeWorkflow(workflow, registry, input, context, observers);
+//     },
+//   };
+// }

package/dist/workflow-composer.d.ts

@@ -1,4 +1,4 @@
-import { ActionParams, ActionRegistry, ActionReturn } from "./types.js";
+import { ActionParams, ActionRegistry, ActionReturn, Simplify } from "./types.js";
 type NormalizedCall = {
     kind: "none";
 } | {
@@ -58,7 +58,6 @@ export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extend
     input: Input;
     results: Results;
     outputResolver?: (ctx: any) => Output;
-    __context?: any;
 };
 type StepRuntimeCtx<I, R, C> = {
     input: I;
@@ -74,17 +73,19 @@ type StepOptions<Input, Results, Context> = {
     label?: string;
     meta?: Record<string, any>;
 };
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown, Context extends Record<string, any> = {}, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Output = undefined> {
+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 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 : [])
+]> : Acc;
+export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown, Context = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Output = undefined> {
     private name;
-    private registry;
-    private context;
     private steps;
     private frontier;
     private pendingWhen?;
     private outputResolver?;
     private clearPendingWhen;
-    constructor(name: string, registry: Reg, context: Context);
+    constructor(name: string);
     step<ID extends string, ActionName extends keyof Reg & string, ResolveOut extends ResolvedStepInput = ResolvedStepInput>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
@@ -92,30 +93,25 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
     } & CallHelpers<Reg, ActionName>) => ResolveOut, dependsOn?: string[], options?: StepOptions<Input, Results, Context>): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
-    ], Results & {
+    ], Simplify<Results & {
         [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>;
-    }>;
+    }>>;
     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, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; }, undefined>;
-    as<NewType>(): WorkflowBuilder<Reg, Input, Context, Steps, Steps extends [...infer Rest, infer Last] ? Last extends StepDef<Reg, infer ID, any> ? Omit<Results, ID> & {
+    } & 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> & {
         [K in ID]: NewType;
-    } : Results : Results, Output>;
-    parallel<Branches extends WorkflowBuilder<Reg, Input, Context, any, any>[]>(...branches: {
+    }> : 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, [
-        ...Steps,
-        ...(Branches[number] extends WorkflowBuilder<Reg, any, any, infer S, any> ? S : never)
-    ], Results & UnionToIntersection<{
-        [K in keyof Branches]: Branches[K] extends WorkflowBuilder<Reg, any, any, any, infer R> ? R : never;
-    }[number]>>;
+    }): WorkflowBuilder<Reg, 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 in ID]: StepResultFromResolve<Reg, ActionName, ResolveOut>; }, undefined>;
+    } & 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: {
         input: Input;
         results: Results;
@@ -145,5 +141,5 @@ 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> = {}>(registry: Reg, context?: Context): <Input = unknown>(name: string) => WorkflowBuilder<Reg, Input, Context, [], {}, undefined>;
+export declare function createWorkflow<Reg extends ActionRegistry, Context extends Record<string, any> = {}>(): <Input = unknown>(name: string) => WorkflowBuilder<Reg, Input, Context, [], {}, undefined>;
 export {};

package/dist/workflow-composer.js

@@ -5,10 +5,8 @@ export class WorkflowBuilder {
     clearPendingWhen() {
         this.pendingWhen = undefined;
     }
-    constructor(name, registry, context) {
+    constructor(name) {
         this.name = name;
-        this.registry = registry;
-        this.context = context;
         this.steps = [];
         this.frontier = [];
     }
@@ -37,55 +35,11 @@ export class WorkflowBuilder {
     as() {
         return this;
     }
-    /* ------------------------------------------------ */
-    /* Parallel branches                               */
-    /* ------------------------------------------------ */
-    // parallel<Branches extends WorkflowBuilder<Reg, Input, Context, any, any>[]>(
-    //   ...branches: {
-    //     [K in keyof Branches]: (
-    //       builder: WorkflowBuilder<Reg, Input, Context, [], Results>,
-    //     ) => Branches[K];
-    //   }
-    // ): WorkflowBuilder<
-    //   Reg,
-    //   Input,
-    //   Context,
-    //   [
-    //     ...Steps,
-    //     ...(Branches[number] extends WorkflowBuilder<Reg, any, any, infer S, any>
-    //       ? S
-    //       : never),
-    //   ],
-    //   Results &
-    //     (Branches[number] extends WorkflowBuilder<Reg, any, any, any, infer R>
-    //       ? UnionToIntersection<R>
-    //       : {})
-    // > {
-    //   const parentFrontier = [...this.frontier];
-    //   const branchEnds: string[] = [];
-    //
-    //   branches.forEach((branch) => {
-    //     const b = new WorkflowBuilder<Reg, Input, Context, [], Results>(
-    //       this.name,
-    //       this.registry,
-    //       this.context,
-    //     );
-    //
-    //     b.frontier = parentFrontier;
-    //     branch(b);
-    //     branchEnds.push(...b.frontier);
-    //     this.steps.push(...(b as any).steps);
-    //   });
-    //
-    //   this.frontier = branchEnds;
-    //   this.clearPendingWhen();
-    //   return this as any;
-    // }
     parallel(...branches) {
         const parentFrontier = [...this.frontier];
         const branchEnds = [];
         branches.forEach((branch) => {
-            const b = new WorkflowBuilder(this.name, this.registry, this.context);
+            const b = new WorkflowBuilder(this.name);
             b.frontier = parentFrontier;
             branch(b);
             branchEnds.push(...b.frontier);
@@ -161,7 +115,6 @@ export class WorkflowBuilder {
             input: {},
             results: {},
             outputResolver: this.outputResolver,
-            __context: this.context,
         };
     }
     validateDependencies() {
@@ -185,8 +138,16 @@ export class WorkflowBuilder {
 /* ------------------------------------------------ */
 /* WORKFLOW CREATOR                                 */
 /* ------------------------------------------------ */
-export function createWorkflow(registry, context) {
+// export function createWorkflow<
+//   Reg extends ActionRegistry,
+//   Context extends Record<string, any> = {},
+// >(registry: Reg, context?: Context) {
+//   return function workflow<Input = unknown>(name: string) {
+//     return new WorkflowBuilder<Reg, Input, Context>(name);
+//   };
+// }
+export function createWorkflow() {
     return function workflow(name) {
-        return new WorkflowBuilder(name, registry, context || {});
+        return new WorkflowBuilder(name);
     };
 }

package/dist/workflow-executor.d.ts

@@ -1,6 +1,6 @@
 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, observers?: WorkflowObserver<Reg>[]): Promise<{
+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;
     extras: Record<string, any>;

package/dist/workflow-executor.js

@@ -39,7 +39,7 @@ async function runWithRetry(actionFn, stepOptions) {
     }
     throw lastError;
 }
-export async function executeWorkflow(workflow, registry, input, observers = []) {
+export async function executeWorkflow(workflow, registry, input, context, observers = []) {
     const results = {};
     const extras = {};
     extras.frames = {};
@@ -93,7 +93,6 @@ export async function executeWorkflow(workflow, registry, input, observers = [])
                 start: Date.now(),
             };
             extras.frames[stepId] = frame;
-            const context = workflow.__context;
             const ctx = {
                 stepId,
                 input,

package/dist/workflow-module.d.ts

@@ -1,10 +1,34 @@
-import { ActionRegistry } from "./types.js";
+import { ActionRegistry, WorkflowObserver } from "./types.js";
 import { createWorkflow, WorkflowDef } from "./workflow-composer.js";
 type AnyWorkflow = WorkflowDef<any, any, any, any, any>;
+type WorkflowFromDeps<Deps extends Record<string, any>> = {
+    [K in keyof Deps]: Deps[K] extends Module<any, any, infer Own, infer SubDeps> ? Own[keyof Own] | WorkflowFromDeps<SubDeps> : never;
+}[keyof Deps];
 type ModuleShape = Record<string, AnyWorkflow>;
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type UnionToIntersectionOrEmpty<U> = [U] extends [never] ? {} : UnionToIntersection<U>;
-export type ModuleContext<Reg extends ActionRegistry, Context extends Record<string, any>, Deps extends ModuleShape> = {
+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<Reg>> = Context & ContextFromDeps<Deps>;
+type ModuleMap<Reg extends ActionRegistry> = Record<string, Module<Reg, 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<Reg> = {}> = {
+    own: Own;
+    deps: Deps;
+    createRuntime: (config: {
+        registry: Reg;
+        context: FinalContext<Reg, Context, Deps>;
+    }) => {
+        run: <W extends Own[keyof Own] | WorkflowFromDeps<Deps>>(workflow: W, input: WorkflowInput<W>, obververs?: WorkflowObserver<Reg>[]) => Promise<{
+            results: WorkflowResults<W>;
+            output: WorkflowOutput<W>;
+            extras: Record<string, any>;
+        }>;
+        getContext: () => FinalContext<Reg, Context, Deps>;
+    };
+};
+export type ModuleContext<Reg extends ActionRegistry, Context extends Record<string, any>, Deps extends ModuleMap<Reg>> = {
     wf: ReturnType<typeof createWorkflow<Reg, Context>>;
     deps: Deps;
     context: Context;
@@ -14,10 +38,12 @@ export type ModuleContext<Reg extends ActionRegistry, Context extends Record<str
         context: Context;
     }) => T) => T;
 };
-export declare function createModule<Reg extends ActionRegistry, Context extends Record<string, any>, Use extends ModuleShape[] = [], Deps extends ModuleShape = UnionToIntersectionOrEmpty<Use[number]> & ModuleShape, Own extends ModuleShape = {}>({ registry, context, use, define, }: {
-    registry: Reg;
-    context: Context;
-    use?: [...Use];
-    define: (ctx: ModuleContext<Reg, Context, Deps>) => Own;
-}): Deps & Own;
+export declare function createModule<Reg extends ActionRegistry, Context extends Record<string, any>, Use extends ModuleMap<Reg>, Own extends ModuleShape>(config: {
+    use?: Use;
+    define: (ctx: ModuleContext<Reg, Context, Use>) => Own;
+}): Module<Reg, Context, Own, Use>;
+export declare function createModuleFactory<Reg extends ActionRegistry, Context extends Record<string, any>>(): <Use extends ModuleMap<Reg> = {}, Own extends ModuleShape = {}>(config: {
+    use?: Use;
+    define: (ctx: ModuleContext<Reg, Context, Use>) => Own;
+}) => Module<Reg, Context, Own, Use>;
 export {};

package/dist/workflow-module.js

@@ -1,16 +1,35 @@
-import { createWorkflow, } from "./workflow-composer.js";
-export function createModule({ registry, context, use, define, }) {
-    const wf = createWorkflow(registry, context);
-    const deps = (use ? Object.assign({}, ...use) : {});
+import { createWorkflow } from "./workflow-composer.js";
+import { executeWorkflow } from "./workflow-executor.js";
+export function createModule(config) {
+    const wf = createWorkflow();
+    const deps = (config.use ?? {});
     const moduleCtx = {
         wf,
         deps,
-        context,
-        tools: (factory) => factory({ wf, deps, context }),
+        context: {},
+        tools: (factory) => factory({
+            wf,
+            deps,
+            context: {},
+        }),
     };
-    const own = define(moduleCtx);
+    const own = config.define(moduleCtx);
     return {
-        ...deps,
-        ...own,
+        own,
+        deps,
+        createRuntime({ registry, context }) {
+            const runtimeCtx = { ...context };
+            return {
+                run: async (workflow, input, observers = []) => {
+                    return executeWorkflow(workflow, registry, input, context, observers);
+                },
+                getContext: () => ({ ...runtimeCtx }),
+            };
+        },
+    };
+}
+export function createModuleFactory() {
+    return function (config) {
+        return createModule(config);
     };
 }

package/package.json

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