@pogodisco/zephyr 1.2.9 → 1.3.0

package/dist/index.d.ts

@@ -7,4 +7,5 @@ export * from "./utils.js";
 export * from "./types.js";
 export * from "./utils.js";
 export * from "./node/index.js";
+export * from "./session.js";
 export { useMetrics, useLog } from "./middleware.js";

package/dist/index.js

@@ -7,4 +7,5 @@ export * from "./utils.js";
 export * from "./types.js";
 export * from "./utils.js";
 export * from "./node/index.js";
+export * from "./session.js";
 export { useMetrics, useLog } from "./middleware.js";

package/dist/session.d.ts

@@ -0,0 +1,25 @@
+import { ActionRegistry, WorkflowMiddleware } 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;
+    private subscribers;
+    private running;
+    private queue;
+    state: State;
+    middleware: WorkflowMiddleware[];
+    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, middleware: WorkflowMiddleware[]);
+    getState(): State;
+    subscribe(fn: (state: Partial<State>) => 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;
+    private processQueue;
+}
+export {};

package/dist/session.js

@@ -0,0 +1,58 @@
+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, middleware) {
+        this.registry = registry;
+        this.subscribers = new Set();
+        this.running = false;
+        this.queue = [];
+        this.middleware = [];
+        // Use the same object for session state and module context
+        this.state = initialContext;
+        this.middleware = middleware;
+        // 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
+        return () => this.subscribers.delete(fn);
+    }
+    notify() {
+        for (const fn of this.subscribers)
+            fn(this.state);
+    }
+    /** Queue a workflow execution by key and input; state/context is automatically updated */
+    dispatch(key, input = {}) {
+        this.queue.push({ key, 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.middleware);
+            // Notify subscribers after workflow mutates state
+            this.notify();
+        }
+        this.running = false;
+    }
+}

package/dist/workflow-composer.d.ts

@@ -16,6 +16,7 @@ export type WorkflowDef<Reg extends ActionRegistry, Input, Results, Steps extend
     input: Input;
     results: Results;
     outputResolver?: (ctx: any) => Output;
+    __context?: 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> {

package/dist/workflow-composer.js

@@ -639,6 +639,7 @@ export class WorkflowBuilder {
             input: {},
             results: {},
             outputResolver: this.outputResolver,
+            __context: this.context,
         };
     }
     validateDependencies() {

package/dist/workflow-executor.js

@@ -231,11 +231,20 @@ export async function executeWorkflow(workflow, registry, input, middleware = []
                 start: Date.now(),
             };
             extras.frames[stepId] = frame;
-            const ctx = { stepId, input, results, registry, extras, frame };
+            const context = workflow.__context;
+            const ctx = {
+                stepId,
+                input,
+                results,
+                context,
+                registry,
+                extras,
+                frame,
+            };
             const core = async () => {
                 frame.attempts++;
                 // 👇 Get the resolved arguments (should be a tuple or undefined)
-                const resolvedArgs = step.resolve?.({ input, results });
+                const resolvedArgs = step.resolve?.({ input, results, context });
                 frame.input = resolvedArgs;
                 try {
                     const action = registry[step.action];

package/package.json

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