@sixb/pipeline-worker 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,11 +1,16 @@
 // @bun
 // src/worker.ts
 import { reportRunFailure } from "@sixb/core/internal/error-reporting";
+import { bindDurablePrimitiveExecution } from "@sixb/core/internal/primitive-execution";
 import { QueueWorker } from "@sixb/core/internal/workers";
+import { PIPELINE_RUN_FAILURE_CODES as PIPELINE_RUN_FAILURE_CODES3 } from "@sixb/core/storage";
 
 // src/events.ts
 var SOURCE = "SixbPipelineWorker";
-async function emitPipelineRunStarted(events, run) {
+async function emitPipelineRunStarted(events, run, correlationId) {
+  if (!run.startedAt) {
+    throw new Error(`[SixbPipelineWorker] Pipeline run '${run.id}' started without a timestamp.`);
+  }
   await events?.emit({
     events: [
       {
@@ -16,10 +21,11 @@ async function emitPipelineRunStarted(events, run) {
           startedAt: run.startedAt.toISOString()
         }
       }
-    ]
+    ],
+    correlationId
   }, { source: SOURCE });
 }
-async function emitPipelineRunStepStarted(events, step, context) {
+async function emitPipelineRunStepStarted(events, step, context, correlationId) {
   await events?.emit({
     events: [
       {
@@ -35,10 +41,11 @@ async function emitPipelineRunStepStarted(events, step, context) {
           startedAt: step.startedAt.toISOString()
         }
       }
-    ]
+    ],
+    correlationId
   }, { source: SOURCE });
 }
-async function emitPipelineRunStepFinished(events, step, context) {
+async function emitPipelineRunStepFinished(events, step, context, correlationId) {
   await events?.emit({
     events: [
       {
@@ -55,13 +62,14 @@ async function emitPipelineRunStepFinished(events, step, context) {
           finishedAt: requireFinishedAt(step.id, step.finishedAt).toISOString(),
           ...step.output ? { versionId: step.output.versionId } : {},
           ...step.rowsWritten !== undefined ? { rowsWritten: step.rowsWritten } : {},
-          ...step.error ? { error: step.error.message } : {}
+          ...step.error ? { error: step.error } : {}
         }
       }
-    ]
+    ],
+    correlationId
   }, { source: SOURCE });
 }
-async function emitDatasetVersionCommitted(events, job, step) {
+async function emitDatasetVersionCommitted(events, job, step, correlationId) {
   if (!step.versionCreated)
     return;
   await events?.emit({
@@ -80,21 +88,26 @@ async function emitDatasetVersionCommitted(events, job, step) {
           }
         }
       }
-    ]
+    ],
+    correlationId
   }, { source: SOURCE });
 }
