@sixb/core 0.0.1 → 0.1.1

package/dist/testing/index.js

@@ -1,10 +1,10 @@
 // @bun
-import"../chunk-hsv43v58.js";
+import"../chunk-rgzed50y.js";
 import {
   SandboxNotRunningError
 } from "../chunk-8ydjhh27.js";
 import"../chunk-ya6brh8a.js";
-import"../chunk-t358gywy.js";
+import"../chunk-p7vj8xgb.js";
 import"../chunk-v5c085yp.js";
 import {
   collectObjectQueryValidationIssues,
@@ -13,8 +13,8 @@ import {
   existsObjects,
   facetObjects,
   validateObjectQuery
-} from "../chunk-2gpr6jsz.js";
-import"../chunk-590dejbp.js";
+} from "../chunk-b1bqvhpe.js";
+import"../chunk-4hwxq5e6.js";
 import"../chunk-gqdd7508.js";
 import {
   ObjectQueryPlanningError,
@@ -25,79 +25,80 @@ import {
 } from "../chunk-xz5g49bp.js";
 import {
   LakeStorageError
-} from "../chunk-2s6sydsh.js";
-import"../chunk-c3zd880g.js";
-import"../chunk-5yny9z0e.js";
-import {
-  col,
-  defineDataset
-} from "../chunk-pv1yad91.js";
-import"../chunk-0psb6kdw.js";
+} from "../chunk-qzyemcj7.js";
+import"../chunk-f6kyyeef.js";
+import"../chunk-6zrpewy4.js";
+import"../chunk-b5dp7gaf.js";
+import"../chunk-btcsywk4.js";
 import"../chunk-867jxh7c.js";
 import"../chunk-k6j72mtt.js";
 import"../chunk-2ab72m2h.js";
-import"../chunk-r65yscvk.js";
+import {
+  change,
+  col,
+  defineDataset
+} from "../chunk-r82k4z7z.js";
 import {
   BrokerError
-} from "../chunk-wj01s5hr.js";
-import"../chunk-yxss87qa.js";
+} from "../chunk-4tvj3ate.js";
+import"../chunk-yn947ck3.js";
 import"../chunk-74drx9gd.js";
 import"../chunk-b49dgvsj.js";
-import"../chunk-dhmj53mx.js";
-import"../chunk-jdwx7vzs.js";
+import"../chunk-nbywkytr.js";
+import"../chunk-avppcgt6.js";
 import {
   ProjectionRegistry,
   createOntologyMaterializer
-} from "../chunk-yvef9xwc.js";
-import"../chunk-aebzcsxr.js";
-import"../chunk-q4qzq0ea.js";
+} from "../chunk-rjqm6ksg.js";
+import"../chunk-raq0x6bd.js";
+import"../chunk-hb9xcx9c.js";
 import"../chunk-xqbtf4wn.js";
 import"../chunk-50kv63vj.js";
 import"../chunk-6wetht33.js";
-import {
-  OntologyRegistry,
-  defineObjectType,
-  link,
-  prop,
-  stringEnum
-} from "../chunk-mx84y05q.js";
-import"../chunk-45tw90k7.js";
 import {
   createEventId
-} from "../chunk-wxhdnwh4.js";
+} from "../chunk-bh8bwma3.js";
 import"../chunk-9dzba0f2.js";
-import"../chunk-p6r5g77m.js";
+import"../chunk-8kv2sez0.js";
 import"../chunk-ry24jbr1.js";
 import"../chunk-1evzqhks.js";
 import"../chunk-t72dvahb.js";
-import"../chunk-tsk2bxs3.js";
-import"../chunk-04b07a9q.js";
-import"../chunk-dktq02ne.js";
 import"../chunk-yt8wphsx.js";
-import"../chunk-nvamz5dv.js";
-import"../chunk-8r8cw2xw.js";
+import"../chunk-86459jn0.js";
+import"../chunk-63te770v.js";
 import {
   computeBlobDigest
-} from "../chunk-vj723r3p.js";
+} from "../chunk-6rzdtvn5.js";
 import"../chunk-51fjndv0.js";
 import {
   AGENT_MESSAGE_CONTENT_VERSION,
   AgentStorageError
-} from "../chunk-k41ajtz7.js";
+} from "../chunk-9k3hgv8h.js";
+import {
+  OntologyRegistry,
+  defineObjectType,
+  link,
+  prop,
+  stringEnum
+} from "../chunk-y2ygpd0m.js";
+import"../chunk-md9jbrm9.js";
+import"../chunk-53s4asfm.js";
+import"../chunk-04b07a9q.js";
+import"../chunk-dktq02ne.js";
 import {
   blobIdFromDigest
-} from "../chunk-4pycxcj3.js";
-import"../chunk-f2b5e2gf.js";
+} from "../chunk-hz8m927w.js";
+import"../chunk-sb0shdvv.js";
 import"../chunk-k25jm1x5.js";
 import {
   AuthStorageError
-} from "../chunk-dcgrzj1t.js";
+} from "../chunk-xt6qx9sh.js";
 import"../chunk-xwnf87e1.js";
-import"../chunk-0fygrz37.js";
+import"../chunk-exrfbt2d.js";
 import {
   defineProjection
-} from "../chunk-btpe64e4.js";
-import"../chunk-1vffvydj.js";
+} from "../chunk-m9w0artv.js";
+import"../chunk-be9vm29v.js";
 import"../chunk-y64skrwp.js";
 
 // src/testing/agent-storage-contract.ts
@@ -3224,8 +3225,244 @@ function temperature(objectId, value, at3) {
     at: at3
   };
 }
-// src/testing/lake-storage-contract.ts
+// src/testing/lake-merge-storage-contract.ts
 import { describe as describe6, expect as expect6, test as test6 } from "bun:test";
