@pogodisco/zephyr 1.0.0

package/dist/event-stream.d.ts

@@ -0,0 +1,7 @@
+declare class ZephyrEventStream {
+    private listeners;
+    emit(evt: any): void;
+    subscribe(listener: (evt: any) => void): () => void;
+}
+export declare const eventStream: ZephyrEventStream;
+export {};

package/dist/event-stream.js

@@ -0,0 +1,16 @@
+class ZephyrEventStream {
+    constructor() {
+        this.listeners = [];
+    }
+    emit(evt) {
+        for (const l of this.listeners)
+            l(evt);
+    }
+    subscribe(listener) {
+        this.listeners.push(listener);
+        return () => {
+            this.listeners = this.listeners.filter((l) => l !== listener);
+        };
+    }
+}
+export const eventStream = new ZephyrEventStream();

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./event-stream.js";
+export * from "./registry.js";
+export * from "./workflow-executor.js";
+export * from "./workflow-composer.js";
+export * from "./utils.js";
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./node/index.js";
+export { useMetrics, useLog } from "./middleware.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./event-stream.js";
+export * from "./registry.js";
+export * from "./workflow-executor.js";
+export * from "./workflow-composer.js";
+export * from "./utils.js";
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./node/index.js";
+export { useMetrics, useLog } from "./middleware.js";

package/dist/middleware.d.ts

@@ -0,0 +1,4 @@
+import { ActionRegistry, WorkflowMiddleware } from "./types.js";
+export declare function composeMiddleware<Reg extends ActionRegistry>(middleware: WorkflowMiddleware<Reg>[], ctx: Parameters<WorkflowMiddleware<Reg>>[0], core: () => Promise<any>): () => Promise<any>;
+export declare function useLog(): WorkflowMiddleware;
+export declare function useMetrics(): WorkflowMiddleware;

package/dist/middleware.js

@@ -0,0 +1,69 @@
+import { eventStream } from "./event-stream.js";
+export function composeMiddleware(middleware, ctx, core) {
+    let index = -1;
+    async function dispatch(i) {
+        if (i <= index)
+            throw new Error("next() called multiple times");
+        index = i;
+        const fn = middleware[i];
+        if (!fn)
+            return core();
+        return fn(ctx, () => dispatch(i + 1));
+    }
+    return () => dispatch(0);
+}
+export function useLog() {
+    return async ({ frame, stepId }, next) => {
+        eventStream.emit({
+            type: "node_start",
+            node: stepId,
+            timestamp: frame.start,
+            input: frame.input,
+        });
+        try {
+            const res = await next();
+            eventStream.emit({
+                type: "node_success",
+                node: stepId,
+                output: frame.output,
+                duration: frame.end - frame.start,
+                attempts: frame.attempts,
+                timestamp: Date.now(),
+            });
+            return res;
+        }
+        catch (err) {
+            eventStream.emit({
+                type: "node_fail",
+                node: stepId,
+                error: frame.error,
+                timestamp: Date.now(),
+                attempts: frame.attempts,
+            });
+            throw err;
+        }
+    };
+}
+export function useMetrics() {
+    return async ({ stepId, extras }, next) => {
+        if (!extras?.metrics) {
+            extras.metrics = {};
+        }
+        const start = Date.now();
+        try {
+            const res = await next();
+            extras.metrics[stepId] = {
+                status: "success",
+                duration: Date.now() - start,
+            };
+            return res;
+        }
+        catch (err) {
+            extras.metrics[stepId] = {
+                status: "fail",
+                duration: Date.now() - start,
+            };
+            throw err;
+        }
+    };
+}

package/dist/node/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./main.js";
+export * from "./types.js";

package/dist/node/index.js

@@ -0,0 +1,2 @@
+export * from "./main.js";
+export * from "./types.js";

package/dist/node/main.d.ts

