@sixb/core 0.1.20 → 0.1.22

package/src/testing/ontology-storage-contract.ts

@@ -3,15 +3,18 @@ import type {
   ProjectionExecution,
   ProjectionMaterializationIdentity,
 } from "../materialization/model"
+import { linkRefSortKey, linkScopeSortKey } from "../materialization/refs"
 import type {
   MaterializationPlanFinalization,
   MaterializationPlanHeader,
   MaterializationSession,
+  MaterializationWorkRecord,
   OntologyOutboxFailure,
   OntologySourceRecord,
 } from "../storage/ontology"
 import type { ProjectionRunStorage } from "../storage/projection-runs"
 import {
+  CONTRACT_COMMITTED_AT,
   commitEmptyEdit,
   commitExactObject,
   contractEditHeader,
@@ -301,7 +304,7 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
             createdAt: "2026-01-01T00:00:00.000Z",
           })
         ).rejects.toThrow("identity")
-        await storage.ontology.sources.beginMaterialization({
+        const begin = {
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
@@ -313,7 +316,16 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
           ownershipHash: identity.ownershipHash,
           ontologyRevision: identity.ontologyRevision,
           createdAt: "2026-01-01T00:00:00.000Z",
+        } as const
+        const staging = await storage.ontology.sources.beginMaterialization(begin)
+        expect(staging).toMatchObject({
+          status: "staging",
+          executionToken: execution.executionToken,
+          rootCount: null,
+          assertionCount: null,
+          readyAt: null,
         })
+        expect(await storage.ontology.sources.beginMaterialization(begin)).toEqual(staging)
         expect(
           await storage.ontology.sources.getActive({ projectId: "contract-project", source })
         ).toBeNull()
@@ -363,7 +375,7 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
           })
         ).rejects.toThrow()
 
-        const ready = await storage.ontology.sources.markReady({
+        const seal = {
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
@@ -371,8 +383,24 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
           rootCount: 1,
           assertionCount: 1,
           readyAt: "2026-01-01T00:01:00.000Z",
+        } as const
+        const ready = await storage.ontology.sources.markReady(seal)
+        expect(ready).toMatchObject({
+          status: "ready",
+          rootCount: 1,
+          assertionCount: 1,
+          readyAt: seal.readyAt,
         })
-        expect(ready).toMatchObject({ status: "ready", rootCount: 1, assertionCount: 1 })
+        expect(await storage.ontology.sources.markReady(seal)).toEqual(ready)
+        await expect(
+          storage.ontology.sources.stageRows({
+            projectId: "contract-project",
+            source,
+            materializationId: "staging-candidate",
+            execution,
+            rows: [],
+          })
+        ).rejects.toThrow("cannot accept rows")
 
         const reclaimed = await storage.projectionRuns.startOrReclaim({
           id: claimed.run.id,
@@ -481,10 +509,20 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
         expect(
           await storage.ontology.sources.purgeAbandoned({ projectId: "contract-project", limit: 1 })
         ).toEqual({ rowsDeleted: 0, materializationsDeleted: 0 })
+
+        // Released, the run begins a candidate again.
+        expect(
+          await storage.ontology.sources.beginMaterialization({
+            ...begin,
+            materializationId: "next-candidate",
+            execution: reclaimed.execution,
+            createdAt: "2026-01-01T00:03:00.000Z",
+          })
+        ).toMatchObject({ status: "staging", executionToken: reclaimed.execution.executionToken })
       })
     })
 