+var invoices = defineDataset("contract.merges.invoices", {
+  schema: [col("id", "string"), col("status", "string"), col("note", "string", { nullable: true })],
+  primaryKey: "id"
+});
+var lineItems = defineDataset("contract.merges.line_items", {
+  schema: [col("invoiceId", "string"), col("lineItemId", "string"), col("description", "string")],
+  primaryKey: ["invoiceId", "lineItemId"]
+});
+var unkeyed = defineDataset("contract.merges.unkeyed", {
+  schema: [col("id", "string")]
+});
+function runLakeMergeStorageContractSuite(label, options) {
+  const withStorage = async (body) => {
+    const storage = await options.createStorage();
+    try {
+      await body(storage);
+    } finally {
+      await options.teardown?.(storage);
+    }
+  };
+  describe6(label, () => {
+    test6("creates an initial merge version from async changes", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices);
+        const merge = await storage.beginMerge({
+          dataset: invoices,
+          producer: { kind: "sync", id: "sync-invoices", runId: "run_1" },
+          inputs: [{ datasetId: "source.events", versionId: "cursor_1" }]
+        });
+        async function* changes() {
+          yield change.upsert({ id: "inv_1", status: "open", note: null });
+          yield change.upsert({ id: "inv_2", status: "paid", note: "settled" });
+        }
+        await merge.writeChanges(changes());
+        const result = await merge.commit({ commitMessage: "initial invoice changes" });
+        const version = expectCreated(result);
+        expect6(version).toMatchObject({
+          datasetId: invoices.id,
+          mode: "merge",
+          rowCount: 2,
+          producer: { kind: "sync", id: "sync-invoices", runId: "run_1" },
+          inputs: [{ datasetId: "source.events", versionId: "cursor_1" }]
+        });
+        expect6(version.parentVersionId).toBeUndefined();
+        await expect6(collectRows(storage.readRows({ datasetId: invoices.id }))).resolves.toEqual([
+          { id: "inv_1", status: "open", note: null },
+          { id: "inv_2", status: "paid", note: "settled" }
+        ]);
+      });
+    });
+    test6("inserts, updates, and deletes while preserving the parent version", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices);
+        const seed = await storage.beginWrite({ dataset: invoices, mode: "snapshot" });
+        await seed.writeRows([
+          { id: "inv_1", status: "open", note: null },
+          { id: "inv_2", status: "open", note: null }
+        ]);
+        const parent = await seed.commit();
+        const merge = await storage.beginMerge({ dataset: invoices });
+        await merge.writeChanges([
+          change.upsert({ id: "inv_1", status: "paid", note: null }),
+          change.delete({ id: "inv_2" }),
+          change.upsert({ id: "inv_2_moved", status: "open", note: "moved" })
+        ]);
+        const version = expectCreated(await merge.commit());
+        expect6(version.parentVersionId).toBe(parent.versionId);
+        expect6(version.mode).toBe("merge");
+        await expect6(collectRows(storage.readRows({ datasetId: invoices.id }))).resolves.toEqual([
+          { id: "inv_1", status: "paid", note: null },
+          { id: "inv_2_moved", status: "open", note: "moved" }
+        ]);
+        await expect6(collectRows(storage.readRows({ datasetId: invoices.id, versionId: parent.versionId }))).resolves.toEqual([
+          { id: "inv_1", status: "open", note: null },
+          { id: "inv_2", status: "open", note: null }
+        ]);
+      });
+    });
+    test6("applies the final change for repeated single and composite keys", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(lineItems);
+        const merge = await storage.beginMerge({ dataset: lineItems });
+        await merge.writeChanges([
+          change.upsert({ invoiceId: "a|b", lineItemId: "c", description: "first" }),
+          change.upsert({ invoiceId: "a", lineItemId: "b|c", description: "other key" })
+        ]);
+        await merge.writeChanges([
+          change.delete({ invoiceId: "a|b", lineItemId: "c" }),
+          change.upsert({ invoiceId: "a|b", lineItemId: "c", description: "final" })
+        ]);
+        expectCreated(await merge.commit());
+        await expect6(collectRows(storage.readRows({ datasetId: lineItems.id }))).resolves.toEqual([
+          { invoiceId: "a|b", lineItemId: "c", description: "final" },
+          { invoiceId: "a", lineItemId: "b|c", description: "other key" }
+        ]);
+      });
+    });
+    test6("does not create versions when visible rows do not change", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices);
+        const empty = await storage.beginMerge({ dataset: invoices });
+        expect6(await empty.commit()).toEqual({ outcome: "unchanged", version: null });
+        const initialNoOp = await storage.beginMerge({ dataset: invoices });
+        await initialNoOp.writeChanges([change.delete({ id: "missing" })]);
+        expect6(await initialNoOp.commit()).toEqual({ outcome: "unchanged", version: null });
+        expect6(await storage.listVersions(invoices.id)).toEqual([]);
+        const seed = await storage.beginMerge({ dataset: invoices });
+        await seed.writeChanges([change.upsert({ id: "inv_1", status: "open", note: null })]);
+        const seedVersion = expectCreated(await seed.commit());
+        const identical = await storage.beginMerge({ dataset: invoices });
+        await identical.writeChanges([change.upsert({ id: "inv_1", status: "open", note: null })]);
+        expect6(await identical.commit()).toMatchObject({
+          outcome: "unchanged",
+          version: { versionId: seedVersion.versionId }
+        });
+        const laterNoOp = await storage.beginMerge({ dataset: invoices });
+        await laterNoOp.writeChanges([
+          change.upsert({ id: "inv_1", status: "paid", note: null }),
+          change.upsert({ id: "inv_1", status: "open" }),
+          change.delete({ id: "missing" })
+        ]);
+        const noOpResult = await laterNoOp.commit();
+        expect6(noOpResult).toMatchObject({ outcome: "unchanged" });
+        expect6(noOpResult.version?.versionId).toBe(seedVersion.versionId);
+        expect6(await storage.listVersions(invoices.id)).toHaveLength(1);
+      });
+    });
+    test6("automatically rejects stale merge sessions, including an absent base", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices);
+        const first = await storage.beginMerge({ dataset: invoices });
+        const stale = await storage.beginMerge({ dataset: invoices });
+        await first.writeChanges([change.upsert({ id: "inv_1", status: "open", note: null })]);
+        await first.commit();
+        await stale.writeChanges([change.upsert({ id: "inv_2", status: "open" })]);
+        await expect6(stale.commit()).rejects.toThrow("Optimistic merge commit failed");
+        await expect6(collectRows(storage.readRows({ datasetId: invoices.id }))).resolves.toEqual([
+          { id: "inv_1", status: "open", note: null }
+        ]);
+      });
+    });
+    test6("checks an explicit latest-version guard against the captured merge base", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices);
+        const seed = await storage.beginMerge({ dataset: invoices });
+        await seed.writeChanges([change.upsert({ id: "inv_1", status: "open" })]);
+        const version = expectCreated(await seed.commit());
+        await expect6(storage.beginMerge({ dataset: invoices, expectedLatestVersionId: "stale-version" })).rejects.toThrow("Optimistic merge start failed");
+        const guarded = await storage.beginMerge({
+          dataset: invoices,
+          expectedLatestVersionId: version.versionId
+        });
+        await guarded.abort();
+      });
+    });
+    test6("serializes concurrent commits from the same base", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices);
+        const left = await storage.beginMerge({ dataset: invoices });
+        const right = await storage.beginMerge({ dataset: invoices });
+        await left.writeChanges([change.upsert({ id: "inv_left", status: "open" })]);
+        await right.writeChanges([change.upsert({ id: "inv_right", status: "open" })]);
+        const results = await Promise.allSettled([left.commit(), right.commit()]);
+        expect6(results.filter((result) => result.status === "fulfilled")).toHaveLength(1);
+        expect6(results.filter((result) => result.status === "rejected")).toHaveLength(1);
+        expect6(await storage.listVersions(invoices.id)).toHaveLength(1);
+        expect6(await collectRows(storage.readRows({ datasetId: invoices.id }))).toHaveLength(1);
+      });
+    });
+    test6("rejects unkeyed datasets and malformed changes", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(unkeyed);
+        await expect6(storage.beginMerge({ dataset: unkeyed })).rejects.toThrow("must define a primaryKey");
+        await storage.createDataset(invoices);
+        const merge = await storage.beginMerge({ dataset: invoices });
+        await expect6(merge.writeChanges([change.upsert({ id: "inv_1" })])).rejects.toThrow("missing required column 'status'");
+        await expect6(merge.writeChanges([change.delete({})])).rejects.toThrow("missing primary-key column 'id'");
+        await expect6(merge.writeChanges([{ kind: "delete", key: { id: "inv_1", extra: "x" } }])).rejects.toThrow("unknown column 'extra'");
+        await merge.abort();
+      });
+    });
+    test6("enforces unique keys for snapshot and append baselines", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices);
+        const duplicateSnapshot = await storage.beginWrite({ dataset: invoices, mode: "snapshot" });
+        await expect6(duplicateSnapshot.writeRows([
+          { id: "inv_1", status: "open" },
+          { id: "inv_1", status: "paid" }
+        ])).rejects.toThrow("duplicate primary key");
+        await duplicateSnapshot.abort();
+        const seed = await storage.beginWrite({ dataset: invoices, mode: "snapshot" });
+        await seed.writeRows([{ id: "inv_1", status: "open" }]);
+        await seed.commit();
+        const conflictingAppend = await storage.beginWrite({ dataset: invoices, mode: "append" });
+        await conflictingAppend.writeRows([{ id: "inv_1", status: "paid" }]);
+        await expect6(conflictingAppend.commit()).rejects.toThrow("duplicate primary key");
+      });
+    });
+    test6("clones staged changes and enforces the session lifecycle", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices);
+        const row = { id: "inv_1", status: "open", note: null };
+        const merge = await storage.beginMerge({ dataset: invoices });
+        await merge.writeChanges([change.upsert(row)]);
+        row.status = "paid";
+        expectCreated(await merge.commit());
+        await merge.abort();
+        await expect6(merge.writeChanges([])).rejects.toThrow("already closed");
+        await expect6(collectRows(storage.readRows({ datasetId: invoices.id }))).resolves.toEqual([
+          { id: "inv_1", status: "open", note: null }
+        ]);
+        const aborted = await storage.beginMerge({ dataset: invoices });
+        await aborted.writeChanges([change.delete({ id: "inv_1" })]);
+        await aborted.abort();
+        await aborted.abort();
+        expect6(await storage.listVersions(invoices.id)).toHaveLength(1);
+      });
+    });
+  });
+}
+function expectCreated(result) {
+  expect6(result.outcome).toBe("created");
+  if (result.outcome !== "created") {
+    throw new Error("Expected merge to create a dataset version");
+  }
+  return result.version;
+}
+async function collectRows(rows) {
+  const result = [];
+  for await (const row of rows) {
+    result.push(row);
+  }
+  return result;
+}
+// src/testing/lake-storage-contract.ts
+import { describe as describe7, expect as expect7, test as test7 } from "bun:test";
 var definitionDataset = defineDataset("contract.definitions.orders", {
   schema: [col("orderId", "string"), col("customerName", "string")],
   description: "Contract orders"
@@ -3234,6 +3471,11 @@ var reorderedDefinitionDataset = defineDataset("contract.definitions.orders", {
   schema: [col("customerName", "string"), col("orderId", "string")],
   description: "Contract orders"
 });
+var keyedDefinitionDataset = defineDataset("contract.definitions.keyed_orders", {
+  schema: [col("tenantId", "string"), col("orderId", "string"), col("customerName", "string")],
+  primaryKey: ["tenantId", "orderId"],
+  description: "Contract keyed orders"
+});
 var writeDataset = defineDataset("contract.writes.orders", {
   schema: [col("orderId", "string"), col("customerName", "string")]
 });
@@ -3265,31 +3507,42 @@ function runLakeStorageContractSuite(label, options) {
       await options.teardown?.(storage);
     }
   };
-  describe6(label, () => {
-    describe6("dataset definitions", () => {
-      test6("creates, gets, lists, and reuses dataset definitions", async () => {
+  describe7(label, () => {
+    describe7("dataset definitions", () => {
+      test7("creates, gets, lists, and reuses dataset definitions", async () => {
         await withStorage(async (storage) => {
-          expect6(await storage.getDataset(definitionDataset.id)).toBeNull();
+          expect7(await storage.getDataset(definitionDataset.id)).toBeNull();
           const created = await storage.createDataset(definitionDataset);
           const repeated = await storage.createDataset(definitionDataset);
-          expect6(created).toEqual(definitionDataset);
-          expect6(repeated).toEqual(definitionDataset);
-          expect6(await storage.getDataset(definitionDataset.id)).toEqual(definitionDataset);
-          expect6(await storage.getDataset("missing.dataset")).toBeNull();
-          expect6(await storage.listDatasets()).toEqual([definitionDataset]);
-          expect6(await storage.listVersions(definitionDataset.id)).toEqual([]);
+          expect7(created).toEqual(definitionDataset);
+          expect7(repeated).toEqual(definitionDataset);
+          expect7(await storage.getDataset(definitionDataset.id)).toEqual(definitionDataset);
+          expect7(await storage.getDataset("missing.dataset")).toBeNull();
+          expect7(await storage.listDatasets()).toEqual([definitionDataset]);
+          expect7(await storage.listVersions(definitionDataset.id)).toEqual([]);
+        });
+      });
+      test7("round-trips keyed definitions through create, get, list, and reuse", async () => {
+        await withStorage(async (storage) => {
+          const created = await storage.createDataset(keyedDefinitionDataset);
+          const repeated = await storage.createDataset(keyedDefinitionDataset);
+          expect7(created).toEqual(keyedDefinitionDataset);
+          expect7(repeated).toEqual(keyedDefinitionDataset);
+          expect7(await storage.getDataset(keyedDefinitionDataset.id)).toEqual(keyedDefinitionDataset);
+          expect7(await storage.listDatasets()).toEqual([keyedDefinitionDataset]);
+          expect7(await storage.listVersions(keyedDefinitionDataset.id)).toEqual([]);
         });
       });
-      test6("treats same-column declaration reorders as a no-op", async () => {
+      test7("treats same-column declaration reorders as a no-op", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(definitionDataset);
           await storage.assertDatasetDefinitionsCompatible([reorderedDefinitionDataset]);
-          expect6(await storage.getDataset(definitionDataset.id)).toEqual(definitionDataset);
-          await expect6(storage.createDataset(reorderedDefinitionDataset)).resolves.toEqual(definitionDataset);
-          expect6(await storage.listVersions(definitionDataset.id)).toEqual([]);
+          expect7(await storage.getDataset(definitionDataset.id)).toEqual(definitionDataset);
+          await expect7(storage.createDataset(reorderedDefinitionDataset)).resolves.toEqual(definitionDataset);
+          expect7(await storage.listVersions(definitionDataset.id)).toEqual([]);
         });
       });
-      test6("persists compatible metadata additions", async () => {
+      test7("persists compatible metadata additions", async () => {
         await withStorage(async (storage) => {
           const minimalDataset = defineDataset("contract.definitions.metadata", {
             schema: [col("orderId", "string"), col("orderDate", "date")]
@@ -3301,24 +3554,24 @@ function runLakeStorageContractSuite(label, options) {
           });
           await storage.createDataset(minimalDataset);
           await storage.assertDatasetDefinitionsCompatible([documentedDataset]);
-          expect6(await storage.getDataset(minimalDataset.id)).toEqual(minimalDataset);
-          await expect6(storage.createDataset(documentedDataset)).resolves.toEqual(documentedDataset);
-          expect6(await storage.getDataset(minimalDataset.id)).toEqual(documentedDataset);
+          expect7(await storage.getDataset(minimalDataset.id)).toEqual(minimalDataset);
+          await expect7(storage.createDataset(documentedDataset)).resolves.toEqual(documentedDataset);
+          expect7(await storage.getDataset(minimalDataset.id)).toEqual(documentedDataset);
         });
       });
-      test6("rejects incompatible definition changes without mutating the stored definition", async () => {
+      test7("rejects incompatible definition changes without mutating the stored definition", async () => {
         await withStorage(async (storage) => {
           const changedDataset = defineDataset(definitionDataset.id, {
             schema: [col("orderId", "int64"), col("customerName", "string")],
             description: "Contract orders"
           });
           await storage.createDataset(definitionDataset);
-          await expect6(storage.assertDatasetDefinitionsCompatible([changedDataset])).rejects.toThrow("changing column 'orderId' type");
-          await expect6(storage.createDataset(changedDataset)).rejects.toBeInstanceOf(LakeStorageError);
-          expect6(await storage.getDataset(definitionDataset.id)).toEqual(definitionDataset);
+          await expect7(storage.assertDatasetDefinitionsCompatible([changedDataset])).rejects.toThrow("changing column 'orderId' type");
+          await expect7(storage.createDataset(changedDataset)).rejects.toBeInstanceOf(LakeStorageError);
+          expect7(await storage.getDataset(definitionDataset.id)).toEqual(definitionDataset);
         });
       });
-      test6("checks provider schema evolution policy", async () => {
+      test7("checks provider schema evolution policy", async () => {
         await withStorage(async (storage) => {
           const initialDataset = defineDataset("contract.definitions.schema_evolution", {
             schema: [col("invoiceId", "string")]
@@ -3331,34 +3584,34 @@ function runLakeStorageContractSuite(label, options) {
           });
           await storage.createDataset(initialDataset);
           if (schemaEvolution === "strict") {
-            await expect6(storage.assertDatasetDefinitionsCompatible([requestedDataset])).rejects.toThrow("incompatible schema");
-            await expect6(storage.createDataset(requestedDataset)).rejects.toThrow("incompatible schema");
-            expect6(await storage.getDataset(initialDataset.id)).toEqual(initialDataset);
+            await expect7(storage.assertDatasetDefinitionsCompatible([requestedDataset])).rejects.toThrow("incompatible schema");
+            await expect7(storage.createDataset(requestedDataset)).rejects.toThrow("incompatible schema");
+            expect7(await storage.getDataset(initialDataset.id)).toEqual(initialDataset);
             return;
           }
           await storage.assertDatasetDefinitionsCompatible([requestedDataset]);
-          expect6(await storage.getDataset(initialDataset.id)).toEqual(initialDataset);
-          expect6(await storage.listVersions(initialDataset.id)).toEqual([]);
-          await expect6(storage.createDataset(requestedDataset)).resolves.toEqual(storedDataset);
-          expect6(await storage.getDataset(initialDataset.id)).toEqual(storedDataset);
+          expect7(await storage.getDataset(initialDataset.id)).toEqual(initialDataset);
+          expect7(await storage.listVersions(initialDataset.id)).toEqual([]);
+          await expect7(storage.createDataset(requestedDataset)).resolves.toEqual(storedDataset);
+          expect7(await storage.getDataset(initialDataset.id)).toEqual(storedDataset);
           const [schemaVersion] = await storage.listVersions(initialDataset.id);
-          expect6(schemaVersion).toMatchObject({
+          expect7(schemaVersion).toMatchObject({
             datasetId: initialDataset.id,
             mode: "schema",
             schema: storedDataset.schema
           });
         });
       });
-      test6("keeps compatibility checks read-only for missing datasets", async () => {
+      test7("keeps compatibility checks read-only for missing datasets", async () => {
         await withStorage(async (storage) => {
           await storage.assertDatasetDefinitionsCompatible([definitionDataset]);
-          expect6(await storage.getDataset(definitionDataset.id)).toBeNull();
-          expect6(await storage.listDatasets()).toEqual([]);
+          expect7(await storage.getDataset(definitionDataset.id)).toBeNull();
+          expect7(await storage.listDatasets()).toEqual([]);
         });
       });
     });
-    describe6("catalog state", () => {
-      test6("reports materialized state and latest version summaries in bulk", async () => {
+    describe7("catalog state", () => {
+      test7("reports materialized state and latest version summaries in bulk", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
@@ -3367,7 +3620,7 @@ function runLakeStorageContractSuite(label, options) {
             { orderId: "ord_2", customerName: "Grace" }
           ]);
           const commit = await write.commit();
-          expect6(commit.outcome).toBe("created");
+          expect7(commit.outcome).toBe("created");
           const version = commit;
           await storage.createDataset(definitionDataset);
           const state = await storage.listDatasetCatalogState([
@@ -3376,36 +3629,36 @@ function runLakeStorageContractSuite(label, options) {
             "contract.missing.dataset"
           ]);
           const byId = new Map(state.map((entry) => [entry.datasetId, entry]));
-          expect6(byId.get(writeDataset.id)).toMatchObject({
+          expect7(byId.get(writeDataset.id)).toMatchObject({
             datasetId: writeDataset.id,
             materialized: true
           });
-          expect6(byId.get(writeDataset.id)?.latestVersion).toMatchObject({
+          expect7(byId.get(writeDataset.id)?.latestVersion).toMatchObject({
             datasetId: writeDataset.id,
             versionId: version.versionId,
             mode: "snapshot",
             rowCount: 2
           });
-          expect6(byId.get(definitionDataset.id)).toEqual({
+          expect7(byId.get(definitionDataset.id)).toEqual({
             datasetId: definitionDataset.id,
             materialized: true,
             latestVersion: null
           });
-          expect6(byId.get("contract.missing.dataset")).toEqual({
+          expect7(byId.get("contract.missing.dataset")).toEqual({
             datasetId: "contract.missing.dataset",
             materialized: false,
             latestVersion: null
           });
         });
       });
-      test6("returns an empty result for an empty request", async () => {
+      test7("returns an empty result for an empty request", async () => {
         await withStorage(async (storage) => {
-          expect6(await storage.listDatasetCatalogState([])).toEqual([]);
+          expect7(await storage.listDatasetCatalogState([])).toEqual([]);
         });
       });
     });
-    describe6("writes and reads", () => {
-      test6("keeps immutable-version row order and offsets stable", async () => {
+    describe7("writes and reads", () => {
+      test7("keeps immutable-version row order and offsets stable", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
@@ -3419,20 +3672,20 @@ function runLakeStorageContractSuite(label, options) {
           await write.writeRows(expected);
           const version = await write.commit();
           const pinned = { datasetId: writeDataset.id, versionId: version.versionId };
-          await expect6(collectRows(storage.readRows(pinned))).resolves.toEqual(expected);
-          await expect6(collectRows(storage.readRows(pinned))).resolves.toEqual(expected);
+          await expect7(collectRows2(storage.readRows(pinned))).resolves.toEqual(expected);
+          await expect7(collectRows2(storage.readRows(pinned))).resolves.toEqual(expected);
           for (const offset of [0, 2, expected.length, expected.length + 3]) {
-            await expect6(collectRows(storage.readRows({ ...pinned, offset }))).resolves.toEqual(expected.slice(offset));
+            await expect7(collectRows2(storage.readRows({ ...pinned, offset }))).resolves.toEqual(expected.slice(offset));
           }
-          await expect6(collectRows(storage.readRows({ ...pinned, columns: ["orderId"], offset: 1, limit: 2 }))).resolves.toEqual([{ orderId: "ord_1" }, { orderId: "ord_5" }]);
+          await expect7(collectRows2(storage.readRows({ ...pinned, columns: ["orderId"], offset: 1, limit: 2 }))).resolves.toEqual([{ orderId: "ord_1" }, { orderId: "ord_5" }]);
         });
       });
-      test6("rejects writes for unknown datasets", async () => {
+      test7("rejects writes for unknown datasets", async () => {
         await withStorage(async (storage) => {
-          await expect6(storage.beginWrite({ dataset: writeDataset })).rejects.toThrow("Unknown dataset");
+          await expect7(storage.beginWrite({ dataset: writeDataset })).rejects.toThrow("Unknown dataset");
         });
       });
-      test6("commits snapshot and append versions with versioned reads", async () => {
+      test7("commits snapshot and append versions with versioned reads", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const snapshotWrite = await storage.beginWrite({
@@ -3445,20 +3698,20 @@ function runLakeStorageContractSuite(label, options) {
             { orderId: "ord_2", customerName: "Grace" }
           ]);
           const snapshotCommit = await snapshotWrite.commit({ commitMessage: "snapshot orders" });
-          expect6(snapshotCommit.outcome).toBe("created");
+          expect7(snapshotCommit.outcome).toBe("created");
           const version1 = snapshotCommit;
-          expect6(version1).toMatchObject({
+          expect7(version1).toMatchObject({
             datasetId: writeDataset.id,
             mode: "snapshot",
             schema: writeDataset.schema,
             producer: { kind: "sync", id: "contract-sync", runId: "run_1" },
             rowCount: 2
           });
-          expect6(version1.parentVersionId).toBeUndefined();
-          expect6(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
+          expect7(version1.parentVersionId).toBeUndefined();
+          expect7(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
             versionId: version1.versionId
           });
-          expect6(await storage.getVersion(writeDataset.id, version1.versionId)).toMatchObject({
+          expect7(await storage.getVersion(writeDataset.id, version1.versionId)).toMatchObject({
             datasetId: writeDataset.id,
             versionId: version1.versionId,
             mode: "snapshot",
@@ -3474,9 +3727,9 @@ function runLakeStorageContractSuite(label, options) {
           const appendCommit = await appendWrite.commit({
             expectedLatestVersionId: version1.versionId
           });
-          expect6(appendCommit.outcome).toBe("created");
+          expect7(appendCommit.outcome).toBe("created");
           const version2 = appendCommit;
-          expect6(version2).toMatchObject({
+          expect7(version2).toMatchObject({
             datasetId: writeDataset.id,
             parentVersionId: version1.versionId,
             mode: "append",
@@ -3484,42 +3737,42 @@ function runLakeStorageContractSuite(label, options) {
             inputs: [{ datasetId: writeDataset.id, versionId: version1.versionId }],
             rowCount: 3
           });
-          expect6(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
+          expect7(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
             versionId: version2.versionId
           });
-          await expect6(collectRows(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([
+          await expect7(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([
             { orderId: "ord_1", customerName: "Ada" },
             { orderId: "ord_2", customerName: "Grace" },
             { orderId: "ord_3", customerName: "Katherine" }
           ]);
-          await expect6(collectRows(storage.readRows({ datasetId: writeDataset.id, versionId: version1.versionId }))).resolves.toEqual([
+          await expect7(collectRows2(storage.readRows({ datasetId: writeDataset.id, versionId: version1.versionId }))).resolves.toEqual([
             { orderId: "ord_1", customerName: "Ada" },
             { orderId: "ord_2", customerName: "Grace" }
           ]);
-          await expect6(collectRows(storage.readRows({
+          await expect7(collectRows2(storage.readRows({
             datasetId: writeDataset.id,
             columns: ["orderId"],
             limit: 2
           }))).resolves.toEqual([{ orderId: "ord_1" }, { orderId: "ord_2" }]);
-          await expect6(collectRows(storage.readRows({
+          await expect7(collectRows2(storage.readRows({
             datasetId: writeDataset.id,
             columns: ["orderId"],
             limit: 1,
             offset: 1
           }))).resolves.toEqual([{ orderId: "ord_2" }]);
-          await expect6(collectRows(storage.readRows({
+          await expect7(collectRows2(storage.readRows({
             datasetId: writeDataset.id,
             columns: ["orderId"],
             offset: 1
           }))).resolves.toEqual([{ orderId: "ord_2" }, { orderId: "ord_3" }]);
-          expect6((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([version2.versionId, version1.versionId]);
-          expect6((await storage.listVersions(writeDataset.id, 1)).map((version) => version.versionId)).toEqual([version2.versionId]);
-          expect6(await storage.listVersions("missing.dataset")).toEqual([]);
-          expect6(await storage.getLatestVersion("missing.dataset")).toBeNull();
-          expect6(await storage.getVersion(writeDataset.id, missingVersionId)).toBeNull();
+          expect7((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([version2.versionId, version1.versionId]);
+          expect7((await storage.listVersions(writeDataset.id, 1)).map((version) => version.versionId)).toEqual([version2.versionId]);
+          expect7(await storage.listVersions("missing.dataset")).toEqual([]);
+          expect7(await storage.getLatestVersion("missing.dataset")).toBeNull();
+          expect7(await storage.getVersion(writeDataset.id, missingVersionId)).toBeNull();
         });
       });
-      test6("snapshot writes replace the visible latest rows", async () => {
+      test7("snapshot writes replace the visible latest rows", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const firstWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
@@ -3531,14 +3784,14 @@ function runLakeStorageContractSuite(label, options) {
           });
           await replacementWrite.writeRows([{ orderId: "ord_9", customerName: "Dorothy" }]);
           const replacementVersion = await replacementWrite.commit();
-          expect6(replacementVersion.versionId).not.toBe(firstVersion.versionId);
-          expect6(replacementVersion.parentVersionId).toBeUndefined();
-          expect6(replacementVersion.rowCount).toBe(1);
-          await expect6(collectRows(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([{ orderId: "ord_9", customerName: "Dorothy" }]);
-          await expect6(collectRows(storage.readRows({ datasetId: writeDataset.id, versionId: firstVersion.versionId }))).resolves.toEqual([{ orderId: "ord_1", customerName: "Ada" }]);
+          expect7(replacementVersion.versionId).not.toBe(firstVersion.versionId);
+          expect7(replacementVersion.parentVersionId).toBeUndefined();
+          expect7(replacementVersion.rowCount).toBe(1);
+          await expect7(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([{ orderId: "ord_9", customerName: "Dorothy" }]);
+          await expect7(collectRows2(storage.readRows({ datasetId: writeDataset.id, versionId: firstVersion.versionId }))).resolves.toEqual([{ orderId: "ord_1", customerName: "Ada" }]);
         });
       });
-      test6("reuses the latest version when a snapshot commits identical content", async () => {
+      test7("reuses the latest version when a snapshot commits identical content", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const seedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
@@ -3547,7 +3800,7 @@ function runLakeStorageContractSuite(label, options) {
             { orderId: "ord_2", customerName: "Grace" }
           ]);
           const seedVersion = await seedWrite.commit();
-          expect6(seedVersion.outcome).toBe("created");
+          expect7(seedVersion.outcome).toBe("created");
           const identicalWrite = await storage.beginWrite({
             dataset: writeDataset,
             mode: "snapshot"
@@ -3557,10 +3810,10 @@ function runLakeStorageContractSuite(label, options) {
             { orderId: "ord_1", customerName: "Ada" }
           ]);
           const identicalVersion = await identicalWrite.commit();
-          expect6(identicalVersion.outcome).toBe("unchanged");
-          expect6(identicalVersion.versionId).toBe(seedVersion.versionId);
-          expect6((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([seedVersion.versionId]);
-          expect6(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
+          expect7(identicalVersion.outcome).toBe("unchanged");
+          expect7(identicalVersion.versionId).toBe(seedVersion.versionId);
+          expect7((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([seedVersion.versionId]);
+          expect7(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
             versionId: seedVersion.versionId
           });
           await Bun.sleep(2);
@@ -3570,12 +3823,12 @@ function runLakeStorageContractSuite(label, options) {
             { orderId: "ord_2", customerName: "Hopper" }
           ]);
           const changedVersion = await changedWrite.commit();
-          expect6(changedVersion.outcome).toBe("created");
-          expect6(changedVersion.versionId).not.toBe(seedVersion.versionId);
-          expect6((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([changedVersion.versionId, seedVersion.versionId]);
+          expect7(changedVersion.outcome).toBe("created");
+          expect7(changedVersion.versionId).not.toBe(seedVersion.versionId);
+          expect7((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([changedVersion.versionId, seedVersion.versionId]);
         });
       });
-      test6("snapshot content comparison respects row multiplicities", async () => {
+      test7("snapshot content comparison respects row multiplicities", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const rowA = { orderId: "ord_1", customerName: "Ada" };
@@ -3587,11 +3840,11 @@ function runLakeStorageContractSuite(label, options) {
           const shiftedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await shiftedWrite.writeRows([rowA, rowB, rowB]);
           const shiftedVersion = await shiftedWrite.commit();
-          expect6(shiftedVersion.outcome).toBe("created");
-          expect6(shiftedVersion.versionId).not.toBe(seedVersion.versionId);
+          expect7(shiftedVersion.outcome).toBe("created");
+          expect7(shiftedVersion.versionId).not.toBe(seedVersion.versionId);
         });
       });
-      test6("treats omitted and null nullable values as the same snapshot content", async () => {
+      test7("treats omitted and null nullable values as the same snapshot content", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(nullableWriteDataset);
           const seedWrite = await storage.beginWrite({
@@ -3606,11 +3859,11 @@ function runLakeStorageContractSuite(label, options) {
           });
           await omittedWrite.writeRows([{ orderId: "ord_1" }]);
           const omittedVersion = await omittedWrite.commit();
-          expect6(omittedVersion.outcome).toBe("unchanged");
-          expect6(omittedVersion.versionId).toBe(seedVersion.versionId);
+          expect7(omittedVersion.outcome).toBe("unchanged");
+          expect7(omittedVersion.versionId).toBe(seedVersion.versionId);
         });
       });
-      test6("reuses the latest version when an append commits zero rows", async () => {
+      test7("reuses the latest version when an append commits zero rows", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const seedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
@@ -3618,14 +3871,14 @@ function runLakeStorageContractSuite(label, options) {
           const seedVersion = await seedWrite.commit();
           const emptyAppend = await storage.beginWrite({ dataset: writeDataset, mode: "append" });
           const appendVersion = await emptyAppend.commit();
-          expect6(appendVersion.outcome).toBe("unchanged");
-          expect6(appendVersion.versionId).toBe(seedVersion.versionId);
-          expect6(appendVersion.rowCount).toBe(1);
-          expect6((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([seedVersion.versionId]);
-          await expect6(collectRows(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([{ orderId: "ord_1", customerName: "Ada" }]);
+          expect7(appendVersion.outcome).toBe("unchanged");
+          expect7(appendVersion.versionId).toBe(seedVersion.versionId);
+          expect7(appendVersion.rowCount).toBe(1);
+          expect7((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([seedVersion.versionId]);
+          await expect7(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([{ orderId: "ord_1", customerName: "Ada" }]);
         });
       });
-      test6("fails stale optimistic commits", async () => {
+      test7("fails stale optimistic commits", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const seedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
@@ -3639,45 +3892,45 @@ function runLakeStorageContractSuite(label, options) {
           });
           await competingWrite.writeRows([{ orderId: "ord_3", customerName: "Katherine" }]);
           await competingWrite.commit({ expectedLatestVersionId: initialVersion.versionId });
-          await expect6(delayedWrite.commit({ expectedLatestVersionId: initialVersion.versionId })).rejects.toThrow("Optimistic commit failed");
-          await expect6(collectRows(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([
+          await expect7(delayedWrite.commit({ expectedLatestVersionId: initialVersion.versionId })).rejects.toThrow("Optimistic commit failed");
+          await expect7(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([
             { orderId: "ord_1", customerName: "Ada" },
             { orderId: "ord_3", customerName: "Katherine" }
           ]);
         });
       });
-      test6("abort closes a write session without committing rows", async () => {
+      test7("abort closes a write session without committing rows", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await write.writeRows([{ orderId: "ord_1", customerName: "Ada" }]);
           await write.abort();
           await write.abort();
-          expect6(await storage.getLatestVersion(writeDataset.id)).toBeNull();
-          expect6(await storage.listVersions(writeDataset.id)).toEqual([]);
-          await expect6(collectRows(storage.readRows({ datasetId: writeDataset.id }))).rejects.toThrow("No committed version found");
+          expect7(await storage.getLatestVersion(writeDataset.id)).toBeNull();
+          expect7(await storage.listVersions(writeDataset.id)).toEqual([]);
+          await expect7(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).rejects.toThrow("No committed version found");
         });
       });
-      test6("commit closes a write session and leaves abort idempotent", async () => {
+      test7("commit closes a write session and leaves abort idempotent", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await write.writeRows([{ orderId: "ord_1", customerName: "Ada" }]);
           await write.commit();
           await write.abort();
-          await expect6(write.writeRows([])).rejects.toThrow("already closed");
+          await expect7(write.writeRows([])).rejects.toThrow("already closed");
         });
       });
-      test6("rejects rows that do not match the dataset schema", async () => {
+      test7("rejects rows that do not match the dataset schema", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
           const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
-          await expect6(write.writeRows([{ orderId: "ord_1" }])).rejects.toThrow("missing required column");
-          await expect6(write.writeRows([{ orderId: "ord_1", customerName: "Ada", unexpected: true }])).rejects.toThrow("unknown column");
+          await expect7(write.writeRows([{ orderId: "ord_1" }])).rejects.toThrow("missing required column");
+          await expect7(write.writeRows([{ orderId: "ord_1", customerName: "Ada", unexpected: true }])).rejects.toThrow("unknown column");
           await write.abort();
         });
       });
-      test6("round-trips exact decimal strings in eager and streaming reads", async () => {
+      test7("round-trips exact decimal strings in eager and streaming reads", async () => {
         await withStorage(async (storage) => {
           const exact = "9007199254740993.123456789";
           await storage.createDataset(decimalWriteDataset);
@@ -3687,18 +3940,18 @@ function runLakeStorageContractSuite(label, options) {
             { id: "amount_2", amount: null }
           ]);
           await write.commit();
-          await expect6(collectRows(storage.readRows({ datasetId: decimalWriteDataset.id }))).resolves.toEqual([
+          await expect7(collectRows2(storage.readRows({ datasetId: decimalWriteDataset.id }))).resolves.toEqual([
             { id: "amount_1", amount: exact },
             { id: "amount_2", amount: null }
           ]);
-          await expect6(collectRows(storage.readRows({
+          await expect7(collectRows2(storage.readRows({
             datasetId: decimalWriteDataset.id,
             columns: ["amount"],
             limit: 1
           }))).resolves.toEqual([{ amount: exact }]);
         });
       });
-      test6("round-trips fileRef row values", async () => {
+      test7("round-trips fileRef row values", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(fileRefDataset);
           const write = await storage.beginWrite({ dataset: fileRefDataset, mode: "snapshot" });
@@ -3707,7 +3960,7 @@ function runLakeStorageContractSuite(label, options) {
             { id: "doc_2", attachment: null }
           ]);
           await write.commit();
-          await expect6(collectRows(storage.readRows({ datasetId: fileRefDataset.id }))).resolves.toEqual([
+          await expect7(collectRows2(storage.readRows({ datasetId: fileRefDataset.id }))).resolves.toEqual([
             { id: "doc_1", attachment: invoiceRef },
             { id: "doc_2", attachment: null }
           ]);
@@ -3716,7 +3969,7 @@ function runLakeStorageContractSuite(label, options) {
     });
   });
 }
-async function collectRows(rows) {
+async function collectRows2(rows) {
   const result = [];
   for await (const row of rows) {
     result.push(row);
@@ -3724,7 +3977,7 @@ async function collectRows(rows) {
   return result;
 }
 // src/testing/materialization-failure-contract.ts
-import { describe as describe7, expect as expect7, test as test7 } from "bun:test";
+import { describe as describe8, expect as expect8, test as test8 } from "bun:test";
 
 // src/testing/ontology-contract-fixture.ts
 var emptyChunk = {
@@ -3888,18 +4141,18 @@ async function commitExactObject(storage, id, options = {}) {
 // src/testing/materialization-failure-contract.ts
 function runMaterializationFailureContractSuite(label, options) {
   const boundaries = options.boundaries ?? ["effective.object.upsert", "outbox.insert", "finalize"];
-  describe7(label, () => {
+  describe8(label, () => {
     for (const boundary of boundaries) {
-      test7(`rolls back the complete transaction when ${boundary} fails`, async () => {
+      test8(`rolls back the complete transaction when ${boundary} fails`, async () => {
         const storage = await options.createStorage();
         try {
           await options.setup?.(storage);
           const before = await options.captureState(storage);
           const failure = new Error(`contract injected ${boundary}`);
           await options.injectFailure(storage, boundary, failure);
-          await expect7(commitExactObject(storage, `failure-${boundary}`)).rejects.toThrow(failure.message);
+          await expect8(commitExactObject(storage, `failure-${boundary}`)).rejects.toThrow(failure.message);
           await options.clearFailure?.(storage);
-          expect7(await options.captureState(storage)).toEqual(before);
+          expect8(await options.captureState(storage)).toEqual(before);
         } finally {
           await options.clearFailure?.(storage);
           await options.cleanup?.(storage);
@@ -3909,7 +4162,7 @@ function runMaterializationFailureContractSuite(label, options) {
   });
 }
 // src/testing/materializer-storage-contract.ts
-import { expect as expect8, test as test8 } from "bun:test";
+import { expect as expect9, test as test9 } from "bun:test";
 var Device2 = defineObjectType({
   id: "StorageContractDevice",
   name: "Device",
@@ -3948,7 +4201,7 @@ var projections = new ProjectionRegistry({
   ])
 });
 function runMaterializerStorageContractSuite(name, provider) {
-  test8(`${name} persists replacement, Action, and telemetry commits atomically`, async () => {
+  test9(`${name} persists replacement, Action, and telemetry commits atomically`, async () => {
     const createdStorage = await provider.createStorage();
     const storage = requireContractStorage(createdStorage);
     let materializationOrdinal = 0;
@@ -3981,8 +4234,8 @@ function runMaterializerStorageContractSuite(name, provider) {
         execution: firstExecution,
         entries: entries([sourceEntry("one", "One", "two"), sourceEntry("two", "Two")])
       });
-      expect8(first.counts).toMatchObject({ objectsCreated: 2, linksCreated: 1 });
-      expect8(await storage.objects.getByPrimaryId({
+      expect9(first.counts).toMatchObject({ objectsCreated: 2, linksCreated: 1 });
+      expect9(await storage.objects.getByPrimaryId({
         projectId: "materializer-storage-contract",
         objectTypeId: Device2.id,
         primaryId: "one"
@@ -4004,17 +4257,17 @@ function runMaterializerStorageContractSuite(name, provider) {
         execution: secondExecution,
         entries: entries([sourceEntry("one", "One updated")])
       });
-      expect8(second.counts).toMatchObject({
+      expect9(second.counts).toMatchObject({
         objectsUpdated: 1,
         objectsDeleted: 1,
         linksDeleted: 1
       });
-      expect8(await storage.objects.getByPrimaryId({
+      expect9(await storage.objects.getByPrimaryId({
         projectId: "materializer-storage-contract",
         objectTypeId: Device2.id,
         primaryId: "two"
       })).toBeNull();
-      await expect8(materializer.edits.commit({
+      await expect9(materializer.edits.commit({
         mode: "atomic",
         source: { kind: "action", actionId: "renameDevice", runId: "missing-action-run" },
         operations: [
@@ -4060,7 +4313,7 @@ function runMaterializerStorageContractSuite(name, provider) {
         expectedLinks: [],
         expectedLinkScopes: []
       });
-      expect8(await storage.ontology.commits.getByOrigin({
+      expect9(await storage.ontology.commits.getByOrigin({
         projectId: "materializer-storage-contract",
         origin: { kind: "action", actionRunId: "action-run" }
       })).toMatchObject({ id: actionCommit.commitId });
@@ -4069,7 +4322,7 @@ function runMaterializerStorageContractSuite(name, provider) {
         versionId: "readings-v1",
         createdAt: "2026-01-03T00:00:00.000Z"
       };
-      await expect8(materializer.telemetry.append({
+      await expect9(materializer.telemetry.append({
         source: {
           kind: "projection",
           projection: { projectionId: temperatureProjection.id },
@@ -4127,8 +4380,8 @@ function runMaterializerStorageContractSuite(name, provider) {
           }
         ]
       });
-      expect8(telemetry).toMatchObject({ pointsCreated: 1, latestObjectsChanged: 1 });
-      expect8(await storage.timeseries.getLatest({
+      expect9(telemetry).toMatchObject({ pointsCreated: 1, latestObjectsChanged: 1 });
+      expect9(await storage.timeseries.getLatest({
         projectId: "materializer-storage-contract",
         objectTypeId: Device2.id,
         objectId: "one",
@@ -4213,7 +4466,7 @@ async function claim(storage, input) {
   return claim2.execution;
 }
 // src/testing/object-query-contract.ts
-import { describe as describe8, expect as expect9, test as test9 } from "bun:test";
+import { describe as describe9, expect as expect10, test as test10 } from "bun:test";
 var projectId4 = "object-query-contract";
 var Device3 = defineObjectType({
   id: "ContractDevice",
@@ -4321,8 +4574,8 @@ function runObjectQueryProviderContractSuite(label, options) {
       await options.teardown?.(storage);
     }
   };
-  describe8(label, () => {
-    test9("normalizes query shape and resolves search profile defaults", () => {
+  describe9(label, () => {
+    test10("normalizes query shape and resolves search profile defaults", () => {
       const normalized = normalizeObjectQuery({
         kind: "limit",
         limit: 10,
@@ -4341,28 +4594,28 @@ function runObjectQueryProviderContractSuite(label, options) {
           }
         }
       });
-      expect9(normalized.kind).toBe("limit");
+      expect10(normalized.kind).toBe("limit");
       if (normalized.kind !== "limit")
         return;
-      expect9(normalized.limit).toBe(3);
-      expect9(normalized.input.kind).toBe("project");
+      expect10(normalized.limit).toBe(3);
+      expect10(normalized.input.kind).toBe("project");
       if (normalized.input.kind !== "project")
         return;
-      expect9(normalized.input.properties).toEqual(["id", "name"]);
-      expect9(normalized.input.input.kind).toBe("text");
+      expect10(normalized.input.properties).toEqual(["id", "name"]);
+      expect10(normalized.input.input.kind).toBe("text");
       if (normalized.input.input.kind !== "text")
         return;
-      expect9(normalized.input.input.fields).toEqual(["name", "description"]);
+      expect10(normalized.input.input.fields).toEqual(["name", "description"]);
       const validated = validateObjectQuery({ kind: "text", query: "alpha", input: { kind: "start", objectTypeId: Room.id } }, { ontology: objectQueryContractOntology });
-      expect9(validated.query.kind).toBe("text");
+      expect10(validated.query.kind).toBe("text");
       if (validated.query.kind === "text") {
-        expect9(validated.query.fields).toBeUndefined();
-        expect9(validated.query.fieldsByObjectType).toEqual({
+        expect10(validated.query.fields).toBeUndefined();
+        expect10(validated.query.fieldsByObjectType).toEqual({
           [Room.id]: ["name", "description"]
         });
       }
     });
-    test9("collects validation failures before provider planning", () => {
+    test10("collects validation failures before provider planning", () => {
       const issues = collectObjectQueryValidationIssues({
         kind: "filter",
         predicate: { op: "eq", propertyId: "missing", value: "x" },
@@ -4373,19 +4626,19 @@ function runObjectQueryProviderContractSuite(label, options) {
           input: { kind: "start", objectTypeId: Room.id }
         }
       }, { ontology: objectQueryContractOntology });
-      expect9(issues.map((issue) => issue.code)).toEqual(expect9.arrayContaining([
+      expect10(issues.map((issue) => issue.code)).toEqual(expect10.arrayContaining([
         "unknown_property",
         "query_field_not_enabled",
         "text_field_not_string_like"
       ]));
     });
-    test9("declares the portable V1 query capability surface", async () => {
+    test10("declares the portable V1 query capability surface", async () => {
       await withStorage(async ({ objects: storage }) => {
         const capabilities = storage.queryCapabilities();
-        expect9(capabilities.queryObjects).toBe(true);
-        expect9(capabilities.countObjects).toBe(true);
-        expect9(capabilities.existsObjects).toBe(true);
-        expect9(capabilities.facetObjects).toBe(true);
+        expect10(capabilities.queryObjects).toBe(true);
+        expect10(capabilities.countObjects).toBe(true);
+        expect10(capabilities.existsObjects).toBe(true);
+        expect10(capabilities.facetObjects).toBe(true);
         for (const node of [
           "start",
           "filter",
@@ -4397,7 +4650,7 @@ function runObjectQueryProviderContractSuite(label, options) {
           "set",
           "project"
         ]) {
-          expect9(capabilities.nodes?.[node]).toBe(true);
+          expect10(capabilities.nodes?.[node]).toBe(true);
         }
         for (const op of [
           "and",
@@ -4413,17 +4666,17 @@ function runObjectQueryProviderContractSuite(label, options) {
           "exists",
           "contains"
         ]) {
-          expect9(capabilities.predicateOps?.[op]).toBe(true);
+          expect10(capabilities.predicateOps?.[op]).toBe(true);
         }
-        expect9(capabilities.sortKinds?.property).toBe(true);
-        expect9(capabilities.traversalDirections?.outgoing).toBe(true);
-        expect9(capabilities.traversalDirections?.incoming).toBe(true);
-        expect9(capabilities.setOps?.union).toBe(true);
-        expect9(capabilities.setOps?.intersect).toBe(true);
-        expect9(capabilities.setOps?.subtract).toBe(true);
+        expect10(capabilities.sortKinds?.property).toBe(true);
+        expect10(capabilities.traversalDirections?.outgoing).toBe(true);
+        expect10(capabilities.traversalDirections?.incoming).toBe(true);
+        expect10(capabilities.setOps?.union).toBe(true);
+        expect10(capabilities.setOps?.intersect).toBe(true);
+        expect10(capabilities.setOps?.subtract).toBe(true);
       });
     });
-    test9("pushes down scalar predicates, boolean groups, sorting, limits, and projections", async () => {
+    test10("pushes down scalar predicates, boolean groups, sorting, limits, and projections", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const result = await executeObjectQuery({
@@ -4464,18 +4717,18 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(result.plan.mode).toBe("pushdown");
-        expect9(ids(result)).toEqual(["room-beta", "room-alpha"]);
-        expect9(result.objects[0]?.properties).toEqual({
+        expect10(result.plan.mode).toBe("pushdown");
+        expect10(ids(result)).toEqual(["room-beta", "room-alpha"]);
+        expect10(result.objects[0]?.properties).toEqual({
           id: "room-beta",
           name: "Beta Lab",
           capacity: 30
         });
-        expect9(result.total).toBe(2);
-        expect9(result.hasMore).toBe(false);
+        expect10(result.total).toBe(2);
+        expect10(result.hasMore).toBe(false);
       });
     });
-    test9("matches null, missing, neq, in, and not predicate semantics", async () => {
+    test10("matches null, missing, neq, in, and not predicate semantics", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const nullable = await executeObjectQuery({
@@ -4538,18 +4791,18 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(ids(nullable)).toEqual(["room-missing-floor", "room-null-floor"]);
-        expect9(ids(notTwoOrNull)).toEqual(["room-gamma", "room-null-floor"]);
-        expect9(ids(notNullFloor)).toEqual([
+        expect10(ids(nullable)).toEqual(["room-missing-floor", "room-null-floor"]);
+        expect10(ids(notTwoOrNull)).toEqual(["room-gamma", "room-null-floor"]);
+        expect10(ids(notNullFloor)).toEqual([
           "room-alpha",
           "room-beta",
           "room-gamma",
           "room-missing-floor"
         ]);
-        expect9(ids(notFloorTwo)).toEqual(["room-gamma", "room-missing-floor", "room-null-floor"]);
+        expect10(ids(notFloorTwo)).toEqual(["room-gamma", "room-missing-floor", "room-null-floor"]);
       });
     });
-    test9("keeps page tokens stable when projection hides sorted cursor fields", async () => {
+    test10("keeps page tokens stable when projection hides sorted cursor fields", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const input = {
@@ -4577,18 +4830,18 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "page", pageSize: 2, pageToken: page1.nextPageToken, input }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(page1.plan.mode).toBe("pushdown");
-        expect9(ids(page1)).toEqual(["room-beta", "room-gamma"]);
-        expect9(page1.objects.map((row) => row.properties)).toEqual([
+        expect10(page1.plan.mode).toBe("pushdown");
+        expect10(ids(page1)).toEqual(["room-beta", "room-gamma"]);
+        expect10(page1.objects.map((row) => row.properties)).toEqual([
           { id: "room-beta" },
           { id: "room-gamma" }
         ]);
-        expect9(page1.hasMore).toBe(true);
-        expect9(page1.nextPageToken).toBeTruthy();
-        expect9(ids(page2)).toEqual(["room-alpha"]);
+        expect10(page1.hasMore).toBe(true);
+        expect10(page1.nextPageToken).toBeTruthy();
+        expect10(ids(page2)).toEqual(["room-alpha"]);
       });
     });
-    test9("omits totals when requested without losing hasMore", async () => {
+    test10("omits totals when requested without losing hasMore", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const limited = await executeObjectQuery({
@@ -4610,20 +4863,20 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "limit", limit: 2, input: { kind: "start", objectTypeId: Room.id } }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(limited.plan.mode).toBe("pushdown");
-        expect9(ids(limited)).toEqual(["room-alpha", "room-beta"]);
-        expect9(limited.total).toBeUndefined();
-        expect9(limited.hasMore).toBe(true);
-        expect9(ids(page)).toEqual(["room-alpha", "room-beta"]);
-        expect9(page.total).toBeUndefined();
-        expect9(page.hasMore).toBe(true);
-        expect9(page.nextPageToken).toBeTruthy();
-        expect9(ids(sortedLimited)).toEqual(["room-beta", "room-alpha"]);
-        expect9(sortedLimited.total).toBeUndefined();
-        expect9(sortedLimited.hasMore).toBe(true);
-      });
-    });
-    test9("counts matching objects without returning rows", async () => {
+        expect10(limited.plan.mode).toBe("pushdown");
+        expect10(ids(limited)).toEqual(["room-alpha", "room-beta"]);
+        expect10(limited.total).toBeUndefined();
+        expect10(limited.hasMore).toBe(true);
+        expect10(ids(page)).toEqual(["room-alpha", "room-beta"]);
+        expect10(page.total).toBeUndefined();
+        expect10(page.hasMore).toBe(true);
+        expect10(page.nextPageToken).toBeTruthy();
+        expect10(ids(sortedLimited)).toEqual(["room-beta", "room-alpha"]);
+        expect10(sortedLimited.total).toBeUndefined();
+        expect10(sortedLimited.hasMore).toBe(true);
+      });
+    });
+    test10("counts matching objects without returning rows", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const active = await countObjects({
@@ -4638,12 +4891,12 @@ function runObjectQueryProviderContractSuite(label, options) {
           projectId: projectId4,
           query: { kind: "limit", limit: 2, input: { kind: "start", objectTypeId: Room.id } }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(active.plan.mode).toBe("pushdown");
-        expect9(active.count).toBe(2);
-        expect9(limited.count).toBe(5);
+        expect10(active.plan.mode).toBe("pushdown");
+        expect10(active.count).toBe(2);
+        expect10(limited.count).toBe(5);
       });
     });
-    test9("checks existence without returning rows", async () => {
+    test10("checks existence without returning rows", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const active = await existsObjects({
@@ -4666,13 +4919,13 @@ function runObjectQueryProviderContractSuite(label, options) {
           projectId: projectId4,
           query: { kind: "limit", limit: 0, input: { kind: "start", objectTypeId: Room.id } }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(active.plan.mode).toBe("pushdown");
-        expect9(active.exists).toBe(true);
-        expect9(missing.exists).toBe(false);
-        expect9(limited.exists).toBe(true);
+        expect10(active.plan.mode).toBe("pushdown");
+        expect10(active.exists).toBe(true);
+        expect10(missing.exists).toBe(false);
+        expect10(limited.exists).toBe(true);
       });
     });
-    test9("plans aggregate operations without outer row-shaping requirements", async () => {
+    test10("plans aggregate operations without outer row-shaping requirements", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const query = {
@@ -4686,19 +4939,19 @@ function runObjectQueryProviderContractSuite(label, options) {
         };
         const count = await countObjects({ projectId: projectId4, query }, { ontology: objectQueryContractOntology, storage });
         const exists = await existsObjects({ projectId: projectId4, query }, { ontology: objectQueryContractOntology, storage });
-        expect9(count.plan.mode).toBe("pushdown");
+        expect10(count.plan.mode).toBe("pushdown");
         if (count.plan.mode !== "pushdown")
           return;
-        expect9(count.plan.query.kind).toBe("text");
-        expect9(count.count).toBe(1);
-        expect9(exists.plan.mode).toBe("pushdown");
+        expect10(count.plan.query.kind).toBe("text");
+        expect10(count.count).toBe(1);
+        expect10(exists.plan.mode).toBe("pushdown");
         if (exists.plan.mode !== "pushdown")
           return;
-        expect9(exists.plan.query.kind).toBe("text");
-        expect9(exists.exists).toBe(true);
+        expect10(exists.plan.query.kind).toBe("text");
+        expect10(exists.exists).toBe(true);
       });
     });
-    test9("counts matching objects by facetable properties without returning rows", async () => {
+    test10("counts matching objects by facetable properties without returning rows", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const status = await facetObjects({
@@ -4717,8 +4970,8 @@ function runObjectQueryProviderContractSuite(label, options) {
             { propertyId: "occupied", limit: 10 }
           ]
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(status.plan.mode).toBe("pushdown");
-        expect9(status.facets).toEqual([
+        expect10(status.plan.mode).toBe("pushdown");
+        expect10(status.facets).toEqual([
           {
             propertyId: "status",
             buckets: [
@@ -4734,10 +4987,10 @@ function runObjectQueryProviderContractSuite(label, options) {
             ]
           }
         ]);
-        expect9(limited.facets).toEqual(status.facets);
+        expect10(limited.facets).toEqual(status.facets);
       });
     });
-    test9("pushes down traversal and set operations", async () => {
+    test10("pushes down traversal and set operations", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const outgoing = await executeObjectQuery({
@@ -4820,18 +5073,18 @@ function runObjectQueryProviderContractSuite(label, options) {
             ]
           }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(outgoing.plan.mode).toBe("pushdown");
-        expect9(incoming.plan.mode).toBe("pushdown");
-        expect9(sortedIds(outgoing)).toEqual(["device-projector", "device-sensor"]);
-        expect9(sortedIds(incoming)).toEqual(["room-alpha", "room-beta", "zone-one"]);
-        expect9(incomingRooms.plan.mode).toBe("pushdown");
-        expect9(sortedIds(incomingRooms)).toEqual(["room-alpha", "room-beta"]);
-        expect9(sortedIds(incomingZones)).toEqual(["zone-one"]);
-        expect9(sortedIds(intersect)).toEqual(["room-alpha", "room-beta"]);
-        expect9(ids(subtract)).toEqual(["room-beta"]);
-      });
-    });
-    test9("hydrates expand links identically via pushdown or bounded fallback", async () => {
+        expect10(outgoing.plan.mode).toBe("pushdown");
+        expect10(incoming.plan.mode).toBe("pushdown");
+        expect10(sortedIds(outgoing)).toEqual(["device-projector", "device-sensor"]);
+        expect10(sortedIds(incoming)).toEqual(["room-alpha", "room-beta", "zone-one"]);
+        expect10(incomingRooms.plan.mode).toBe("pushdown");
+        expect10(sortedIds(incomingRooms)).toEqual(["room-alpha", "room-beta"]);
+        expect10(sortedIds(incomingZones)).toEqual(["zone-one"]);
+        expect10(sortedIds(intersect)).toEqual(["room-alpha", "room-beta"]);
+        expect10(ids(subtract)).toEqual(["room-beta"]);
+      });
+    });
+    test10("hydrates expand links identically via pushdown or bounded fallback", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const outgoing = await executeObjectQuery({
@@ -4851,9 +5104,9 @@ function runObjectQueryProviderContractSuite(label, options) {
           }
         }, { ontology: objectQueryContractOntology, storage });
         const expandMode = storage.queryCapabilities().nodes?.expand ? "pushdown" : "fallback";
-        expect9(outgoing.plan.mode).toBe(expandMode);
-        expect9(expandedIds(outgoing, "room-alpha", "hasDevice")).toEqual(["device-projector"]);
-        expect9(expandedIds(outgoing, "room-beta", "hasDevice")).toEqual(["device-sensor"]);
+        expect10(outgoing.plan.mode).toBe(expandMode);
+        expect10(expandedIds(outgoing, "room-alpha", "hasDevice")).toEqual(["device-projector"]);
+        expect10(expandedIds(outgoing, "room-beta", "hasDevice")).toEqual(["device-sensor"]);
         const incoming = await executeObjectQuery({
           projectId: projectId4,
           query: {
@@ -4866,15 +5119,15 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(incoming.plan.mode).toBe(expandMode);
-        expect9(expandedIds(incoming, "device-projector", "hasDevice")).toEqual([
+        expect10(incoming.plan.mode).toBe(expandMode);
+        expect10(expandedIds(incoming, "device-projector", "hasDevice")).toEqual([
           "room-alpha",
           "zone-one"
         ]);
-        expect9(expandedIds(incoming, "device-sensor", "hasDevice")).toEqual(["room-beta"]);
+        expect10(expandedIds(incoming, "device-sensor", "hasDevice")).toEqual(["room-beta"]);
       });
     });
-    test9("expands includeSubtypes outside storage when the expanded query can push down", async () => {
+    test10("expands includeSubtypes outside storage when the expanded query can push down", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const result = await executeObjectQuery({
@@ -4885,11 +5138,11 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "start", objectTypeId: Asset.id, includeSubtypes: true }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(result.plan.mode).toBe("pushdown");
-        expect9(sortedIds(result)).toEqual(["asset-base", "laptop-1"]);
+        expect10(result.plan.mode).toBe("pushdown");
+        expect10(sortedIds(result)).toEqual(["asset-base", "laptop-1"]);
       });
     });
-    test9("pushes down basic text search using search profile defaults", async () => {
+    test10("pushes down basic text search using search profile defaults", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const result = await executeObjectQuery({
@@ -4904,11 +5157,11 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(result.plan.mode).toBe("pushdown");
-        expect9(ids(result)).toEqual(["room-alpha"]);
+        expect10(result.plan.mode).toBe("pushdown");
+        expect10(ids(result)).toEqual(["room-alpha"]);
       });
     });
-    test9("scopes search profile defaults by object type for subtype text queries", async () => {
+    test10("scopes search profile defaults by object type for subtype text queries", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await fixture.seed({
           objects: [
@@ -4934,10 +5187,10 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        expect9(ids(result)).toEqual(["default-child"]);
+        expect10(ids(result)).toEqual(["default-child"]);
       });
     });
-    test9("executes or rejects relevance sorting according to provider capabilities", async () => {
+    test10("executes or rejects relevance sorting according to provider capabilities", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const query = {
@@ -4951,14 +5204,14 @@ function runObjectQueryProviderContractSuite(label, options) {
         };
         if (storage.queryCapabilities().sortKinds?.relevance === true) {
           const result = await executeObjectQuery({ projectId: projectId4, query }, { ontology: objectQueryContractOntology, storage });
-          expect9(result.plan.mode).toBe("pushdown");
-          expect9(ids(result)).toEqual(["room-alpha"]);
+          expect10(result.plan.mode).toBe("pushdown");
+          expect10(ids(result)).toEqual(["room-alpha"]);
           return;
         }
         await expectPlanningIssue(executeObjectQuery({ projectId: projectId4, query }, { ontology: objectQueryContractOntology, storage }), "sort_kind_not_supported");
       });
     });
-    test9("executes or rejects vector search according to provider capabilities", async () => {
+    test10("executes or rejects vector search according to provider capabilities", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const query = {
@@ -4970,14 +5223,14 @@ function runObjectQueryProviderContractSuite(label, options) {
         };
         if (storage.queryCapabilities().nodes?.vector === true) {
           const result = await executeObjectQuery({ projectId: projectId4, query }, { ontology: objectQueryContractOntology, storage });
-          expect9(result.plan.mode).toBe("pushdown");
-          expect9(ids(result)).toEqual(["room-alpha", "room-beta"]);
+          expect10(result.plan.mode).toBe("pushdown");
+          expect10(ids(result)).toEqual(["room-alpha", "room-beta"]);
           return;
         }
         await expectPlanningIssue(executeObjectQuery({ projectId: projectId4, query }, { ontology: objectQueryContractOntology, storage }), "query_node_not_supported");
       });
     });
-    test9("executes bounded fallback when pushdown is disabled for a safe query", async () => {
+    test10("executes bounded fallback when pushdown is disabled for a safe query", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const fallbackStorage = withoutQueryPushdown(storage);
@@ -4997,11 +5250,11 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage: fallbackStorage, maxFallbackRows: 20 });
-        expect9(result.plan.mode).toBe("fallback");
-        expect9(ids(result)).toEqual(["room-alpha", "room-beta"]);
+        expect10(result.plan.mode).toBe("fallback");
+        expect10(ids(result)).toEqual(["room-alpha", "room-beta"]);
       });
     });
-    test9("rejects fallback for unsupported query nodes when pushdown is disabled", async () => {
+    test10("rejects fallback for unsupported query nodes when pushdown is disabled", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const fallbackStorage = withoutQueryPushdown(storage);
@@ -5144,16 +5397,16 @@ async function expectPlanningIssue(promise, code) {
   try {
     await promise;
   } catch (error) {
-    expect9(error).toBeInstanceOf(ObjectQueryPlanningError);
+    expect10(error).toBeInstanceOf(ObjectQueryPlanningError);
     if (error instanceof ObjectQueryPlanningError) {
-      expect9(error.issues.map((issue) => issue.code)).toContain(code);
+      expect10(error.issues.map((issue) => issue.code)).toContain(code);
     }
     return;
   }
   throw new Error(`Expected ObjectQueryPlanningError with code '${code}'`);
 }
 // src/testing/ontology-storage-contract.ts
-import { describe as describe9, expect as expect10, test as test10 } from "bun:test";
+import { describe as describe10, expect as expect11, test as test11 } from "bun:test";
 var replacementIdentity = (versionId, projectionId = "contract.devices") => ({
   projectionId,
   projectionKind: "object",
@@ -5187,31 +5440,31 @@ function runOntologyStorageContractSuite(label, options) {
       await options.cleanup?.(storage);
     }
   };
-  describe9(label, () => {
-    test10("stores one authoritative commit and rejects duplicate commit identities", async () => {
+  describe10(label, () => {
+    test11("stores one authoritative commit and rejects duplicate commit identities", async () => {
       await withStorage(async (storage) => {
         await commitEmptyEdit(storage, "commit-one");
         const stored = await storage.ontology.commits.getById({
           projectId: "contract-project",
           id: "commit-one"
         });
-        expect10(stored).toMatchObject({
+        expect11(stored).toMatchObject({
           id: "commit-one",
           idempotencyKey: "runtime:commit-one",
           requestHash: "hash:commit-one",
           result: { commitId: "commit-one" }
         });
-        expect10(await storage.ontology.commits.getByIdempotencyKey({
+        expect11(await storage.ontology.commits.getByIdempotencyKey({
           projectId: "contract-project",
           idempotencyKey: "runtime:commit-one"
         })).toEqual(stored);
-        await expect10(commitEmptyEdit(storage, "commit-one")).rejects.toMatchObject({
+        await expect11(commitEmptyEdit(storage, "commit-one")).rejects.toMatchObject({
           kind: "idempotency"
         });
         const divergent = structuredClone(contractEditHeader("different-id"));
         divergent.commit.idempotencyKey = "runtime:commit-one";
         divergent.commit.requestHash = "different-hash";
-        await expect10(storage.transaction(async (tx) => {
+        await expect11(storage.transaction(async (tx) => {
           await tx.ontology.materializations.begin(divergent);
         })).rejects.toMatchObject({ kind: "idempotency" });
         const list = await storage.ontology.commits.list({
@@ -5219,25 +5472,25 @@ function runOntologyStorageContractSuite(label, options) {
           limit: 1,
           offset: 0
         });
-        expect10(list).toMatchObject({ total: 1, hasMore: false });
-        expect10(list.commits.map((commit) => commit.id)).toEqual(["commit-one"]);
+        expect11(list).toMatchObject({ total: 1, hasMore: false });
+        expect11(list.commits.map((commit) => commit.id)).toEqual(["commit-one"]);
       });
     });
-    test10("rejects unfinished sessions and rolls back their authoritative writes", async () => {
+    test11("rejects unfinished sessions and rolls back their authoritative writes", async () => {
       await withStorage(async (storage) => {
         const header = contractEditHeader("session-contract");
-        await expect10(storage.ontology.materializations.begin(header)).rejects.toThrow("active storage transaction");
-        await expect10(commitExactObject(storage, "unfinished-session", { omitFinalize: true })).rejects.toThrow("unfinished materialization session");
-        expect10(await storage.objects.getByPrimaryId({
+        await expect11(storage.ontology.materializations.begin(header)).rejects.toThrow("active storage transaction");
+        await expect11(commitExactObject(storage, "unfinished-session", { omitFinalize: true })).rejects.toThrow("unfinished materialization session");
+        expect11(await storage.objects.getByPrimaryId({
           projectId: "contract-project",
           objectTypeId: "ContractDevice",
           primaryId: "unfinished-session"
         })).toBeNull();
-        expect10(await storage.ontology.commits.getById({
+        expect11(await storage.ontology.commits.getById({
           projectId: "contract-project",
           id: "unfinished-session"
         })).toBeNull();
-        expect10(await storage.ontology.outbox.claim({
+        expect11(await storage.ontology.outbox.claim({
           projectId: "contract-project",
           now: "2027-01-01T00:00:00.000Z",
           limit: 10,
@@ -5245,14 +5498,14 @@ function runOntologyStorageContractSuite(label, options) {
           leaseExpiresAt: "2027-01-01T01:00:00.000Z"
         })).toEqual([]);
         let leakedSession;
-        await expect10(storage.transaction(async (tx) => {
+        await expect11(storage.transaction(async (tx) => {
           leakedSession = await tx.ontology.materializations.begin(contractEditHeader("leaked-session"));
         })).rejects.toThrow("unfinished materialization session");
         if (!leakedSession)
           throw new Error("Expected an unfinished session handle");
         const staleSession = leakedSession;
         await storage.transaction(async (tx) => {
-          await expect10(tx.ontology.materializations.finalize({
+          await expect11(tx.ontology.materializations.finalize({
             session: staleSession,
             finalization: {
               sourceActivations: [],
@@ -5262,7 +5515,7 @@ function runOntologyStorageContractSuite(label, options) {
         });
       });
     });
-    test10("stages insert-only source rows, seals counts, and fences stale execution tokens", async () => {
+    test11("stages insert-only source rows, seals counts, and fences stale execution tokens", async () => {
       await withStorage(async (storage) => {
         const identity = replacementIdentity("01");
         const claimed = await storage.projectionRuns.startOrReclaim({
@@ -5273,7 +5526,7 @@ function runOntologyStorageContractSuite(label, options) {
         });
         const execution2 = claimed.execution;
         const source = { projectionId: identity.projectionId };
-        await expect10(storage.ontology.sources.beginMaterialization({
+        await expect11(storage.ontology.sources.beginMaterialization({
           projectId: "contract-project",
           source,
           materializationId: "mismatched-candidate",
@@ -5299,7 +5552,7 @@ function runOntologyStorageContractSuite(label, options) {
           ontologyRevision: identity.ontologyRevision,
           createdAt: "2026-01-01T00:00:00.000Z"
         });
-        expect10(await storage.ontology.sources.getActive({ projectId: "contract-project", source })).toBeNull();
+        expect11(await storage.ontology.sources.getActive({ projectId: "contract-project", source })).toBeNull();
         const row = {
           root: {
             kind: "object",
@@ -5312,21 +5565,21 @@ function runOntologyStorageContractSuite(label, options) {
           },
           stagingOrdinal: 0
         };
-        expect10(await storage.ontology.sources.stageRows({
+        expect11(await storage.ontology.sources.stageRows({
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
           execution: execution2,
           rows: [row]
         })).toEqual({ inserted: 1, unchanged: 0 });
-        expect10(await storage.ontology.sources.stageRows({
+        expect11(await storage.ontology.sources.stageRows({
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
           execution: execution2,
           rows: [row]
         })).toEqual({ inserted: 0, unchanged: 1 });
-        await expect10(storage.ontology.sources.stageRows({
+        await expect11(storage.ontology.sources.stageRows({
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
@@ -5347,21 +5600,21 @@ function runOntologyStorageContractSuite(label, options) {
           assertionCount: 1,
           readyAt: "2026-01-01T00:01:00.000Z"
         });
-        expect10(ready).toMatchObject({ status: "ready", rootCount: 1, assertionCount: 1 });
+        expect11(ready).toMatchObject({ status: "ready", rootCount: 1, assertionCount: 1 });
         const reclaimed = await storage.projectionRuns.startOrReclaim({
           id: claimed.run.id,
           projectId: claimed.run.projectId,
           identity,
           target: { objectTypeId: "ContractDevice" }
         });
-        await expect10(storage.ontology.sources.stageRows({
+        await expect11(storage.ontology.sources.stageRows({
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
           execution: execution2,
           rows: []
         })).rejects.toMatchObject({ kind: "execution-lost" });
-        await expect10(storage.ontology.sources.markReady({
+        await expect11(storage.ontology.sources.markReady({
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
@@ -5370,7 +5623,7 @@ function runOntologyStorageContractSuite(label, options) {
           assertionCount: 1,
           readyAt: "2026-01-01T00:03:00.000Z"
         })).rejects.toMatchObject({ kind: "execution-lost" });
-        await expect10(storage.ontology.sources.abandon({
+        await expect11(storage.ontology.sources.abandon({
           kind: "candidate",
           projectId: "contract-project",
           source,
@@ -5385,22 +5638,22 @@ function runOntologyStorageContractSuite(label, options) {
           execution: reclaimed.execution,
           abandonedAt: "2026-01-01T00:02:00.000Z"
         });
-        expect10(abandoned).toMatchObject({ status: "abandoned", executionToken: null });
-        expect10(await storage.ontology.sources.summarizeTerminal({ projectId: "contract-project" })).toEqual({ count: 1, oldestTerminalAt: "2026-01-01T00:02:00.000Z" });
-        expect10(await storage.ontology.sources.cleanupTerminal({
+        expect11(abandoned).toMatchObject({ status: "abandoned", executionToken: null });
+        expect11(await storage.ontology.sources.summarizeTerminal({ projectId: "contract-project" })).toEqual({ count: 1, oldestTerminalAt: "2026-01-01T00:02:00.000Z" });
+        expect11(await storage.ontology.sources.cleanupTerminal({
           projectId: "contract-project",
           terminalBefore: "2026-02-01T00:00:00.000Z",
           limit: 1
         })).toEqual({ rowsDeleted: 1, materializationsDeleted: 0 });
-        expect10(await storage.ontology.sources.cleanupTerminal({
+        expect11(await storage.ontology.sources.cleanupTerminal({
           projectId: "contract-project",
           terminalBefore: "2026-02-01T00:00:00.000Z",
           limit: 1
         })).toEqual({ rowsDeleted: 0, materializationsDeleted: 1 });
-        expect10(await storage.ontology.sources.summarizeTerminal({ projectId: "contract-project" })).toEqual({ count: 0, oldestTerminalAt: null });
+        expect11(await storage.ontology.sources.summarizeTerminal({ projectId: "contract-project" })).toEqual({ count: 0, oldestTerminalAt: null });
       });
     });
-    test10("atomically activates explicit empty candidates and rejects competing stale heads", async () => {
+    test11("atomically activates explicit empty candidates and rejects competing stale heads", async () => {
       await withStorage(async (storage) => {
         const first = await createReadyEmptyCandidate(storage, "run-one", "candidate-one", "01");
         await activateEmptyCandidate(storage, first, null, "commit-source-one", "2026-01-03T00:00:00.000Z");
@@ -5408,27 +5661,27 @@ function runOntologyStorageContractSuite(label, options) {
           projectId: "contract-project",
           source: first.source
         });
-        expect10(activeOne).toMatchObject({
+        expect11(activeOne).toMatchObject({
           materializationId: first.materializationId,
           status: "active",
           rootCount: 0,
           assertionCount: 0,
           executionToken: null
         });
-        expect10(await storage.ontology.commits.getByOrigin({
+        expect11(await storage.ontology.commits.getByOrigin({
           projectId: "contract-project",
           origin: { kind: "projection", projectionRunId: first.execution.projectionRunId }
         })).toMatchObject({ id: "commit-source-one" });
-        await expect10(activateEmptyCandidate(storage, first, activeOne, "duplicate-projection-origin", "2026-01-03T01:00:00.000Z")).rejects.toMatchObject({ kind: "run-correlation" });
+        await expect11(activateEmptyCandidate(storage, first, activeOne, "duplicate-projection-origin", "2026-01-03T01:00:00.000Z")).rejects.toMatchObject({ kind: "run-correlation" });
         const left = await createReadyEmptyCandidate(storage, "run-left", "candidate-left", "02");
         const right = await createReadyEmptyCandidate(storage, "run-right", "candidate-right", "03");
         await activateEmptyCandidate(storage, left, activeOne, "commit-source-left", "2026-01-04T00:00:00.000Z");
-        await expect10(activateEmptyCandidate(storage, right, activeOne, "commit-source-right", "2026-01-05T00:00:00.000Z")).rejects.toMatchObject({ kind: "projection-fence" });
+        await expect11(activateEmptyCandidate(storage, right, activeOne, "commit-source-right", "2026-01-05T00:00:00.000Z")).rejects.toMatchObject({ kind: "projection-fence" });
         const currentActive = await storage.ontology.sources.getActive({
           projectId: "contract-project",
           source: first.source
         });
-        expect10(currentActive).toMatchObject({ materializationId: left.materializationId });
+        expect11(currentActive).toMatchObject({ materializationId: left.materializationId });
         const stale = await createReadyEmptyCandidate(storage, "run-stale-activation", "candidate-stale-activation", "04");
         const reclaimed = await storage.projectionRuns.startOrReclaim({
           id: stale.execution.projectionRunId,
@@ -5436,7 +5689,7 @@ function runOntologyStorageContractSuite(label, options) {
           identity: stale.identity,
           target: { objectTypeId: "ContractDevice" }
         });
-        await expect10(activateEmptyCandidate(storage, stale, currentActive, "commit-stale-activation", "2026-01-06T00:00:00.000Z")).rejects.toThrow("execution token is stale");
+        await expect11(activateEmptyCandidate(storage, stale, currentActive, "commit-stale-activation", "2026-01-06T00:00:00.000Z")).rejects.toThrow("execution token is stale");
         await storage.ontology.sources.abandon({
           kind: "reclaim",
           projectId: "contract-project",
@@ -5449,12 +5702,12 @@ function runOntologyStorageContractSuite(label, options) {
           terminalBefore: "2026-02-01T00:00:00.000Z",
           limit: 10
         });
-        expect10(cleanup.materializationsDeleted).toBeGreaterThanOrEqual(1);
-        expect10(await storage.ontology.sources.getActive({
+        expect11(cleanup.materializationsDeleted).toBeGreaterThanOrEqual(1);
+        expect11(await storage.ontology.sources.getActive({
           projectId: "contract-project",
           source: first.source
         })).toMatchObject({ materializationId: left.materializationId });
-        expect10(await storage.ontology.sources.abandon({
+        expect11(await storage.ontology.sources.abandon({
           kind: "candidate",
           projectId: "contract-project",
           source: right.source,
@@ -5464,19 +5717,19 @@ function runOntologyStorageContractSuite(label, options) {
         })).toMatchObject({ status: "abandoned" });
       });
     });
-    test10("rolls back exact rows, commits, and outbox writes through one transaction facade", async () => {
+    test11("rolls back exact rows, commits, and outbox writes through one transaction facade", async () => {
       await withStorage(async (storage) => {
-        await expect10(commitExactObject(storage, "rolled-back", { throwAfterFinalize: true })).rejects.toThrow("contract rollback");
-        expect10(await storage.objects.getByPrimaryId({
+        await expect11(commitExactObject(storage, "rolled-back", { throwAfterFinalize: true })).rejects.toThrow("contract rollback");
+        expect11(await storage.objects.getByPrimaryId({
           projectId: "contract-project",
           objectTypeId: "ContractDevice",
           primaryId: "rolled-back"
         })).toBeNull();
-        expect10(await storage.ontology.commits.getById({
+        expect11(await storage.ontology.commits.getById({
           projectId: "contract-project",
           id: "rolled-back"
         })).toBeNull();
-        expect10(await storage.ontology.outbox.claim({
+        expect11(await storage.ontology.outbox.claim({
           projectId: "contract-project",
           now: "2027-01-01T00:00:00.000Z",
           limit: 10,
@@ -5484,28 +5737,28 @@ function runOntologyStorageContractSuite(label, options) {
           leaseExpiresAt: "2027-01-01T01:00:00.000Z"
         })).toEqual([]);
         await commitExactObject(storage, "committed");
-        expect10(await storage.objects.getByPrimaryId({
+        expect11(await storage.objects.getByPrimaryId({
           projectId: "contract-project",
           objectTypeId: "ContractDevice",
           primaryId: "committed"
         })).toMatchObject({ properties: { name: "committed" }, lastCommitId: "committed" });
-        await expect10(commitExactObject(storage, "stale-object-cas", { primaryId: "committed" })).rejects.toThrow("to be absent");
-        expect10(await storage.ontology.commits.getById({
+        await expect11(commitExactObject(storage, "stale-object-cas", { primaryId: "committed" })).rejects.toThrow("to be absent");
+        expect11(await storage.ontology.commits.getById({
           projectId: "contract-project",
           id: "stale-object-cas"
         })).toBeNull();
-        expect10(await storage.objects.getByPrimaryId({
+        expect11(await storage.objects.getByPrimaryId({
           projectId: "contract-project",
           objectTypeId: "ContractDevice",
           primaryId: "committed"
         })).toMatchObject({ properties: { name: "committed" }, lastCommitId: "committed" });
       });
     });
-    test10("leases outbox rows exclusively, reclaims expiry, fences stale workers, and purges", async () => {
+    test11("leases outbox rows exclusively, reclaims expiry, fences stale workers, and purges", async () => {
       await withStorage(async (storage) => {
         const outboxB = await commitExactObject(storage, "outbox-b");
         const outboxA = await commitExactObject(storage, "outbox-a");
-        await expect10(storage.ontology.outbox.claim({
+        await expect11(storage.ontology.outbox.claim({
           projectId: "contract-project",
           now: "2026-01-02T19:00:00-05:00",
           limit: 1,
@@ -5519,9 +5772,9 @@ function runOntologyStorageContractSuite(label, options) {
           leaseId: "lease-one",
           leaseExpiresAt: "2026-01-03T01:00:00.000Z"
         });
-        expect10(first).toHaveLength(1);
-        expect10(first[0]).toMatchObject({ attempts: 1, leaseId: "lease-one" });
-        expect10(first[0].envelope.id).toBe([outboxA.eventId, outboxB.eventId].sort()[0]);
+        expect11(first).toHaveLength(1);
+        expect11(first[0]).toMatchObject({ attempts: 1, leaseId: "lease-one" });
+        expect11(first[0].envelope.id).toBe([outboxA.eventId, outboxB.eventId].sort()[0]);
         const concurrent = await storage.ontology.outbox.claim({
           projectId: "contract-project",
           now: "2026-01-03T00:30:00.000Z",
@@ -5529,8 +5782,8 @@ function runOntologyStorageContractSuite(label, options) {
           leaseId: "lease-concurrent",
           leaseExpiresAt: "2026-01-03T01:30:00.000Z"
         });
-        expect10(concurrent).toHaveLength(1);
-        expect10(concurrent[0].envelope.id).not.toBe(first[0].envelope.id);
+        expect11(concurrent).toHaveLength(1);
+        expect11(concurrent[0].envelope.id).not.toBe(first[0].envelope.id);
         const reclaimed = await storage.ontology.outbox.claim({
           projectId: "contract-project",
           now: "2026-01-03T02:00:00.000Z",
@@ -5538,8 +5791,8 @@ function runOntologyStorageContractSuite(label, options) {
           leaseId: "lease-two",
           leaseExpiresAt: "2026-01-03T03:00:00.000Z"
         });
-        expect10(reclaimed[0].envelope.id).toBe(first[0].envelope.id);
-        await expect10(storage.ontology.outbox.markPublished({
+        expect11(reclaimed[0].envelope.id).toBe(first[0].envelope.id);
+        await expect11(storage.ontology.outbox.markPublished({
           projectId: "contract-project",
           ids: [first[0].envelope.id],
           leaseId: "lease-one",
@@ -5559,22 +5812,22 @@ function runOntologyStorageContractSuite(label, options) {
           leaseId: "lease-three",
           leaseExpiresAt: "2026-01-04T01:00:00.000Z"
         });
-        expect10(retried[0]).toMatchObject({ attempts: 3, lastError: "broker unavailable" });
-        expect10(await storage.ontology.outbox.summarize({ projectId: "contract-project" })).toMatchObject({ pendingCount: 2, retryingCount: 2, maxAttempts: 3 });
+        expect11(retried[0]).toMatchObject({ attempts: 3, lastError: "broker unavailable" });
+        expect11(await storage.ontology.outbox.summarize({ projectId: "contract-project" })).toMatchObject({ pendingCount: 2, retryingCount: 2, maxAttempts: 3 });
         await storage.ontology.outbox.markPublished({
           projectId: "contract-project",
           ids: [retried[0].envelope.id],
           leaseId: "lease-three",
           publishedAt: "2026-01-04T00:30:00.000Z"
         });
-        expect10(await storage.ontology.outbox.purgePublished({
+        expect11(await storage.ontology.outbox.purgePublished({
           projectId: "contract-project",
           publishedBefore: "2026-01-05T00:00:00.000Z",
           limit: 1
         })).toBe(1);
       });
     });
-    test10("keeps batch outbox settlement atomic when callers catch a stale lease", async () => {
+    test11("keeps batch outbox settlement atomic when callers catch a stale lease", async () => {
       await withStorage(async (storage) => {
         await commitExactObject(storage, "lease-atomic-a");
         await commitExactObject(storage, "lease-atomic-b");
@@ -5585,7 +5838,7 @@ function runOntologyStorageContractSuite(label, options) {
           leaseId: "lease-atomic-old",
           leaseExpiresAt: "2026-01-03T01:00:00.000Z"
         });
-        expect10(claimed).toHaveLength(2);
+        expect11(claimed).toHaveLength(2);
         const [reclaimed] = await storage.ontology.outbox.claim({
           projectId: "contract-project",
           now: "2026-01-03T02:00:00.000Z",
@@ -5607,7 +5860,7 @@ function runOntologyStorageContractSuite(label, options) {
             conflict = error;
           }
         });
-        expect10(conflict).toMatchObject({ kind: "outbox-lease" });
+        expect11(conflict).toMatchObject({ kind: "outbox-lease" });
         await storage.ontology.outbox.markPublished({
           projectId: "contract-project",
           ids: [untouched.envelope.id],
@@ -5616,7 +5869,7 @@ function runOntologyStorageContractSuite(label, options) {
         });
       });
     });
-    test10("rolls back a telemetry checkpoint with its authoritative ontology commit", async () => {
+    test11("rolls back a telemetry checkpoint with its authoritative ontology commit", async () => {
       await withStorage(async (storage) => {
         const identity = {
           projectionId: "contract.telemetry",
@@ -5676,20 +5929,20 @@ function runOntologyStorageContractSuite(label, options) {
               throw new Error("telemetry rollback");
           });
         };
-        await expect10(execute(true)).rejects.toThrow("telemetry rollback");
-        expect10(await storage.ontology.commits.getByOrigin({
+        await expect11(execute(true)).rejects.toThrow("telemetry rollback");
+        expect11(await storage.ontology.commits.getByOrigin({
           projectId: "contract-project",
           origin: { kind: "telemetry", projectionRunId: run.run.id, batchOrdinal: 0 }
         })).toBeNull();
-        expect10(await storage.projectionRuns.getById({ projectId: run.run.projectId, id: run.run.id })).toMatchObject({
+        expect11(await storage.projectionRuns.getById({ projectId: run.run.projectId, id: run.run.id })).toMatchObject({
           telemetryCheckpoint: { nextBatchOrdinal: 0, nextRowOffset: 0, inputExhausted: false }
         });
         await execute(false);
-        expect10(await storage.ontology.commits.getByOrigin({
+        expect11(await storage.ontology.commits.getByOrigin({
           projectId: "contract-project",
           origin: { kind: "telemetry", projectionRunId: run.run.id, batchOrdinal: 0 }
         })).toMatchObject({ id: "telemetry-commit" });
-        expect10(await storage.projectionRuns.getById({ projectId: run.run.projectId, id: run.run.id })).toMatchObject({
+        expect11(await storage.projectionRuns.getById({ projectId: run.run.projectId, id: run.run.id })).toMatchObject({
           telemetryCheckpoint: { nextBatchOrdinal: 1, nextRowOffset: 2, inputExhausted: true }
         });
       });
@@ -5853,7 +6106,7 @@ function telemetryHeader(identity, projectionRunId) {
   };
 }
 // src/testing/projection-run-storage-contract.ts
-import { describe as describe10, expect as expect11, test as test11 } from "bun:test";
+import { describe as describe11, expect as expect12, test as test12 } from "bun:test";
 var projectId5 = "contract-project";
 var objectTarget = { objectTypeId: "Device" };
 var replacementIdentity2 = {
@@ -5892,62 +6145,62 @@ function runProjectionRunStorageContractSuite(label, options) {
       await options.cleanup?.(storage);
     }
   };
-  describe10(label, () => {
-    test11("keeps one run while reclaim rotates its execution", async () => {
+  describe11(label, () => {
+    test12("keeps one run while reclaim rotates its execution", async () => {
       await withStorage(async (storage) => {
         const input = replacementInput("replacement-run");
         const first = await storage.startOrReclaim(input);
         const second = await storage.startOrReclaim(input);
-        expect11(first.run).toMatchObject({ id: input.id, attempt: 1, status: "running" });
-        expect11(second.run).toMatchObject({ id: input.id, attempt: 2, status: "running" });
-        expect11(second.execution.executionToken).not.toBe(first.execution.executionToken);
-        expect11(second.run).not.toHaveProperty("executionToken");
-        expect11(await storage.getById({ projectId: projectId5, id: input.id })).toMatchObject({
+        expect12(first.run).toMatchObject({ id: input.id, attempt: 1, status: "running" });
+        expect12(second.run).toMatchObject({ id: input.id, attempt: 2, status: "running" });
+        expect12(second.execution.executionToken).not.toBe(first.execution.executionToken);
+        expect12(second.run).not.toHaveProperty("executionToken");
+        expect12(await storage.getById({ projectId: projectId5, id: input.id })).toMatchObject({
           identity: replacementIdentity2,
           target: objectTarget,
           progress: { sourceRowsRead: 0, sourceRowsSkipped: 0 }
         });
       });
     });
-    test11("fences every stale lock, progress, and terminal write", async () => {
+    test12("fences every stale lock, progress, and terminal write", async () => {
       await withStorage(async (storage) => {
         const input = replacementInput("fenced-run");
         const stale = await storage.startOrReclaim(input);
         const current = await storage.startOrReclaim(input);
-        await expect11(storage.lockForMaterialization(executionInput(stale))).rejects.toThrow("execution token is stale");
-        await expect11(storage.update({
+        await expect12(storage.lockForMaterialization(executionInput(stale))).rejects.toThrow("execution token is stale");
+        await expect12(storage.update({
           ...executionInput(stale),
           progress: { sourceRowsRead: 1 }
         })).rejects.toThrow("execution token is stale");
-        await expect11(storage.finish({
+        await expect12(storage.finish({
           ...executionInput(stale),
           protocol: "replacement",
           status: "cancelled"
         })).rejects.toThrow("execution token is stale");
-        await expect11(storage.update({
+        await expect12(storage.update({
           ...executionInput(current),
           progress: { sourceRowsRead: 3 }
         })).resolves.toMatchObject({ progress: { sourceRowsRead: 3 } });
       });
     });
-    test11("rejects immutable identity and target drift", async () => {
+    test12("rejects immutable identity and target drift", async () => {
       await withStorage(async (storage) => {
         const input = replacementInput("identity-run");
         const claim2 = await storage.startOrReclaim(input);
         const changedIdentity = { ...replacementIdentity2, ownershipHash: "different-ownership" };
-        await expect11(storage.startOrReclaim({ ...input, identity: changedIdentity })).rejects.toThrow("identity does not match");
-        await expect11(storage.startOrReclaim({ ...input, target: { objectTypeId: "OtherDevice" } })).rejects.toThrow("target object types do not match");
-        await expect11(storage.lockForMaterialization({
+        await expect12(storage.startOrReclaim({ ...input, identity: changedIdentity })).rejects.toThrow("identity does not match");
+        await expect12(storage.startOrReclaim({ ...input, target: { objectTypeId: "OtherDevice" } })).rejects.toThrow("target object types do not match");
+        await expect12(storage.lockForMaterialization({
           ...executionInput(claim2),
           identity: changedIdentity
         })).rejects.toThrow("identity does not match");
       });
     });
-    test11("keeps physical progress monotone and internally consistent", async () => {
+    test12("keeps physical progress monotone and internally consistent", async () => {
       await withStorage(async (storage) => {
         const claim2 = await storage.startOrReclaim(replacementInput("progress-run"));
         const execution2 = executionInput(claim2);
-        await expect11(storage.update({
+        await expect12(storage.update({
           ...execution2,
           progress: { sourceRowsRead: 1, sourceRowsSkipped: 2 }
         })).rejects.toThrow("sourceRowsSkipped must not exceed sourceRowsRead");
@@ -5955,13 +6208,13 @@ function runProjectionRunStorageContractSuite(label, options) {
           ...execution2,
           progress: { sourceRowsRead: 5, sourceRowsSkipped: 1 }
         });
-        await expect11(storage.update({ ...execution2, progress: { sourceRowsRead: 4 } })).rejects.toThrow("must not decrease");
+        await expect12(storage.update({ ...execution2, progress: { sourceRowsRead: 4 } })).rejects.toThrow("must not decrease");
       });
     });
-    test11("rejects immutable dataset-version metadata reuse", async () => {
+    test12("rejects immutable dataset-version metadata reuse", async () => {
       await withStorage(async (storage) => {
         await storage.startOrReclaim(replacementInput("dataset-metadata-first"));
-        await expect11(storage.startOrReclaim({
+        await expect12(storage.startOrReclaim({
           ...replacementInput("dataset-metadata-conflict"),
           identity: {
             ...replacementIdentity2,
@@ -5973,7 +6226,7 @@ function runProjectionRunStorageContractSuite(label, options) {
         })).rejects.toThrow("immutable dataset version id with different metadata");
       });
     });
-    test11("advances telemetry in contiguous fixed physical batches", async () => {
+    test12("advances telemetry in contiguous fixed physical batches", async () => {
       await withStorage(async (storage) => {
         const claim2 = await storage.startOrReclaim({
           id: "telemetry-run",
@@ -5983,7 +6236,7 @@ function runProjectionRunStorageContractSuite(label, options) {
           fixedBatchSize: 3
         });
         const execution2 = executionInput(claim2);
-        expect11(claim2.run).toMatchObject({
+        expect12(claim2.run).toMatchObject({
           telemetryCheckpoint: {
             fixedBatchSize: 3,
             nextBatchOrdinal: 0,
@@ -5991,7 +6244,7 @@ function runProjectionRunStorageContractSuite(label, options) {
             inputExhausted: false
           }
         });
-        await expect11(storage.update({ ...execution2, progress: { sourceRowsRead: 1 } })).rejects.toThrow("can only advance with its checkpoint");
+        await expect12(storage.update({ ...execution2, progress: { sourceRowsRead: 1 } })).rejects.toThrow("can only advance with its checkpoint");
         await storage.advanceTelemetryCheckpoint({
           ...execution2,
           batchOrdinal: 0,
@@ -5999,14 +6252,14 @@ function runProjectionRunStorageContractSuite(label, options) {
           batchRowsSkipped: 1,
           inputExhausted: false
         });
-        await expect11(storage.advanceTelemetryCheckpoint({
+        await expect12(storage.advanceTelemetryCheckpoint({
           ...execution2,
           batchOrdinal: 2,
           batchRowCount: 1,
           batchRowsSkipped: 0,
           inputExhausted: true
         })).rejects.toThrow("expected batch ordinal 1");
-        await expect11(storage.advanceTelemetryCheckpoint({
+        await expect12(storage.advanceTelemetryCheckpoint({
           ...execution2,
           batchOrdinal: 1,
           batchRowCount: 1,
@@ -6020,13 +6273,13 @@ function runProjectionRunStorageContractSuite(label, options) {
           batchRowsSkipped: 1,
           inputExhausted: true
         });
-        expect11(exhausted).toMatchObject({
+        expect12(exhausted).toMatchObject({
           progress: { sourceRowsRead: 5, sourceRowsSkipped: 2 },
           telemetryCheckpoint: { nextBatchOrdinal: 2, nextRowOffset: 5, inputExhausted: true }
         });
       });
     });
-    test11("keeps a missing target until the batch it blocks commits", async () => {
+    test12("keeps a missing target until the batch it blocks commits", async () => {
       await withStorage(async (storage) => {
         const claim2 = await storage.startOrReclaim({
           id: "telemetry-missing-target-run",
@@ -6044,13 +6297,13 @@ function runProjectionRunStorageContractSuite(label, options) {
           firstSeenAt
         };
         const waiting = await storage.recordMissingTarget({ ...execution2, missingTarget });
-        expect11(waiting.missingTarget).toEqual(missingTarget);
-        expect11((await storage.getById({ projectId: projectId5, id: "telemetry-missing-target-run" }))?.missingTarget).toEqual(missingTarget);
-        await expect11(storage.recordMissingTarget({
+        expect12(waiting.missingTarget).toEqual(missingTarget);
+        expect12((await storage.getById({ projectId: projectId5, id: "telemetry-missing-target-run" }))?.missingTarget).toEqual(missingTarget);
+        await expect12(storage.recordMissingTarget({
           ...execution2,
           missingTarget: { ...missingTarget, batchOrdinal: 1 }
         })).rejects.toThrow("cannot wait on batch 1");
-        await expect11(storage.recordMissingTarget({
+        await expect12(storage.recordMissingTarget({
           ...execution2,
           missingTarget: { ...missingTarget, objectTypeId: "Building" }
         })).rejects.toThrow("cannot wait on 'Building'");
@@ -6059,7 +6312,7 @@ function runProjectionRunStorageContractSuite(label, options) {
           { objectTypeId: "" },
           { firstSeenAt: new Date(Number.NaN) }
         ]) {
-          await expect11(storage.recordMissingTarget({
+          await expect12(storage.recordMissingTarget({
             ...execution2,
             missingTarget: { ...missingTarget, ...partial }
           })).rejects.toThrow();
@@ -6068,7 +6321,7 @@ function runProjectionRunStorageContractSuite(label, options) {
           ...execution2,
           missingTarget: { ...missingTarget, firstSeenAt: new Date("2026-06-01T12:01:00.000Z") }
         });
-        expect11(rerecorded.missingTarget?.firstSeenAt).toEqual(new Date("2026-06-01T12:01:00.000Z"));
+        expect12(rerecorded.missingTarget?.firstSeenAt).toEqual(new Date("2026-06-01T12:01:00.000Z"));
         const advanced = await storage.advanceTelemetryCheckpoint({
           ...execution2,
           batchOrdinal: 0,
@@ -6076,10 +6329,10 @@ function runProjectionRunStorageContractSuite(label, options) {
           batchRowsSkipped: 0,
           inputExhausted: true
         });
-        expect11(advanced.missingTarget).toBeUndefined();
+        expect12(advanced.missingTarget).toBeUndefined();
       });
     });
-    test11("requires and records explicit telemetry EOF with terminal success", async () => {
+    test12("requires and records explicit telemetry EOF with terminal success", async () => {
       await withStorage(async (storage) => {
         const claim2 = await storage.startOrReclaim({
           id: "empty-telemetry-run",
@@ -6088,12 +6341,12 @@ function runProjectionRunStorageContractSuite(label, options) {
           target: objectTarget,
           fixedBatchSize: 10
         });
-        await expect11(storage.finish({
+        await expect12(storage.finish({
           ...executionInput(claim2),
           protocol: "telemetry",
           status: "succeeded"
         })).rejects.toThrow("cannot succeed before input exhaustion");
-        await expect11(storage.getById({ projectId: projectId5, id: claim2.run.id })).resolves.toMatchObject({
+        await expect12(storage.getById({ projectId: projectId5, id: claim2.run.id })).resolves.toMatchObject({
           status: "running",
           telemetryCheckpoint: { inputExhausted: false }
         });
@@ -6103,21 +6356,21 @@ function runProjectionRunStorageContractSuite(label, options) {
           status: "succeeded",
           inputExhausted: true
         });
-        expect11(finished).toMatchObject({
+        expect12(finished).toMatchObject({
           status: "succeeded",
           progress: { sourceRowsRead: 0 },
           telemetryCheckpoint: { inputExhausted: true }
         });
-        await expect11(storage.lockForMaterialization(executionInput(claim2))).rejects.toThrow("already terminal");
+        await expect12(storage.lockForMaterialization(executionInput(claim2))).rejects.toThrow("already terminal");
       });
     });
-    test11("keeps equal run ids isolated by project", async () => {
+    test12("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" });
-        expect11(await storage.getById({ projectId: "project-a", id: "shared-id" })).not.toBeNull();
-        expect11(await storage.getById({ projectId: "project-b", id: "shared-id" })).not.toBeNull();
-        expect11(await storage.getById({ projectId: "project-c", id: "shared-id" })).toBeNull();
+        expect12(await storage.getById({ projectId: "project-a", id: "shared-id" })).not.toBeNull();
+        expect12(await storage.getById({ projectId: "project-b", id: "shared-id" })).not.toBeNull();
+        expect12(await storage.getById({ projectId: "project-c", id: "shared-id" })).toBeNull();
       });
     });
   });
@@ -6134,7 +6387,7 @@ function executionInput(claim2) {
   };
 }
 // src/testing/queues-contract.ts
-import { describe as describe11, expect as expect12, test as test12 } from "bun:test";
+import { describe as describe12, expect as expect13, test as test13 } from "bun:test";
 function runQueueContractSuite(label, options) {
   const shortLeaseMs = options.shortLeaseMs ?? 20;
   const leaseExpiryRedeliveryMs = options.leaseExpiryRedeliveryMs ?? shortLeaseMs + 10;
@@ -6147,9 +6400,9 @@ function runQueueContractSuite(label, options) {
       await options.teardown?.(queues);
     }
   };
-  describe11(label, () => {
-    describe11("enqueue", () => {
-      test12("returns envelopes with generated id, createdAt, availableAt, attempt=0", async () => {
+  describe12(label, () => {
+    describe12("enqueue", () => {
+      test13("returns envelopes with generated id, createdAt, availableAt, attempt=0", async () => {
         await withQueues(async (queues) => {
           const before = Date.now();
           const [job] = await queues.syncRuns.enqueue({
@@ -6161,16 +6414,16 @@ function runQueueContractSuite(label, options) {
               }
             ]
           });
-          expect12(job?.id).toMatch(/^[0-9a-f-]{36}$/);
-          expect12(job?.projectId).toBe("project-a");
-          expect12(job?.attempt).toBe(0);
-          expect12(job?.type).toBe("sync.run.requested");
-          expect12(job?.payload.syncId).toBe("sync-1");
-          expect12(Date.parse(job.createdAt)).toBeGreaterThanOrEqual(before);
-          expect12(job?.availableAt).toBe(job?.createdAt);
+          expect13(job?.id).toMatch(/^[0-9a-f-]{36}$/);
+          expect13(job?.projectId).toBe("project-a");
+          expect13(job?.attempt).toBe(0);
+          expect13(job?.type).toBe("sync.run.requested");
+          expect13(job?.payload.syncId).toBe("sync-1");
+          expect13(Date.parse(job.createdAt)).toBeGreaterThanOrEqual(before);
+          expect13(job?.availableAt).toBe(job?.createdAt);
         });
       });
-      test12("deduplicates repeated enqueue with a caller-supplied id", async () => {
+      test13("deduplicates repeated enqueue with a caller-supplied id", async () => {
         await withQueues(async (queues) => {
           const input = {
             id: "dispatch-run-1",
@@ -6181,12 +6434,12 @@ function runQueueContractSuite(label, options) {
             queues.syncRuns.enqueue({ projectId: "project-a", jobs: [input] }),
             queues.syncRuns.enqueue({ projectId: "project-a", jobs: [input] })
           ]);
-          expect12(first?.id).toBe(input.id);
-          expect12(second?.id).toBe(input.id);
-          await expect12(queues.syncRuns.claim({ projectId: "project-a", workerId: "worker-1", limit: 2 })).resolves.toHaveLength(1);
+          expect13(first?.id).toBe(input.id);
+          expect13(second?.id).toBe(input.id);
+          await expect13(queues.syncRuns.claim({ projectId: "project-a", workerId: "worker-1", limit: 2 })).resolves.toHaveLength(1);
         });
       });
-      test12("treats caller-supplied ids as opaque across the job lifecycle", async () => {
+      test13("treats caller-supplied ids as opaque across the job lifecycle", async () => {
         await withQueues(async (queues) => {
           const id = "workflow:review-meeting:node:0";
           const input = {
@@ -6203,11 +6456,11 @@ function runQueueContractSuite(label, options) {
             workerId: "worker-1",
             limit: 2
           });
-          expect12(first?.id).toBe(id);
-          expect12(duplicate?.id).toBe(id);
-          expect12(claimed?.job.id).toBe(id);
+          expect13(first?.id).toBe(id);
+          expect13(duplicate?.id).toBe(id);
+          expect13(claimed?.job.id).toBe(id);
           if (queues.syncRuns.renewLease) {
-            await expect12(queues.syncRuns.renewLease({
+            await expect13(queues.syncRuns.renewLease({
               projectId: "project-a",
               jobId: id,
               leaseId: claimed.leaseId,
@@ -6219,26 +6472,26 @@ function runQueueContractSuite(label, options) {
             jobId: id,
             leaseId: claimed.leaseId
           });
-          await expect12(queues.syncRuns.claim({ projectId: "project-a", workerId: "worker-2" })).resolves.toHaveLength(0);
+          await expect13(queues.syncRuns.claim({ projectId: "project-a", workerId: "worker-2" })).resolves.toHaveLength(0);
         });
       });
-      test12("returns empty array when no jobs are passed", async () => {
+      test13("returns empty array when no jobs are passed", async () => {
         await withQueues(async (queues) => {
           const result = await queues.syncRuns.enqueue({ projectId: "project-a", jobs: [] });
-          expect12(result).toEqual([]);
+          expect13(result).toEqual([]);
         });
       });
-      test12("rejects empty projectId with QueueError", async () => {
+      test13("rejects empty projectId with QueueError", async () => {
         await withQueues(async (queues) => {
-          await expect12(queues.syncRuns.enqueue({
+          await expect13(queues.syncRuns.enqueue({
             projectId: "   ",
             jobs: [{ type: "sync.run.requested", payload: { syncId: "sync-1" } }]
           })).rejects.toBeInstanceOf(QueueError);
         });
       });
     });
-    describe11("claim", () => {
-      test12("increments attempt to 1 on first successful claim", async () => {
+    describe12("claim", () => {
+      test13("increments attempt to 1 on first successful claim", async () => {
         await withQueues(async (queues) => {
           await queues.pipelines.enqueue({
             projectId: "project-a",
@@ -6248,13 +6501,13 @@ function runQueueContractSuite(label, options) {
             projectId: "project-a",
             workerId: "worker-1"
           });
-          expect12(claimed?.job.attempt).toBe(1);
-          expect12(claimed?.job.payload.pipelineId).toBe("p-1");
-          expect12(claimed?.leaseId).toBeTruthy();
-          expect12(Date.parse(claimed.leaseExpiresAt)).toBeGreaterThan(Date.parse(claimed.claimedAt));
+          expect13(claimed?.job.attempt).toBe(1);
+          expect13(claimed?.job.payload.pipelineId).toBe("p-1");
+          expect13(claimed?.leaseId).toBeTruthy();
+          expect13(Date.parse(claimed.leaseExpiresAt)).toBeGreaterThan(Date.parse(claimed.claimedAt));
         });
       });
-      test12("returns empty array when limit is 0 or negative", async () => {
+      test13("returns empty array when limit is 0 or negative", async () => {
         await withQueues(async (queues) => {
           await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6270,21 +6523,21 @@ function runQueueContractSuite(label, options) {
             workerId: "worker-1",
             limit: -5
           });
-          expect12(zero).toEqual([]);
-          expect12(negative).toEqual([]);
+          expect13(zero).toEqual([]);
+          expect13(negative).toEqual([]);
         });
       });
-      test12("rejects non-positive leaseMs with QueueError", async () => {
+      test13("rejects non-positive leaseMs with QueueError", async () => {
         await withQueues(async (queues) => {
           await queues.syncRuns.enqueue({
             projectId: "project-a",
             jobs: [{ type: "sync.run.requested", payload: { syncId: "s-1" } }]
           });
-          await expect12(queues.syncRuns.claim({ projectId: "project-a", workerId: "w-1", leaseMs: 0 })).rejects.toBeInstanceOf(QueueError);
-          await expect12(queues.syncRuns.claim({ projectId: "project-a", workerId: "w-1", leaseMs: -1 })).rejects.toBeInstanceOf(QueueError);
+          await expect13(queues.syncRuns.claim({ projectId: "project-a", workerId: "w-1", leaseMs: 0 })).rejects.toBeInstanceOf(QueueError);
+          await expect13(queues.syncRuns.claim({ projectId: "project-a", workerId: "w-1", leaseMs: -1 })).rejects.toBeInstanceOf(QueueError);
         });
       });
-      test12("respects delayed visibility via availableAt", async () => {
+      test13("respects delayed visibility via availableAt", async () => {
         await withQueues(async (queues) => {
           const availableAt = new Date(Date.now() + shortLeaseMs + 20).toISOString();
           await queues.syncRuns.enqueue({
@@ -6300,12 +6553,12 @@ function runQueueContractSuite(label, options) {
             projectId: "project-a",
             workerId: "worker-1"
           });
-          expect12(before).toHaveLength(0);
-          expect12(after).toHaveLength(1);
-          expect12(after[0]?.job.availableAt).toBe(availableAt);
+          expect13(before).toHaveLength(0);
+          expect13(after).toHaveLength(1);
+          expect13(after[0]?.job.availableAt).toBe(availableAt);
         });
       });
-      test12("isolates jobs across distinct projectIds", async () => {
+      test13("isolates jobs across distinct projectIds", async () => {
         await withQueues(async (queues) => {
           await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6320,12 +6573,12 @@ function runQueueContractSuite(label, options) {
             workerId: "worker-b",
             limit: 10
           });
-          expect12(claimedB).toHaveLength(1);
-          expect12(claimedB[0]?.job.payload.syncId).toBe("b-1");
-          expect12(claimedB[0]?.job.projectId).toBe("project-b");
+          expect13(claimedB).toHaveLength(1);
+          expect13(claimedB[0]?.job.payload.syncId).toBe("b-1");
+          expect13(claimedB[0]?.job.projectId).toBe("project-b");
         });
       });
-      test12("keeps syncRuns, pipelines, projections, workflows, and actions lanes independent", async () => {
+      test13("keeps syncRuns, pipelines, projections, workflows, and actions lanes independent", async () => {
         await withQueues(async (queues) => {
           await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6407,20 +6660,20 @@ function runQueueContractSuite(label, options) {
             workerId: "sync-worker-1",
             limit: 10
           });
-          expect12(crossLane).toHaveLength(1);
-          expect12(crossLane[0]?.job.payload.pipelineId).toBe("p-1");
-          expect12(projectionLane).toHaveLength(1);
-          expect12(projectionLane[0]?.job.payload.projectionId).toBe("room-projection");
-          expect12(workflowLane).toHaveLength(1);
-          expect12(workflowLane[0]?.job.payload.workflowId).toBe("reconcile-transaction");
-          expect12(actionLane).toHaveLength(1);
-          expect12(actionLane[0]?.job.payload.actionId).toBe("mark-paid");
-          expect12(sameLane).toHaveLength(1);
+          expect13(crossLane).toHaveLength(1);
+          expect13(crossLane[0]?.job.payload.pipelineId).toBe("p-1");
+          expect13(projectionLane).toHaveLength(1);
+          expect13(projectionLane[0]?.job.payload.projectionId).toBe("room-projection");
+          expect13(workflowLane).toHaveLength(1);
+          expect13(workflowLane[0]?.job.payload.workflowId).toBe("reconcile-transaction");
+          expect13(actionLane).toHaveLength(1);
+          expect13(actionLane[0]?.job.payload.actionId).toBe("mark-paid");
+          expect13(sameLane).toHaveLength(1);
         });
       });
     });
-    describe11("complete", () => {
-      test12("removes the job from the lane permanently", async () => {
+    describe12("complete", () => {
+      test13("removes the job from the lane permanently", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6440,10 +6693,10 @@ function runQueueContractSuite(label, options) {
             workerId: "worker-2",
             limit: 10
           });
-          expect12(later).toHaveLength(0);
+          expect13(later).toHaveLength(0);
         });
       });
-      test12("rejects a wrong leaseId with QueueError", async () => {
+      test13("rejects a wrong leaseId with QueueError", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6454,7 +6707,7 @@ function runQueueContractSuite(label, options) {
             workerId: "worker-1",
             leaseMs: shortLeaseMs * 10
           });
-          await expect12(queues.syncRuns.complete({
+          await expect13(queues.syncRuns.complete({
             projectId: "project-a",
             jobId: job.id,
             leaseId: "not-the-right-lease"
@@ -6462,8 +6715,8 @@ function runQueueContractSuite(label, options) {
         });
       });
     });
-    describe11("retry", () => {
-      test12("reschedules the job and bumps attempt on next claim", async () => {
+    describe12("retry", () => {
+      test13("reschedules the job and bumps attempt on next claim", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6488,11 +6741,11 @@ function runQueueContractSuite(label, options) {
             workerId: "worker-2",
             leaseMs: shortLeaseMs
           });
-          expect12(secondClaim?.job.id).toBe(job?.id);
-          expect12(secondClaim?.job.attempt).toBe(2);
+          expect13(secondClaim?.job.id).toBe(job?.id);
+          expect13(secondClaim?.job.attempt).toBe(2);
         });
       });
-      test12("rejects invalid availableAt with QueueError", async () => {
+      test13("rejects invalid availableAt with QueueError", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6503,7 +6756,7 @@ function runQueueContractSuite(label, options) {
             workerId: "worker-1",
             leaseMs: shortLeaseMs * 10
           });
-          await expect12(queues.syncRuns.retry({
+          await expect13(queues.syncRuns.retry({
             projectId: "project-a",
             jobId: job.id,
             leaseId: claim2.leaseId,
@@ -6512,8 +6765,8 @@ function runQueueContractSuite(label, options) {
         });
       });
     });
-    describe11("fail", () => {
-      test12("marks the job as terminally failed", async () => {
+    describe12("fail", () => {
+      test13("marks the job as terminally failed", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.pipelines.enqueue({
             projectId: "project-a",
@@ -6534,12 +6787,12 @@ function runQueueContractSuite(label, options) {
             workerId: "pipeline-worker-2",
             limit: 10
           });
-          expect12(later).toHaveLength(0);
+          expect13(later).toHaveLength(0);
         });
       });
     });
-    describe11("renewLease", () => {
-      test12("extends the lease and returns an updated claim", async () => {
+    describe12("renewLease", () => {
+      test13("extends the lease and returns an updated claim", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6556,12 +6809,12 @@ function runQueueContractSuite(label, options) {
             leaseId: claim2.leaseId,
             leaseMs: shortLeaseMs * 5
           });
-          expect12(renewed?.job.id).toBe(job?.id);
-          expect12(renewed?.leaseId).toBe(claim2?.leaseId);
-          expect12(Date.parse(renewed.leaseExpiresAt)).toBeGreaterThan(Date.parse(claim2.leaseExpiresAt));
+          expect13(renewed?.job.id).toBe(job?.id);
+          expect13(renewed?.leaseId).toBe(claim2?.leaseId);
+          expect13(Date.parse(renewed.leaseExpiresAt)).toBeGreaterThan(Date.parse(claim2.leaseExpiresAt));
         });
       });
-      test12("returns null for unknown jobId", async () => {
+      test13("returns null for unknown jobId", async () => {
         await withQueues(async (queues) => {
           const result = await queues.syncRuns.renewLease?.({
             projectId: "project-a",
@@ -6569,10 +6822,10 @@ function runQueueContractSuite(label, options) {
             leaseId: "no-such-lease",
             leaseMs: shortLeaseMs
           });
-          expect12(result).toBeNull();
+          expect13(result).toBeNull();
         });
       });
-      test12("returns null when the leaseId does not match", async () => {
+      test13("returns null when the leaseId does not match", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6589,12 +6842,12 @@ function runQueueContractSuite(label, options) {
             leaseId: "not-the-right-lease",
             leaseMs: shortLeaseMs
           });
-          expect12(renewed).toBeNull();
+          expect13(renewed).toBeNull();
         });
       });
     });
-    describe11("redelivery", () => {
-      test12("redelivers after lease expiry with attempt incremented", async () => {
+    describe12("redelivery", () => {
+      test13("redelivers after lease expiry with attempt incremented", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6611,12 +6864,12 @@ function runQueueContractSuite(label, options) {
             workerId: "worker-2",
             leaseMs: shortLeaseMs
           });
-          expect12(first?.job.attempt).toBe(1);
-          expect12(second?.job.id).toBe(job?.id);
-          expect12(second.job.attempt).toBeGreaterThanOrEqual(2);
+          expect13(first?.job.attempt).toBe(1);
+          expect13(second?.job.id).toBe(job?.id);
+          expect13(second.job.attempt).toBeGreaterThanOrEqual(2);
         });
       });
-      test12("rejects complete on an already-expired lease", async () => {
+      test13("rejects complete on an already-expired lease", async () => {
         await withQueues(async (queues) => {
           const [job] = await queues.syncRuns.enqueue({
             projectId: "project-a",
@@ -6628,7 +6881,7 @@ function runQueueContractSuite(label, options) {
             leaseMs: shortLeaseMs
           });
           await Bun.sleep(leaseExpiryRedeliveryMs);
-          await expect12(queues.syncRuns.complete({
+          await expect13(queues.syncRuns.complete({
             projectId: "project-a",
             jobId: job.id,
             leaseId: claim2.leaseId
@@ -6636,30 +6889,30 @@ function runQueueContractSuite(label, options) {
         });
       });
     });
-    describe11("health", () => {
-      test12("resolves against a reachable backend", async () => {
+    describe12("health", () => {
+      test13("resolves against a reachable backend", async () => {
         await withQueues(async (queues) => {
-          await expect12(queues.health()).resolves.toBeUndefined();
+          await expect13(queues.health()).resolves.toBeUndefined();
         });
       });
     });
-    describe11("scope", () => {
-      test12("declares whether it can be shared across processes", async () => {
+    describe12("scope", () => {
+      test13("declares whether it can be shared across processes", async () => {
         await withQueues(async (queues) => {
-          expect12(["process", "shared"]).toContain(queues.scope);
+          expect13(["process", "shared"]).toContain(queues.scope);
         });
       });
     });
   });
 }
 // src/testing/sandboxes-contract.ts
-import { afterEach, beforeEach, describe as describe12, expect as expect13, test as test13 } from "bun:test";
+import { afterEach, beforeEach, describe as describe13, expect as expect14, test as test14 } from "bun:test";
 import { realpath } from "fs/promises";
 var SLEEP_BUDGET_SECONDS = 5;
 function runSandboxesContractSuite(label, options) {
   const shortTimeoutMs = options.shortTimeoutMs ?? 200;
   const capabilities = options.capabilities ?? {};
-  describe12(label, () => {
+  describe13(label, () => {
     let factory;
     beforeEach(async () => {
       factory = await options.createFactory();
@@ -6667,108 +6920,108 @@ function runSandboxesContractSuite(label, options) {
     afterEach(async () => {
       await options.teardown?.(factory);
     });
-    describe12("lifecycle", () => {
-      test13("create returns a running sandbox with a non-empty id", async () => {
+    describe13("lifecycle", () => {
+      test14("create returns a running sandbox with a non-empty id", async () => {
         const sandbox = await factory.create();
         try {
-          expect13(sandbox.status).toBe("running");
-          expect13(sandbox.id.length).toBeGreaterThan(0);
-          expect13(sandbox.workingDirectory.length).toBeGreaterThan(0);
+          expect14(sandbox.status).toBe("running");
+          expect14(sandbox.id.length).toBeGreaterThan(0);
+          expect14(sandbox.workingDirectory.length).toBeGreaterThan(0);
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("runCommand returns exit code 0 and captured stdout for echo", async () => {
+      test14("runCommand returns exit code 0 and captured stdout for echo", async () => {
         const sandbox = await factory.create();
         try {
           const result = await sandbox.runCommand("echo", ["hello"]);
-          expect13(result.exitCode).toBe(0);
-          expect13(result.stdout.trim()).toBe("hello");
-          expect13(result.stderr).toBe("");
-          expect13(result.durationMs).toBeGreaterThanOrEqual(0);
-          expect13(result.timedOut).not.toBe(true);
+          expect14(result.exitCode).toBe(0);
+          expect14(result.stdout.trim()).toBe("hello");
+          expect14(result.stderr).toBe("");
+          expect14(result.durationMs).toBeGreaterThanOrEqual(0);
+          expect14(result.timedOut).not.toBe(true);
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("nonexistent binary resolves with non-zero exit code", async () => {
+      test14("nonexistent binary resolves with non-zero exit code", async () => {
         const sandbox = await factory.create();
         try {
           const result = await sandbox.runCommand("does-not-exist-xyz-sixb-test", []);
-          expect13(result.exitCode).not.toBe(0);
+          expect14(result.exitCode).not.toBe(0);
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("captures stdout and stderr as separate streams", async () => {
+      test14("captures stdout and stderr as separate streams", async () => {
         const sandbox = await factory.create();
         try {
           const result = await sandbox.runCommand("/bin/sh", [
             "-c",
             "echo out-line; echo err-line >&2; exit 0"
           ]);
-          expect13(result.exitCode).toBe(0);
-          expect13(result.stdout).toContain("out-line");
-          expect13(result.stderr).toContain("err-line");
-          expect13(result.stdout).not.toContain("err-line");
-          expect13(result.stderr).not.toContain("out-line");
+          expect14(result.exitCode).toBe(0);
+          expect14(result.stdout).toContain("out-line");
+          expect14(result.stderr).toContain("err-line");
+          expect14(result.stdout).not.toContain("err-line");
+          expect14(result.stderr).not.toContain("out-line");
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("stop transitions status and rejects subsequent runCommand", async () => {
+      test14("stop transitions status and rejects subsequent runCommand", async () => {
         const sandbox = await factory.create();
         try {
           await sandbox.stop();
-          expect13(sandbox.status).toBe("stopped");
-          await expect13(sandbox.runCommand("echo", ["nope"])).rejects.toBeInstanceOf(SandboxNotRunningError);
+          expect14(sandbox.status).toBe("stopped");
+          await expect14(sandbox.runCommand("echo", ["nope"])).rejects.toBeInstanceOf(SandboxNotRunningError);
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("destroy is idempotent", async () => {
+      test14("destroy is idempotent", async () => {
         const sandbox = await factory.create();
         await sandbox.destroy();
         await sandbox.destroy();
-        await expect13(sandbox.runCommand("echo", ["x"])).rejects.toBeInstanceOf(SandboxNotRunningError);
+        await expect14(sandbox.runCommand("echo", ["x"])).rejects.toBeInstanceOf(SandboxNotRunningError);
       });
     });
-    describe12("working directory", () => {
-      test13("pwd reflects the configured workingDirectory", async () => {
+    describe13("working directory", () => {
+      test14("pwd reflects the configured workingDirectory", async () => {
         const sandbox = await factory.create();
         try {
           const result = await sandbox.runCommand("pwd");
           const expected = await realpath(sandbox.workingDirectory);
-          expect13(result.exitCode).toBe(0);
-          expect13(result.stdout.trim()).toBe(expected);
+          expect14(result.exitCode).toBe(0);
+          expect14(result.stdout.trim()).toBe(expected);
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("per-call cwd overrides the sandbox-level workingDirectory", async () => {
+      test14("per-call cwd overrides the sandbox-level workingDirectory", async () => {
         const sandbox = await factory.create();
         try {
           const expected = await realpath("/tmp");
           const result = await sandbox.runCommand("pwd", [], { cwd: "/tmp" });
-          expect13(result.exitCode).toBe(0);
-          expect13(result.stdout.trim()).toBe(expected);
+          expect14(result.exitCode).toBe(0);
+          expect14(result.stdout.trim()).toBe(expected);
         } finally {
           await sandbox.destroy();
         }
       });
     });
-    describe12("env merging", () => {
-      test13("sandbox-level env is visible to commands", async () => {
+    describe13("env merging", () => {
+      test14("sandbox-level env is visible to commands", async () => {
         const sandbox = await factory.create({ env: { SIXB_TEST_A: "alpha" } });
         try {
           const result = await sandbox.runCommand("printenv", ["SIXB_TEST_A"]);
-          expect13(result.exitCode).toBe(0);
-          expect13(result.stdout.trim()).toBe("alpha");
+          expect14(result.exitCode).toBe(0);
+          expect14(result.stdout.trim()).toBe("alpha");
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("per-call env wins on collision and adds new keys", async () => {
+      test14("per-call env wins on collision and adds new keys", async () => {
         const sandbox = await factory.create({
           env: { SIXB_TEST_A: "alpha", SIXB_TEST_B: "beta" }
         });
@@ -6782,14 +7035,14 @@ function runSandboxesContractSuite(label, options) {
           const c = await sandbox.runCommand("printenv", ["SIXB_TEST_C"], {
             env: { SIXB_TEST_A: "alpha2", SIXB_TEST_C: "gamma" }
           });
-          expect13(a.stdout.trim()).toBe("alpha2");
-          expect13(b.stdout.trim()).toBe("beta");
-          expect13(c.stdout.trim()).toBe("gamma");
+          expect14(a.stdout.trim()).toBe("alpha2");
+          expect14(b.stdout.trim()).toBe("beta");
+          expect14(c.stdout.trim()).toBe("gamma");
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("host secrets are not leaked into the sandbox", async () => {
+      test14("host secrets are not leaked into the sandbox", async () => {
         const secretKey = "SIXB_HOST_SECRET_DO_NOT_LEAK";
         const previous = process.env[secretKey];
         process.env[secretKey] = "host-only-value";
@@ -6797,8 +7050,8 @@ function runSandboxesContractSuite(label, options) {
           const sandbox = await factory.create();
           try {
             const result = await sandbox.runCommand("printenv", [secretKey]);
-            expect13(result.exitCode).not.toBe(0);
-            expect13(result.stdout).not.toContain("host-only-value");
+            expect14(result.exitCode).not.toBe(0);
+            expect14(result.stdout).not.toContain("host-only-value");
           } finally {
             await sandbox.destroy();
           }
@@ -6811,8 +7064,8 @@ function runSandboxesContractSuite(label, options) {
         }
       });
     });
-    describe12("timeout and abort", () => {
-      test13("sleep beyond timeout marks the result timedOut and exits non-zero", async () => {
+    describe13("timeout and abort", () => {
+      test14("sleep beyond timeout marks the result timedOut and exits non-zero", async () => {
         const sandbox = await factory.create();
         try {
           const start = Date.now();
@@ -6820,14 +7073,14 @@ function runSandboxesContractSuite(label, options) {
             timeout: shortTimeoutMs
           });
           const elapsed = Date.now() - start;
-          expect13(result.timedOut).toBe(true);
-          expect13(result.exitCode).not.toBe(0);
-          expect13(elapsed).toBeLessThan(SLEEP_BUDGET_SECONDS * 1000);
+          expect14(result.timedOut).toBe(true);
+          expect14(result.exitCode).not.toBe(0);
+          expect14(elapsed).toBeLessThan(SLEEP_BUDGET_SECONDS * 1000);
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("abort signal aborts an in-flight command", async () => {
+      test14("abort signal aborts an in-flight command", async () => {
         const sandbox = await factory.create();
         try {
           const ac = new AbortController;
@@ -6837,26 +7090,26 @@ function runSandboxesContractSuite(label, options) {
             signal: ac.signal
           });
           const elapsed = Date.now() - start;
-          expect13(result.exitCode).not.toBe(0);
-          expect13(elapsed).toBeLessThan(SLEEP_BUDGET_SECONDS * 1000);
+          expect14(result.exitCode).not.toBe(0);
+          expect14(elapsed).toBeLessThan(SLEEP_BUDGET_SECONDS * 1000);
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("per-call timeout overrides sandbox-level timeout", async () => {
+      test14("per-call timeout overrides sandbox-level timeout", async () => {
         const sandbox = await factory.create({ timeout: SLEEP_BUDGET_SECONDS * 1000 });
         try {
           const result = await sandbox.runCommand("sleep", [String(SLEEP_BUDGET_SECONDS)], {
             timeout: shortTimeoutMs
           });
-          expect13(result.timedOut).toBe(true);
+          expect14(result.timedOut).toBe(true);
         } finally {
           await sandbox.destroy();
         }
       });
     });
-    describe12("file materialization", () => {
-      test13("writeFiles materializes files a subsequent command can read", async () => {
+    describe13("file materialization", () => {
+      test14("writeFiles materializes files a subsequent command can read", async () => {
         const sandbox = await factory.create();
         try {
           const flat = `${sandbox.workingDirectory}/materialized.txt`;
@@ -6866,32 +7119,32 @@ function runSandboxesContractSuite(label, options) {
             { path: nested, contents: "nested-contents" }
           ]);
           const flatResult = await sandbox.runCommand("cat", [flat]);
-          expect13(flatResult.exitCode).toBe(0);
-          expect13(flatResult.stdout).toContain("flat-contents");
+          expect14(flatResult.exitCode).toBe(0);
+          expect14(flatResult.stdout).toContain("flat-contents");
           const nestedResult = await sandbox.runCommand("cat", [nested]);
-          expect13(nestedResult.exitCode).toBe(0);
-          expect13(nestedResult.stdout).toContain("nested-contents");
+          expect14(nestedResult.exitCode).toBe(0);
+          expect14(nestedResult.stdout).toContain("nested-contents");
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("writeFiles round-trips binary contents faithfully", async () => {
+      test14("writeFiles round-trips binary contents faithfully", async () => {
         const sandbox = await factory.create();
         try {
           const path = `${sandbox.workingDirectory}/binary.dat`;
           const bytes = new Uint8Array([0, 1, 254, 255, 10, 127]);
           await sandbox.writeFiles([{ path, contents: bytes }]);
           const size = await sandbox.runCommand("wc", ["-c", path]);
-          expect13(size.exitCode).toBe(0);
-          expect13(size.stdout.trim().split(/\s+/)[0]).toBe(String(bytes.length));
+          expect14(size.exitCode).toBe(0);
+          expect14(size.stdout.trim().split(/\s+/)[0]).toBe(String(bytes.length));
           const hex = await sandbox.runCommand("od", ["-An", "-v", "-tx1", path]);
-          expect13(hex.exitCode).toBe(0);
-          expect13(hex.stdout.replace(/\s+/g, " ").trim()).toBe("00 01 fe ff 0a 7f");
+          expect14(hex.exitCode).toBe(0);
+          expect14(hex.stdout.replace(/\s+/g, " ").trim()).toBe("00 01 fe ff 0a 7f");
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("writeFiles applies an explicit file mode", async () => {
+      test14("writeFiles applies an explicit file mode", async () => {
         const sandbox = await factory.create();
         try {
           const path = `${sandbox.workingDirectory}/run.sh`;
@@ -6899,25 +7152,25 @@ function runSandboxesContractSuite(label, options) {
 echo ran
 `, mode: 493 }]);
           const result = await sandbox.runCommand("/bin/sh", ["-c", `test -x ${path} && echo yes`]);
-          expect13(result.exitCode).toBe(0);
-          expect13(result.stdout).toContain("yes");
+          expect14(result.exitCode).toBe(0);
+          expect14(result.stdout).toContain("yes");
         } finally {
           await sandbox.destroy();
         }
       });
-      test13("writeFiles after stop rejects", async () => {
+      test14("writeFiles after stop rejects", async () => {
         const sandbox = await factory.create();
         await sandbox.stop();
         try {
-          await expect13(sandbox.writeFiles([{ path: `${sandbox.workingDirectory}/x.txt`, contents: "x" }])).rejects.toThrow(SandboxNotRunningError);
+          await expect14(sandbox.writeFiles([{ path: `${sandbox.workingDirectory}/x.txt`, contents: "x" }])).rejects.toThrow(SandboxNotRunningError);
         } finally {
           await sandbox.destroy();
         }
       });
     });
     if (capabilities.networkBlocking) {
-      describe12("network isolation", () => {
-        test13('network.mode="none" blocks outbound DNS / TCP', async () => {
+      describe13("network isolation", () => {
+        test14('network.mode="none" blocks outbound DNS / TCP', async () => {
           const sandbox = await factory.create({ network: { mode: "none" } });
           try {
             const result = await sandbox.runCommand("curl", [
@@ -6926,12 +7179,12 @@ echo ran
               "2",
               "https://example.com"
             ]);
-            expect13(result.exitCode).not.toBe(0);
+            expect14(result.exitCode).not.toBe(0);
           } finally {
             await sandbox.destroy();
           }
         });
-        test13('network.mode="all" permits outbound traffic', async () => {
+        test14('network.mode="all" permits outbound traffic', async () => {
           const sandbox = await factory.create({ network: { mode: "all" } });
           try {
             const result = await sandbox.runCommand("curl", [
@@ -6940,7 +7193,7 @@ echo ran
               "5",
               "https://example.com"
             ]);
-            expect13(result.exitCode).not.toBe(6);
+            expect14(result.exitCode).not.toBe(6);
           } finally {
             await sandbox.destroy();
           }
@@ -6948,28 +7201,28 @@ echo ran
       });
     }
     if (capabilities.readOnlyEnforcement) {
-      describe12("filesystem isolation", () => {
-        test13("writing inside readWritePaths succeeds", async () => {
+      describe13("filesystem isolation", () => {
+        test14("writing inside readWritePaths succeeds", async () => {
           const sandbox = await factory.create();
           try {
             const result = await sandbox.runCommand("/bin/sh", [
               "-c",
               `echo content > ${sandbox.workingDirectory}/probe.txt && cat ${sandbox.workingDirectory}/probe.txt`
             ]);
-            expect13(result.exitCode).toBe(0);
-            expect13(result.stdout.trim()).toBe("content");
+            expect14(result.exitCode).toBe(0);
+            expect14(result.stdout.trim()).toBe("content");
           } finally {
             await sandbox.destroy();
           }
         });
-        test13("writing outside readWritePaths fails", async () => {
+        test14("writing outside readWritePaths fails", async () => {
           const sandbox = await factory.create();
           try {
             const result = await sandbox.runCommand("/bin/sh", [
               "-c",
               "echo nope > /etc/sixb-sandbox-must-not-write"
             ]);
-            expect13(result.exitCode).not.toBe(0);
+            expect14(result.exitCode).not.toBe(0);
           } finally {
             await sandbox.destroy();
           }
@@ -6988,6 +7241,7 @@ export {
   runMaterializerStorageContractSuite,
   runMaterializationFailureContractSuite,
   runLakeStorageContractSuite,
+  runLakeMergeStorageContractSuite,
   runEffectiveStorageContractSuite,
   runBrokerContractSuite,
   runBlobStorageContractSuite,
@@ -6997,4 +7251,4 @@ export {
   createMaterializerTestFixture
 };
 
-//# debugId=8890E73064CEA99D64756E2164756E21
+//# debugId=9AC10C19BCFC4FB264756E2164756E21