@bratsos/workflow-engine 0.1.0 → 0.2.0

package/dist/chunk-HL3OJG7W.js

@@ -0,0 +1,1033 @@
+import { z } from 'zod';
+
+// src/core/types.ts
+z.object({
+  batchId: z.string(),
+  statusUrl: z.string().optional(),
+  apiKey: z.string().optional(),
+  submittedAt: z.string(),
+  // ISO date string
+  pollInterval: z.number(),
+  // milliseconds
+  maxWaitTime: z.number(),
+  // milliseconds
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+function isSuspendedResult(result) {
+  return "suspended" in result && result.suspended === true;
+}
+
+// src/kernel/errors.ts
+var IdempotencyInProgressError = class extends Error {
+  constructor(key, commandType) {
+    super(
+      `Command "${commandType}" with idempotency key "${key}" is already in progress`
+    );
+    this.key = key;
+    this.commandType = commandType;
+    this.name = "IdempotencyInProgressError";
+  }
+};
+
+// src/kernel/helpers/load-workflow-context.ts
+async function loadWorkflowContext(workflowRunId, deps) {
+  const completedStages = await deps.persistence.getStagesByRun(workflowRunId, {
+    status: "COMPLETED",
+    orderBy: "asc"
+  });
+  const context = {};
+  for (const stage of completedStages) {
+    const outputData = stage.outputData;
+    if (outputData?._artifactKey) {
+      context[stage.stageId] = await deps.blobStore.get(
+        outputData._artifactKey
+      );
+    } else if (outputData && typeof outputData === "object") {
+      context[stage.stageId] = outputData;
+    }
+  }
+  return context;
+}
+
+// src/kernel/helpers/save-stage-output.ts
+async function saveStageOutput(runId, workflowType, stageId, output, deps) {
+  const key = `workflow-v2/${workflowType}/${runId}/${stageId}/output.json`;
+  await deps.blobStore.put(key, output);
+  return key;
+}
+
+// src/kernel/helpers/create-storage-shim.ts
+function createStorageShim(workflowRunId, workflowType, deps) {
+  return {
+    async save(key, data) {
+      await deps.blobStore.put(key, data);
+    },
+    async load(key) {
+      return deps.blobStore.get(key);
+    },
+    async exists(key) {
+      return deps.blobStore.has(key);
+    },
+    async delete(key) {
+      return deps.blobStore.delete(key);
+    },
+    getStageKey(stageId, suffix) {
+      const base = `workflow-v2/${workflowType}/${workflowRunId}/${stageId}`;
+      return suffix ? `${base}/${suffix}` : `${base}/output.json`;
+    }
+  };
+}
+
+// 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;
+}
+async function handleJobExecute(command, deps) {
+  const { workflowRunId, workflowId, stageId, config } = command;
+  const events = [];
+  const startTime = deps.clock.now().getTime();
+  const workflow = deps.registry.getWorkflow(workflowId);
+  if (!workflow)
+    throw new Error(`Workflow ${workflowId} not found in registry`);
+  const stageDef = workflow.getStage(stageId);
+  if (!stageDef)
+    throw new Error(`Stage ${stageId} not found in workflow ${workflowId}`);
+  const workflowRun = await deps.persistence.getRun(workflowRunId);
+  if (!workflowRun) throw new Error(`WorkflowRun ${workflowRunId} not found`);
+  const workflowContext = await loadWorkflowContext(workflowRunId, deps);
+  const stageRecord = await deps.persistence.upsertStage({
+    workflowRunId,
+    stageId,
+    create: {
+      workflowRunId,
+      stageId,
+      stageName: stageDef.name,
+      stageNumber: workflow.getStageIndex(stageId) + 1,
+      executionGroup: workflow.getExecutionGroupIndex(stageId),
+      status: "RUNNING",
+      startedAt: deps.clock.now(),
+      config
+    },
+    update: {
+      status: "RUNNING",
+      startedAt: deps.clock.now()
+    }
+  });
+  events.push({
+    type: "stage:started",
+    timestamp: deps.clock.now(),
+    workflowRunId,
+    stageId,
+    stageName: stageDef.name,
+    stageNumber: stageRecord.stageNumber
+  });
+  try {
+    const rawInput = resolveStageInput(
+      workflow,
+      stageId,
+      workflowRun,
+      workflowContext
+    );
+    const validatedInput = stageDef.inputSchema.parse(rawInput);
+    let stageConfig = config[stageId] || {};
+    try {
+      if (stageDef.configSchema) {
+        stageConfig = stageDef.configSchema.parse(stageConfig);
+      }
+    } catch {
+    }
+    const logFn = async (level, message, meta) => {
+      await deps.persistence.createLog({
+        workflowRunId,
+        workflowStageId: stageRecord.id,
+        level,
+        message,
+        metadata: meta
+      }).catch(() => {
+      });
+    };
+    const context = {
+      workflowRunId,
+      stageId,
+      stageNumber: stageRecord.stageNumber,
+      stageName: stageDef.name,
+      stageRecordId: stageRecord.id,
+      input: validatedInput,
+      config: stageConfig,
+      resumeState: stageRecord.suspendedState,
+      onProgress: (update) => {
+        events.push({
+          type: "stage:progress",
+          timestamp: deps.clock.now(),
+          workflowRunId,
+          stageId,
+          progress: update.progress,
+          message: update.message,
+          details: update.details
+        });
+      },
+      onLog: logFn,
+      log: logFn,
+      storage: createStorageShim(workflowRunId, workflowRun.workflowType, deps),
+      workflowContext
+    };
+    const result = await stageDef.execute(context);
+    if (isSuspendedResult(result)) {
+      const { state, pollConfig, metrics } = result;
+      const nextPollAt = new Date(
+        pollConfig.nextPollAt?.getTime() ?? deps.clock.now().getTime() + (pollConfig.pollInterval || 6e4)
+      );
+      await deps.persistence.updateStage(stageRecord.id, {
+        status: "SUSPENDED",
+        suspendedState: state,
+        nextPollAt,
+        pollInterval: pollConfig.pollInterval,
+        maxWaitUntil: pollConfig.maxWaitTime ? new Date(deps.clock.now().getTime() + pollConfig.maxWaitTime) : void 0,
+        metrics
+      });
+      events.push({
+        type: "stage:suspended",
+        timestamp: deps.clock.now(),
+        workflowRunId,
+        stageId,
+        stageName: stageDef.name,
+        nextPollAt
+      });
+      return { outcome: "suspended", nextPollAt, _events: events };
+    } else {
+      const duration = deps.clock.now().getTime() - startTime;
+      const outputKey = await saveStageOutput(
+        workflowRunId,
+        workflowRun.workflowType,
+        stageId,
+        result.output,
+        deps
+      );
+      await deps.persistence.updateStage(stageRecord.id, {
+        status: "COMPLETED",
+        completedAt: deps.clock.now(),
+        duration,
+        outputData: { _artifactKey: outputKey },
+        metrics: result.metrics,
+        embeddingInfo: result.embeddings
+      });
+      events.push({
+        type: "stage:completed",
+        timestamp: deps.clock.now(),
+        workflowRunId,
+        stageId,
+        stageName: stageDef.name,
+        duration
+      });
+      return {
+        outcome: "completed",
+        output: result.output,
+        _events: events
+      };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const duration = deps.clock.now().getTime() - startTime;
+    await deps.persistence.updateStage(stageRecord.id, {
+      status: "FAILED",
+      completedAt: deps.clock.now(),
+      duration,
+      errorMessage
+    });
+    await deps.persistence.createLog({
+      workflowRunId,
+      workflowStageId: stageRecord.id,
+      level: "ERROR",
+      message: errorMessage
+    }).catch(() => {
+    });
+    events.push({
+      type: "stage:failed",
+      timestamp: deps.clock.now(),
+      workflowRunId,
+      stageId,
+      stageName: stageDef.name,
+      error: errorMessage
+    });
+    return { outcome: "failed", error: errorMessage, _events: events };
+  }
+}
+
+// src/kernel/handlers/lease-reap-stale.ts
+async function handleLeaseReapStale(command, deps) {
+  const released = await deps.jobTransport.releaseStaleJobs(
+    command.staleThresholdMs
+  );
+  return { released, _events: [] };
+}
+
+// src/kernel/handlers/outbox-flush.ts
+async function handleOutboxFlush(command, deps) {
+  const limit = command.maxEvents ?? 100;
+  const events = await deps.persistence.getUnpublishedOutboxEvents(limit);
+  const maxRetries = deps.eventSink.maxRetries ?? 3;
+  const publishedIds = [];
+  for (const outboxEvent of events) {
+    try {
+      await deps.eventSink.emit(outboxEvent.payload);
+      publishedIds.push(outboxEvent.id);
+    } catch {
+      const newCount = await deps.persistence.incrementOutboxRetryCount(
+        outboxEvent.id
+      );
+      if (newCount >= maxRetries) {
+        await deps.persistence.moveOutboxEventToDLQ(outboxEvent.id);
+      }
+    }
+  }
+  if (publishedIds.length > 0) {
+    await deps.persistence.markOutboxEventsPublished(publishedIds);
+  }
+  return { published: publishedIds.length, _events: [] };
+}
+
+// src/kernel/handlers/plugin-replay-dlq.ts
+async function handlePluginReplayDLQ(command, deps) {
+  const maxEvents = command.maxEvents ?? 100;
+  const replayed = await deps.persistence.replayDLQEvents(maxEvents);
+  return { replayed, _events: [] };
+}
+
+// src/kernel/handlers/run-cancel.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["COMPLETED", "FAILED", "CANCELLED"]);
+async function handleRunCancel(command, deps) {
+  const run = await deps.persistence.getRun(command.workflowRunId);
+  if (!run || TERMINAL_STATUSES.has(run.status)) {
+    return { cancelled: false, _events: [] };
+  }
+  await deps.persistence.updateRun(command.workflowRunId, {
+    status: "CANCELLED",
+    completedAt: deps.clock.now()
+  });
+  return {
+    cancelled: true,
+    _events: [
+      {
+        type: "workflow:cancelled",
+        timestamp: deps.clock.now(),
+        workflowRunId: command.workflowRunId,
+        reason: command.reason
+      }
+    ]
+  };
+}
+
+// src/kernel/handlers/run-claim-pending.ts
+async function handleRunClaimPending(command, deps) {
+  const maxClaims = command.maxClaims ?? 10;
+  const claimed = [];
+  const events = [];
+  for (let i = 0; i < maxClaims; i++) {
+    const run = await deps.persistence.claimNextPendingRun();
+    if (!run) break;
+    const workflow = deps.registry.getWorkflow(run.workflowId);
+    if (!workflow) {
+      const error = `Workflow ${run.workflowId} not found in registry`;
+      const failedAt = deps.clock.now();
+      await deps.persistence.updateRun(run.id, {
+        status: "FAILED",
+        completedAt: failedAt,
+        output: {
+          error: {
+            code: "WORKFLOW_NOT_FOUND",
+            message: error,
+            workerId: command.workerId
+          }
+        }
+      });
+      await deps.persistence.createLog({
+        workflowRunId: run.id,
+        level: "ERROR",
+        message: error,
+        metadata: {
+          workerId: command.workerId,
+          code: "WORKFLOW_NOT_FOUND"
+        }
+      }).catch(() => {
+      });
+      events.push({
+        type: "workflow:failed",
+        timestamp: failedAt,
+        workflowRunId: run.id,
+        error
+      });
+      continue;
+    }
+    const stages = workflow.getStagesInExecutionGroup(1);
+    if (stages.length === 0) {
+      const error = `Workflow ${run.workflowId} has no stages in execution group 1`;
+      const failedAt = deps.clock.now();
+      await deps.persistence.updateRun(run.id, {
+        status: "FAILED",
+        completedAt: failedAt,
+        output: {
+          error: {
+            code: "EMPTY_STAGE_GRAPH",
+            message: error,
+            workerId: command.workerId
+          }
+        }
+      });
+      await deps.persistence.createLog({
+        workflowRunId: run.id,
+        level: "ERROR",
+        message: error,
+        metadata: {
+          workerId: command.workerId,
+          code: "EMPTY_STAGE_GRAPH"
+        }
+      }).catch(() => {
+      });
+      events.push({
+        type: "workflow:failed",
+        timestamp: failedAt,
+        workflowRunId: run.id,
+        error
+      });
+      continue;
+    }
+    for (const stage of stages) {
+      await deps.persistence.createStage({
+        workflowRunId: run.id,
+        stageId: stage.id,
+        stageName: stage.name,
+        stageNumber: workflow.getStageIndex(stage.id) + 1,
+        executionGroup: 1,
+        status: "PENDING",
+        config: run.config?.[stage.id] || {}
+      });
+    }
+    const jobIds = await deps.jobTransport.enqueueParallel(
+      stages.map((stage) => ({
+        workflowRunId: run.id,
+        workflowId: run.workflowId,
+        stageId: stage.id,
+        priority: run.priority,
+        payload: { config: run.config || {} }
+      }))
+    );
+    events.push({
+      type: "workflow:started",
+      timestamp: deps.clock.now(),
+      workflowRunId: run.id
+    });
+    claimed.push({
+      workflowRunId: run.id,
+      workflowId: run.workflowId,
+      jobIds
+    });
+  }
+  return { claimed, _events: events };
+}
+
+// src/kernel/handlers/run-create.ts
+async function handleRunCreate(command, deps) {
+  const workflow = deps.registry.getWorkflow(command.workflowId);
+  if (!workflow) {
+    throw new Error(`Workflow ${command.workflowId} not found in registry`);
+  }
+  try {
+    workflow.inputSchema.parse(command.input);
+  } catch (error) {
+    throw new Error(`Invalid workflow input: ${error}`);
+  }
+  const defaultConfig = workflow.getDefaultConfig?.() ?? {};
+  const mergedConfig = { ...defaultConfig, ...command.config };
+  const configValidation = workflow.validateConfig(mergedConfig);
+  if (!configValidation.valid) {
+    const errors = configValidation.errors.map((e) => `${e.stageId}: ${e.error}`).join(", ");
+    throw new Error(`Invalid workflow config: ${errors}`);
+  }
+  const priority = command.priority ?? 5;
+  const run = await deps.persistence.createRun({
+    workflowId: command.workflowId,
+    workflowName: workflow.name,
+    workflowType: command.workflowId,
+    input: command.input,
+    config: mergedConfig,
+    priority,
+    metadata: command.metadata
+  });
+  return {
+    workflowRunId: run.id,
+    status: "PENDING",
+    _events: [
+      {
+        type: "workflow:created",
+        timestamp: deps.clock.now(),
+        workflowRunId: run.id,
+        workflowId: command.workflowId
+      }
+    ]
+  };
+}
+
+// src/kernel/handlers/run-rerun-from.ts
+async function handleRunRerunFrom(command, deps) {
+  const { workflowRunId, fromStageId } = command;
+  const events = [];
+  const run = await deps.persistence.getRun(workflowRunId);
+  if (!run) throw new Error(`WorkflowRun ${workflowRunId} not found`);
+  if (run.status !== "COMPLETED" && run.status !== "FAILED") {
+    throw new Error(
+      `Cannot rerun workflow in ${run.status} state. Must be COMPLETED or FAILED.`
+    );
+  }
+  const workflow = deps.registry.getWorkflow(run.workflowId);
+  if (!workflow)
+    throw new Error(`Workflow ${run.workflowId} not found in registry`);
+  const stageDef = workflow.getStage(fromStageId);
+  if (!stageDef) {
+    throw new Error(
+      `Stage ${fromStageId} not found in workflow ${run.workflowId}`
+    );
+  }
+  const targetGroup = workflow.getExecutionGroupIndex(fromStageId);
+  const existingStages = await deps.persistence.getStagesByRun(workflowRunId);
+  if (targetGroup > 1) {
+    const priorStages = existingStages.filter(
+      (s) => s.executionGroup < targetGroup
+    );
+    if (priorStages.length === 0) {
+      throw new Error(
+        `Cannot rerun from stage ${fromStageId}: previous stages have not been executed`
+      );
+    }
+  }
+  const stagesToDelete = existingStages.filter(
+    (s) => s.executionGroup >= targetGroup
+  );
+  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(() => {
+      });
+    }
+  }
+  for (const stage of stagesToDelete) {
+    await deps.persistence.deleteStage(stage.id);
+  }
+  await deps.persistence.updateRun(workflowRunId, {
+    status: "RUNNING",
+    completedAt: null
+  });
+  const targetStages = workflow.getStagesInExecutionGroup(targetGroup);
+  for (const stage of targetStages) {
+    await deps.persistence.createStage({
+      workflowRunId,
+      stageId: stage.id,
+      stageName: stage.name,
+      stageNumber: workflow.getStageIndex(stage.id) + 1,
+      executionGroup: targetGroup,
+      status: "PENDING",
+      config: run.config?.[stage.id] || {}
+    });
+  }
+  await deps.jobTransport.enqueueParallel(
+    targetStages.map((stage) => ({
+      workflowRunId,
+      workflowId: run.workflowId,
+      stageId: stage.id,
+      priority: run.priority,
+      payload: { config: run.config || {} }
+    }))
+  );
+  events.push({
+    type: "workflow:started",
+    timestamp: deps.clock.now(),
+    workflowRunId
+  });
+  return {
+    workflowRunId,
+    fromStageId,
+    deletedStages: deletedStageIds,
+    _events: events
+  };
+}
+
+// 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 enqueueExecutionGroup(run, workflow, groupIndex, deps) {
+  const stages = workflow.getStagesInExecutionGroup(groupIndex);
+  for (const stage of stages) {
+    await deps.persistence.createStage({
+      workflowRunId: run.id,
+      stageId: stage.id,
+      stageName: stage.name,
+      stageNumber: workflow.getStageIndex(stage.id) + 1,
+      executionGroup: groupIndex,
+      status: "PENDING",
+      config: run.config?.[stage.id] || {}
+    });
+  }
+  return deps.jobTransport.enqueueParallel(
+    stages.map((stage) => ({
+      workflowRunId: run.id,
+      workflowId: run.workflowId,
+      stageId: stage.id,
+      priority: run.priority,
+      payload: { config: run.config || {} }
+    }))
+  );
+}
+async function handleRunTransition(command, deps) {
+  const events = [];
+  const run = await deps.persistence.getRun(command.workflowRunId);
+  if (!run) {
+    return { action: "noop", _events: [] };
+  }
+  if (TERMINAL_STATUSES2.has(run.status)) {
+    return { action: "noop", _events: [] };
+  }
+  const workflow = deps.registry.getWorkflow(run.workflowId);
+  if (!workflow) {
+    return { action: "noop", _events: [] };
+  }
+  const stages = await deps.persistence.getStagesByRun(command.workflowRunId);
+  if (stages.length === 0) {
+    await enqueueExecutionGroup(run, workflow, 1, deps);
+    events.push({
+      type: "workflow:started",
+      timestamp: deps.clock.now(),
+      workflowRunId: run.id
+    });
+    return { action: "advanced", nextGroup: 1, _events: events };
+  }
+  const hasActive = stages.some((s) => ACTIVE_STATUSES.has(s.status));
+  if (hasActive) {
+    return { action: "noop", _events: [] };
+  }
+  const failedStage = stages.find((s) => s.status === "FAILED");
+  if (failedStage) {
+    await deps.persistence.updateRun(command.workflowRunId, {
+      status: "FAILED",
+      completedAt: deps.clock.now()
+    });
+    events.push({
+      type: "workflow:failed",
+      timestamp: deps.clock.now(),
+      workflowRunId: command.workflowRunId,
+      error: failedStage.errorMessage || "Stage failed"
+    });
+    return { action: "failed", _events: events };
+  }
+  const maxGroup = stages.reduce(
+    (max, s) => s.executionGroup > max ? s.executionGroup : max,
+    0
+  );
+  const nextGroupStages = workflow.getStagesInExecutionGroup(maxGroup + 1);
+  if (nextGroupStages.length > 0) {
+    await enqueueExecutionGroup(run, workflow, maxGroup + 1, deps);
+    return {
+      action: "advanced",
+      nextGroup: maxGroup + 1,
+      _events: events
+    };
+  }
+  let totalCost = 0;
+  let totalTokens = 0;
+  for (const stage of stages) {
+    const metrics = stage.metrics;
+    if (metrics) {
+      totalCost += metrics.totalCost ?? 0;
+      totalTokens += metrics.totalTokens ?? 0;
+    }
+  }
+  const duration = deps.clock.now().getTime() - run.createdAt.getTime();
+  await deps.persistence.updateRun(command.workflowRunId, {
+    status: "COMPLETED",
+    completedAt: deps.clock.now(),
+    duration,
+    totalCost,
+    totalTokens
+  });
+  events.push({
+    type: "workflow:completed",
+    timestamp: deps.clock.now(),
+    workflowRunId: command.workflowRunId,
+    duration,
+    totalCost,
+    totalTokens
+  });
+  return { action: "completed", _events: events };
+}
+
+// src/kernel/handlers/stage-poll-suspended.ts
+async function handleStagePollSuspended(command, deps) {
+  const events = [];
+  const maxChecks = command.maxChecks ?? 50;
+  const suspendedStages = await deps.persistence.getSuspendedStages(
+    deps.clock.now()
+  );
+  const stagesToCheck = suspendedStages.slice(0, maxChecks);
+  let checked = 0;
+  let resumed = 0;
+  let failed = 0;
+  const resumedWorkflowRunIds = /* @__PURE__ */ new Set();
+  for (const stageRecord of stagesToCheck) {
+    checked++;
+    const run = await deps.persistence.getRun(stageRecord.workflowRunId);
+    if (!run) 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`
+      });
+      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
+      });
+      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(
+      stageRecord.workflowRunId,
+      run.workflowType,
+      deps
+    );
+    const logFn = async (level, message, meta) => {
+      await deps.persistence.createLog({
+        workflowRunId: stageRecord.workflowRunId,
+        workflowStageId: stageRecord.id,
+        level,
+        message,
+        metadata: meta
+      }).catch(() => {
+      });
+    };
+    const checkContext = {
+      workflowRunId: run.id,
+      stageId: stageRecord.stageId,
+      stageRecordId: stageRecord.id,
+      config: stageRecord.config || {},
+      log: logFn,
+      onLog: logFn,
+      storage
+    };
+    try {
+      const checkResult = await stageDef.checkCompletion(
+        stageRecord.suspendedState,
+        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()
+        });
+        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) {
+          let validatedOutput = checkResult.output;
+          try {
+            validatedOutput = stageDef.outputSchema.parse(checkResult.output);
+          } catch {
+          }
+          const outputKey = await saveStageOutput(
+            stageRecord.workflowRunId,
+            run.workflowType,
+            stageRecord.stageId,
+            validatedOutput,
+            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
+        });
+        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
+        });
+      }
+    } 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()
+      });
+      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 {
+    checked,
+    resumed,
+    failed,
+    resumedWorkflowRunIds: [...resumedWorkflowRunIds],
+    _events: events
+  };
+}
+
+// src/kernel/kernel.ts
+function getIdempotencyKey(command) {
+  if (command.type === "run.create") return command.idempotencyKey;
+  if (command.type === "job.execute") return command.idempotencyKey;
+  return void 0;
+}
+function createKernel(config) {
+  const {
+    persistence,
+    blobStore,
+    jobTransport,
+    eventSink,
+    scheduler,
+    clock,
+    registry
+  } = config;
+  const deps = {
+    persistence,
+    blobStore,
+    jobTransport,
+    eventSink,
+    scheduler,
+    clock,
+    registry
+  };
+  async function dispatch(command) {
+    if (command.type === "outbox.flush") {
+      const result = await handleOutboxFlush(
+        command,
+        deps
+      );
+      const { _events: _, ...publicResult } = result;
+      return publicResult;
+    }
+    if (command.type === "plugin.replayDLQ") {
+      const result = await handlePluginReplayDLQ(
+        command,
+        deps
+      );
+      const { _events: _, ...publicResult } = result;
+      return publicResult;
+    }
+    const idempotencyKey = getIdempotencyKey(command);
+    let idempotencyAcquired = false;
+    if (idempotencyKey) {
+      const acquired = await persistence.acquireIdempotencyKey(
+        idempotencyKey,
+        command.type
+      );
+      if (acquired.status === "replay") {
+        return acquired.result;
+      }
+      if (acquired.status === "in_progress") {
+        throw new IdempotencyInProgressError(idempotencyKey, command.type);
+      }
+      idempotencyAcquired = true;
+    }
+    try {
+      const publicResult = await persistence.withTransaction(async (tx) => {
+        const txDeps = { ...deps, persistence: tx };
+        let result;
+        switch (command.type) {
+          case "run.create":
+            result = await handleRunCreate(command, txDeps);
+            break;
+          case "run.claimPending":
+            result = await handleRunClaimPending(
+              command,
+              txDeps
+            );
+            break;
+          case "run.transition":
+            result = await handleRunTransition(
+              command,
+              txDeps
+            );
+            break;
+          case "run.cancel":
+            result = await handleRunCancel(command, txDeps);
+            break;
+          case "run.rerunFrom":
+            result = await handleRunRerunFrom(
+              command,
+              txDeps
+            );
+            break;
+          case "job.execute":
+            result = await handleJobExecute(
+              command,
+              txDeps
+            );
+            break;
+          case "stage.pollSuspended":
+            result = await handleStagePollSuspended(
+              command,
+              txDeps
+            );
+            break;
+          case "lease.reapStale":
+            result = await handleLeaseReapStale(
+              command,
+              txDeps
+            );
+            break;
+          default: {
+            const _exhaustive = command;
+            throw new Error(
+              `Unknown command type: ${_exhaustive.type}`
+            );
+          }
+        }
+        const events = result._events;
+        if (events.length > 0) {
+          const causationId = idempotencyKey ?? crypto.randomUUID();
+          const outboxEvents = events.map(
+            (event) => ({
+              workflowRunId: event.workflowRunId,
+              eventType: event.type,
+              payload: event,
+              causationId,
+              occurredAt: event.timestamp
+            })
+          );
+          await tx.appendOutboxEvents(outboxEvents);
+        }
+        const { _events: _, ...stripped } = result;
+        return stripped;
+      });
+      if (idempotencyKey && idempotencyAcquired) {
+        await persistence.completeIdempotencyKey(
+          idempotencyKey,
+          command.type,
+          publicResult
+        );
+      }
+      return publicResult;
+    } catch (error) {
+      if (idempotencyKey && idempotencyAcquired) {
+        await persistence.releaseIdempotencyKey(idempotencyKey, command.type).catch(() => {
+        });
+      }
+      throw error;
+    }
+  }
+  return { dispatch };
+}
+
+// src/kernel/plugins.ts
+function definePlugin(definition) {
+  return definition;
+}
+function createPluginRunner(config) {
+  const { plugins, maxRetries = 3 } = config;
+  const handlersByType = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    for (const eventType of plugin.on) {
+      const existing = handlersByType.get(eventType) ?? [];
+      existing.push(plugin);
+      handlersByType.set(eventType, existing);
+    }
+  }
+  return {
+    maxRetries,
+    async emit(event) {
+      const matching = handlersByType.get(event.type);
+      if (!matching || matching.length === 0) return;
+      for (const plugin of matching) {
+        await plugin.handle(event);
+      }
+    }
+  };
+}
+
+export { IdempotencyInProgressError, createKernel, createPluginRunner, definePlugin, loadWorkflowContext, saveStageOutput };
+//# sourceMappingURL=chunk-HL3OJG7W.js.map
+//# sourceMappingURL=chunk-HL3OJG7W.js.map