@pogodisco/zephyr 1.2.7 → 1.2.9

package/dist/registry.d.ts

@@ -1,8 +1,12 @@
-import { Action, ActionRegistry, MergeActionRegistries } from "./types.js";
+import { ActionRegistry, MergeActionRegistries } from "./types.js";
 export declare class ActionRegistryBuilder<R extends ActionRegistry = {}> {
     private registry;
     constructor(initial?: R);
-    action<K extends string, I, O>(key: K, action: Action<I, O>): ActionRegistryBuilder<MergeActionRegistries<R, Record<K, Action<I, O>>>>;
+    /**
+     * Accepts ANY function - sync or async, any parameter shape
+     * F captures the complete function signature for full type inference
+     */
+    action<K extends string, F extends (...args: any[]) => any>(key: K, action: F): ActionRegistryBuilder<MergeActionRegistries<R, Record<K, F>>>;
     extend<Other extends ActionRegistry>(other: ActionRegistryBuilder<Other> | Other): ActionRegistryBuilder<MergeActionRegistries<R, Other>>;
     build(): R;
 }

package/dist/registry.js

@@ -1,3 +1,43 @@
+// import { Action, ActionRegistry, MergeActionRegistries } from "./types.js";
+//
+// export class ActionRegistryBuilder<R extends ActionRegistry = {}> {
+//   private registry: Partial<R> = {};
+//
+//   constructor(initial?: R) {
+//     if (initial) {
+//       this.registry = { ...initial };
+//     }
+//   }
+//
+//   action<K extends string, I, O>(
+//     key: K,
+//     action: Action<I, O>,
+//   ): ActionRegistryBuilder<MergeActionRegistries<R, Record<K, Action<I, O>>>> {
+//     (this.registry as any)[key] = action;
+//     return this as any;
+//   }
+//
+//   // Extend with another registry (with override)
+//   extend<Other extends ActionRegistry>(
+//     other: ActionRegistryBuilder<Other> | Other,
+//   ): ActionRegistryBuilder<MergeActionRegistries<R, Other>> {
+//     const otherRegistry =
+//       other instanceof ActionRegistryBuilder ? other.build() : other;
+//
+//     Object.assign(this.registry, otherRegistry);
+//     return this as any;
+//   }
+//
+//   build(): R {
+//     return this.registry as R;
+//   }
+// }
+//
+// export function createActionRegistry<R extends ActionRegistry = {}>(
+//   initial?: R,
+// ): ActionRegistryBuilder<R> {
+//   return new ActionRegistryBuilder(initial);
+// }
 export class ActionRegistryBuilder {
     constructor(initial) {
         this.registry = {};
@@ -5,6 +45,10 @@ export class ActionRegistryBuilder {
             this.registry = { ...initial };
         }
     }
+    /**
+     * Accepts ANY function - sync or async, any parameter shape
+     * F captures the complete function signature for full type inference
+     */
     action(key, action) {
         this.registry[key] = action;
         return this;

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { createWorkflow } from "./workflow-composer.js";
-export type Action<I = any, O = any> = (args: I) => Promise<O>;
+export type Action<F extends (...args: any[]) => any = (...args: any[]) => any> = F;
 export interface ActionRegistry {
     [key: string]: Action;
 }
@@ -13,6 +13,8 @@ export type ExecutionFrame = {
     output?: any;
     error?: any;
 };
+export type ActionParams<Reg extends ActionRegistry, K extends keyof Reg> = Parameters<Reg[K]>;
+export type ActionReturn<Reg extends ActionRegistry, K extends keyof Reg> = Awaited<ReturnType<Reg[K]>>;
 export type WorkflowMiddleware<Reg extends ActionRegistry = any> = {
     (ctx: {
         stepId: string;

package/dist/types.js

@@ -1 +1,47 @@
+// import { createWorkflow } from "./workflow-composer.js";
+//
+// export type Action<I = any, O = any> = (args: I) => Promise<O>;
+//
+// export interface ActionRegistry {
+//   [key: string]: Action;
+// }
+//
+// export type MergeActionRegistries<
+//   A extends ActionRegistry,
+//   B extends ActionRegistry,
+// > = Omit<A, keyof B> & B;
+//
+// export type ExecutionFrame = {
+//   stepId: string;
+//   attempts: number;
+//   start: number;
+//   end?: number;
+//   input?: any;
+//   output?: any;
+//   error?: any;
+// };
+//
+// export type WorkflowMiddleware<Reg extends ActionRegistry = any> = {
+//   (
+//     ctx: {
+//       stepId: string;
+//       input: any;
+//       results: Record<string, any>;
+//       registry: Reg;
+//       extras: Record<string, any>;
+//       frame: ExecutionFrame;
+//     },
+//     next: () => Promise<any>,
+//   ): Promise<any>;
+// };
+//
+// export type WF<
+//   Reg extends ActionRegistry,
+//   Context extends Record<string, any>,
+// > = ReturnType<typeof createWorkflow<Reg, Context>>;
+// // TODO: this needs enforcing
+// type Observer = (
+//   frame: Readonly<ExecutionFrame>,
+//   extras: Record<string, any>,
+// ) => void | Promise<void>;
 export {};

package/dist/utils.d.ts

@@ -1,8 +1,14 @@
-import { TaskMap, TaskNodeWithContracts, TasksFromFns } from "./node/types.js";
-export declare function createAction<FN extends (args: any) => any, // Allow sync or async
-Out = Awaited<ReturnType<FN>>>(fn: FN): TaskNodeWithContracts<TasksFromFns<{
-    run: FN;
-}>, Parameters<FN>[0], Out>;
-export declare function genericAction<FN extends (args: any) => any>(fn: FN): <T = Awaited<ReturnType<FN>>>() => (initArgs: Parameters<FN>[0]) => Promise<T>;
-export declare function fixedAction<FN extends (args: any) => any, T = Awaited<ReturnType<FN>>>(fn: FN): () => (args: Parameters<FN>[0]) => Promise<T>;
-export declare function useAction<T extends TaskMap, I extends Record<string, any> | undefined, O>(node: TaskNodeWithContracts<T, I, O>): (initArgs: I) => Promise<O>;
+type AnyFn = (...args: any[]) => Promise<any>;
+type Input<F extends AnyFn> = Parameters<F>[0];
+type Output<F extends AnyFn> = Awaited<ReturnType<F>>;
+/**
+ * For generic actions where you want to specify the return type
+ * Just a type helper, does nothing at runtime
+ */
+export declare function genericAction<F extends AnyFn>(fn: F): <T = Output<F>>() => (args: Input<F>) => Promise<T>;
+/**
+ * For fixed actions - just returns the function
+ * The type parameter T is for convenience when you want to override the return type
+ */
+export declare function fixedAction<F extends AnyFn>(fn: F): <T = Output<F>>() => ((args: Input<F>) => Promise<T>);
+export {};

package/dist/utils.js

@@ -1,25 +1,55 @@
-import { defineNode, execNode } from "./node/main.js";
-export function createAction(fn) {
-    // Just return the raw node definition, not wrapped with useNode
-    return defineNode({
-        run: {
-            fn, // Function can throw or return data
-            argMap: (r) => r._init,
-        },
-        _output: (r) => r.run,
-    });
-}
+// import { defineNode, execNode } from "./node/main.js";
+// import { TaskMap, TaskNodeWithContracts, TasksFromFns } from "./node/types.js";
+//
+// export function createAction<
+//   FN extends (args: any) => any, // Allow sync or async
+//   Out = Awaited<ReturnType<FN>>, // Unwrap Promise if present
+// >(fn: FN) {
+//   // Just return the raw node definition, not wrapped with useNode
+//   return defineNode<TasksFromFns<{ run: FN }>, Parameters<FN>[0], Out>({
+//     run: {
+//       fn, // Function can throw or return data
+//       argMap: (r) => r._init,
+//     },
+//     _output: (r) => r.run as Out,
+//   });
+// }
+//
+// export function genericAction<FN extends (args: any) => any>(fn: FN) {
+//   return <T = Awaited<ReturnType<FN>>>() => useAction(createAction<FN, T>(fn));
+// }
+//
+// export function fixedAction<
+//   FN extends (args: any) => any,
+//   T = Awaited<ReturnType<FN>>,
+// >(fn: FN): () => (args: Parameters<FN>[0]) => Promise<T> {
+//   return () => useAction(createAction<FN, T>(fn));
+// }
+//
+// export function useAction<
+//   T extends TaskMap,
+//   I extends Record<string, any> | undefined,
+//   O,
+// >(node: TaskNodeWithContracts<T, I, O>) {
+//   // Returns a function that graph can call, but WITHOUT withResponse
+//   // Just a simple adapter that calls callNode and returns raw _output
+//   return async (initArgs: I): Promise<O> => {
+//     const result = await execNode(node, initArgs);
+//     return result._output; // Just raw data, throws on error
+//   };
+// }
+//
+/**
+ * For generic actions where you want to specify the return type
+ * Just a type helper, does nothing at runtime
+ */
 export function genericAction(fn) {
-    return () => useAction(createAction(fn));
+    return () => fn;
 }
+/**
+ * For fixed actions - just returns the function
+ * The type parameter T is for convenience when you want to override the return type
+ */
 export function fixedAction(fn) {
-    return () => useAction(createAction(fn));
-}
-export function useAction(node) {
-    // Returns a function that graph can call, but WITHOUT withResponse
-    // Just a simple adapter that calls callNode and returns raw _output
-    return async (initArgs) => {
-        const result = await execNode(node, initArgs);
-        return result._output; // Just raw data, throws on error
-    };
+    return () => fn;
 }

package/dist/workflow-composer.d.ts

@@ -1,11 +1,11 @@
-import { ActionRegistry } from "./types.js";
+import { ActionRegistry, ActionParams, ActionReturn } from "./types.js";
 type SubflowResult<SubResults, SubOutput> = SubOutput extends undefined ? SubResults : SubOutput;
-type StepResult<Reg extends ActionRegistry, ActionName extends keyof Reg> = Awaited<ReturnType<Reg[ActionName]>>;
+type StepResult<Reg extends ActionRegistry, ActionName extends keyof Reg> = ActionReturn<Reg, ActionName>;
 export type StepDef<Reg extends ActionRegistry, ID extends string = string, ActionName extends keyof Reg = any> = {
     id: ID;
     action: ActionName;
     dependsOn: string[];
-    resolve: (ctx: any) => Parameters<Reg[ActionName]>[0];
+    resolve: (ctx: any) => ActionParams<Reg, ActionName>;
     when?: (ctx: any) => boolean;
 };
 export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
@@ -26,36 +26,47 @@ export declare class WorkflowBuilder<Reg extends ActionRegistry, Input = unknown
     private frontier;
     private outputResolver?;
     constructor(name: string, registry: Reg, context: Context);
-    step<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve: (ctx: {
+    step<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: ActionParams<Reg, ActionName> extends [] ? (ctx?: {
         input: Input;
         results: Results;
         context: Context;
-    }) => Parameters<Reg[ActionName]>[0], dependsOn?: string[]): WorkflowBuilder<Reg, Input, Context, [
+    }) => undefined : (ctx: {
+        input: Input;
+        results: Results;
+        context: Context;
+    }) => ActionParams<Reg, ActionName>, dependsOn?: string[]): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         StepDef<Reg, ID, ActionName>
     ], Results & {
         [K in ID]: StepResult<Reg, ActionName>;
     }>;
-    seq<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve: (ctx: {
+    seq<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: ActionParams<Reg, ActionName> extends [] ? (ctx?: {
+        input: Input;
+        results: Results;
+        context: Context;
+    }) => undefined : (ctx: {
         input: Input;
         results: Results;
         context: Context;
-    }) => Parameters<Reg[ActionName]>[0]): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }, undefined>;
+    }) => ActionParams<Reg, ActionName>): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }, undefined>;
     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> : {})>;