-    test("adopts a staging candidate at its last staged root", async () => {
+    test("resumes an adopted staging candidate and seals only contiguous, exactly counted roots", async () => {
       await withStorage(async (storage) => {
         const identity = replacementIdentity("01")
         const claimed = await startTestProjectionRun(storage, {
@@ -494,7 +532,7 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
           target: { objectTypeId: "ContractDevice" },
         })
         const source = { projectionId: identity.projectionId }
-        await storage.ontology.sources.beginMaterialization({
+        const begin = {
           projectId: "contract-project",
           source,
           materializationId: "resumed-candidate",
@@ -506,7 +544,8 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
           ownershipHash: identity.ownershipHash,
           ontologyRevision: identity.ontologyRevision,
           createdAt: "2026-01-01T00:00:00.000Z",
-        })
+        } as const
+        await storage.ontology.sources.beginMaterialization(begin)
         const row = (primaryId: string, stagingOrdinal: number) => ({
           root: { kind: "object" as const, ref: { objectTypeId: "ContractDevice", primaryId } },
           assertion: {
@@ -530,6 +569,13 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
           identity,
           target: { objectTypeId: "ContractDevice" },
         })
+        await expect(
+          storage.ontology.sources.beginMaterialization({
+            ...begin,
+            materializationId: "competing-candidate",
+            execution: reclaimed.execution,
+          })
+        ).rejects.toThrow("adopt it before beginning another")
         const adopted = await storage.ontology.sources.adopt({
           projectId: "contract-project",
           source,
@@ -559,17 +605,74 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
             rows: [row("one", 1), row("two", 2)],
           })
         ).toEqual({ inserted: 1, unchanged: 1 })
-        expect(
-          await storage.ontology.sources.markReady({
+
+        const stage = (rows: ReturnType<typeof row>[]) =>
+          storage.ontology.sources.stageRows({
             projectId: "contract-project",
             source,
             materializationId: "resumed-candidate",
             execution: reclaimed.execution,
-            rootCount: 3,
-            assertionCount: 3,
+            rows,
+          })
+        const seal = (rootCount: number, assertionCount: number) =>
+          storage.ontology.sources.markReady({
+            projectId: "contract-project",
+            source,
+            materializationId: "resumed-candidate",
+            execution: reclaimed.execution,
+            rootCount,
+            assertionCount,
             readyAt: "2026-01-01T00:02:00.000Z",
           })
-        ).toMatchObject({ status: "ready", rootCount: 3 })
+        // A batch is staged whole or not at all: four is new again once its batch fails.
+        await expect(stage([row("four", 4), row("five", 4)])).rejects.toThrow("stream ordinal 4")
+        expect(await stage([row("four", 4)])).toEqual({ inserted: 1, unchanged: 0 })
+        // Ordinal 3 is missing.
+        await expect(seal(4, 4)).rejects.toMatchObject({ name: "MaterializationValidationError" })
+        await stage([row("three", 3)])
+        await expect(seal(5, 4)).rejects.toThrow("do not match")
+        expect(await seal(5, 5)).toMatchObject({ status: "ready", rootCount: 5 })
+      })
+    })
+
+    // Removal proof: make adopt() resume an empty candidate at 1; ordinal 0 is never staged.
+    test("resumes an adopted candidate that staged nothing from ordinal zero", async () => {
+      await withStorage(async (storage) => {
+        const identity = replacementIdentity("01")
+        const run = {
+          id: "empty-resumed-run",
+          projectId: "contract-project",
+          identity,
+          target: { objectTypeId: "ContractDevice" },
+        }
+        const claimed = await startTestProjectionRun(storage, run)
+        const source = { projectionId: identity.projectionId }
+        await storage.ontology.sources.beginMaterialization({
+          projectId: "contract-project",
+          source,
+          materializationId: "empty-resumed-candidate",
+          execution: claimed.execution,
+          projectionKind: "object",
+          protocol: "replacement",
+          datasetVersion: identity.datasetVersion,
+          projectionRevision: identity.projectionRevision,
+          ownershipHash: identity.ownershipHash,
+          ontologyRevision: identity.ontologyRevision,
+          createdAt: "2026-01-01T00:00:00.000Z",
+        })
+
+        const reclaimed = await storage.projectionRuns.startOrReclaim(run)
+        expect(
+          await storage.ontology.sources.adopt({
+            projectId: "contract-project",
+            source,
+            execution: reclaimed.execution,
+            adoptedAt: "2026-01-01T00:01:00.000Z",
+          })
+        ).toMatchObject({
+          record: { materializationId: "empty-resumed-candidate", status: "staging" },
+          resumeStagingOrdinal: 0,
+        })
       })
     })
 
@@ -708,16 +811,101 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
             source: first.source,
           })
         ).toMatchObject({ materializationId: left.materializationId })
+        const abandonRight = {
+          kind: "candidate",
+          projectId: "contract-project",
+          source: right.source,
+          materializationId: right.materializationId,
+          execution: right.execution,
+          abandonedAt: "2026-02-02T00:00:00.000Z",
+        } as const
+        const abandoned = await storage.ontology.sources.abandon(abandonRight)
+        expect(abandoned).toMatchObject({ status: "abandoned" })
+        expect(await storage.ontology.sources.abandon(abandonRight)).toEqual(abandoned)
+      })
+    })
+
+    test("orders source activation after candidate readiness and the active update", async () => {
+      await withStorage(async (storage) => {
+        // Ready one second after its dataset version was created.
+        const early = await createReadyEmptyCandidate(storage, "run-early", "candidate-early", "01")
+        await expect(
+          activateEmptyCandidate(storage, early, null, "commit-early", "2026-01-01T00:00:00.500Z")
+        ).rejects.toMatchObject({ name: "MaterializationValidationError" })
+
+        // The same activation commits once it follows readiness.
+        const ready = await createReadyEmptyCandidate(storage, "run-ready", "candidate-ready", "02")
+        await activateEmptyCandidate(
+          storage,
+          ready,
+          null,
+          "commit-ready",
+          "2026-01-05T00:00:00.000Z"
+        )
+        const active = await storage.ontology.sources.getActive({
+          projectId: "contract-project",
+          source: ready.source,
+        })
+
+        // Ready on Jan 3, but activated before the active source's Jan 5 update.
+        const late = await createReadyEmptyCandidate(storage, "run-late", "candidate-late", "03")
+        await expect(
+          activateEmptyCandidate(storage, late, active, "commit-late", "2026-01-04T00:00:00.000Z")
+        ).rejects.toThrow("cannot precede the active materialization update")
+      })
+    })
+
+    test("lists the dataset version each active source applied, in one read", async () => {
+      await withStorage(async (storage) => {
         expect(
-          await storage.ontology.sources.abandon({
-            kind: "candidate",
-            projectId: "contract-project",
-            source: right.source,
-            materializationId: right.materializationId,
-            execution: right.execution,
-            abandonedAt: "2026-02-02T00:00:00.000Z",
-          })
-        ).toMatchObject({ status: "abandoned" })
+          await storage.ontology.sources.listActive({ projectId: "contract-project" })
+        ).toEqual([])
+
+        const devices = await createReadyEmptyCandidate(storage, "run-a", "candidate-a", "01")
+        await activateEmptyCandidate(storage, devices, null, "commit-a", "2026-01-03T00:00:00.000Z")
+
+        const others = await createReadyEmptyCandidate(
+          storage,
+          "run-b",
+          "candidate-b",
+          "02",
+          "contract.others"
+        )
+        await activateEmptyCandidate(storage, others, null, "commit-b", "2026-01-04T00:00:00.000Z")
+
+        // A newer version supersedes the first one; a ready candidate is not active yet.
+        const newer = await createReadyEmptyCandidate(storage, "run-c", "candidate-c", "05")
+        const activeDevices = await storage.ontology.sources.getActive({
+          projectId: "contract-project",
+          source: devices.source,
+        })
+        await activateEmptyCandidate(
+          storage,
+          newer,
+          activeDevices,
+          "commit-c",
+          "2026-01-06T00:00:00.000Z"
+        )
+        await createReadyEmptyCandidate(storage, "run-d", "candidate-d", "07", "contract.pending")
+
+        const active = await storage.ontology.sources.listActive({ projectId: "contract-project" })
+        expect(
+          [...active].sort((a, b) => a.source.projectionId.localeCompare(b.source.projectionId))
+        ).toEqual([
+          {
+            source: { projectionId: "contract.devices" },
+            datasetVersion: newer.identity.datasetVersion,
+            projectionRevision: "projection-contract-revision",
+          },
+          {
+            source: { projectionId: "contract.others" },
+            datasetVersion: others.identity.datasetVersion,
+            projectionRevision: "projection-contract-revision",
+          },
+        ])
+        expect(await storage.ontology.sources.listActive({ projectId: "other-project" })).toEqual(
+          []
+        )
       })
     })
 