@@ -0,0 +1,11 @@
+import { TaskMap, TaskDefinition, TaskResultsData, TaskState, TaskNodeWithContracts } from "./types.js";
+export declare function defineNode<T extends TaskMap, I extends Record<string, any>, O>(node: {
+    [K in keyof T]: T[K] extends TaskDefinition<infer F, any, any> ? TaskDefinition<F, T, I> : never;
+} & {
+    _output: (results: TaskResultsData<T, I>, status?: Record<keyof T, TaskState>) => O;
+}): TaskNodeWithContracts<T, I, O>;
+export declare const execNode: <T extends TaskMap, I extends Record<string, any> | undefined, O>(node: TaskNodeWithContracts<T, I, O>, initArgs: I) => Promise<{
+    _output: O;
+    _status: Record<keyof T, TaskState>;
+    _results: any;
+}>;

package/dist/node/main.js

@@ -0,0 +1,99 @@
+export function defineNode(node) {
+    preflightCheck(node);
+    return node;
+}
+// --- preflight check & circular detection ---
+function preflightCheck(node) {
+    const keys = new Set();
+    for (const key in node) {
+        if (key === "_output" || key === "_init")
+            continue;
+        if (keys.has(key))
+            throw new Error(`Duplicate task key: ${key}`);
+        keys.add(key);
+        const task = node[key];
+        if (!task)
+            continue;
+        if (task.abort === undefined)
+            task.abort = true;
+    }
+    const visited = new Set();
+    const stack = new Set();
+    const visit = (taskKey) => {
+        if (taskKey === "_output" || taskKey === "_init")
+            return;
+        if (stack.has(taskKey))
+            throw new Error(`Circular dependency: ${[...stack, taskKey].join(" -> ")}`);
+        if (visited.has(taskKey))
+            return;
+        stack.add(taskKey);
+        const task = node[taskKey];
+        for (const dep of task?.dependencies ?? []) {
+            if (!(dep in node))
+                throw new Error(`Task "${taskKey}" depends on unknown "${String(dep)}"`);
+            visit(String(dep));
+        }
+        stack.delete(taskKey);
+        visited.add(taskKey);
+    };
+    for (const key of Object.keys(node))
+        visit(key);
+}
+function buildTopologicalBatches(node, keys) {
+    const remaining = new Set(keys);
+    const resolved = new Set();
+    const batches = [];
+    while (remaining.size > 0) {
+        const batch = [];
+        for (const key of remaining) {
+            const deps = node[key]?.dependencies ?? [];
+            if (deps.every((d) => resolved.has(d))) {
+                batch.push(key);
+            }
+        }
+        if (batch.length === 0) {
+            throw new Error("Unable to build execution batches (circular or unresolved deps)");
+        }
+        for (const key of batch) {
+            remaining.delete(key);
+            resolved.add(key);
+        }
+        batches.push(batch);
+    }
+    return batches;
+}
+export const execNode = async (node, initArgs) => {
+    const results = { _init: initArgs };
+    const status = {};
+    const taskKeys = Object.keys(node).filter((k) => k !== "_output");
+    for (const k of taskKeys)
+        status[k] = "pending";
+    const batches = buildTopologicalBatches(node, taskKeys);
+    for (const batch of batches) {
+        for (const key of batch) {
+            const task = node[key];
+            const deps = task.dependencies ?? [];
+            if (!deps.every((d) => status[d] === "success"))
+                continue;
+            try {
+                const args = task.argMap?.(results) ?? initArgs;
+                // Just call the function - it either returns data or throws
+                const raw = await task.fn(args);
+                // No ok check - if we get here, it succeeded
+                status[key] = "success";
+                results[key] = raw; // Store the raw return value
+            }
+            catch (err) {
+                status[key] = "failed";
+                if (task.abort !== false)
+                    throw err;
+                // If abort is false, continue to next task
+            }
+        }
+    }
+    return {
+        _output: node._output(results, status),
+        _status: status,
+        _results: results,
+    };
+};

package/dist/node/types.d.ts

