@pogodisco/zephyr 1.5.3 → 1.5.5

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -1,6 +1,20 @@
 export function generateWorkflowId(name) {
-    // Short random + timestamp for practically unique ID
     const random = Math.random().toString(36).slice(2, 10);
     const time = Date.now().toString(36);
     return `${name}-${time}-${random}`;
 }
+export function exposeAll(name, mod) {
+    const result = {};
+    for (const key in mod.workflows) {
+        const full = `${name}.${key}`;
+        result[full] = full;
+    }
+    return result;
+}
+export function exposeAllAs(name, mod) {
+    const result = {};
+    for (const key in mod.workflows) {
+        result[key] = `${name}.${key}`;
+    }
+    return result;
+}

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

@@ -25,7 +25,7 @@ export declare class PipeBuilder<Current, Reg extends ActionRegistry, Services e
     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, [
+    } & Results & CallHelpers<Reg, A>) => NormalizedCall): PipeBuilder<ActionReturn<Reg, A>, Reg, Services, Results, [
         ...Steps,
         {
             type: "action";
@@ -35,7 +35,7 @@ export declare class PipeBuilder<Current, Reg extends ActionRegistry, Services e
     service<SK extends keyof Services & string, MK extends keyof Services[SK] & string>(id: string, service: SK, method: MK, resolve: (ctx: {
         current: Current;
         results: Results;
-    } & {
+    } & Results & {
         args: (...args: ServiceParams<Services, SK, MK>) => {
             kind: "positional";
             args: ServiceParams<Services, SK, MK>;
@@ -47,16 +47,6 @@ export declare class PipeBuilder<Current, Reg extends ActionRegistry, Services e
         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,
         {

package/dist/workflow-composer.d.ts

@@ -57,7 +57,7 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
     step<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-    } & CallHelpers<Reg, ActionName>) => NormalizedCall, dependsOn?: string[], options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
+    } & Results & CallHelpers<Reg, ActionName>) => NormalizedCall, dependsOn?: string[], options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Simplify<Results & {
@@ -66,11 +66,11 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
     seq<ID extends string = string, ActionName extends keyof Reg & string = any>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-    } & 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>;
+    } & Results & 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;
-    } & {
+    } & Results & {
         args: (...args: ServiceParams<Services, SK, MK>) => {
             kind: "positional";
             args: ServiceParams<Services, SK, MK>;
@@ -91,7 +91,7 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
     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, [
+    } & 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 & {
@@ -106,22 +106,24 @@ Input = unknown, Steps extends StepDef<Reg, any, any>[] = [], Results = {}, Outp
     join<ID extends string = string, ActionName extends keyof Reg & string = any>(id: ID, action: ActionName, resolve?: (ctx: {
         input: Input;
         results: Results;
-    } & 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>;
+    } & Results & 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;
     }) => WorkflowInput<WFReg[K]>, options?: StepOptions<Input, Results>): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results & {
         [P in Prefix]: WorkflowOutput<WFReg[K]>;
     }>;
+    private _subflow;
+    sub: this["subflow"];
     when(predicate: (ctx: {
         input: Input;
         results: Results;
-    }) => boolean): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results, Output>;
+    } & Results) => boolean): WorkflowBuilder<Reg, Services, WFReg, Input, Steps, Results, Output>;
     endWhen(): this;
     output<Output>(fn: (ctx: {
         input: Input;
         results: Results;
-    }) => Output): WorkflowDef<Reg, Input, Results, Steps, Output>;
+    } & Results) => Output): WorkflowDef<Reg, Input, Results, Steps, Output>;
     build(): WorkflowDef<Reg, Input, Results, Steps>;
     private validateDependencies;
     private getEndSteps;

package/dist/workflow-composer.js

@@ -11,6 +11,8 @@ export class WorkflowBuilder {
         this.name = name;
         this.steps = [];
         this.frontier = [];
+        this._subflow = this.subflow.bind(this);
+        this.sub = ((...args) => this._subflow(...args));
     }
     step(id, action, resolve, dependsOn, options) {
         const deps = dependsOn ?? [...this.frontier];

package/dist/workflow-executor.js

@@ -14,6 +14,24 @@ async function withTimeout(promise, ms) {
         new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), ms)),
     ]);
 }
+function createStepCtx(input, results) {
+    const helpers = createCallHelpers();
+    return new Proxy({
+        input,
+        results,
+        ...helpers,
+    }, {
+        get(target, prop) {
+            // 1. explicit keys first
+            if (prop in target)
+                return target[prop];
+            // 2. fallback to results
+            if (prop in results)
+                return results[prop];
+            return undefined;
+        },
+    });
+}
 // Helper to run action with retry support
 async function runWithRetry(actionFn, stepOptions) {
     const maxRetries = stepOptions?.retry ?? 0;
@@ -100,11 +118,13 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                 extras,
                 frame,
             };
-            const stepCtx = {
-                input,
-                results,
-                ...createCallHelpers(),
-            };
+            const stepCtx = createStepCtx(input, results);
+            // const stepCtx = {
+            //   input,
+            //   results,
+            //
+            //   ...createCallHelpers(),
+            // };
             const resolvedArgs = step.resolve?.(stepCtx);
             frame.input = resolvedArgs;
             const core = async () => {
@@ -128,11 +148,43 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
                     const pipeResults = await Promise.all(items.map(async (item) => {
                         let current = item;
                         for (const pipeStep of step.pipe.steps) {
-                            const pipeCtx = {
+                            //  return new Proxy(
+                            //     {
+                            //       input,
+                            //       results,
+                            //       ...helpers,
+                            //     },
+                            //     {
+                            //       get(target, prop) {
+                            //         // 1. explicit keys first
+                            //         if (prop in target) return target[prop as keyof typeof target];
+                            //
+                            //         // 2. fallback to results
+                            //         if (prop in results) return results[prop as keyof typeof target];
+                            //
+                            //         return undefined;
+                            //       },
+                            //     },
+                            //   );
+                            // }
+                            // const pipeCtx = {
+                            //   current,
+                            //   results,
+                            //   ...createCallHelpers(),
+                            // };
+                            const pipeCtx = new Proxy({
                                 current,
                                 results,
                                 ...createCallHelpers(),
-                            };
+                            }, {
+                                get(target, prop) {
+                                    if (prop in target)
+                                        return target[prop];
+                                    if (prop in results)
+                                        return results[prop];
+                                    return undefined;
+                                },
+                            });
                             const resolved = pipeStep.resolve(pipeCtx);
                             let action;
                             if (pipeStep.type === "action") {
@@ -219,11 +271,9 @@ export async function executeWorkflow({ workflow, actionRegistry, services, inpu
     if (completed !== workflow.steps.length) {
         throw new Error("Workflow execution failed (cycle or missing dependency)");
     }
+    const outputCtx = createStepCtx(input, results);
     const output = workflow.outputResolver
-        ? workflow.outputResolver({
-            input,
-            results,
-        })
+        ? workflow.outputResolver(outputCtx)
         : results;
     return {
         // results: results as WorkflowResults<WR[K]>,

package/dist/workflow-module.d.ts

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

package/dist/workflow-module.js

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

package/package.json

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