@gobing-ai/ts-dual-workflow-engine 0.4.32 → 0.4.35

package/dist/action-step.d.ts

@@ -1,7 +1,7 @@
 import type { WorkflowEngineHost } from './host';
 import type { RunLifecycle } from './run-lifecycle';
 import { type WorkflowMode } from './run-lifecycle';
-import type { ActionDef, ActionResult, OnErrorPolicy, WorkflowPersistenceAdapter, WorkflowRunOptions } from './types';
+import type { ActionDef, ActionResult, OnErrorPolicy, Vars, WorkflowPersistenceAdapter, WorkflowRunOptions } from './types';
 /**
  * Outcome discriminator for a single action step. `terminal` means the action
  * declared terminal success (the run is done); `fail` means a failure under a
@@ -9,10 +9,17 @@ import type { ActionDef, ActionResult, OnErrorPolicy, WorkflowPersistenceAdapter
  * a failure that the 'continue' policy logged past) and the loop may proceed.
  */
 export type ActionStepOutcome = 'completed' | 'terminal' | 'fail';
-/** Result of running one or more action steps: last result plus a control-flow discriminator. */
+/** Result of running one or more action steps: last result, a control-flow discriminator, and the accumulated `setVars` of every step in the sequence. */
 export interface ActionStepResult {
     readonly outcome: ActionStepOutcome;
     readonly result: ActionResult | undefined;
+    /**
+     * Sequence-level accumulation of `setVars` from every action that ran
+     * (including the terminal/failing one). Single-step callers get just that
+     * step's setVars. Drivers merge this map into their run-local vars after
+     * the sequence settles.
+     */
+    readonly setVars?: Vars;
 }
 /**
  * Everything an action step needs that does not change between the two drivers:
@@ -38,9 +45,9 @@ export interface ActionStepDeps {
  * Run one action through its full lifecycle: resolve templates, persist the
  * start row, time the host invocation inside try/finally, persist + emit the
  * finalize, then classify terminal/fail/continue. `vars` is read-only here;
- * callers thread any `setVars` from the returned result back into their own
- * vars map (the merge stays caller-owned because the two drivers carry vars
- * differently across their loops).
+ * callers thread any `setVars` from the returned result forward — the sequence
+ * runner does so within a sequence, and drivers merge the accumulated map
+ * across states/nodes (each dialect carries vars differently across its loop).
  *
  * This is the single seam both drivers share for action execution (ADR-006 §7
  * keeps the *control loops* dialect-specific; only this per-action mechanism is
@@ -49,13 +56,15 @@ export interface ActionStepDeps {
 export declare function runActionStep(action: ActionDef, vars: Record<string, string>, deps: ActionStepDeps): Promise<ActionStepResult>;
 /**
  * Run a sequence of actions in declaration order, stopping at the first
- * `terminal` or `fail` outcome. Every action resolves its templates against the
- * same `vars` snapshot the caller passed in — `setVars` does not affect later
- * actions within the same sequence; it is the caller (the state-machine driver)
- * that merges the returned result's `setVars` into its run-local vars after the
- * sequence settles. Returns the last action result (retained even when a failure
- * was continued past, so downstream guards can inspect it) plus the controlling
- * outcome.
+ * `terminal` or `fail` outcome. `setVars` from each action is threaded forward
+ * BEFORE the next action runs, so action N+1 resolves its templates (and sees
+ * `context.vars`) with every prior same-sequence `setVars` applied — the YAML
+ * reads imperatively. The returned `setVars` accumulates the maps of every
+ * action that ran (including a continued-past failure and the terminal/failing
+ * action itself); it is the caller (the state-machine driver) that merges it
+ * into run-local vars after the sequence settles. Returns the last action
+ * result (retained even when a failure was continued past, so downstream
+ * guards can inspect it) plus the controlling outcome.
  */
 export declare function runActionSequence(actions: readonly ActionDef[], vars: Record<string, string>, deps: ActionStepDeps): Promise<ActionStepResult>;
 //# sourceMappingURL=action-step.d.ts.map

