@sixb/core 0.1.1 → 0.1.3

package/src/testing/projection-run-storage-contract.ts

@@ -1,19 +1,46 @@
 import { describe, expect, test } from "bun:test"
+import type { SixbFailure } from "../errors/types"
 import type { ProjectionMaterializationIdentity } from "../materialization/model"
-import type { ProjectionRunClaim, ProjectionRunStorage } from "../storage/projection-runs"
+import type { ExecutionStorage } from "../storage/executions"
+import type {
+  ProjectionRunClaim,
+  ProjectionRunFailureCode,
+  ProjectionRunStorage,
+  QueueProjectionRunInput,
+  StartOrReclaimProjectionRunInput,
+} from "../storage/projection-runs"
+
+export interface ProjectionRunStorageContractContext<
+  TStorage extends ProjectionRunStorage = ProjectionRunStorage,
+> {
+  readonly projectionRuns: TStorage
+  readonly executions: ExecutionStorage
+}
 
 export interface ProjectionRunStorageContractSuiteOptions<
   TStorage extends ProjectionRunStorage = ProjectionRunStorage,
 > {
-  /** Factory that returns an isolated projection-run store for each test. */
-  readonly createStorage: () => TStorage | Promise<TStorage>
-  readonly setup?: (storage: TStorage) => void | Promise<void>
-  readonly cleanup?: (storage: TStorage) => void | Promise<void>
+  /** Factory that returns one isolated execution + projection-run store for each test. */
+  readonly createStorage: () =>
+    | ProjectionRunStorageContractContext<TStorage>
+    | Promise<ProjectionRunStorageContractContext<TStorage>>
+  readonly setup?: (context: ProjectionRunStorageContractContext<TStorage>) => void | Promise<void>
+  readonly cleanup?: (
+    context: ProjectionRunStorageContractContext<TStorage>
+  ) => void | Promise<void>
 }
 
 const projectId = "contract-project"
 const objectTarget = { objectTypeId: "Device" } as const
 