-async function emitPipelineRunFinished(events, job) {
-  await events?.emit({ events: [{ type: "pipeline.run.finished", payload: buildPipelineRunFinishedPayload(job) }] }, { source: SOURCE });
+async function emitPipelineRunFinished(events, run, correlationId) {
+  await events?.emit({
+    events: [{ type: "pipeline.run.finished", payload: buildPipelineRunFinishedPayload(run) }],
+    correlationId
+  }, { source: SOURCE });
 }
-function buildPipelineRunFinishedPayload(job) {
+function buildPipelineRunFinishedPayload(run) {
   return {
-    pipelineId: job.pipelineId,
-    runId: job.id,
-    status: job.status,
-    ...job.datasetId && job.versionId ? {
-      datasetId: job.datasetId,
-      versionId: job.versionId
-    } : {}
+    pipelineId: run.pipelineId,
+    runId: run.id,
+    status: requireTerminalStatus(run.status, `Pipeline run '${run.id}'`),
+    ...run.output ? {
+      datasetId: run.output.datasetId,
+      versionId: run.output.versionId
+    } : {},
+    ...run.error ? { error: run.error } : {}
   };
 }
 function requireFinishedAt(stepRunId, finishedAt) {
@@ -104,30 +117,19 @@ function requireFinishedAt(stepRunId, finishedAt) {
   throw new Error(`[SixbPipelineWorker] Pipeline step run '${stepRunId}' has no finishedAt.`);
 }
 function requireTerminalStatus(status, context) {
-  if (status === "running") {
+  if (status === "queued" || status === "running") {
     throw new Error(`[SixbPipelineWorker] ${context} is still running.`);
   }
   return status;
 }
 
 // src/run-pipeline-job.ts
-import { resolveLogsRuntime } from "@sixb/core/internal/logging";
+import { captureSixbFailure as captureSixbFailure2 } from "@sixb/core/internal/errors";
+import { resolveLoggingService } from "@sixb/core/internal/logging";
+import { PIPELINE_RUN_FAILURE_CODES as PIPELINE_RUN_FAILURE_CODES2 } from "@sixb/core/storage";
 
 // src/errors.ts
-class PipelineWorkerError extends Error {
-  name = "PipelineWorkerError";
-}
-function toPipelineRunFailure(error) {
-  if (error instanceof Error) {
-    return {
-      name: error.name,
-      message: error.message
-    };
-  }
-  return {
-    message: String(error)
-  };
-}
+import { createSixbError, isSixbError, summarizeErrorMessage } from "@sixb/core/internal/errors";
 function throwIfAborted(signal) {
   if (signal.aborted) {
     throw createAbortError();
@@ -136,21 +138,53 @@ function throwIfAborted(signal) {
 function statusForFailure(signal, error) {
   return signal.aborted || isAbortError(error) ? "cancelled" : "failed";
 }
-function requireFinishedAt2(runId, finishedAt) {
-  if (finishedAt) {
-    return finishedAt;
+function requireFinishedAt2(input) {
+  if (input.finishedAt) {
+    return input.finishedAt;
   }
-  throw new PipelineWorkerError(`[SixbPipelineWorker] Pipeline run '${runId}' finished without a finishedAt timestamp.`);
+  throw createSixbError("internal.unexpected", `[SixbPipelineWorker] Pipeline run '${input.runId}' finished without a finishedAt timestamp.`, { details: { pipelineId: input.pipelineId, runId: input.runId } });
 }
 function createStepBookkeepingError(options) {
-  return new PipelineWorkerError(`[SixbPipelineWorker] Pipeline '${options.pipelineId}' step '${options.stepId}' committed dataset version '${options.version.versionId}', but failed to finalize step run '${options.runId}'. The dataset commit may already have succeeded and the step run record may need repair.`, { cause: options.cause });
+  return createSixbError("internal.unexpected", `[SixbPipelineWorker] Pipeline '${options.pipelineId}' step '${options.stepId}' committed dataset version '${options.version.versionId}', but failed to finalize step run '${options.stepRunId}'. The dataset commit may already have succeeded and the step run record may need repair.`, {
+    cause: options.cause,
+    details: {
+      pipelineId: options.pipelineId,
+      pipelineRunId: options.pipelineRunId,
+      stepId: options.stepId,
+      stepRunId: options.stepRunId,
+      datasetId: options.version.datasetId,
+      versionId: options.version.versionId
+    }
+  });
+}
+function createPipelineStepFailure(options) {
+  return createSixbError("pipeline.step_failed", summarizeErrorMessage(options.cause, "Pipeline step execution failed."), {
+    cause: options.cause,
+    details: {
+      pipelineId: options.pipelineId,
+      pipelineRunId: options.pipelineRunId,
+      stepId: options.stepId,
+      ...options.stepRunId ? { stepRunId: options.stepRunId } : {}
+    }
+  });
+}
+function unwrapPipelineStepFailure(error) {
+  return isSixbError(error) && error.code === "pipeline.step_failed" && error.cause !== undefined ? error.cause : error;
 }
 function createPipelineBookkeepingError(options) {
-  return new PipelineWorkerError(`[SixbPipelineWorker] Pipeline '${options.pipelineId}' committed final dataset version '${options.version.versionId}', but failed to finalize pipeline run '${options.runId}'. The dataset commit may already have succeeded and the pipeline run record may need repair.`, { cause: options.cause });
+  return createSixbError("internal.unexpected", `[SixbPipelineWorker] Pipeline '${options.pipelineId}' committed final dataset version '${options.version.versionId}', but failed to finalize pipeline run '${options.runId}'. The dataset commit may already have succeeded and the pipeline run record may need repair.`, {
+    cause: options.cause,
+    details: {
+      pipelineId: options.pipelineId,
+      runId: options.runId,
+      datasetId: options.version.datasetId,
+      versionId: options.version.versionId
+    }
+  });
 }
 function requirePipeline(pipeline, job) {
   if (!pipeline) {
-    throw new PipelineWorkerError(`[SixbPipelineWorker] Unknown pipeline '${job.pipelineId}'.`);
+    throw createSixbError("internal.unexpected", `[SixbPipelineWorker] Unknown pipeline '${job.pipelineId}'.`, { details: { pipelineId: job.pipelineId, runId: job.id } });
   }
   return pipeline;
 }
@@ -159,7 +193,14 @@ function requireRegisteredDataset(options) {
     return options.dataset;
   }
   const namedRole = options.role === "input" ? `input '${options.name ?? "unknown"}'` : "output";
-  throw new PipelineWorkerError(`[SixbPipelineWorker] Pipeline '${options.pipelineId}' step '${options.stepId}' ${namedRole} references unknown dataset '${options.datasetId}'.`);
+  throw createSixbError("internal.unexpected", `[SixbPipelineWorker] Pipeline '${options.pipelineId}' step '${options.stepId}' ${namedRole} references unknown dataset '${options.datasetId}'.`, {
+    details: {
+      pipelineId: options.pipelineId,
+      pipelineRunId: options.pipelineRunId,
+      stepId: options.stepId,
+      datasetId: options.datasetId
+    }
+  });
 }
 function createAbortError() {
   const error = new Error("Worker runtime aborted.");
@@ -170,14 +211,23 @@ function isAbortError(error) {
   return error instanceof Error && error.name === "AbortError";
 }
 
+// src/run-step.ts
+import { captureSixbFailure } from "@sixb/core/internal/errors";
+import { PIPELINE_RUN_FAILURE_CODES } from "@sixb/core/storage";
+
+// src/execute-run-step.ts
+import { createSixbError as createSixbError3 } from "@sixb/core/internal/errors";
+
 // src/step-inputs.ts
+import { createSixbError as createSixbError2 } from "@sixb/core/internal/errors";
 async function resolveStepInputs(input) {
-  const { runtime, pipeline, step } = input;
+  const { runtime, pipeline, step, pipelineRunId } = input;
   const resolved = [];
   for (const [name, declaredDataset] of Object.entries(step.inputs)) {
     const dataset = requireRegisteredDataset({
-      dataset: runtime.getDatasetById(declaredDataset.id),
+      dataset: runtime.datasets.getById(declaredDataset.id),
       pipelineId: pipeline.id,
+      pipelineRunId,
       stepId: step.id,
       role: "input",
       name,
@@ -185,7 +235,14 @@ async function resolveStepInputs(input) {
     });
     const version = await runtime.lakeStorage.getLatestVersion(dataset.id);
     if (!version) {
-      throw new PipelineWorkerError(`[SixbPipelineWorker] Pipeline '${pipeline.id}' step '${step.id}' input '${name}' dataset '${dataset.id}' has no committed version.`);
+      throw createSixbError2("internal.unexpected", `[SixbPipelineWorker] Pipeline '${pipeline.id}' step '${step.id}' input '${name}' dataset '${dataset.id}' has no committed version.`, {
+        details: {
+          pipelineId: pipeline.id,
+          pipelineRunId,
+          stepId: step.id,
+          datasetId: dataset.id
+        }
+      });
     }
     resolved.push({
       name,
@@ -221,7 +278,14 @@ function createStepInputs(lakeStorage, resolved) {
 async function executeRunStep(input) {
   const { runtime, pipeline, step, job, signal, outputDataset, resolvedInputs } = input;
   if (step.executor.kind !== "run") {
-    throw new PipelineWorkerError(`[SixbPipelineWorker] Pipeline '${pipeline.id}' step '${step.id}' uses SQL execution, which is not supported by the run step executor.`);
+    throw createSixbError3("internal.unexpected", `[SixbPipelineWorker] Pipeline '${pipeline.id}' step '${step.id}' uses SQL execution, which is not supported by the run step executor.`, {
+      details: {
+        pipelineId: pipeline.id,
+        pipelineRunId: job.id,
+        stepId: step.id,
+        datasetId: outputDataset.id
+      }
+    });
   }
   const logger = input.logSession.withContext({ stepId: step.id });
   let rowsWritten = 0;
@@ -278,6 +342,7 @@ async function* countRowsWritten(rows, signal, onWritten) {
 }
 
 // src/execute-sql-step.ts
+import { createSixbError as createSixbError4 } from "@sixb/core/internal/errors";
 function hasSqlExecutor(lakeStorage) {
   const sql = "sql" in lakeStorage ? lakeStorage.sql : null;
   return typeof sql === "object" && sql !== null && "execute" in sql && typeof sql.execute === "function";
@@ -286,22 +351,45 @@ function assertSqlModeSupported(input) {
   const supported = input.mode === "append" ? input.capabilities.supportsAppend : input.capabilities.supportsSnapshot;
   if (supported)
     return;
-  throw new PipelineWorkerError(`[SixbPipelineWorker] Pipeline '${input.pipelineId}' step '${input.stepId}' writes in ` + `'${input.mode}' mode, which the ${input.dialect} SQL executor does not support.`);
+  throw createSixbError4("internal.unexpected", `[SixbPipelineWorker] Pipeline '${input.pipelineId}' step '${input.stepId}' writes in ` + `'${input.mode}' mode, which the ${input.dialect} SQL executor does not support.`, {
+    details: {
+      pipelineId: input.pipelineId,
+      pipelineRunId: input.pipelineRunId,
+      stepId: input.stepId,
+      datasetId: input.datasetId
+    }
+  });
 }
 async function executeSqlStep(input) {
   const { runtime, pipeline, step, job, signal, outputDataset, resolvedInputs } = input;
   if (step.executor.kind !== "sql") {
-    throw new PipelineWorkerError(`[SixbPipelineWorker] Pipeline '${pipeline.id}' step '${step.id}' uses run execution, which is not supported by the SQL step executor.`);
+    throw createSixbError4("internal.unexpected", `[SixbPipelineWorker] Pipeline '${pipeline.id}' step '${step.id}' uses run execution, which is not supported by the SQL step executor.`, {
+      details: {
+        pipelineId: pipeline.id,
+        pipelineRunId: job.id,
+        stepId: step.id,
+        datasetId: outputDataset.id
+      }
+    });
   }
   if (!hasSqlExecutor(runtime.lakeStorage)) {
-    throw new PipelineWorkerError(`[SixbPipelineWorker] Pipeline '${pipeline.id}' step '${step.id}' requires SQL transform support, but lake storage does not provide lakeStorage.sql.execute(...).`);
+    throw createSixbError4("internal.unexpected", `[SixbPipelineWorker] Pipeline '${pipeline.id}' step '${step.id}' requires SQL transform support, but lake storage does not provide lakeStorage.sql.execute(...).`, {
+      details: {
+        pipelineId: pipeline.id,
+        pipelineRunId: job.id,
+        stepId: step.id,
+        datasetId: outputDataset.id
+      }
+    });
   }
   assertSqlModeSupported({
     capabilities: runtime.lakeStorage.sql.capabilities,
     dialect: runtime.lakeStorage.sql.dialect,
     mode: step.mode,
     pipelineId: pipeline.id,
-    stepId: step.id
+    pipelineRunId: job.id,
+    stepId: step.id,
+    datasetId: outputDataset.id
   });
   throwIfAborted(signal);
   const commit = await runtime.lakeStorage.sql.execute({
@@ -340,16 +428,36 @@ async function runStep(input) {
     totalSteps: pipeline.graph.nodes.length
   };
   throwIfAborted(signal);
-  const resolvedInputs = await resolveStepInputs({ runtime, pipeline, step });
+  let resolvedInputs;
+  let outputDataset;
+  try {
+    resolvedInputs = await resolveStepInputs({
+      runtime,
+      pipeline,
+      step,
+      pipelineRunId: job.id
+    });
+    outputDataset = requireRegisteredDataset({
+      dataset: runtime.datasets.getById(step.output.id),
+      pipelineId: pipeline.id,
+      pipelineRunId: job.id,
+      stepId: step.id,
+      role: "output",
+      datasetId: step.output.id
+    });
+    await runtime.lakeStorage.createDataset(outputDataset);
+  } catch (error) {
+    if (statusForFailure(signal, error) === "failed") {
+      throw createPipelineStepFailure({
+        pipelineId: pipeline.id,
+        pipelineRunId: job.id,
+        stepId: step.id,
+        cause: error
+      });
+    }
+    throw error;
+  }
   const inputRefs = resolvedInputs.map((resolved) => resolved.ref);
-  const outputDataset = requireRegisteredDataset({
-    dataset: runtime.getDatasetById(step.output.id),
-    pipelineId: pipeline.id,
-    stepId: step.id,
-    role: "output",
-    datasetId: step.output.id
-  });
-  await runtime.lakeStorage.createDataset(outputDataset);
   const stepRunId = `${job.id}:step:${stepIndex + 1}:${step.id}`;
   const startedStepRun = await runtime.pipelineRunsStorage.startStep({
     projectId: runtime.id,
@@ -392,8 +500,9 @@ async function runStep(input) {
     } catch (error) {
       throw createStepBookkeepingError({
         pipelineId: pipeline.id,
+        pipelineRunId: job.id,
         stepId: step.id,
-        runId: stepRunId,
+        stepRunId,
         version: committedVersion,
         cause: error
       });
@@ -406,16 +515,34 @@ async function runStep(input) {
     };
   } catch (error) {
     if (!committedVersion) {
+      const status = statusForFailure(signal, error);
+      const failureError = status === "failed" ? createPipelineStepFailure({
+        pipelineId: pipeline.id,
+        pipelineRunId: job.id,
+        stepId: step.id,
+        stepRunId,
+        cause: error
+      }) : error;
       const failedStepRun = await runtime.pipelineRunsStorage.finishStep({
         projectId: runtime.id,
         id: stepRunId,
-        status: statusForFailure(signal, error),
+        status,
         rowsWritten,
-        error: toPipelineRunFailure(error)
+        error: captureSixbFailure(failureError, {
+          allowedCodes: PIPELINE_RUN_FAILURE_CODES,
+          defaultCode: status === "cancelled" ? "runtime.cancelled" : "internal.unexpected",
+          details: {
+            pipelineId: pipeline.id,
+            pipelineRunId: job.id,
+            stepId: step.id,
+            stepRunId
+          }
+        })
       }).catch(() => null);
       if (failedStepRun) {
         await input.onStepFinished?.(failedStepRun, lifecycleContext);
       }
+      throw failureError;
     }
     throw error;
   }
@@ -439,10 +566,13 @@ class PipelineRunAlreadyStartedError extends Error {
   }
 }
 async function runPipelineJob(input) {
-  const { runtime, job } = input;
+  const { runtime, run: durableRun } = input;
+  const job = { id: durableRun.id, pipelineId: durableRun.pipelineId };
   const signal = input.signal ?? new AbortController().signal;
-  const pipeline = requirePipeline(runtime.getPipelineById(job.pipelineId), job);
-  const logSession = resolveLogsRuntime(runtime.id, runtime.logs).startExecution({
+  if (durableRun.projectId !== runtime.id) {
+    throw new Error(`[SixbPipelineWorker] Pipeline run '${durableRun.id}' belongs to project '${durableRun.projectId}', not '${runtime.id}'.`);
+  }
+  const logSession = resolveLoggingService(runtime.id, runtime.logging).startExecution({
     kind: "pipeline",
     id: job.id
   });
@@ -455,20 +585,20 @@ async function runPipelineJob(input) {
     try {
       startedRun = await runtime.pipelineRunsStorage.start({
         projectId: runtime.id,
-        id: job.id,
-        pipelineId: pipeline.id
+        id: job.id
       });
     } catch (error) {
       const existing = await runtime.pipelineRunsStorage.getById({
         projectId: runtime.id,
         id: job.id
       });
-      if (existing?.pipelineId === pipeline.id) {
+      if (existing?.pipelineId === durableRun.pipelineId && existing.executionId === durableRun.executionId) {
         throw new PipelineRunAlreadyStartedError(existing);
       }
       throw error;
     }
     await input.onRunStarted?.(startedRun);
+    const pipeline = requirePipeline(runtime.pipelines.getById(job.pipelineId), job);
     for (const [stepIndex, node] of pipeline.graph.nodes.entries()) {
       const stepResult = await runStep({
         runtime,
@@ -507,135 +637,160 @@ async function runPipelineJob(input) {
       }
       throw error;
     }
+    const finishedRun = {
+      ...run,
+      finishedAt: requireFinishedAt2({
+        pipelineId: pipeline.id,
+        runId: job.id,
+        finishedAt: run.finishedAt
+      })
+    };
     finished = true;
+    await notifyRunFinished(input.onRunFinished, finishedRun);
     return {
-      run: {
-        ...run,
-        finishedAt: requireFinishedAt2(job.id, run.finishedAt)
-      },
+      run: finishedRun,
       steps,
       version: finalVersion
     };
   } catch (error) {
+    const reportedError = unwrapPipelineStepFailure(error);
     if (startedRun && !finished) {
       const status = statusForFailure(signal, error);
       try {
+        const failure = captureSixbFailure2(error, {
+          allowedCodes: PIPELINE_RUN_FAILURE_CODES2,
+          defaultCode: status === "cancelled" ? "runtime.cancelled" : "internal.unexpected",
+          details: { pipelineId: durableRun.pipelineId, runId: job.id }
+        });
         const run = await runtime.pipelineRunsStorage.finish({
           projectId: runtime.id,
           id: job.id,
           status,
-          error: toPipelineRunFailure(error)
+          error: failure
         });
-        if (status === "failed" && run.status === "failed")
-          input.onRunFailed?.(error, run);
+        if (status === "failed" && run.status === "failed") {
+          input.onRunFailed?.(reportedError, run, failure);
+        }
+        await notifyRunFinished(input.onRunFinished, run);
       } catch {}
     }
-    throw error;
+    throw reportedError;
   } finally {
     await logSession.flush();
   }
 }
+async function notifyRunFinished(handler, run) {
+  try {
+    await handler?.(run);
+  } catch (error) {
+    console.error("[SixbPipelineWorker] Pipeline run lifecycle handler failed:", error);
+  }
+}
 
 // src/worker.ts
 class PipelineWorker extends QueueWorker {
   context;
-  sixb;
-  constructor(sixb) {
-    if (sixb.listPipelines().length === 0) {
+  host;
+  constructor(host, options = {}) {
+    if (host.definitions.pipelines.list().length === 0) {
       throw new Error("[SixbPipelineWorker] No pipeline definitions are registered.");
     }
-    const pipelineRunsStorage = sixb.storage.pipelineRuns;
+    const pipelineRunsStorage = host.storage.pipelineRuns;
     if (!pipelineRunsStorage) {
       throw new Error("[SixbPipelineWorker] Pipeline workers require storage.pipelineRuns support.");
     }
     super({
-      projectId: sixb.id,
-      queue: sixb.queues.pipelines,
-      workerId: `pipeline-worker-${sixb.id}`
+      projectId: host.id,
+      queue: host.queues.pipelines,
+      failureCodes: PIPELINE_RUN_FAILURE_CODES3,
+      workerId: `pipeline-worker-${host.id}`,
+      claimLimit: options.concurrency
     });
-    this.context = buildPipelineContext(sixb, pipelineRunsStorage);
-    this.sixb = sixb;
+    this.context = buildPipelineContext(host, pipelineRunsStorage);
+    this.host = host;
   }
   async execute(claimed, signal) {
     const { job } = claimed;
+    const pipelineRuns = this.host.storage.pipelineRuns;
+    if (!pipelineRuns) {
+      throw new Error("[SixbPipelineWorker] Pipeline workers require storage.pipelineRuns support.");
+    }
+    const run = await pipelineRuns.getById({ projectId: this.host.id, id: job.payload.runId });
+    if (!run) {
+      throw new Error(`[SixbPipelineWorker] Pipeline run '${job.payload.runId}' was not found.`);
+    }
+    const durableExecution = await this.host.storage.executions.getById({
+      projectId: this.host.id,
+      id: run.executionId
+    });
+    if (!durableExecution) {
+      throw new Error(`[SixbPipelineWorker] Pipeline run '${run.id}' references missing execution '${run.executionId}'.`);
+    }
     const pipelineJob = {
-      id: job.payload.runId ?? `${job.id}:attempt:${job.attempt}`,
-      pipelineId: job.payload.pipelineId
+      id: run.id,
+      pipelineId: run.pipelineId
     };
-    let result;
+    bindDurablePrimitiveExecution(this.host, {
+      execution: durableExecution,
+      primitive: { kind: "pipeline", id: run.pipelineId, runId: run.id }
+    });
     try {
-      result = await runPipelineJob({
+      await runPipelineJob({
         runtime: this.context,
-        job: pipelineJob,
+        run,
         signal,
-        onRunStarted: (run) => emitPipelineRunStarted(this.sixb.events, run),
-        onRunFailed: (error, run) => {
-          reportRunFailure(this.sixb, error, {
-            projectId: this.sixb.id,
-            occurredAt: run.finishedAt,
+        onRunStarted: (run2) => emitPipelineRunStarted(this.host.events, run2, durableExecution.correlationId),
+        onRunFinished: (run2) => emitPipelineRunFinished(this.host.events, run2, durableExecution.correlationId),
+        onRunFailed: (error, run2, failure) => {
+          reportRunFailure(this.host, error, {
+            projectId: this.host.id,
             attempt: job.attempt,
+            runKind: "pipeline",
             run: {
-              kind: "pipeline",
-              runId: run.id,
-              pipelineId: run.pipelineId
-            }
+              runId: run2.id,
+              pipelineId: run2.pipelineId
+            },
+            failure
           });
         },
-        onStepStarted: (step, context) => emitPipelineRunStepStarted(this.sixb.events, step, context),
-        onStepFinished: (step, context) => emitPipelineRunStepFinished(this.sixb.events, step, context),
-        onStepCommitted: (step) => emitDatasetVersionCommitted(this.sixb.events, pipelineJob, step)
+        onStepStarted: (step, context) => emitPipelineRunStepStarted(this.host.events, step, context, durableExecution.correlationId),
+        onStepFinished: (step, context) => emitPipelineRunStepFinished(this.host.events, step, context, durableExecution.correlationId),
+        onStepCommitted: (step) => emitDatasetVersionCommitted(this.host.events, pipelineJob, step, durableExecution.correlationId)
       });
     } catch (error) {
       if (error instanceof PipelineRunAlreadyStartedError)
         return;
       throw error;
     }
-    await emitPipelineRunFinished(this.sixb.events, {
-      id: pipelineJob.id,
-      pipelineId: pipelineJob.pipelineId,
-      status: "succeeded",
-      datasetId: result.version?.datasetId,
-      versionId: result.version?.versionId
-    });
   }
   async onExecutionError(claimed, _error) {
-    const { job } = claimed;
-    await emitPipelineRunFinished(this.sixb.events, {
-      id: job.payload.runId ?? `${job.id}:attempt:${job.attempt}`,
-      pipelineId: job.payload.pipelineId,
-      status: "failed"
+    const run = await this.host.storage.pipelineRuns?.getById({
+      projectId: this.host.id,
+      id: claimed.job.payload.runId
     });
-    return { kind: "fail" };
+    return run?.status === "failed" && run.error ? { kind: "fail", failure: run.error } : { kind: "fail" };
   }
   async onAbortError(claimed, _error) {
-    const { job } = claimed;
-    const pipelineJob = {
-      id: job.payload.runId ?? `${job.id}:attempt:${job.attempt}`,
-      pipelineId: job.payload.pipelineId
-    };
-    if (!await hasCommittedStep(this.context, pipelineJob.id)) {
+    const run = await this.host.storage.pipelineRuns?.getById({
+      projectId: this.host.id,
+      id: claimed.job.payload.runId
+    });
+    if (!run)
+      return { kind: "fail" };
+    if (!await hasCommittedStep(this.context, run.id)) {
       return { kind: "retry" };
     }
-    await emitPipelineRunFinished(this.sixb.events, {
-      id: pipelineJob.id,
-      pipelineId: pipelineJob.pipelineId,
-      status: "cancelled"
-    });
-    return { kind: "fail" };
+    return run.status === "cancelled" && run.error ? { kind: "fail", failure: run.error } : { kind: "fail" };
   }
 }
-function buildPipelineContext(sixb, pipelineRunsStorage) {
+function buildPipelineContext(host, pipelineRunsStorage) {
   return {
-    id: sixb.id,
+    id: host.id,
     pipelineRunsStorage,
-    lakeStorage: sixb.lakeStorage,
-    logs: sixb.logs,
-    getPipelineById(pipelineId) {
-      return sixb.getPipelineById(pipelineId);
-    },
-    getDatasetById(datasetId) {
-      return sixb.getDatasetById(datasetId);
-    }
+    lakeStorage: host.lakeStorage,
+    logging: host.logging,
+    pipelines: host.definitions.pipelines,
+    datasets: host.definitions.datasets
   };
 }
 async function hasCommittedStep(context, pipelineRunId) {
@@ -651,4 +806,4 @@ export {
   PipelineWorker
 };
 
-//# debugId=068611D3BE49C18D64756E2164756E21
+//# debugId=DD983D45D23B0E1464756E2164756E21