@@ -0,0 +1,41 @@
+export type TraceEventType = "start" | "success" | "fail" | "skipped" | "background";
+export interface TraceEvent {
+    task: string;
+    type: TraceEventType;
+    timestamp: number;
+    meta?: any;
+}
+export interface ExecutionTrace {
+    batches: string[][];
+    events: TraceEvent[];
+}
+export type LogEvent = "start" | "finish" | "data" | "deferred" | "skipped" | "background" | "parallel" | "success" | "fail";
+export type TaskLogger = (event: LogEvent, key: string, meta?: any) => void;
+export interface NodeOptions {
+    log?: TaskLogger;
+    parallel?: boolean;
+}
+export type TaskState = "pending" | "skipped" | "failed" | "success";
+export type TaskDefinition<F extends (...args: any) => any, T extends TaskMap, I extends Record<string, any> | undefined> = {
+    fn: F;
+    dependencies?: (keyof T)[];
+    abort?: boolean;
+    argMap?: (results: TaskResultsData<T, I>) => Parameters<F>[0];
+};
+export type TaskMap = Record<string, TaskDefinition<any, any, any>>;
+export type TaskResultsData<T extends TaskMap, I> = {
+    _init: I;
+} & {
+    [K in keyof T]: Awaited<ReturnType<T[K]["fn"]>>;
+};
+export type TasksFromFns<T extends Record<string, (...args: any) => any>> = {
+    [K in keyof T]: TaskDefinition<T[K], any, any>;
+};
+export type TaskNodeWithContracts<T extends TaskMap, I extends Record<string, any> | undefined, O> = {
+    [K in keyof T]: T[K] extends TaskDefinition<infer F, any, any> ? TaskDefinition<F, T, I> : never;
+} & {
+    _init?: I;
+    _output: (results: TaskResultsData<T, I>, status?: Record<keyof T, TaskState>) => O;
+    _batches?: (keyof T)[][];
+    _trace?: ExecutionTrace;
+};

package/dist/node/types.js

@@ -0,0 +1 @@
+export {};

package/dist/registry.d.ts

@@ -0,0 +1,9 @@
+import { Action, 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>>>>;
+    extend<Other extends ActionRegistry>(other: ActionRegistryBuilder<Other> | Other): ActionRegistryBuilder<MergeActionRegistries<R, Other>>;
+    build(): R;
+}
+export declare function createActionRegistry<R extends ActionRegistry = {}>(initial?: R): ActionRegistryBuilder<R>;

package/dist/registry.js

@@ -0,0 +1,24 @@
+export class ActionRegistryBuilder {
+    constructor(initial) {
+        this.registry = {};
+        if (initial) {
+            this.registry = { ...initial };
+        }
+    }
+    action(key, action) {
+        this.registry[key] = action;
+        return this;
+    }
+    // Extend with another registry (with override)
+    extend(other) {
+        const otherRegistry = other instanceof ActionRegistryBuilder ? other.build() : other;
+        Object.assign(this.registry, otherRegistry);
+        return this;
+    }
+    build() {
+        return this.registry;
+    }
+}
+export function createActionRegistry(initial) {
+    return new ActionRegistryBuilder(initial);
+}

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+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>;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+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>;

package/dist/utils.js

@@ -0,0 +1,25 @@
+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,
+    });
+}
+export function genericAction(fn) {
+    return () => useAction(createAction(fn));
+}
+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
+    };
+}

package/dist/workflow-composer.d.ts