@@ -777,6 +965,81 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
       })
     })
 
+    test("rescans final link scopes instead of trusting staged occupancy", async () => {
+      await withStorage(async (storage) => {
+        const ref = {
+          source: { objectTypeId: "ContractDevice", primaryId: "one" },
+          linkId: "parent",
+          target: { objectTypeId: "ContractDevice", primaryId: "two" },
+        }
+        const commit = async (id: string, records: readonly MaterializationWorkRecord[]) => {
+          const header = contractEditHeader(id)
+          await storage.transaction(async (tx) => {
+            await ensureContractExecution(tx, header)
+            const session = await tx.ontology.materializations.begin(header)
+            await tx.ontology.materializations.stageWork({ session, records })
+            await tx.ontology.materializations.apply({ session })
+            await tx.ontology.materializations.finalize({
+              session,
+              finalization: { sourceActivations: [], result: contractEditResult(id) },
+            })
+          })
+        }
+        const written = {
+          createdAt: CONTRACT_COMMITTED_AT,
+          updatedAt: CONTRACT_COMMITTED_AT,
+          lastCommitId: "existing-link",
+        }
+        await commit("existing-link", [
+          ...[ref.source, ref.target].map(
+            (object, index): MaterializationWorkRecord => ({
+              kind: "plan",
+              recordKey: `plan:object-upsert:${index}`,
+              applyPhase: 4,
+              sortKey: `6${index}`,
+              item: {
+                kind: "object-upsert",
+                value: {
+                  row: {
+                    ref: object,
+                    properties: { name: object.primaryId },
+                    version: 1,
+                    ...written,
+                  },
+                  expected: { ref: object, exists: false },
+                },
+              },
+            })
+          ),
+          {
+            kind: "plan",
+            recordKey: "plan:link-upsert",
+            applyPhase: 5,
+            sortKey: "62",
+            item: {
+              kind: "link-upsert",
+              value: { row: { ref, ...written }, expected: { ref, exists: false } },
+            },
+          },
+        ])
+
+        // Apply accepts the dishonest record; finalization must inspect the durable scope.
+        await expect(
+          commit("dishonest-empty-scope", [
+            {
+              kind: "cardinality",
+              recordKey: "cardinality:dishonest-empty-scope",
+              view: "effective",
+              scopeSortKey: linkScopeSortKey(ref.source, ref.linkId),
+              linkSortKey: linkRefSortKey(ref),
+              ref,
+              occupied: false,
+            },
+          ])
+        ).rejects.toThrow("does not match the final effective link scope")
+      })
+    })
+
     test("leases outbox rows exclusively, reclaims expiry, fences stale workers, and purges", async () => {
       await withStorage(async (storage) => {
         const outboxB = await commitExactObject(storage, "outbox-b")
@@ -1025,9 +1288,10 @@ async function createReadyEmptyCandidate(
   storage: OntologyStorageContractStorage,
   runId: string,
   materializationId: string,
-  versionId: string
+  versionId: string,
+  projectionId?: string
 ): Promise<ReadyCandidate> {
-  const identity = replacementIdentity(versionId)
+  const identity = replacementIdentity(versionId, projectionId)
   const run = await startTestProjectionRun(storage, {
     id: runId,
     projectId: "contract-project",

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

@@ -316,33 +316,23 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
       })
     })
 
-    test("keeps one run while reclaim rotates its execution", async () => {
+    test("keeps one run while reclaim rotates its execution and fences every stale write", async () => {
       await withStorage(async (context) => {
         const storage = context.projectionRuns
-        const input = replacementInput("replacement-run")
+        const input = replacementInput("fenced-run")
         await admitProjectionRun(context, input)
-        const first = await storage.startOrReclaim(input)
-        const second = await storage.startOrReclaim(input)
+        const stale = await storage.startOrReclaim(input)
+        const current = await storage.startOrReclaim(input)
 
-        expect(first.run).toMatchObject({ id: input.id, attempt: 1, status: "running" })
-        expect(second.run).toMatchObject({ id: input.id, attempt: 2, status: "running" })
-        expect(second.execution.executionToken).not.toBe(first.execution.executionToken)
-        expect(second.run).not.toHaveProperty("executionToken")
+        expect(stale.run).toMatchObject({ id: input.id, attempt: 1, status: "running" })
+        expect(current.run).toMatchObject({ id: input.id, attempt: 2, status: "running" })
+        expect(current.execution.executionToken).not.toBe(stale.execution.executionToken)
+        expect(current.run).not.toHaveProperty("executionToken")
         expect(await storage.getById({ projectId, id: input.id })).toMatchObject({
           identity: replacementIdentity,
           target: objectTarget,
           progress: { sourceRowsRead: 0, sourceRowsSkipped: 0 },
         })
-      })
-    })
-
-    test("fences every stale lock, progress, and terminal write", async () => {
-      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)
 
         await expect(storage.lockForMaterialization(executionInput(stale))).rejects.toThrow(
           "execution token is stale"

package/src/testing/queues-contract.ts

@@ -29,6 +29,11 @@ export interface QueueContractSuiteOptions {
    * Time to wait for a delayed retry to become visible again. Defaults to `shortLeaseMs + 15`.
    */
   readonly retryRedeliveryMs?: number
+  /**
+   * Lets `ms` milliseconds pass for the provider. Defaults to a real sleep. An in-process
+   * provider can advance fake timers here instead, so lease and delay waits cost no wall time.
+   */
+  readonly sleep?: (ms: number) => Promise<void>
 }
 
 /**
@@ -43,6 +48,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
   const shortLeaseMs = options.shortLeaseMs ?? 20
   const leaseExpiryRedeliveryMs = options.leaseExpiryRedeliveryMs ?? shortLeaseMs + 10
   const retryRedeliveryMs = options.retryRedeliveryMs ?? shortLeaseMs + 15
+  const sleep = options.sleep ?? ((ms: number) => Bun.sleep(ms))
 
   const withQueues = async (body: (queues: Queues) => Promise<void>): Promise<void> => {
     const queues = await options.createQueues()
@@ -110,27 +116,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         })
       })
 
-      test("deduplicates repeated enqueue with a caller-supplied id", async () => {
-        await withQueues(async (queues) => {
-          const input = {
-            id: "dispatch-run-1",
-            type: "sync.run.requested" as const,
-            payload: { runId: "sync-1" },
-          }
-          const [[first], [second]] = await Promise.all([
-            queues.syncRuns.enqueue({ projectId: "project-a", jobs: [input] }),
-            queues.syncRuns.enqueue({ projectId: "project-a", jobs: [input] }),
-          ])
-
-          expect(first?.id).toBe(input.id)
-          expect(second?.id).toBe(input.id)
-          await expect(
-            queues.syncRuns.claim({ projectId: "project-a", workerId: "worker-1", limit: 2 })
-          ).resolves.toHaveLength(1)
-        })
-      })
-
-      test("treats caller-supplied ids as opaque across the job lifecycle", async () => {
+      test("deduplicates a caller-supplied id and treats it as opaque across the lifecycle", async () => {
         await withQueues(async (queues) => {
           const id = "workflow:review-meeting:node:0"
           const input = {
@@ -143,14 +129,16 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             queues.syncRuns.enqueue({ projectId: "project-a", jobs: [input] }),
             queues.syncRuns.enqueue({ projectId: "project-a", jobs: [input] }),
           ])
-          const [claimed] = await queues.syncRuns.claim({
+          const claims = await queues.syncRuns.claim({
             projectId: "project-a",
             workerId: "worker-1",
             limit: 2,
           })
+          const [claimed] = claims
 
           expect(first?.id).toBe(id)
           expect(duplicate?.id).toBe(id)
+          expect(claims).toHaveLength(1)
           expect(claimed?.job.id).toBe(id)
           if (queues.syncRuns.renewLease) {
             await expect(
@@ -266,7 +254,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             projectId: "project-a",
             workerId: "worker-1",
           })
-          await Bun.sleep(shortLeaseMs + 40)
+          await sleep(shortLeaseMs + 40)
           const after = await queues.syncRuns.claim({
             projectId: "project-a",
             workerId: "worker-1",
@@ -290,7 +278,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             .finally(() => {
               settled = true
             })
-          await Bun.sleep(50)
+          await sleep(50)
           expect(settled).toBe(false)
 
           await queues.syncRuns.enqueue({
@@ -310,14 +298,17 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" }, availableAt }],
           })
 
-          const claimed = await queues.syncRuns.claim({
+          const claiming = queues.syncRuns.claim({
             projectId: "project-a",
             workerId: "worker-1",
             signal: AbortSignal.timeout(4_000),
           })
+          await sleep(shortLeaseMs)
+          const claimed = await claiming
 
           expect(claimed).toHaveLength(1)
-          expect(Date.now()).toBeGreaterThanOrEqual(Date.parse(availableAt))
+          // claimedAt, not Date.now(): a claim that returned at once still settles after the sleep.
+          expect(Date.parse(claimed[0]!.claimedAt)).toBeGreaterThanOrEqual(Date.parse(availableAt))
         })
       })
 
@@ -330,7 +321,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             workerId: "worker-1",
             signal: waiting.signal,
           })
-          await Bun.sleep(20)
+          await sleep(20)
           waiting.abort()
 
           expect(await claim).toEqual([])
@@ -526,7 +517,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             leaseId: firstClaim!.leaseId,
             availableAt: retryAt,
           })
-          await Bun.sleep(retryRedeliveryMs + 30)
+          await sleep(retryRedeliveryMs + 30)
           const [secondClaim] = await queues.syncRuns.claim({
             projectId: "project-a",
             workerId: "worker-2",
@@ -619,20 +610,7 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
         })
       })
 
-      test("returns null for unknown jobId", async () => {
-        await withQueues(async (queues) => {
-          const result = await queues.syncRuns.renewLease?.({
-            projectId: "project-a",
-            jobId: "00000000-0000-0000-0000-000000000000",
-            leaseId: "no-such-lease",
-            leaseMs: shortLeaseMs,
-          })
-
-          expect(result).toBeNull()
-        })
-      })
-
-      test("returns null when the leaseId does not match", async () => {
+      test("returns null for an unknown job or a lease it does not hold", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -644,20 +622,27 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             leaseMs: shortLeaseMs * 10,
           })
 
-          const renewed = await queues.syncRuns.renewLease?.({
+          const unknown = await queues.syncRuns.renewLease?.({
+            projectId: "project-a",
+            jobId: "00000000-0000-0000-0000-000000000000",
+            leaseId: "no-such-lease",
+            leaseMs: shortLeaseMs,
+          })
+          const mismatched = await queues.syncRuns.renewLease?.({
             projectId: "project-a",
             jobId: job!.id,
             leaseId: "not-the-right-lease",
             leaseMs: shortLeaseMs,
           })
 
-          expect(renewed).toBeNull()
+          expect(unknown).toBeNull()
+          expect(mismatched).toBeNull()
         })
       })
     })
 
     describe("redelivery", () => {
-      test("redelivers after lease expiry with attempt incremented", async () => {
+      test("redelivers after lease expiry and rejects completing the expired lease", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -669,7 +654,15 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
             leaseMs: shortLeaseMs,
           })
 
-          await Bun.sleep(leaseExpiryRedeliveryMs)
+          await sleep(leaseExpiryRedeliveryMs)
+
+          await expect(
+            queues.syncRuns.complete({
+              projectId: "project-a",
+              jobId: job!.id,
+              leaseId: first!.leaseId,
+            })
+          ).rejects.toBeInstanceOf(QueueError)
           const [second] = await queues.syncRuns.claim({
             projectId: "project-a",
             workerId: "worker-2",
@@ -681,30 +674,6 @@ export function runQueueContractSuite(label: string, options: QueueContractSuite
           expect(second!.job.attempt).toBeGreaterThanOrEqual(2)
         })
       })
-
-      test("rejects complete on an already-expired lease", async () => {
-        await withQueues(async (queues) => {
-          const [job] = await queues.syncRuns.enqueue({
-            projectId: "project-a",
-            jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }],
-          })
-          const [claim] = await queues.syncRuns.claim({
-            projectId: "project-a",
-            workerId: "worker-1",
-            leaseMs: shortLeaseMs,
-          })
-
-          await Bun.sleep(leaseExpiryRedeliveryMs)
-
-          await expect(
-            queues.syncRuns.complete({
-              projectId: "project-a",
-              jobId: job!.id,
-              leaseId: claim!.leaseId,
-            })
-          ).rejects.toBeInstanceOf(QueueError)
-        })
-      })
     })
 
     describe("health", () => {