+const failure = {
+  code: "internal.unexpected",
+  message: "Projection failed",
+  retryable: false,
+  at: "2026-06-01T12:00:00.000Z",
+  details: { projectionId: "contract.devices", runId: "failed-run" },
+} as const satisfies SixbFailure<ProjectionRunFailureCode>
+
 const replacementIdentity = {
   projectionId: "contract.devices",
   projectionKind: "object",
@@ -47,20 +74,94 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
   label: string,
   options: ProjectionRunStorageContractSuiteOptions<TStorage>
 ): void {
-  const withStorage = async (body: (storage: TStorage) => Promise<void>): Promise<void> => {
-    const storage = await options.createStorage()
+  const withStorage = async (
+    body: (context: ProjectionRunStorageContractContext<TStorage>) => Promise<void>
+  ): Promise<void> => {
+    const context = await options.createStorage()
     try {
-      await options.setup?.(storage)
-      await body(storage)
+      await options.setup?.(context)
+      await body(context)
     } finally {
-      await options.cleanup?.(storage)
+      await options.cleanup?.(context)
     }
   }
 
   describe(label, () => {
+    test("admits a queued run only after its durable execution exists", async () => {
+      await withStorage(async (context) => {
+        const input = replacementInput("queued-run")
+        await expect(
+          context.projectionRuns.queue({
+            ...input,
+            executionId: "missing-execution",
+          })
+        ).rejects.toThrow()
+
+        const wrongSourceExecutionId = "execution:wrong-source"
+        await context.executions.create({
+          id: wrongSourceExecutionId,
+          projectId: input.projectId,
+          executor: { type: "primitive", kind: "projection", runId: input.id },
+          source: { type: "event", eventId: "wrong-source" },
+          correlationId: input.id,
+          authorizationRef: {
+            type: "trustedPrimitive",
+            primitive: { kind: "projection", id: input.identity.projectionId, runId: input.id },
+          },
+        })
+        await expect(
+          context.projectionRuns.queue({
+            ...input,
+            executionId: wrongSourceExecutionId,
+          })
+        ).rejects.toThrow("does not authorize Projection run")
+
+        const admission = await admitProjectionRun(context, input)
+        await expect(
+          context.projectionRuns.getById({ projectId: input.projectId, id: input.id })
+        ).resolves.toMatchObject({
+          id: input.id,
+          executionId: admission.executionId,
+          status: "queued",
+          attempt: 0,
+        })
+      })
+    })
+
+    test("requeues the same admission after an enqueue failure", async () => {
+      await withStorage(async (context) => {
+        const input = replacementInput("enqueue-retry-run")
+        const admission = await admitProjectionRun(context, input)
+        await expect(
+          context.projectionRuns.failEnqueue({
+            id: input.id,
+            projectId: input.projectId,
+            error: {
+              code: "queue.enqueue_failed",
+              message: "queue unavailable",
+              retryable: true,
+              at: "2026-06-01T12:00:00.000Z",
+              details: { projectionId: input.identity.projectionId, runId: input.id },
+            },
+          })
+        ).resolves.toMatchObject({
+          status: "failed",
+          error: { code: "queue.enqueue_failed", message: "queue unavailable" },
+        })
+
+        await expect(context.projectionRuns.queue(admission)).resolves.toMatchObject({
+          executionId: admission.executionId,
+          status: "queued",
+          attempt: 0,
+        })
+      })
+    })
+
     test("keeps one run while reclaim rotates its execution", async () => {
-      await withStorage(async (storage) => {
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns
         const input = replacementInput("replacement-run")
+        await admitProjectionRun(context, input)
         const first = await storage.startOrReclaim(input)
         const second = await storage.startOrReclaim(input)
 
@@ -77,8 +178,10 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
     })
 
     test("fences every stale lock, progress, and terminal write", async () => {
-      await withStorage(async (storage) => {
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns
         const input = replacementInput("fenced-run")
+        await admitProjectionRun(context, input)
         const stale = await storage.startOrReclaim(input)
         const current = await storage.startOrReclaim(input)
 
@@ -109,8 +212,10 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
     })
 
     test("rejects immutable identity and target drift", async () => {
-      await withStorage(async (storage) => {
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns
         const input = replacementInput("identity-run")
+        await admitProjectionRun(context, input)
         const claim = await storage.startOrReclaim(input)
         const changedIdentity = { ...replacementIdentity, ownershipHash: "different-ownership" }
 
@@ -130,7 +235,9 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
     })
 
     test("keeps physical progress monotone and internally consistent", async () => {
-      await withStorage(async (storage) => {
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns
+        await admitProjectionRun(context, replacementInput("progress-run"))
         const claim = await storage.startOrReclaim(replacementInput("progress-run"))
         const execution = executionInput(claim)
         await expect(
@@ -150,10 +257,10 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
     })
 
     test("rejects immutable dataset-version metadata reuse", async () => {
-      await withStorage(async (storage) => {
-        await storage.startOrReclaim(replacementInput("dataset-metadata-first"))
+      await withStorage(async (context) => {
+        await admitProjectionRun(context, replacementInput("dataset-metadata-first"))
         await expect(
-          storage.startOrReclaim({
+          admitProjectionRun(context, {
             ...replacementInput("dataset-metadata-conflict"),
             identity: {
               ...replacementIdentity,
@@ -168,14 +275,17 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
     })
 
     test("advances telemetry in contiguous fixed physical batches", async () => {
-      await withStorage(async (storage) => {
-        const claim = await storage.startOrReclaim({
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns
+        const input = {
           id: "telemetry-run",
           projectId,
           identity: telemetryIdentity,
           target: objectTarget,
           fixedBatchSize: 3,
-        })
+        } as const
+        await admitProjectionRun(context, input)
+        const claim = await storage.startOrReclaim(input)
         const execution = executionInput(claim)
         expect(claim.run).toMatchObject({
           telemetryCheckpoint: {
@@ -230,14 +340,17 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
     })
 
     test("keeps a missing target until the batch it blocks commits", async () => {
-      await withStorage(async (storage) => {
-        const claim = await storage.startOrReclaim({
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns
+        const input = {
           id: "telemetry-missing-target-run",
           projectId,
           identity: telemetryIdentity,
           target: objectTarget,
           fixedBatchSize: 2,
-        })
+        } as const
+        await admitProjectionRun(context, input)
+        const claim = await storage.startOrReclaim(input)
         const execution = executionInput(claim)
         const firstSeenAt = new Date("2026-06-01T12:00:00.000Z")
         const missingTarget = {
@@ -307,14 +420,17 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
     })
 
     test("requires and records explicit telemetry EOF with terminal success", async () => {
-      await withStorage(async (storage) => {
-        const claim = await storage.startOrReclaim({
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns
+        const input = {
           id: "empty-telemetry-run",
           projectId,
           identity: telemetryIdentity,
           target: objectTarget,
           fixedBatchSize: 10,
-        })
+        } as const
+        await admitProjectionRun(context, input)
+        const claim = await storage.startOrReclaim(input)
 
         await expect(
           storage.finish({
@@ -345,10 +461,51 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
       })
     })
 
+    test("validates, detaches, and persists scoped failures", async () => {
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns
+        await admitProjectionRun(context, replacementInput("failed-run"))
+        const claim = await storage.startOrReclaim(replacementInput("failed-run"))
+        const finished = await storage.finish({
+          ...executionInput(claim),
+          protocol: "replacement",
+          status: "failed",
+          finishedAt: new Date(failure.at),
+          error: failure,
+        })
+
+        expect(finished).toMatchObject({
+          status: "failed",
+          finishedAt: new Date(failure.at),
+          error: failure,
+        })
+        expect(finished.error).not.toBe(failure)
+        await expect(storage.getById({ projectId, id: "failed-run" })).resolves.toMatchObject({
+          error: failure,
+        })
+
+        await admitProjectionRun(context, replacementInput("invalid-failure-run"))
+        const invalid = await storage.startOrReclaim(replacementInput("invalid-failure-run"))
+        await expect(
+          storage.finish({
+            ...executionInput(invalid),
+            protocol: "replacement",
+            status: "failed",
+            error: { ...failure, code: "dataset.not_found" } as never,
+          })
+        ).rejects.toThrow("code is not allowed by this failure contract")
+      })
+    })
+
     test("keeps equal run ids isolated by project", async () => {
-      await withStorage(async (storage) => {
-        await storage.startOrReclaim({ ...replacementInput("shared-id"), projectId: "project-a" })
-        await storage.startOrReclaim({ ...replacementInput("shared-id"), projectId: "project-b" })
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns
+        const projectA = { ...replacementInput("shared-id"), projectId: "project-a" } as const
+        const projectB = { ...replacementInput("shared-id"), projectId: "project-b" } as const
+        await admitProjectionRun(context, projectA)
+        await admitProjectionRun(context, projectB)
+        await storage.startOrReclaim(projectA)
+        await storage.startOrReclaim(projectB)
 
         expect(await storage.getById({ projectId: "project-a", id: "shared-id" })).not.toBeNull()
         expect(await storage.getById({ projectId: "project-b", id: "shared-id" })).not.toBeNull()
@@ -358,6 +515,35 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
   })
 }
 
+async function admitProjectionRun<TStorage extends ProjectionRunStorage>(
+  context: ProjectionRunStorageContractContext<TStorage>,
+  input: StartOrReclaimProjectionRunInput
+): Promise<QueueProjectionRunInput> {
+  const executionId = `execution:${input.projectId}:${input.id}`
+  await context.executions.create({
+    id: executionId,
+    projectId: input.projectId,
+    executor: { type: "primitive", kind: "projection", runId: input.id },
+    source: {
+      type: "datasetVersion",
+      datasetId: input.identity.datasetVersion.datasetId,
+      versionId: input.identity.datasetVersion.versionId,
+    },
+    correlationId: input.id,
+    authorizationRef: {
+      type: "trustedPrimitive",
+      primitive: { kind: "projection", id: input.identity.projectionId, runId: input.id },
+    },
+  })
+  const admission = {
+    ...input,
+    executionId,
+    queuedAt: new Date("2026-01-01T00:00:01.000Z"),
+  } satisfies QueueProjectionRunInput
+  await context.projectionRuns.queue(admission)
+  return admission
+}
+
 function replacementInput(id: string) {
   return { id, projectId, identity: replacementIdentity, target: objectTarget } as const
 }

package/src/testing/queues-contract.ts

@@ -1,6 +1,14 @@
 import { describe, expect, test } from "bun:test"
 import { QueueError } from "../queues/errors"
-import type { Queues } from "../queues/types"
+import type { PipelineQueueJobFailureCode, QueueJobFailure, Queues } from "../queues/types"
+
+const TERMINAL_FAILURE = {
+  code: "internal.unexpected",
+  retryable: false,
+  message: "boom",
+  at: "2026-01-01T00:00:00.000Z",
+  details: { pipelineId: "p-1" },
+} as const satisfies QueueJobFailure<PipelineQueueJobFailureCode>
 
 export interface QueueContractSuiteOptions {
   /** Factory that produces a fresh `Queues` instance for each test case. */
@@ -56,7 +64,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             jobs: [
               {
                 type: "sync.run.requested",
-                payload: { syncId: "sync-1", commitMessage: "manual" },
+                payload: { runId: "sync-1" },
               },
             ],
           })
@@ -65,7 +73,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
           expect(job?.projectId).toBe("project-a")
           expect(job?.attempt).toBe(0)
           expect(job?.type).toBe("sync.run.requested")
-          expect(job?.payload.syncId).toBe("sync-1")
+          expect(job?.payload.runId).toBe("sync-1")
           expect(Date.parse(job!.createdAt)).toBeGreaterThanOrEqual(before)
           expect(job?.availableAt).toBe(job?.createdAt)
         })
@@ -76,7 +84,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
           const input = {
             id: "dispatch-run-1",
             type: "sync.run.requested" as const,
-            payload: { syncId: "sync-1" },
+            payload: { runId: "sync-1" },
           }
           const [[first], [second]] = await Promise.all([
             queues.syncRuns.enqueue({ projectId: "project-a", jobs: [input] }),
@@ -97,7 +105,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
           const input = {
             id,
             type: "sync.run.requested" as const,
-            payload: { syncId: "sync-1" },
+            payload: { runId: "sync-1" },
           }
 
           const [[first], [duplicate]] = await Promise.all([
@@ -147,7 +155,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
           await expect(
             queues.syncRuns.enqueue({
               projectId: "   ",
-              jobs: [{ type: "sync.run.requested", payload: { syncId: "sync-1" } }],
+              jobs: [{ type: "sync.run.requested", payload: { runId: "sync-1" } }],
             })
           ).rejects.toBeInstanceOf(QueueError)
         })
@@ -159,7 +167,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           await queues.pipelines.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "pipeline.run.requested", payload: { pipelineId: "p-1" } }],
+            jobs: [{ type: "pipeline.run.requested", payload: { runId: "p-1" } }],
           })
 
           const [claimed] = await queues.pipelines.claim({
@@ -168,7 +176,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
           })
 
           expect(claimed?.job.attempt).toBe(1)
-          expect(claimed?.job.payload.pipelineId).toBe("p-1")
+          expect(claimed?.job.payload.runId).toBe("p-1")
           expect(claimed?.leaseId).toBeTruthy()
           expect(Date.parse(claimed!.leaseExpiresAt)).toBeGreaterThan(
             Date.parse(claimed!.claimedAt)
@@ -180,7 +188,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
 
           const zero = await queues.syncRuns.claim({
@@ -203,7 +211,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
 
           await expect(
@@ -220,7 +228,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
           const availableAt = new Date(Date.now() + shortLeaseMs + 20).toISOString()
           await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" }, availableAt }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" }, availableAt }],
           })
 
           const before = await queues.syncRuns.claim({
@@ -243,11 +251,11 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "a-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "a-1" } }],
           })
           await queues.syncRuns.enqueue({
             projectId: "project-b",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "b-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "b-1" } }],
           })
 
           const claimedB = await queues.syncRuns.claim({
@@ -257,7 +265,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
           })
 
           expect(claimedB).toHaveLength(1)
-          expect(claimedB[0]?.job.payload.syncId).toBe("b-1")
+          expect(claimedB[0]?.job.payload.runId).toBe("b-1")
           expect(claimedB[0]?.job.projectId).toBe("project-b")
         })
       })
@@ -266,30 +274,18 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
           await queues.pipelines.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "pipeline.run.requested", payload: { pipelineId: "p-1" } }],
+            jobs: [{ type: "pipeline.run.requested", payload: { runId: "p-1" } }],
           })
           await queues.projections.enqueue({
             projectId: "project-a",
             jobs: [
               {
                 type: "projection.run.requested",
-                payload: {
-                  projectionId: "room-projection",
-                  projectionKind: "object",
-                  protocol: "replacement",
-                  datasetVersion: {
-                    datasetId: "canonical.rooms",
-                    versionId: "ver_1",
-                    createdAt: "2026-01-01T00:00:00.000Z",
-                  },
-                  ontologyRevision: "ontology-v1",
-                  projectionRevision: "projection-v1",
-                  ownershipHash: "ownership-v1",
-                },
+                payload: { runId: "projection-run-1" },
               },
             ],
           })
@@ -298,12 +294,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             jobs: [
               {
                 type: "workflow.run.requested",
-                payload: {
-                  workflowId: "reconcile-transaction",
-                  input: {
-                    transaction: { objectTypeId: "Transaction", primaryId: "txn_123" },
-                  },
-                },
+                payload: { runId: "workflow-run-1" },
               },
             ],
           })
@@ -313,7 +304,6 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
               {
                 type: "action.run.requested",
                 payload: {
-                  actionId: "mark-paid",
                   runId: "act_1",
                 },
               },
@@ -347,13 +337,13 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
           })
 
           expect(crossLane).toHaveLength(1)
-          expect(crossLane[0]?.job.payload.pipelineId).toBe("p-1")
+          expect(crossLane[0]?.job.payload.runId).toBe("p-1")
           expect(projectionLane).toHaveLength(1)
-          expect(projectionLane[0]?.job.payload.projectionId).toBe("room-projection")
+          expect(projectionLane[0]?.job.payload.runId).toBe("projection-run-1")
           expect(workflowLane).toHaveLength(1)
-          expect(workflowLane[0]?.job.payload.workflowId).toBe("reconcile-transaction")
+          expect(workflowLane[0]?.job.payload.runId).toBe("workflow-run-1")
           expect(actionLane).toHaveLength(1)
-          expect(actionLane[0]?.job.payload.actionId).toBe("mark-paid")
+          expect(actionLane[0]?.job.payload.runId).toBe("act_1")
           expect(sameLane).toHaveLength(1)
         })
       })
@@ -364,7 +354,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
           const [claim] = await queues.syncRuns.claim({
             projectId: "project-a",
@@ -390,7 +380,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
           await queues.syncRuns.claim({
             projectId: "project-a",
@@ -414,7 +404,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
           const [firstClaim] = await queues.syncRuns.claim({
             projectId: "project-a",
@@ -428,7 +418,6 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             jobId: job!.id,
             leaseId: firstClaim!.leaseId,
             availableAt: retryAt,
-            error: { message: "try again" },
           })
           await Bun.sleep(retryRedeliveryMs + 30)
           const [secondClaim] = await queues.syncRuns.claim({
@@ -446,7 +435,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
           const [claim] = await queues.syncRuns.claim({
             projectId: "project-a",
@@ -471,7 +460,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           const [job] = await queues.pipelines.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "pipeline.run.requested", payload: { pipelineId: "p-1" } }],
+            jobs: [{ type: "pipeline.run.requested", payload: { runId: "p-1" } }],
           })
           const [claim] = await queues.pipelines.claim({
             projectId: "project-a",
@@ -482,7 +471,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             projectId: "project-a",
             jobId: job!.id,
             leaseId: claim!.leaseId,
-            error: { message: "boom" },
+            failure: TERMINAL_FAILURE,
           })
 
           const later = await queues.pipelines.claim({
@@ -500,7 +489,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
           const [claim] = await queues.syncRuns.claim({
             projectId: "project-a",
@@ -540,7 +529,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
           await queues.syncRuns.claim({
             projectId: "project-a",
@@ -565,7 +554,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
           const [first] = await queues.syncRuns.claim({
             projectId: "project-a",
@@ -590,7 +579,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }],
+            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
           })
           const [claim] = await queues.syncRuns.claim({
             projectId: "project-a",