package/dist/action-step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action-step.d.ts","sourceRoot":"","sources":["../src/action-step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAGtH;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;AAElE,iGAAiG;AACjG,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAC;CAC7C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,0BAA0B,CAAC;IACjD,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,cAAc,EAAE,aAAa,GAAG,SAAS,CAAC;CACtD;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAC/B,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,IAAI,EAAE,cAAc,GACrB,OAAO,CAAC,gBAAgB,CAAC,CAkD3B;AAED;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,SAAS,SAAS,EAAE,EAC7B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,IAAI,EAAE,cAAc,GACrB,OAAO,CAAC,gBAAgB,CAAC,CAS3B"}
+{"version":3,"file":"action-step.d.ts","sourceRoot":"","sources":["../src/action-step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,KAAK,EACR,SAAS,EACT,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,0BAA0B,EAC1B,kBAAkB,EACrB,MAAM,SAAS,CAAC;AAGjB;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;AAElE,0JAA0J;AAC1J,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAC;IAC1C;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,0BAA0B,CAAC;IACjD,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,cAAc,EAAE,aAAa,GAAG,SAAS,CAAC;CACtD;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAC/B,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,IAAI,EAAE,cAAc,GACrB,OAAO,CAAC,gBAAgB,CAAC,CAkD3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,SAAS,SAAS,EAAE,EAC7B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,IAAI,EAAE,cAAc,GACrB,OAAO,CAAC,gBAAgB,CAAC,CAc3B"}

package/dist/action-step.js

@@ -1,13 +1,13 @@
 import { defaultActionRedactor } from './persistence.js';
 import { runtimeBuiltins } from './run-lifecycle.js';
-import { resolveOnErrorPolicy, resolveTemplates } from './variables.js';
+import { mergeSetVars, resolveOnErrorPolicy, resolveTemplates } from './variables.js';
 /**
  * Run one action through its full lifecycle: resolve templates, persist the
  * start row, time the host invocation inside try/finally, persist + emit the
  * finalize, then classify terminal/fail/continue. `vars` is read-only here;
- * callers thread any `setVars` from the returned result back into their own
- * vars map (the merge stays caller-owned because the two drivers carry vars
- * differently across their loops).
+ * callers thread any `setVars` from the returned result forward — the sequence
+ * runner does so within a sequence, and drivers merge the accumulated map
+ * across states/nodes (each dialect carries vars differently across its loop).
  *
  * This is the single seam both drivers share for action execution (ADR-006 §7
  * keeps the *control loops* dialect-specific; only this per-action mechanism is
@@ -60,24 +60,31 @@ export async function runActionStep(action, vars, deps) {
 }
 /**
  * Run a sequence of actions in declaration order, stopping at the first
- * `terminal` or `fail` outcome. Every action resolves its templates against the
- * same `vars` snapshot the caller passed in — `setVars` does not affect later
- * actions within the same sequence; it is the caller (the state-machine driver)
- * that merges the returned result's `setVars` into its run-local vars after the
- * sequence settles. Returns the last action result (retained even when a failure
- * was continued past, so downstream guards can inspect it) plus the controlling
- * outcome.
+ * `terminal` or `fail` outcome. `setVars` from each action is threaded forward
+ * BEFORE the next action runs, so action N+1 resolves its templates (and sees
+ * `context.vars`) with every prior same-sequence `setVars` applied — the YAML
+ * reads imperatively. The returned `setVars` accumulates the maps of every
+ * action that ran (including a continued-past failure and the terminal/failing
+ * action itself); it is the caller (the state-machine driver) that merges it
+ * into run-local vars after the sequence settles. Returns the last action
+ * result (retained even when a failure was continued past, so downstream
+ * guards can inspect it) plus the controlling outcome.
  */
 export async function runActionSequence(actions, vars, deps) {
     let last;
+    let acc;
     for (const action of actions) {
         const step = await runActionStep(action, vars, deps);
         if (step.result !== undefined)
             last = step.result;
+        if (step.result?.setVars) {
+            acc = mergeSetVars(acc ?? {}, step.result.setVars);
+            vars = mergeSetVars(vars, step.result.setVars);
+        }
         if (step.outcome === 'terminal')
-            return { outcome: 'terminal', result: last };
+            return { outcome: 'terminal', result: last, setVars: acc };
         if (step.outcome === 'fail')
-            return { outcome: 'fail', result: last };
+            return { outcome: 'fail', result: last, setVars: acc };
     }
-    return { outcome: 'completed', result: last };
+    return { outcome: 'completed', result: last, setVars: acc };
 }

package/dist/state-machine.js

@@ -69,8 +69,8 @@ export class StateMachineDriver {
                 // erase the previous result.
                 if (enter.result !== undefined)
                     lastActionResult = enter.result;
-                if (enter.result?.setVars)
-                    vars = mergeSetVars(vars, enter.result.setVars);
+                if (enter.setVars)
+                    vars = mergeSetVars(vars, enter.setVars);
                 if (enter.outcome === 'terminal') {
                     return failure.has(current.id)
                         ? await lifecycle.fail(current.id, transitionsTaken, `terminal:${current.id}`)
@@ -122,8 +122,8 @@ export class StateMachineDriver {
                 });
             if (exit.result !== undefined)
                 lastActionResult = exit.result;
-            if (exit.result?.setVars)
-                vars = mergeSetVars(vars, exit.result.setVars);
+            if (exit.setVars)
+                vars = mergeSetVars(vars, exit.setVars);
             if (exit.outcome === 'fail')
                 return await lifecycle.fail(current.id, transitionsTaken, exit.result?.error);
             // 7. Atomically commit the transition + new state snapshot + phase in a
@@ -146,7 +146,7 @@ export class StateMachineDriver {
     }
 }
 /** Dry-run sentinel: no action ran, so there is nothing to retain and nothing to halt on. */
-const EMPTY_OUTCOME = { outcome: 'completed', result: undefined };
+const EMPTY_OUTCOME = { outcome: 'completed', result: undefined, setVars: undefined };
 async function firstPassingTransition(transitions, host, context, lifecycle) {
     for (const transition of transitions) {
         if (transition.guard === undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/ts-dual-workflow-engine",
-    "version": "0.4.32",
+    "version": "0.4.35",
     "description": "@gobing-ai/ts-dual-workflow-engine — State-machine and transition-flow workflow runtime.",
     "keywords": [
         "typescript",
@@ -48,9 +48,9 @@
         "release": "echo 'Manual publish is disabled. Releases go through GitHub Actions via Trusted Publishing — push a tag: git tag @gobing-ai/ts-dual-workflow-engine-v<version> && git push --tags' && exit 1"
     },
     "dependencies": {
-        "@gobing-ai/ts-db": "^0.4.32",
-        "@gobing-ai/ts-infra": "^0.4.32",
-        "@gobing-ai/ts-runtime": "^0.4.32",
+        "@gobing-ai/ts-db": "^0.4.35",
+        "@gobing-ai/ts-infra": "^0.4.35",
+        "@gobing-ai/ts-runtime": "^0.4.35",
         "zod": "^4.1.0"
     },
     "devDependencies": {

package/src/action-step.ts

@@ -2,8 +2,15 @@ import type { WorkflowEngineHost } from './host';
 import { defaultActionRedactor } from './persistence';
 import type { RunLifecycle } from './run-lifecycle';
 import { runtimeBuiltins, type WorkflowMode } from './run-lifecycle';
-import type { ActionDef, ActionResult, OnErrorPolicy, WorkflowPersistenceAdapter, WorkflowRunOptions } from './types';
-import { resolveOnErrorPolicy, resolveTemplates } from './variables';
+import type {
+    ActionDef,
+    ActionResult,
+    OnErrorPolicy,
+    Vars,
+    WorkflowPersistenceAdapter,
+    WorkflowRunOptions,
+} from './types';
+import { mergeSetVars, resolveOnErrorPolicy, resolveTemplates } from './variables';
 
 /**
  * Outcome discriminator for a single action step. `terminal` means the action
@@ -13,10 +20,17 @@ import { resolveOnErrorPolicy, resolveTemplates } from './variables';
  */
 export type ActionStepOutcome = 'completed' | 'terminal' | 'fail';
 
-/** Result of running one or more action steps: last result plus a control-flow discriminator. */
+/** Result of running one or more action steps: last result, a control-flow discriminator, and the accumulated `setVars` of every step in the sequence. */
 export interface ActionStepResult {
     readonly outcome: ActionStepOutcome;
     readonly result: ActionResult | undefined;
+    /**
+     * Sequence-level accumulation of `setVars` from every action that ran
+     * (including the terminal/failing one). Single-step callers get just that
+     * step's setVars. Drivers merge this map into their run-local vars after
+     * the sequence settles.
+     */
+    readonly setVars?: Vars;
 }
 
 /**
@@ -44,9 +58,9 @@ export interface ActionStepDeps {
  * Run one action through its full lifecycle: resolve templates, persist the
  * start row, time the host invocation inside try/finally, persist + emit the
  * finalize, then classify terminal/fail/continue. `vars` is read-only here;
- * callers thread any `setVars` from the returned result back into their own
- * vars map (the merge stays caller-owned because the two drivers carry vars
- * differently across their loops).
+ * callers thread any `setVars` from the returned result forward — the sequence
+ * runner does so within a sequence, and drivers merge the accumulated map
+ * across states/nodes (each dialect carries vars differently across its loop).
  *
  * This is the single seam both drivers share for action execution (ADR-006 §7
  * keeps the *control loops* dialect-specific; only this per-action mechanism is
@@ -110,13 +124,15 @@ export async function runActionStep(
 
 /**
  * Run a sequence of actions in declaration order, stopping at the first
- * `terminal` or `fail` outcome. Every action resolves its templates against the
- * same `vars` snapshot the caller passed in — `setVars` does not affect later
- * actions within the same sequence; it is the caller (the state-machine driver)
- * that merges the returned result's `setVars` into its run-local vars after the
- * sequence settles. Returns the last action result (retained even when a failure
- * was continued past, so downstream guards can inspect it) plus the controlling
- * outcome.
+ * `terminal` or `fail` outcome. `setVars` from each action is threaded forward
+ * BEFORE the next action runs, so action N+1 resolves its templates (and sees
+ * `context.vars`) with every prior same-sequence `setVars` applied — the YAML
+ * reads imperatively. The returned `setVars` accumulates the maps of every
+ * action that ran (including a continued-past failure and the terminal/failing
+ * action itself); it is the caller (the state-machine driver) that merges it
+ * into run-local vars after the sequence settles. Returns the last action
+ * result (retained even when a failure was continued past, so downstream
+ * guards can inspect it) plus the controlling outcome.
  */
 export async function runActionSequence(
     actions: readonly ActionDef[],
@@ -124,11 +140,16 @@ export async function runActionSequence(
     deps: ActionStepDeps,
 ): Promise<ActionStepResult> {
     let last: ActionResult | undefined;
+    let acc: Vars | undefined;
     for (const action of actions) {
         const step = await runActionStep(action, vars, deps);
         if (step.result !== undefined) last = step.result;
-        if (step.outcome === 'terminal') return { outcome: 'terminal', result: last };
-        if (step.outcome === 'fail') return { outcome: 'fail', result: last };
+        if (step.result?.setVars) {
+            acc = mergeSetVars(acc ?? {}, step.result.setVars);
+            vars = mergeSetVars(vars, step.result.setVars);
+        }
+        if (step.outcome === 'terminal') return { outcome: 'terminal', result: last, setVars: acc };
+        if (step.outcome === 'fail') return { outcome: 'fail', result: last, setVars: acc };
     }
-    return { outcome: 'completed', result: last };
+    return { outcome: 'completed', result: last, setVars: acc };
 }

package/src/state-machine.ts

@@ -109,7 +109,7 @@ export class StateMachineDriver {
                 // driver's `continue` semantics. A state with no enter actions must not
                 // erase the previous result.
                 if (enter.result !== undefined) lastActionResult = enter.result;
-                if (enter.result?.setVars) vars = mergeSetVars(vars, enter.result.setVars);
+                if (enter.setVars) vars = mergeSetVars(vars, enter.setVars);
                 if (enter.outcome === 'terminal') {
                     return failure.has(current.id)
                         ? await lifecycle.fail(current.id, transitionsTaken, `terminal:${current.id}`)
@@ -170,7 +170,7 @@ export class StateMachineDriver {
                       defaultOnError,
                   });
             if (exit.result !== undefined) lastActionResult = exit.result;
-            if (exit.result?.setVars) vars = mergeSetVars(vars, exit.result.setVars);
+            if (exit.setVars) vars = mergeSetVars(vars, exit.setVars);
             if (exit.outcome === 'fail') return await lifecycle.fail(current.id, transitionsTaken, exit.result?.error);
 
             // 7. Atomically commit the transition + new state snapshot + phase in a
@@ -200,7 +200,7 @@ export class StateMachineDriver {
 }
 
 /** Dry-run sentinel: no action ran, so there is nothing to retain and nothing to halt on. */
-const EMPTY_OUTCOME = { outcome: 'completed', result: undefined } as const;
+const EMPTY_OUTCOME = { outcome: 'completed', result: undefined, setVars: undefined } as const;
 
 async function firstPassingTransition(
     transitions: StateMachineWorkflowDef['transitions'],