@bratsos/workflow-engine 0.5.0 → 0.6.0

package/dist/{chunk-3NEGRI4M.js → chunk-HOGDFLCG.js}

@@ -1,6 +1,6 @@
+import { StaleVersionError } from './chunk-2MWO6UVR.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
   });
@@ -810,8 +912,40 @@ async function handleRunTransition(command, deps) {
 }
 
 // src/kernel/handlers/stage-poll-suspended.ts
+function toOutboxEvents2(workflowRunId, events) {
+  const causationId = crypto.randomUUID();
+  return events.map((event) => ({
+    workflowRunId,
+    eventType: event.type,
+    payload: event,
+    causationId,
+    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 events = [];
   const maxChecks = command.maxChecks ?? 50;
   const suspendedStages = await deps.persistence.getSuspendedStages(
     deps.clock.now()
@@ -825,41 +959,57 @@ 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.updateStage(stageRecord.id, {
-        status: "FAILED",
-        completedAt: deps.clock.now(),
-        errorMessage: `Workflow ${run.workflowId} not found in registry`
+      await deps.persistence.withTransaction(async (tx) => {
+        await tx.updateStage(stageRecord.id, {
+          status: "FAILED",
+          completedAt: deps.clock.now(),
+          errorMessage: `Workflow ${run.workflowId} not found in registry`
+        });
+        await tx.appendOutboxEvents(
+          toOutboxEvents2(stageRecord.workflowRunId, [
+            {
+              type: "stage:failed",
+              timestamp: deps.clock.now(),
+              workflowRunId: stageRecord.workflowRunId,
+              stageId: stageRecord.stageId,
+              stageName: stageRecord.stageName,
+              error: `Workflow ${run.workflowId} not found in registry`
+            }
+          ])
+        );
       });
       failed++;
-      events.push({
-        type: "stage:failed",
-        timestamp: deps.clock.now(),
-        workflowRunId: stageRecord.workflowRunId,
-        stageId: stageRecord.stageId,
-        stageName: stageRecord.stageName,
-        error: `Workflow ${run.workflowId} not found in registry`
-      });
       continue;
     }
     const stageDef = workflow.getStage(stageRecord.stageId);
     if (!stageDef || !stageDef.checkCompletion) {
       const errorMsg = !stageDef ? `Stage ${stageRecord.stageId} not found in workflow ${run.workflowId}` : `Stage ${stageRecord.stageId} does not support checkCompletion`;
-      await deps.persistence.updateStage(stageRecord.id, {
-        status: "FAILED",
-        completedAt: deps.clock.now(),
-        errorMessage: errorMsg
+      await deps.persistence.withTransaction(async (tx) => {
+        await tx.updateStage(stageRecord.id, {
+          status: "FAILED",
+          completedAt: deps.clock.now(),
+          errorMessage: errorMsg
+        });
+        await tx.appendOutboxEvents(
+          toOutboxEvents2(stageRecord.workflowRunId, [
+            {
+              type: "stage:failed",
+              timestamp: deps.clock.now(),
+              workflowRunId: stageRecord.workflowRunId,
+              stageId: stageRecord.stageId,
+              stageName: stageRecord.stageName,
+              error: errorMsg
+            }
+          ])
+        );
       });
       failed++;
-      events.push({
-        type: "stage:failed",
-        timestamp: deps.clock.now(),
-        workflowRunId: stageRecord.workflowRunId,
-        stageId: stageRecord.stageId,
-        stageName: stageRecord.stageName,
-        error: errorMsg
-      });
       continue;
     }
     const storage = createStorageShim(
@@ -892,31 +1042,51 @@ async function handleStagePollSuspended(command, deps) {
         checkContext
       );
       if (checkResult.error) {
-        await deps.persistence.updateStage(stageRecord.id, {
-          status: "FAILED",
-          completedAt: deps.clock.now(),
-          errorMessage: checkResult.error,
-          nextPollAt: null
-        });
-        await deps.persistence.updateRun(stageRecord.workflowRunId, {
-          status: "FAILED",
-          completedAt: deps.clock.now()
-        });
+        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++;
-        events.push({
-          type: "stage:failed",
-          timestamp: deps.clock.now(),
-          workflowRunId: stageRecord.workflowRunId,
-          stageId: stageRecord.stageId,
-          stageName: stageRecord.stageName,
-          error: checkResult.error
-        });
-        events.push({
-          type: "workflow:failed",
-          timestamp: deps.clock.now(),
-          workflowRunId: stageRecord.workflowRunId,
-          error: checkResult.error
-        });
       } else if (checkResult.ready) {
         let outputRef;
         if (checkResult.output !== void 0) {
@@ -935,59 +1105,115 @@ async function handleStagePollSuspended(command, deps) {
           outputRef = { _artifactKey: outputKey };
         }
         const duration = deps.clock.now().getTime() - (stageRecord.startedAt?.getTime() ?? deps.clock.now().getTime());
-        await deps.persistence.updateStage(stageRecord.id, {
-          status: "COMPLETED",
-          completedAt: deps.clock.now(),
-          duration,
-          outputData: outputRef,
-          nextPollAt: null,
-          metrics: checkResult.metrics,
-          embeddingInfo: checkResult.embeddings
-        });
+        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);
-        events.push({
-          type: "stage:completed",
-          timestamp: deps.clock.now(),
-          workflowRunId: stageRecord.workflowRunId,
-          stageId: stageRecord.stageId,
-          stageName: stageRecord.stageName,
-          duration
-        });
       } else {
         const pollInterval = checkResult.nextCheckIn ?? stageRecord.pollInterval ?? 6e4;
         const nextPollAt = new Date(deps.clock.now().getTime() + pollInterval);
-        await deps.persistence.updateStage(stageRecord.id, {
-          nextPollAt
-        });
+        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);
-      await deps.persistence.updateStage(stageRecord.id, {
-        status: "FAILED",
-        completedAt: deps.clock.now(),
-        errorMessage,
-        nextPollAt: null
-      });
-      await deps.persistence.updateRun(stageRecord.workflowRunId, {
-        status: "FAILED",
-        completedAt: deps.clock.now()
-      });
+      const claimResult = await withClaimedRun(
+        stageRecord.workflowRunId,
+        run.version,
+        deps,
+        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++;
-      events.push({
-        type: "stage:failed",
-        timestamp: deps.clock.now(),
-        workflowRunId: stageRecord.workflowRunId,
-        stageId: stageRecord.stageId,
-        stageName: stageRecord.stageName,
-        error: errorMessage
-      });
-      events.push({
-        type: "workflow:failed",
-        timestamp: deps.clock.now(),
-        workflowRunId: stageRecord.workflowRunId,
-        error: errorMessage
-      });
     }
   }
   return {
@@ -995,7 +1221,7 @@ async function handleStagePollSuspended(command, deps) {
     resumed,
     failed,
     resumedWorkflowRunIds: [...resumedWorkflowRunIds],
-    _events: events
+    _events: []
   };
 }
 
@@ -1041,6 +1267,14 @@ function createKernel(config) {
       const { _events: _, ...publicResult } = result;
       return publicResult;
     }
+    if (command.type === "stage.pollSuspended") {
+      const result = await handleStagePollSuspended(
+        command,
+        deps
+      );
+      const { _events: _, ...publicResult } = result;
+      return publicResult;
+    }
     if (command.type === "job.execute") {
       const jobCommand = command;
       const jobIdempotencyKey = jobCommand.idempotencyKey;
@@ -1121,12 +1355,6 @@ function createKernel(config) {
               txDeps
             );
             break;
-          case "stage.pollSuspended":
-            result = await handleStagePollSuspended(
-              command,
-              txDeps
-            );
-            break;
           case "lease.reapStale":
             result = await handleLeaseReapStale(
               command,
@@ -1209,5 +1437,5 @@ function createPluginRunner(config) {
 }
 
 export { IdempotencyInProgressError, createKernel, createPluginRunner, definePlugin, loadWorkflowContext, saveStageOutput };
-//# sourceMappingURL=chunk-3NEGRI4M.js.map
-//# sourceMappingURL=chunk-3NEGRI4M.js.map
+//# sourceMappingURL=chunk-HOGDFLCG.js.map
+//# sourceMappingURL=chunk-HOGDFLCG.js.map