-    join<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve: (ctx: {
+    join<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve?: ActionParams<Reg, ActionName> extends [] ? (ctx?: {
+        input: Input;
+        results: Results;
+    }) => undefined : (ctx: {
         input: Input;
         results: Results;
-    }) => Parameters<Reg[ActionName]>[0]): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }, undefined>;
-    subflow<Prefix extends string, SubInput, SubResults, SubSteps extends StepDef<Reg, any, any>[], SubOutput>(prefix: Prefix, workflow: WorkflowDef<Reg, SubInput, SubResults, SubSteps, SubOutput>, resolveInput: (ctx: {
+    }) => ActionParams<Reg, ActionName>): WorkflowBuilder<Reg, Input, Context, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }, undefined>;
+    subflow<Prefix extends string, SubInput, SubResults, SubSteps extends StepDef<Reg, any, any>[], SubOutput>(prefix: Prefix, workflow: WorkflowDef<Reg, SubInput, SubResults, SubSteps, SubOutput>, resolveInput?: (ctx: {
         input: Input;
         results: Results;
         context: Context;
-    }) => SubInput): WorkflowBuilder<Reg, Input, Context, [
+    }) => [SubInput] extends [never] ? any : SubInput & Record<Exclude<keyof SubInput, keyof any>, never>): WorkflowBuilder<Reg, Input, Context, [
         ...Steps,
         ...SubSteps
     ], Results & {

package/dist/workflow-composer.js

@@ -555,12 +555,14 @@ export class WorkflowBuilder {
     /* ------------------------------------------------ */
     /* Base Step                                         */
     /* ------------------------------------------------ */
-    step(id, action, resolve, dependsOn) {
+    step(id, action, 
+    // 👇 resolve returns whatever the action expects (tuple, object, single value, etc.)
+    resolve, dependsOn) {
         const deps = dependsOn ?? [...this.frontier];
         this.steps.push({
             id,
             action,
-            resolve,
+            resolve: (resolve ?? (() => undefined)),
             dependsOn: deps,
         });
         this.frontier = [id];
@@ -607,7 +609,7 @@ export class WorkflowBuilder {
                 id: idMap.get(step.id),
                 dependsOn: step.dependsOn.map((d) => idMap.get(d)),
                 resolve: (ctx) => {
-                    const subInput = resolveInput(ctx);
+                    const subInput = resolveInput ? resolveInput(ctx) : undefined;
                     return step.resolve({
                         input: subInput,
                         results: ctx.results,
@@ -627,9 +629,6 @@ export class WorkflowBuilder {
         this.outputResolver = fn;
         return this.build();
     }
-    /* ------------------------------------------------ */
-    /* Build                                             */
-    /* ------------------------------------------------ */
     build() {
         this.validateDependencies();
         return {
@@ -642,7 +641,6 @@ export class WorkflowBuilder {
             outputResolver: this.outputResolver,
         };
     }
-    /* ------------------------------------------------ */
     validateDependencies() {
         const stepIds = new Set(this.steps.map((s) => s.id));
         for (const step of this.steps) {

package/dist/workflow-executor.js

@@ -97,12 +97,114 @@
 //
 //   return { results: results as R, extras };
 // }
+// import { composeMiddleware } from "./middleware.js";
+// import { ActionRegistry, ExecutionFrame, WorkflowMiddleware } from "./types.js";
+// import { StepDef, WorkflowDef } from "./workflow-composer.js";
+//
+// export async function executeWorkflow<Reg extends ActionRegistry, I, R, O = R>(
+//   workflow: WorkflowDef<Reg, I, R, any, O>,
+//   registry: Reg,
+//   input: I,
+//   middleware: WorkflowMiddleware<Reg>[] = [],
+// ): Promise<{ results: R; output: O; extras: Record<string, any> }> {
+//   const results: Record<string, any> = {};
+//   const extras: Record<string, any> = {};
+//   extras.frames = {} as Record<string, ExecutionFrame>;
+//
+//   // --- strongly type steps ---
+//
+//   const stepById = new Map<string, StepDef<Reg, any, any>>(
+//     workflow.steps.map((s: StepDef<Reg, any, any>) => [s.id, s]),
+//   );
+//   const remainingDeps = new Map<string, number>();
+//   const dependents = new Map<string, string[]>();
+//   const ready: string[] = [];
+//
+//   // Build dependency graph
+//   for (const step of workflow.steps) {
+//     remainingDeps.set(step.id, step.dependsOn.length);
+//     if (step.dependsOn.length === 0) ready.push(step.id);
+//
+//     for (const dep of step.dependsOn) {
+//       if (!dependents.has(dep)) dependents.set(dep, []);
+//       dependents.get(dep)!.push(step.id);
+//     }
+//   }
+//
+//   let completed = 0;
+//
+//   while (ready.length > 0) {
+//     const batch = ready.splice(0);
+//
+//     await Promise.all(
+//       batch.map(async (stepId) => {
+//         const step = stepById.get(stepId)!;
+//
+//         const frame: ExecutionFrame = {
+//           stepId,
+//           attempts: 0,
+//           start: Date.now(),
+//         };
+//         extras.frames[stepId] = frame;
+//
+//         const ctx = { stepId, input, results, registry, extras, frame };
+//
+//         const core = async () => {
+//           frame.attempts++;
+//           frame.input = step.resolve?.({ input, results }) ?? undefined;
+//
+//           try {
+//             const action = registry[step.action];
+//             const result =
+//               frame.input === undefined
+//                 ? await (action as () => Promise<any>)()
+//                 : await action(frame.input);
+//             // const result = await action(frame.input);
+//             frame.output = result;
+//             frame.end = Date.now();
+//
+//             results[step.id] = result;
+//             return result;
+//           } catch (err) {
+//             frame.error = err;
+//             frame.end = Date.now();
+//             throw err;
+//           }
+//         };
+//
+//         const composed = composeMiddleware(middleware, ctx, core);
+//         await composed();
+//
+//         for (const childId of dependents.get(stepId) ?? []) {
+//           const remaining = remainingDeps.get(childId)! - 1;
+//           remainingDeps.set(childId, remaining);
+//           if (remaining === 0) ready.push(childId);
+//         }
+//
+//         completed++;
+//       }),
+//     );
+//   }
+//
+//   if (completed !== workflow.steps.length) {
+//     throw new Error("Workflow execution failed (cycle or missing dependency)");
+//   }
+//
+//   // Resolve output
+//   const output: O = workflow.outputResolver
+//     ? workflow.outputResolver({ input, results: results as R })
+//     : (results as unknown as O);
+//
+//   return { results: results as R, output, extras };
+// }
+//
+//
+///// with any fn shape
 import { composeMiddleware } from "./middleware.js";
 export async function executeWorkflow(workflow, registry, input, middleware = []) {
     const results = {};
     const extras = {};
     extras.frames = {};
-    // --- strongly type steps ---
     const stepById = new Map(workflow.steps.map((s) => [s.id, s]));
     const remainingDeps = new Map();
     const dependents = new Map();
@@ -132,10 +234,24 @@ export async function executeWorkflow(workflow, registry, input, middleware = []
             const ctx = { stepId, input, results, registry, extras, frame };
             const core = async () => {
                 frame.attempts++;
-                frame.input = step.resolve({ input, results });
+                // 👇 Get the resolved arguments (should be a tuple or undefined)
+                const resolvedArgs = step.resolve?.({ input, results });
+                frame.input = resolvedArgs;
                 try {
                     const action = registry[step.action];
-                    const result = await action(frame.input);
+                    let result;
+                    if (resolvedArgs === undefined) {
+                        // No arguments - call with nothing
+                        result = await action();
+                    }
+                    else if (Array.isArray(resolvedArgs)) {
+                        // Tuple arguments - spread as positional params
+                        result = await action(...resolvedArgs);
+                    }
+                    else {
+                        // Single object argument (backward compatibility)
+                        result = await action(resolvedArgs);
+                    }
                     frame.output = result;
                     frame.end = Date.now();
                     results[step.id] = result;

package/dist/workflow-module.js

@@ -44,53 +44,3 @@ export function createModule({ registry, context, use, define, }) {
         ...own,
     };
 }
-// type MergeFlows<T extends any[]> = T extends [infer F, ...infer R]
-//   ? F extends { flows: infer Fl }
-//     ? MergeFlows<R> & Fl
-//     : MergeFlows<R>
-//   : {};
-//
-// type Module<
-//   Reg extends ActionRegistry,
-//   Context extends Record<string, any>,
-//   Flows,
-// > = {
-//   wf: ReturnType<typeof createWorkflow<Reg, Context>>;
-//   flows: Flows;
-// };
-//
-// export function createModule<
-//   Reg extends ActionRegistry,
-//   Context extends Record<string, any>,
-//   Flows extends Record<string, any>,
-//   UseModules extends Module<any, any, any>[] = [],
-// >({
-//   registry,
-//   context,
-//   use = [] as unknown as UseModules,
-//   define,
-// }: {
-//   registry: Reg;
-//   context: Context;
-//   use?: UseModules;
-//   define?: (
-//     wf: ReturnType<typeof createWorkflow<Reg, Context>>,
-//     deps: MergeFlows<UseModules>,
-//   ) => Flows;
-// }) {
-//   const wf = createWorkflow(registry, context);
-//
-//   const inherited = Object.assign({}, ...use.map((m) => m.flows));
-//   const own = define ? define(wf, inherited as MergeFlows<UseModules>) : {};
-//
-//   const flows = {
-//     ...inherited,
-//     ...own,
-//   };
-//
-//   return {
-//     wf,
-//     flows,
-//     ...flows,
-//   } as Module<Reg, Context, typeof flows>;
-// }

package/package.json

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