@@ -0,0 +1,68 @@
+import { ActionRegistry } from "./types.js";
+type StepResult<Reg extends ActionRegistry, ActionName extends keyof Reg> = Awaited<ReturnType<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];
+    when?: (ctx: any) => boolean;
+};
+export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[], Output = undefined> = {
+    name: string;
+    steps: Steps;
+    entrySteps: StepDef<Reg>[];
+    endSteps: StepDef<Reg>[];
+    input: Input;
+    results: Results;
+    outputResolver?: (ctx: any) => Output;
+};
+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, Steps extends StepDef<Reg, any, any>[] = [], Results = {}> {
+    private name;
+    private registry;
+    private steps;
+    private frontier;
+    private outputResolver?;
+    constructor(name: string, registry: Reg);
+    step<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve: (ctx: {
+        input: Input;
+        results: Results;
+    }) => Parameters<Reg[ActionName]>[0], dependsOn?: string[]): WorkflowBuilder<Reg, Input, [
+        ...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: {
+        input: Input;
+        results: Results;
+    }) => Parameters<Reg[ActionName]>[0]): WorkflowBuilder<Reg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }>;
+    parallel<Branches extends WorkflowBuilder<Reg, Input, any, any>[]>(...branches: {
+        [K in keyof Branches]: (builder: WorkflowBuilder<Reg, Input, [], Results>) => Branches[K];
+    }): WorkflowBuilder<Reg, Input, [
+        ...Steps,
+        ...(Branches[number] extends WorkflowBuilder<Reg, any, infer S, any> ? S : never)
+    ], Results & (Branches[number] extends WorkflowBuilder<Reg, any, any, infer R> ? UnionToIntersection<R> : {})>;
+    join<ID extends string, ActionName extends keyof Reg & string>(id: ID, action: ActionName, resolve: (ctx: {
+        input: Input;
+        results: Results;
+    }) => Parameters<Reg[ActionName]>[0]): WorkflowBuilder<Reg, Input, [...Steps, StepDef<Reg, ID, ActionName>], Results & { [K in ID]: Awaited<ReturnType<Reg[ActionName]>>; }>;
+    subflow<Prefix extends string, SubInput, SubResults, SubSteps extends StepDef<Reg, any, any>[]>(prefix: Prefix, workflow: WorkflowDef<Reg, SubInput, SubResults, SubSteps>, resolveInput: (ctx: {
+        input: Input;
+        results: Results;
+    }) => SubInput): WorkflowBuilder<Reg, Input, [
+        ...Steps,
+        ...SubSteps
+    ], Results & {
+        [K in Prefix]: SubResults;
+    }>;
+    output<Output>(fn: (ctx: {
+        input: Input;
+        results: Results;
+    }) => Output): WorkflowDef<Reg, Input, Results, Steps, Output>;
+    build(): WorkflowDef<Reg, Input, Results, Steps>;
+    private validateDependencies;
+    private getEndSteps;
+}
+export declare function createWorkflow<Reg extends ActionRegistry>(registry: Reg): <Input = unknown>(name: string) => WorkflowBuilder<Reg, Input, [], {}>;
+export {};

package/dist/workflow-composer.js

