@bratsos/workflow-engine 0.5.1 → 0.7.0

package/dist/{chunk-WQPZ6KON.js → chunk-5C7LRNM7.js}

@@ -1,6 +1,6 @@
+import { StaleVersionError } from './chunk-2HEV5ZJL.js';
 import { z } from 'zod';
 
-// src/core/types.ts
 z.object({
   batchId: z.string(),
   statusUrl: z.string().optional(),
@@ -78,15 +78,44 @@ function createStorageShim(workflowRunId, workflowType, deps) {
   };
 }
 
+// src/kernel/helpers/resolve-execution-group-output.ts
+function resolveExecutionGroupOutput(workflow, groupIndex, workflowContext) {
+  const stages = workflow.getStagesInExecutionGroup(groupIndex);
+  if (stages.length === 0) return void 0;
+  if (stages.length === 1) {
+    return workflowContext[stages[0].id];
+  }
+  const merged = {};
+  for (const stage of stages) {
+    if (workflowContext[stage.id] !== void 0) {
+      merged[stage.id] = workflowContext[stage.id];
+    }
+  }
+  return merged;
+}
+
+// src/kernel/helpers/save-stage-artifacts.ts
+async function saveStageArtifacts(runId, workflowType, stageId, artifacts, deps) {
+  const artifactKeys = {};
+  for (const [artifactName, artifact] of Object.entries(artifacts)) {
+    const encodedName = encodeURIComponent(artifactName);
+    const key = `workflow-v2/${workflowType}/${runId}/${stageId}/artifacts/${encodedName}.json`;
+    await deps.blobStore.put(key, artifact);
+    artifactKeys[artifactName] = key;
+  }
+  return artifactKeys;
+}
+
 // src/kernel/handlers/job-execute.ts
 function resolveStageInput(workflow, stageId, workflowRun, workflowContext) {
   const groupIndex = workflow.getExecutionGroupIndex(stageId);
-  if (groupIndex === 0) return workflowRun.input;
-  const prevStageId = workflow.getPreviousStageId(stageId);
-  if (prevStageId && workflowContext[prevStageId] !== void 0) {
-    return workflowContext[prevStageId];
-  }
-  return workflowRun.input;
+  if (groupIndex <= 1) return workflowRun.input;
+  const prevOutput = resolveExecutionGroupOutput(
+    workflow,
+    groupIndex - 1,
+    workflowContext
+  );
+  return prevOutput ?? workflowRun.input;
 }
 function toOutboxEvents(workflowRunId, causationId, events) {
   return events.map((event) => ({
@@ -112,6 +141,7 @@ async function handleJobExecute(command, deps) {
   if (workflowRun.status !== "RUNNING") {
     return {
       outcome: "failed",
+      ghost: true,
       error: `Run ${workflowRunId} is ${workflowRun.status}, expected RUNNING \u2014 ghost job discarded`,
       _events: []
     };
@@ -202,6 +232,15 @@ async function handleJobExecute(command, deps) {
       workflowContext
     };
     const result = await stageDef.execute(context);
+    const currentRunStatus = await deps.persistence.getRunStatus(workflowRunId);
+    if (currentRunStatus !== "RUNNING") {
+      return {
+        outcome: "failed",
+        ghost: true,
+        error: `Run ${workflowRunId} was ${currentRunStatus} after stage execution \u2014 result discarded`,
+        _events: []
+      };
+    }
     if (isSuspendedResult(result)) {
       const { state, pollConfig, metrics } = result;
       const nextPollAt = new Date(
@@ -241,12 +280,22 @@ async function handleJobExecute(command, deps) {
         result.output,
         deps
       );
+      const artifactKeys = result.artifacts && Object.keys(result.artifacts).length > 0 ? await saveStageArtifacts(
+        workflowRunId,
+        workflowRun.workflowType,
+        stageId,
+        result.artifacts,
+        deps
+      ) : void 0;
       await deps.persistence.withTransaction(async (tx) => {
         await tx.updateStage(stageRecord.id, {
           status: "COMPLETED",
           completedAt: deps.clock.now(),
           duration,
-          outputData: { _artifactKey: outputKey },
+          outputData: {
+            _artifactKey: outputKey,
+            ...artifactKeys ? { _artifactKeys: artifactKeys } : {}
+          },
           metrics: result.metrics,
           embeddingInfo: result.embeddings
         });
@@ -362,6 +411,17 @@ async function handleRunCancel(command, deps) {
     status: "CANCELLED",
     completedAt: deps.clock.now()
   });
+  const stages = await deps.persistence.getStagesByRun(command.workflowRunId);
+  for (const stage of stages) {
+    if (!TERMINAL_STATUSES.has(stage.status)) {
+      await deps.persistence.updateStage(stage.id, {
+        status: "CANCELLED",
+        completedAt: deps.clock.now(),
+        nextPollAt: null
+      });
+    }
+  }
+  await deps.jobTransport.cancelByRun(command.workflowRunId);
   return {
     cancelled: true,
     _events: [
@@ -644,9 +704,10 @@ async function handleRunRerunFrom(command, deps) {
   );
   const deletedStageIds = stagesToDelete.map((s) => s.stageId);
   for (const stage of stagesToDelete) {
-    const outputRef = stage.outputData;
-    if (outputRef?._artifactKey) {
-      await deps.blobStore.delete(outputRef._artifactKey).catch(() => {
+    const prefix = `workflow-v2/${run.workflowType}/${workflowRunId}/${stage.stageId}/`;
+    const keys = await deps.blobStore.list(prefix).catch(() => []);
+    for (const key of keys) {
+      await deps.blobStore.delete(key).catch(() => {
       });
     }
   }
@@ -655,7 +716,12 @@ async function handleRunRerunFrom(command, deps) {
   }
   await deps.persistence.updateRun(workflowRunId, {
     status: "RUNNING",
-    completedAt: null
+    startedAt: deps.clock.now(),
+    completedAt: null,
+    duration: null,
+    output: null,
+    totalCost: 0,
+    totalTokens: 0
   });
   const targetStages = workflow.getStagesInExecutionGroup(targetGroup);
   for (const stage of targetStages) {
@@ -694,6 +760,19 @@ async function handleRunRerunFrom(command, deps) {
 // src/kernel/handlers/run-transition.ts
 var TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["COMPLETED", "FAILED", "CANCELLED"]);
 var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["RUNNING", "PENDING", "SUSPENDED"]);
+async function claimRunTransition(run, deps) {
+  try {
+    await deps.persistence.updateRun(run.id, {
+      expectedVersion: run.version
+    });
+    return true;
+  } catch (error) {
+    if (error instanceof StaleVersionError) {
+      return false;
+    }
+    throw error;
+  }
+}
 async function enqueueExecutionGroup(run, workflow, groupIndex, deps) {
   const stages = workflow.getStagesInExecutionGroup(groupIndex);
   const stagesToEnqueue = [];
@@ -742,6 +821,9 @@ async function handleRunTransition(command, deps) {
   }
   const stages = await deps.persistence.getStagesByRun(command.workflowRunId);
   if (stages.length === 0) {
+    if (!await claimRunTransition(run, deps)) {
+      return { action: "noop", _events: [] };
+    }
     await enqueueExecutionGroup(run, workflow, 1, deps);
     events.push({
       type: "workflow:started",
@@ -756,6 +838,9 @@ async function handleRunTransition(command, deps) {
   }
   const failedStage = stages.find((s) => s.status === "FAILED");
   if (failedStage) {
+    if (!await claimRunTransition(run, deps)) {
+      return { action: "noop", _events: [] };
+    }
     await deps.persistence.updateRun(command.workflowRunId, {
       status: "FAILED",
       completedAt: deps.clock.now()
@@ -774,6 +859,9 @@ async function handleRunTransition(command, deps) {
   );
   const nextGroupStages = workflow.getStagesInExecutionGroup(maxGroup + 1);
   if (nextGroupStages.length > 0) {
+    if (!await claimRunTransition(run, deps)) {
+      return { action: "noop", _events: [] };
+    }
     await enqueueExecutionGroup(run, workflow, maxGroup + 1, deps);
     return {
       action: "advanced",
@@ -791,10 +879,23 @@ async function handleRunTransition(command, deps) {
     }
   }
   const duration = deps.clock.now().getTime() - run.createdAt.getTime();
+  const workflowContext = await loadWorkflowContext(
+    command.workflowRunId,
+    deps
+  );
+  const output = resolveExecutionGroupOutput(
+    workflow,
+    maxGroup,
+    workflowContext
+  );
+  if (!await claimRunTransition(run, deps)) {
+    return { action: "noop", _events: [] };
+  }
   await deps.persistence.updateRun(command.workflowRunId, {
     status: "COMPLETED",
     completedAt: deps.clock.now(),
     duration,
+    output,
     totalCost,
     totalTokens
   });
@@ -803,6 +904,7 @@ async function handleRunTransition(command, deps) {
     timestamp: deps.clock.now(),
     workflowRunId: command.workflowRunId,
     duration,
+    output,
     totalCost,
     totalTokens
   });
@@ -820,6 +922,29 @@ function toOutboxEvents2(workflowRunId, events) {
     occurredAt: event.timestamp
   }));
 }
+async function markStageCancelled(stageId, deps) {
+  await deps.persistence.updateStage(stageId, {
+    status: "CANCELLED",
+    completedAt: deps.clock.now(),
+    nextPollAt: null
+  });
+}
+async function withClaimedRun(workflowRunId, expectedVersion, deps, fn) {
+  try {
+    const value = await deps.persistence.withTransaction(async (tx) => {
+      await tx.updateRun(workflowRunId, {
+        expectedVersion
+      });
+      return fn(tx);
+    });
+    return { status: "claimed", value };
+  } catch (error) {
+    if (error instanceof StaleVersionError) {
+      return { status: "stale" };
+    }
+    throw error;
+  }
+}
 async function handleStagePollSuspended(command, deps) {
   const maxChecks = command.maxChecks ?? 50;
   const suspendedStages = await deps.persistence.getSuspendedStages(
@@ -834,6 +959,10 @@ async function handleStagePollSuspended(command, deps) {
     checked++;
     const run = await deps.persistence.getRun(stageRecord.workflowRunId);
     if (!run) continue;
+    if (run.status === "CANCELLED") {
+      await markStageCancelled(stageRecord.id, deps);
+      continue;
+    }
     const workflow = deps.registry.getWorkflow(run.workflowId);
     if (!workflow) {
       await deps.persistence.withTransaction(async (tx) => {
@@ -913,36 +1042,50 @@ async function handleStagePollSuspended(command, deps) {
         checkContext
       );
       if (checkResult.error) {
-        await deps.persistence.withTransaction(async (tx) => {
-          await tx.updateStage(stageRecord.id, {
-            status: "FAILED",
-            completedAt: deps.clock.now(),
-            errorMessage: checkResult.error,
-            nextPollAt: null
-          });
-          await tx.updateRun(stageRecord.workflowRunId, {
-            status: "FAILED",
-            completedAt: deps.clock.now()
-          });
-          await tx.appendOutboxEvents(
-            toOutboxEvents2(stageRecord.workflowRunId, [
-              {
-                type: "stage:failed",
-                timestamp: deps.clock.now(),
-                workflowRunId: stageRecord.workflowRunId,
-                stageId: stageRecord.stageId,
-                stageName: stageRecord.stageName,
-                error: checkResult.error
-              },
-              {
-                type: "workflow:failed",
-                timestamp: deps.clock.now(),
-                workflowRunId: stageRecord.workflowRunId,
-                error: checkResult.error
-              }
-            ])
+        const claimResult = await withClaimedRun(
+          stageRecord.workflowRunId,
+          run.version,
+          deps,
+          async (tx) => {
+            await tx.updateStage(stageRecord.id, {
+              status: "FAILED",
+              completedAt: deps.clock.now(),
+              errorMessage: checkResult.error,
+              nextPollAt: null
+            });
+            await tx.updateRun(stageRecord.workflowRunId, {
+              status: "FAILED",
+              completedAt: deps.clock.now()
+            });
+            await tx.appendOutboxEvents(
+              toOutboxEvents2(stageRecord.workflowRunId, [
+                {
+                  type: "stage:failed",
+                  timestamp: deps.clock.now(),
+                  workflowRunId: stageRecord.workflowRunId,
+                  stageId: stageRecord.stageId,
+                  stageName: stageRecord.stageName,
+                  error: checkResult.error
+                },
+                {
+                  type: "workflow:failed",
+                  timestamp: deps.clock.now(),
+                  workflowRunId: stageRecord.workflowRunId,
+                  error: checkResult.error
+                }
+              ])
+            );
+          }
+        );
+        if (claimResult.status === "stale") {
+          const latestStatus = await deps.persistence.getRunStatus(
+            stageRecord.workflowRunId
           );
-        });
+          if (latestStatus === "CANCELLED") {
+            await markStageCancelled(stageRecord.id, deps);
+          }
+          continue;
+        }
         failed++;
       } else if (checkResult.ready) {
         let outputRef;
@@ -962,70 +1105,114 @@ async function handleStagePollSuspended(command, deps) {
           outputRef = { _artifactKey: outputKey };
         }
         const duration = deps.clock.now().getTime() - (stageRecord.startedAt?.getTime() ?? deps.clock.now().getTime());
-        await deps.persistence.withTransaction(async (tx) => {
+        const claimResult = await withClaimedRun(
+          stageRecord.workflowRunId,
+          run.version,
+          deps,
+          async (tx) => {
+            await tx.updateStage(stageRecord.id, {
+              status: "COMPLETED",
+              completedAt: deps.clock.now(),
+              duration,
+              outputData: outputRef,
+              nextPollAt: null,
+              metrics: checkResult.metrics,
+              embeddingInfo: checkResult.embeddings
+            });
+            await tx.appendOutboxEvents(
+              toOutboxEvents2(stageRecord.workflowRunId, [
+                {
+                  type: "stage:completed",
+                  timestamp: deps.clock.now(),
+                  workflowRunId: stageRecord.workflowRunId,
+                  stageId: stageRecord.stageId,
+                  stageName: stageRecord.stageName,
+                  duration
+                }
+              ])
+            );
+          }
+        );
+        if (claimResult.status === "stale") {
+          const latestStatus = await deps.persistence.getRunStatus(
+            stageRecord.workflowRunId
+          );
+          if (latestStatus === "CANCELLED") {
+            await markStageCancelled(stageRecord.id, deps);
+          }
+          continue;
+        }
+        resumed++;
+        resumedWorkflowRunIds.add(stageRecord.workflowRunId);
+      } else {
+        const pollInterval = checkResult.nextCheckIn ?? stageRecord.pollInterval ?? 6e4;
+        const nextPollAt = new Date(deps.clock.now().getTime() + pollInterval);
+        const claimResult = await withClaimedRun(
+          stageRecord.workflowRunId,
+          run.version,
+          deps,
+          async (tx) => {
+            await tx.updateStage(stageRecord.id, {
+              nextPollAt
+            });
+          }
+        );
+        if (claimResult.status === "stale") {
+          const latestStatus = await deps.persistence.getRunStatus(
+            stageRecord.workflowRunId
+          );
+          if (latestStatus === "CANCELLED") {
+            await markStageCancelled(stageRecord.id, deps);
+          }
+          continue;
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const claimResult = await withClaimedRun(
+        stageRecord.workflowRunId,
+        run.version,
+        deps,
+        async (tx) => {
           await tx.updateStage(stageRecord.id, {
-            status: "COMPLETED",
+            status: "FAILED",
             completedAt: deps.clock.now(),
-            duration,
-            outputData: outputRef,
-            nextPollAt: null,
-            metrics: checkResult.metrics,
-            embeddingInfo: checkResult.embeddings
+            errorMessage,
+            nextPollAt: null
+          });
+          await tx.updateRun(stageRecord.workflowRunId, {
+            status: "FAILED",
+            completedAt: deps.clock.now()
           });
           await tx.appendOutboxEvents(
             toOutboxEvents2(stageRecord.workflowRunId, [
               {
-                type: "stage:completed",
+                type: "stage:failed",
                 timestamp: deps.clock.now(),
                 workflowRunId: stageRecord.workflowRunId,
                 stageId: stageRecord.stageId,
                 stageName: stageRecord.stageName,
-                duration
+                error: errorMessage
+              },
+              {
+                type: "workflow:failed",
+                timestamp: deps.clock.now(),
+                workflowRunId: stageRecord.workflowRunId,
+                error: errorMessage
               }
             ])
           );
-        });
-        resumed++;
-        resumedWorkflowRunIds.add(stageRecord.workflowRunId);
-      } else {
-        const pollInterval = checkResult.nextCheckIn ?? stageRecord.pollInterval ?? 6e4;
-        const nextPollAt = new Date(deps.clock.now().getTime() + pollInterval);
-        await deps.persistence.updateStage(stageRecord.id, {
-          nextPollAt
-        });
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      await deps.persistence.withTransaction(async (tx) => {
-        await tx.updateStage(stageRecord.id, {
-          status: "FAILED",
-          completedAt: deps.clock.now(),
-          errorMessage,
-          nextPollAt: null
-        });
-        await tx.updateRun(stageRecord.workflowRunId, {
-          status: "FAILED",
-          completedAt: deps.clock.now()
-        });
-        await tx.appendOutboxEvents(
-          toOutboxEvents2(stageRecord.workflowRunId, [
-            {
-              type: "stage:failed",
-              timestamp: deps.clock.now(),
-              workflowRunId: stageRecord.workflowRunId,
-              stageId: stageRecord.stageId,
-              stageName: stageRecord.stageName,
-              error: errorMessage
-            },
-            {
-              type: "workflow:failed",
-              timestamp: deps.clock.now(),
-              workflowRunId: stageRecord.workflowRunId,
-              error: errorMessage
-            }
-          ])
+        }
+      );
+      if (claimResult.status === "stale") {
+        const latestStatus = await deps.persistence.getRunStatus(
+          stageRecord.workflowRunId
         );
-      });
+        if (latestStatus === "CANCELLED") {
+          await markStageCancelled(stageRecord.id, deps);
+        }
+        continue;
+      }
       failed++;
     }
   }
@@ -1250,5 +1437,5 @@ function createPluginRunner(config) {
 }
 
 export { IdempotencyInProgressError, createKernel, createPluginRunner, definePlugin, loadWorkflowContext, saveStageOutput };
-//# sourceMappingURL=chunk-WQPZ6KON.js.map
-//# sourceMappingURL=chunk-WQPZ6KON.js.map
+//# sourceMappingURL=chunk-5C7LRNM7.js.map
+//# sourceMappingURL=chunk-5C7LRNM7.js.map