@@ -0,0 +1,405 @@
+// import { ActionRegistry } from "../registry/types.js";
+//
+// type StepResult<
+//   Reg extends ActionRegistry,
+//   ActionName extends keyof Reg,
+// > = Awaited<ReturnType<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];
+//   when?: (ctx: any) => boolean;
+// };
+//
+// export type WorkflowDef<
+//   Reg extends ActionRegistry,
+//   Input,
+//   Results,
+//   Steps extends StepDef<Reg, any, any>[] = StepDef<Reg, any, any>[],
+// > = {
+//   name: string;
+//   steps: Steps;
+//   entrySteps: StepDef<Reg>[];
+//   endSteps: StepDef<Reg>[];
+//   input: Input;
+//   results: Results;
+// };
+//
+// type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+//   k: infer I,
+// ) => void
+//   ? I
+//   : never;
+//
+// export class WorkflowBuilder<
+//   Reg extends ActionRegistry,
+//   Input = unknown,
+//   Steps extends StepDef<Reg, any, any>[] = [],
+//   Results = {},
+// > {
+//   private steps: StepDef<Reg, any, any>[] = [];
+//   private frontier: string[] = [];
+//
+//   constructor(
+//     private name: string,
+//     private registry: Reg,
+//   ) {}
+//
+//   /* ------------------------------------------------ */
+//   /* Base Step                                         */
+//   /* ------------------------------------------------ */
+//
+//   step<ID extends string, ActionName extends keyof Reg & string>(
+//     id: ID,
+//     action: ActionName,
+//     resolve: (ctx: {
+//       input: Input;
+//       results: Results;
+//     }) => Parameters<Reg[ActionName]>[0],
+//     dependsOn?: string[],
+//   ): WorkflowBuilder<
+//     Reg,
+//     Input,
+//     [...Steps, StepDef<Reg, ID, ActionName>],
+//     Results & { [K in ID]: StepResult<Reg, ActionName> }
+//   > {
+//     const deps = dependsOn ?? [...this.frontier];
+//
+//     this.steps.push({
+//       id,
+//       action,
+//       resolve,
+//       dependsOn: deps,
+//     });
+//
+//     this.frontier = [id];
+//
+//     return this as any;
+//   }
+//
+//   /* ------------------------------------------------ */
+//   /* Sequential shortcut                               */
+//   /* ------------------------------------------------ */
+//
+//   seq<ID extends string, ActionName extends keyof Reg & string>(
+//     id: ID,
+//     action: ActionName,
+//     resolve: (ctx: {
+//       input: Input;
+//       results: Results;
+//     }) => Parameters<Reg[ActionName]>[0],
+//   ) {
+//     return this.step(id, action, resolve);
+//   }
+//
+//   /* ------------------------------------------------ */
+//   /* Parallel branches                                 */
+//   /* ------------------------------------------------ */
+//
+//   parallel<Branches extends WorkflowBuilder<Reg, Input, any, any>[]>(
+//     ...branches: {
+//       [K in keyof Branches]: (
+//         builder: WorkflowBuilder<Reg, Input, [], Results>,
+//       ) => Branches[K];
+//     }
+//   ): WorkflowBuilder<
+//     Reg,
+//     Input,
+//     [
+//       ...Steps,
+//       ...(Branches[number] extends WorkflowBuilder<Reg, any, infer S, any>
+//         ? S
+//         : never),
+//     ],
+//     Results &
+//       (Branches[number] extends WorkflowBuilder<Reg, any, any, infer R>
+//         ? UnionToIntersection<R>
+//         : {})
+//   > {
+//     const parentFrontier = [...this.frontier];
+//     const branchEnds: string[] = [];
+//
+//     branches.forEach((branch) => {
+//       const b = new WorkflowBuilder<Reg, Input, [], Results>(
+//         this.name,
+//         this.registry,
+//       );
+//
+//       b.frontier = parentFrontier;
+//
+//       branch(b);
+//
+//       branchEnds.push(...b.frontier);
+//
+//       this.steps.push(...(b as any).steps);
+//     });
+//
+//     this.frontier = branchEnds;
+//
+//     return this as any;
+//   }
+//
+//   /* ------------------------------------------------ */
+//   /* Join helper                                       */
+//   /* ------------------------------------------------ */
+//
+//   join<ID extends string, ActionName extends keyof Reg & string>(
+//     id: ID,
+//     action: ActionName,
+//     resolve: (ctx: {
+//       input: Input;
+//       results: Results;
+//     }) => Parameters<Reg[ActionName]>[0],
+//   ) {
+//     return this.step(id, action, resolve, [...this.frontier]);
+//   }
+//
+//   /* ------------------------------------------------ */
+//   /* Subflow                                           */
+//   /* ------------------------------------------------ */
+//
+//   subflow<
+//     Prefix extends string,
+//     SubInput,
+//     SubResults,
+//     SubSteps extends StepDef<Reg, any, any>[],
+//   >(
+//     prefix: Prefix,
+//     workflow: WorkflowDef<Reg, SubInput, SubResults, SubSteps>,
+//     resolveInput: (ctx: { input: Input; results: Results }) => SubInput,
+//   ): WorkflowBuilder<
+//     Reg,
+//     Input,
+//     [...Steps, ...SubSteps],
+//     Results & { [K in Prefix]: SubResults }
+//   > {
+//     const idMap = new Map<string, string>();
+//
+//     workflow.steps.forEach((step) => {
+//       idMap.set(step.id, `${prefix}.${step.id}`);
+//     });
+//
+//     workflow.steps.forEach((step) => {
+//       const newStep = {
+//         ...step,
+//
+//         id: idMap.get(step.id)!,
+//
+//         dependsOn: step.dependsOn.map((d) => idMap.get(d)!),
+//
+//         resolve: (ctx: any) => {
+//           const subInput = resolveInput(ctx);
+//
+//           return step.resolve({
+//             input: subInput,
+//             results: ctx.results,
+//           });
+//         },
+//       };
+//
+//       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;
+//   }
+//
+//   /* ------------------------------------------------ */
+//   /* Build                                             */
+//   /* ------------------------------------------------ */
+//
+//   build(): WorkflowDef<Reg, Input, Results, Steps> {
+//     this.validateDependencies();
+//
+//     return {
+//       name: this.name,
+//
+//       steps: this.steps as Steps,
+//
+//       entrySteps: this.steps.filter((s) => s.dependsOn.length === 0),
+//
+//       endSteps: this.getEndSteps(),
+//
+//       input: {} as Input,
+//
+//       results: {} as Results,
+//     };
+//   }
+//
+//   /* ------------------------------------------------ */
+//
+//   private validateDependencies() {
+//     const stepIds = new Set(this.steps.map((s) => s.id));
+//
+//     for (const step of this.steps) {
+//       for (const dep of step.dependsOn) {
+//         if (!stepIds.has(dep)) {
+//           throw new Error(`Step ${step.id} depends on unknown step ${dep}`);
+//         }
+//       }
+//     }
+//   }
+//
+//   private getEndSteps() {
+//     const hasDependents = new Set<string>();
+//
+//     for (const step of this.steps) {
+//       for (const dep of step.dependsOn) {
+//         hasDependents.add(dep);
+//       }
+//     }
+//
+//     return this.steps.filter((s) => !hasDependents.has(s.id));
+//   }
+// }
+//
+// // export function createWorkflow<Reg extends ActionRegistry, Input = unknown>(
+// //   registry: Reg,
+// // ) {
+// //   return (name: string) => new WorkflowBuilder<Reg, Input>(name, registry);
+// // }
+//
+// export function createWorkflow<Reg extends ActionRegistry>(registry: Reg) {
+//   return function workflow<Input = unknown>(name: string) {
+//     return new WorkflowBuilder<Reg, Input>(name, registry);
+//   };
+// }
+//
+export class WorkflowBuilder {
+    constructor(name, registry) {
+        this.name = name;
+        this.registry = registry;
+        this.steps = [];
+        this.frontier = [];
+    }
+    /* ------------------------------------------------ */
+    /* Base Step                                         */
+    /* ------------------------------------------------ */
+    step(id, action, resolve, dependsOn) {
+        const deps = dependsOn ?? [...this.frontier];
+        this.steps.push({
+            id,
+            action,
+            resolve,
+            dependsOn: deps,
+        });
+        this.frontier = [id];
+        return this;
+    }
+    /* ------------------------------------------------ */
+    /* Sequential shortcut                               */
+    /* ------------------------------------------------ */
+    seq(id, action, resolve) {
+        return this.step(id, action, resolve);
+    }
+    /* ------------------------------------------------ */
+    /* Parallel branches                                 */
+    parallel(...branches) {
+        const parentFrontier = [...this.frontier];
+        const branchEnds = [];
+        branches.forEach((branch) => {
+            const b = new WorkflowBuilder(this.name, this.registry);
+            b.frontier = parentFrontier;
+            branch(b);
+            branchEnds.push(...b.frontier);
+            this.steps.push(...b.steps);
+        });
+        this.frontier = branchEnds;
+        return this;
+    }
+    /* ------------------------------------------------ */
+    /* Join helper                                       */
+    /* ------------------------------------------------ */
+    join(id, action, resolve) {
+        return this.step(id, action, resolve, [...this.frontier]);
+    }
+    /* ------------------------------------------------ */
+    /* Subflow                                           */
+    /* ------------------------------------------------ */
+    subflow(prefix, workflow, resolveInput) {
+        const idMap = new Map();
+        workflow.steps.forEach((step) => {
+            idMap.set(step.id, `${prefix}.${step.id}`);
+        });
+        workflow.steps.forEach((step) => {
+            const newStep = {
+                ...step,
+                id: idMap.get(step.id),
+                dependsOn: step.dependsOn.map((d) => idMap.get(d)),
+                resolve: (ctx) => {
+                    const subInput = resolveInput(ctx);
+                    return step.resolve({
+                        input: subInput,
+                        results: ctx.results,
+                    });
+                },
+            };
+            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;
+    }
+    output(fn) {
+        this.outputResolver = fn;
+        return this.build();
+    }
+    /* ------------------------------------------------ */
+    /* Build                                             */
+    /* ------------------------------------------------ */
+    build() {
+        this.validateDependencies();
+        return {
+            name: this.name,
+            steps: this.steps,
+            entrySteps: this.steps.filter((s) => s.dependsOn.length === 0),
+            endSteps: this.getEndSteps(),
+            input: {},
+            results: {},
+            outputResolver: this.outputResolver,
+        };
+    }
+    /* ------------------------------------------------ */
+    validateDependencies() {
+        const stepIds = new Set(this.steps.map((s) => s.id));
+        for (const step of this.steps) {
+            for (const dep of step.dependsOn) {
+                if (!stepIds.has(dep)) {
+                    throw new Error(`Step ${step.id} depends on unknown step ${dep}`);
+                }
+            }
+        }
+    }
+    getEndSteps() {
+        const hasDependents = new Set();
+        for (const step of this.steps) {
+            for (const dep of step.dependsOn) {
+                hasDependents.add(dep);
+            }
+        }
+        return this.steps.filter((s) => !hasDependents.has(s.id));
+    }
+}
+// export function createWorkflow<Reg extends ActionRegistry, Input = unknown>(
+//   registry: Reg,
+// ) {
+//   return (name: string) => new WorkflowBuilder<Reg, Input>(name, registry);
+// }
+export function createWorkflow(registry) {
+    return function workflow(name) {
+        return new WorkflowBuilder(name, registry);
+    };
+}

package/dist/workflow-executor.d.ts

@@ -0,0 +1,7 @@
+import { ActionRegistry, WorkflowMiddleware } from "./types.js";
+import { WorkflowDef } from "./workflow-composer.js";
+export declare 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>;
+}>;

package/dist/workflow-executor.js

@@ -0,0 +1,169 @@
+// import { composeMiddleware } from "../middleware/index.js";
+// import { ActionRegistry } from "../registry/types.js";
+// import { WorkflowDef } from "./main.js";
+// import { ExecutionFrame, WorkflowMiddleware } from "./types.js";
+//
+// export async function executeWorkflow<Reg extends ActionRegistry, I, R>(
+//   workflow: WorkflowDef<Reg, I, R>,
+//   registry: Reg,
+//   input: I,
+//   middleware: WorkflowMiddleware<Reg>[] = [],
+// ): Promise<{ results: R; extras: Record<string, any> }> {
+//   const results: Record<string, any> = {};
+//   const extras: Record<string, any> = {};
+//   extras.frames = {} as Record<string, ExecutionFrame>; // <-- store execution frames per step
+//
+//   const stepById = new Map(workflow.steps.map((s) => [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;
+//
+//   // Scheduler loop
+//   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 });
+//
+//           try {
+//             const action = registry[step.action];
+//
+//             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();
+//
+//         // Activate dependents
+//         for (const childId of dependents.get(stepId) ?? []) {
+//           const remaining = remainingDeps.get(childId)! - 1;
+//           remainingDeps.set(childId, remaining);
+//           if (remaining === 0) ready.push(childId);
+//         }
+//
+//         completed++;
+//       }),
+//     );
+//   }
+//
+//   // Deadlock detection
+//   if (completed !== workflow.steps.length) {
+//     throw new Error("Workflow execution failed (cycle or missing dependency)");
+//   }
+//
+//   return { results: results as R, extras };
+// }
+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();
+    const ready = [];
+    // 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 = {
+                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 });
+                try {
+                    const action = registry[step.action];
+                    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 = workflow.outputResolver
+        ? workflow.outputResolver({ input, results: results })
+        : results;
+    return { results: results, output, extras };
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@pogodisco/zephyr",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Jakub Bystroński",
+  "description": "dsl to dag orchestrator",
+  "keywords": [
+    "DSL",
+    "DAG",
+    "graph",
+    "flow",
+    "orchestrator",
+    "task",
+    "typescript"
+  ],
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -w -p tsconfig.json",
+    "test:types": "tsd"
+  },
+  "tsd": {
+    "directory": "test-dts"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "chalk": "^5.6.2",
+    "pretty-format": "^30.2.0",
+    "tsd": "^0.33.0"
+  }
+}