@sixb/core 0.1.8 → 0.1.9

package/dist/testing/index.js

@@ -1,171 +1,160 @@
 // @bun
 import {
-  SixbHost
-} from "../chunk-mwsxn98e.js";
+  defineProjection2,
+  agentServiceAccountId2,
+  MAX_OBJECT_READ_FACETS2
+} from "../chunk-dz5h08xv.js";
+import"../chunk-f4w3yp4f.js";
 import {
-  SandboxNotRunningError
-} from "../chunk-8ydjhh27.js";
-import"../chunk-9t8f5xfx.js";
-import"../chunk-ajnan18g.js";
+  compileSelectedObjectReadScope2
+} from "../chunk-v4jbb3rs.js";
+import"../chunk-ms2tmn1k.js";
 import {
-  InMemoryQueues,
-  QueueError
-} from "../chunk-tpnd31c1.js";
-import"../chunk-mth82m8t.js";
-import"../chunk-s5y30bc9.js";
-import"../chunk-407j3msh.js";
-import"../chunk-zqqz8052.js";
-import"../chunk-n2w475r0.js";
+  AuthStorageError2,
+  SYSTEM_PRINCIPAL2
+} from "../chunk-g00bfdq6.js";
+import"../chunk-q5gz3g2j.js";
+import"../chunk-pqajwytd.js";
+import"../chunk-e0d1rzef.js";
+import"../chunk-gfdh9kqa.js";
 import {
-  createTestingScope
-} from "../chunk-fvt9rjsa.js";
-import"../chunk-3xep5cjx.js";
+  computeBlobDigest2,
+  InMemoryBlobStorage2
+} from "../chunk-39tqv9hz.js";
 import {
-  workflowAgentStepActorId
-} from "../chunk-3z1qec12.js";
-import"../chunk-gbejpkex.js";
-import"../chunk-z4ccwbkz.js";
-import"../chunk-gzasd5b6.js";
-import"../chunk-5sz8ta9r.js";
-import"../chunk-979ww6b3.js";
-import"../chunk-2ab72m2h.js";
-import"../chunk-74drx9gd.js";
-import"../chunk-b49dgvsj.js";
+  AgentStorageError2
+} from "../chunk-7bs40fe1.js";
 import {
-  BrokerError,
-  InMemoryBroker
-} from "../chunk-k34z5rvh.js";
-import"../chunk-4qfkag59.js";
+  AiUsageStorageError2
+} from "../chunk-g53f0e4j.js";
+import"../chunk-b19g04jk.js";
+import"../chunk-vsj3mdfj.js";
 import {
-  isBoundSixb
-} from "../chunk-xajtptbw.js";
-import"../chunk-wtf06et8.js";
-import"../chunk-c15dr03f.js";
-import"../chunk-v4en4jc2.js";
-import"../chunk-w9tg6yyb.js";
-import"../chunk-aa2pen2v.js";
-import"../chunk-xhy826cz.js";
-import"../chunk-4rh2m6zg.js";
-import"../chunk-9nbmsvn5.js";
-import"../chunk-8m5ejdpn.js";
-import"../chunk-nf4r78r4.js";
+  aiLimitCalendarMonth2
+} from "../chunk-jgwb25gc.js";
+import"../chunk-8vj0rjgs.js";
+import"../chunk-93csa55g.js";
 import {
-  writeDataset
-} from "../chunk-359jm1jw.js";
+  OntologyRegistry2,
+  defineObjectType2,
+  prop2,
+  link2,
+  stringEnum2
+} from "../chunk-ap0g1g74.js";
 import {
-  LakeStorageError
-} from "../chunk-n4khvw9n.js";
+  AGENT_MESSAGE_CONTENT_VERSION2,
+  AiCostStorageError2,
+  objectBatchKey2,
+  linkBatchKey2,
+  objectLinkCursor2,
+  InMemoryStorage2
+} from "../chunk-mjbk2djy.js";
+import"../chunk-c5rkjrgp.js";
 import {
-  change,
-  col,
-  defineDataset
-} from "../chunk-pc7ys28c.js";
-import"../chunk-v1xppd0y.js";
-import"../chunk-h5vqbfmd.js";
+  createEventId2
+} from "../chunk-x57ycxq0.js";
+import"../chunk-z30bv4ga.js";
+import"../chunk-mmagke4x.js";
+import"../chunk-3frsnm7x.js";
+import"../chunk-ppytyr6w.js";
+import"../chunk-jmfet9r4.js";
+import"../chunk-qf954wje.js";
+import"../chunk-pr2h4bv4.js";
 import {
-  collectObjectQueryValidationIssues,
-  countObjects,
-  executeObjectQuery,
-  executeObjectQueryLinks,
-  existsObjects,
-  facetObjects,
-  validateObjectQuery
-} from "../chunk-q0k9nc5a.js";
+  ProjectionRegistry2,
+  createLinkScopeFingerprint2,
+  createOntologyMaterializer2
+} from "../chunk-an5tt9y0.js";
 import {
-  ObjectQueryPlanningError,
-  normalizeObjectQuery
-} from "../chunk-rte5sm3z.js";
+  bindModelExecutionAttempt,
+  isBoundSixb
+} from "../chunk-hpr1r6av.js";
+import"../chunk-5a4a52tq.js";
 import {
-  ProjectionRegistry,
-  createLinkScopeFingerprint,
-  createOntologyMaterializer
-} from "../chunk-f26bck4t.js";
-import"../chunk-96swp2wd.js";
+  SixbHost2
+} from "../chunk-52hbv0ak.js";
+import"../chunk-7apz6hg4.js";
+import"../chunk-3tgwrcyh.js";
+import"../chunk-r2y23egw.js";
+import"../chunk-dfm066qg.js";
 import {
-  restoreTrustedPrimitiveExecutionScope
-} from "../chunk-k522z7v6.js";
+  validateObjectQuery2,
+  collectObjectQueryValidationIssues2,
+  executeObjectQuery2,
+  countObjects2,
+  existsObjects2,
+  facetObjects2,
+  executeObjectQueryLinks2
+} from "../chunk-0w35wavj.js";
+import"../chunk-ypbtykv6.js";
+import"../chunk-kxwa347f.js";
+import"../chunk-k3cqkkn2.js";
+import"../chunk-fb3feg1e.js";
+import"../chunk-z5rnrmz1.js";
+import"../chunk-zcnq6105.js";
+import"../chunk-wr8qp979.js";
+import"../chunk-vf691g1r.js";
+import"../chunk-skz0hst3.js";
 import {
-  AGENT_MESSAGE_CONTENT_VERSION,
-  AiCostStorageError,
-  InMemoryStorage,
-  linkBatchKey,
-  objectBatchKey,
-  objectLinkCursor
-} from "../chunk-sbzzr4kx.js";
-import"../chunk-4jjp5k14.js";
-import"../chunk-rv2hkwwa.js";
-import"../chunk-nx7k8tpr.js";
-import"../chunk-4yqmp43v.js";
-import"../chunk-wdage1eb.js";
-import"../chunk-5ntny1qx.js";
-import"../chunk-nn0tekr1.js";
+  col2,
+  defineDataset2,
+  change2
+} from "../chunk-860dwwy0.js";
+import"../chunk-e1c18xjx.js";
+import"../chunk-awbhdqyc.js";
+import"../chunk-9vx5e9g1.js";
+import"../chunk-dmn70ztd.js";
+import"../chunk-emyyk7dx.js";
 import {
-  AiUsageStorageError
-} from "../chunk-p03r0h5s.js";
+  writeDataset2
+} from "../chunk-mrp7k0pw.js";
+import"../chunk-g6cke204.js";
+import"../chunk-0y39rgsb.js";
+import"../chunk-92vk7gta.js";
 import {
-  aiLimitCalendarMonth
-} from "../chunk-jecn6t54.js";
-import"../chunk-5gd7tpv6.js";
-import"../chunk-rafagrwr.js";
+  workflowAgentStepActorId2
+} from "../chunk-m3z3x9v0.js";
 import {
-  createEventId
-} from "../chunk-8tsf6dmc.js";
-import"../chunk-yp8ee62z.js";
-import"../chunk-ka3a2ft3.js";
-import"../chunk-w1tvjszy.js";
+  BrokerError2,
+  InMemoryBroker2
+} from "../chunk-0rdrecsb.js";
 import {
-  AgentStorageError
-} from "../chunk-p1rzczbt.js";
-import"../chunk-j1sbhm7p.js";
-import"../chunk-9dzba0f2.js";
-import"../chunk-dbc80ad7.js";
-import"../chunk-ry24jbr1.js";
-import"../chunk-p2vqaxkc.js";
-import"../chunk-trxxmgnf.js";
-import"../chunk-zcnhxkvd.js";
+  QueueError2,
+  InMemoryQueues2
+} from "../chunk-r29fxdhn.js";
+import"../chunk-qhcpj9wc.js";
 import {
-  InMemoryBlobStorage,
-  computeBlobDigest
-} from "../chunk-w3e09qqk.js";
-import"../chunk-51fjndv0.js";
-import"../chunk-1evzqhks.js";
-import"../chunk-jq43kdvk.js";
-import"../chunk-qw9gvjv5.js";
-import"../chunk-yt8wphsx.js";
-import"../chunk-5e3pq99w.js";
-import"../chunk-7y0f6rf1.js";
-import"../chunk-d8qkxt2v.js";
+  SandboxNotRunningError2
+} from "../chunk-z3y411fq.js";
+import"../chunk-xfbydgzy.js";
+import"../chunk-xyr8kppc.js";
+import"../chunk-7n30ybym.js";
+import"../chunk-r4tfx1sf.js";
 import {
-  AuthStorageError,
-  SYSTEM_PRINCIPAL
-} from "../chunk-4sm0aznx.js";
-import"../chunk-4a849fr1.js";
+  createTestingScope
+} from "../chunk-38zv5rkr.js";
+import"../chunk-x9v4cx1d.js";
+import"../chunk-1enhpacz.js";
+import"../chunk-jjy0fhrn.js";
+import"../chunk-h1gfhhbh.js";
 import {
-  OntologyRegistry,
-  defineObjectType,
-  link,
-  prop,
-  stringEnum
-} from "../chunk-2dw777qw.js";
-import"../chunk-19jp6g9d.js";
-import"../chunk-xwnf87e1.js";
+  LakeStorageError2
+} from "../chunk-9qsh3p5y.js";
 import {
-  MAX_OBJECT_READ_FACETS,
-  agentServiceAccountId,
-  defineProjection
-} from "../chunk-p1x242ad.js";
+  ObjectQueryPlanningError2,
+  normalizeObjectQuery2
+} from "../chunk-5hz0fnca.js";
 import {
-  compileSelectedObjectReadScope
-} from "../chunk-r8jrnexe.js";
-import"../chunk-h0k55pc7.js";
-import"../chunk-dktq02ne.js";
-import"../chunk-04b07a9q.js";
+  restoreTrustedPrimitiveExecutionScope
+} from "../chunk-17kfctj6.js";
+import"../chunk-br3k6qbf.js";
+import"../chunk-s3csryxe.js";
+import"../chunk-653vwrzr.js";
+import"../chunk-72w2pxk7.js";
+import"../chunk-f0rwz2vh.js";
 import {
-  blobIdFromDigest
-} from "../chunk-08m3b6w8.js";
-import"../chunk-2xns679x.js";
-import"../chunk-n6jxh8sw.js";
-import"../chunk-y64skrwp.js";
+  blobIdFromDigest2
+} from "../chunk-h3v76ams.js";
 
 // src/testing/action-execution.ts
 async function createTestActionExecution(executions, input) {
@@ -183,6 +172,7 @@ async function createTestActionExecution(executions, input) {
   if (!parent) {
     await executions.create({
       id: parentExecutionId,
+      requesterGroupIds: input.requesterGroupIds ?? [],
       projectId: input.projectId,
       executor: { type: "request", requestId: `test_request:${input.runId}` },
       source: { type: "http", requestId: `test_request:${input.runId}` },
@@ -192,6 +182,7 @@ async function createTestActionExecution(executions, input) {
   }
   await executions.create({
     id: executionId,
+    requesterGroupIds: input.requesterGroupIds ?? [],
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: { type: "execution", executionId: parentExecutionId },
@@ -206,9 +197,11 @@ async function queueTestActionRun(storage, input) {
   const executionId = await createTestActionExecution(storage.executions, {
     projectId: input.projectId,
     actionId: input.actionId,
-    runId: input.id
+    runId: input.id,
+    requesterGroupIds: input.requesterGroupIds
   });
-  return storage.actionRuns.queue({ ...input, executionId });
+  const { requesterGroupIds: _groups, ...run } = input;
+  return storage.actionRuns.queue({ ...run, executionId });
 }
 // src/testing/agent-execution.ts
 async function createTestAgentExecution(storage, input) {
@@ -216,7 +209,7 @@ async function createTestAgentExecution(storage, input) {
   if (authority === "managed" && input.actorId === undefined) {
     throw new Error("Managed Agent execution fixtures require an agent id.");
   }
-  const serviceAccountId = input.actorId ? agentServiceAccountId(input.actorId) : undefined;
+  const serviceAccountId = input.actorId ? agentServiceAccountId2(input.actorId) : undefined;
   if (authority === "managed") {
     const auth = storage.auth;
     if (!auth)
@@ -234,12 +227,12 @@ async function createTestAgentExecution(storage, input) {
           name: `Test Agent ${input.actorId}`,
           description: `Test service account for Agent '${input.actorId}'.`,
           status: "active",
-          createdByPrincipal: SYSTEM_PRINCIPAL,
+          createdByPrincipal: SYSTEM_PRINCIPAL2,
           createdAt: now,
           updatedAt: now
         });
       } catch (error) {
-        if (!(error instanceof AuthStorageError) || error.code !== "duplicate_service_account") {
+        if (!(error instanceof AuthStorageError2) || error.code !== "duplicate_service_account") {
           throw error;
         }
       }
@@ -260,6 +253,7 @@ async function createTestAgentExecution(storage, input) {
   if (!parent) {
     parent = await storage.executions.create({
       id: sourceExecutionId,
+      requesterGroupIds: input.requesterGroupIds ?? [],
       projectId: input.projectId,
       executor: { type: "request", requestId: `test_request:${input.runId}` },
       source: { type: "http", requestId: `test_request:${input.runId}` },
@@ -269,6 +263,7 @@ async function createTestAgentExecution(storage, input) {
   }
   await storage.executions.create({
     id: executionId,
+    requesterGroupIds: parent.requesterGroupIds,
     projectId: input.projectId,
     executor: { type: "agent", runId: input.runId },
     source: { type: "execution", executionId: sourceExecutionId },
@@ -297,7 +292,7 @@ function at(value) {
   return new Date(value);
 }
 async function expectAgentError(promise, code) {
-  await expect(promise).rejects.toBeInstanceOf(AgentStorageError);
+  await expect(promise).rejects.toBeInstanceOf(AgentStorageError2);
   await expect(promise).rejects.toMatchObject({ code });
 }
 function threadInput(overrides = {}) {
@@ -320,7 +315,6 @@ function runInput(overrides = {}) {
     triggerMessageId: "msg_user_1",
     spec: { model: { provider: "test", modelId: "large" } },
     executionId: "test_agent_execution:run_1",
-    requesterGroupIds: ["support", "engineering", "support"],
     execution: execution("exec_1"),
     createdAt: at("2026-06-23T10:00:10.000Z"),
     ...overrides
@@ -619,7 +613,6 @@ function runAgentStorageContractSuite(label, options) {
           spawnKey: "research-orders",
           status: "queued",
           attempt: 0,
-          requesterGroupIds: ["engineering", "support"],
           spec: input.spec
         });
         expect(child).not.toHaveProperty("threadId");
@@ -749,7 +742,6 @@ function runAgentStorageContractSuite(label, options) {
         const run = await createAndStartRun(storage, fixture, runInput({ id: "run_1" }));
         expect(run).toMatchObject({ status: "running", attempt: 1, threadId: "thr_1" });
         expect(run.executionId).toBe("test_agent_execution:run_1");
-        expect(run.requesterGroupIds).toEqual(["engineering", "support"]);
         expect(run.execution?.token).toBe("exec_1");
         await expect(storage.threads.getById({ projectId, id: "thr_1" })).resolves.toMatchObject({
           activeRunId: "run_1"
@@ -769,7 +761,7 @@ function runAgentStorageContractSuite(label, options) {
         const rejected = results.filter((result) => result.status === "rejected");
         expect(fulfilled).toHaveLength(1);
         expect(rejected).toHaveLength(1);
-        expect(rejected[0].reason).toBeInstanceOf(AgentStorageError);
+        expect(rejected[0].reason).toBeInstanceOf(AgentStorageError2);
         expect(rejected[0].reason.code).toBe("active_run_exists");
       });
     });
@@ -835,10 +827,8 @@ function runAgentStorageContractSuite(label, options) {
           mutableExecution.token = "mutated";
           mutableExecution.queueLeaseExpiresAt.setTime(0);
         }
-        run.requesterGroupIds.push("mutated");
         const reread = await storage.runs.getById({ projectId, id: "run_1" });
         expect(reread?.execution?.token).toBe("exec_1");
-        expect(reread?.requesterGroupIds).toEqual(["engineering", "support"]);
       });
     });
     test("releasing a run only clears its own thread's active pointer", async () => {
@@ -1023,7 +1013,7 @@ function runAgentStorageContractSuite(label, options) {
           seq: 1,
           role: "user",
           runId: null,
-          contentVersion: AGENT_MESSAGE_CONTENT_VERSION
+          contentVersion: AGENT_MESSAGE_CONTENT_VERSION2
         });
         expect(userMessage.authorPrincipal).toEqual(owner);
         const run = await createAndStartRun(storage, fixture, runInput({ id: "run_1" }));
@@ -1620,7 +1610,7 @@ function runAiCostStorageContractSuite(name, options) {
       try {
         const missing = ratedCost("missing");
         const missingError = await storage.recordModelCallCost(missing).catch((value) => value);
-        expect2(missingError).toBeInstanceOf(AiCostStorageError);
+        expect2(missingError).toBeInstanceOf(AiCostStorageError2);
         expect2(missingError.code).toBe("missing_usage");
         const base = ratedCost();
         const mismatch = ratedCost("usage_1", {
@@ -1631,7 +1621,7 @@ function runAiCostStorageContractSuite(name, options) {
           ]
         });
         const mismatchError = await storage.recordModelCallCost(mismatch).catch((value) => value);
-        expect2(mismatchError).toBeInstanceOf(AiCostStorageError);
+        expect2(mismatchError).toBeInstanceOf(AiCostStorageError2);
         expect2(mismatchError.code).toBe("cost_mismatch");
         await expect2(storage.recordModelCallCost({
           ...base,
@@ -1753,7 +1743,7 @@ function runAiLimitStorageContractSuite(label, options) {
   };
   describe3(label, () => {
     test3("uses inclusive-start, exclusive-end UTC calendar months", () => {
-      expect3(aiLimitCalendarMonth(at2("2026-12-31T23:59:59.999-05:00"))).toEqual({
+      expect3(aiLimitCalendarMonth2(at2("2026-12-31T23:59:59.999-05:00"))).toEqual({
         kind: "calendarMonth",
         start: at2("2027-01-01T00:00:00.000Z"),
         end: at2("2027-02-01T00:00:00.000Z"),
@@ -2283,12 +2273,12 @@ function runAiLimitStorageContractSuite(label, options) {
     test3("derives each subject's actuals from immutable execution and usage attribution", async () => {
       await withStorage(async (storage) => {
         const engineering = { type: "group", id: "engineering" };
-        const serviceAccount2 = { type: "serviceAccount", id: "automation" };
+        const serviceAccount = { type: "serviceAccount", id: "automation" };
         await recordUsage(storage.aiUsage, "usage-all-subjects", "all-subjects", 7, {
           requesterGroupIds: ["support", "engineering"]
         });
         const serviceExecutionId = "exec_ai_limit_service";
-        await seedPrincipalExecution(storage.auth, storage.executions, serviceExecutionId, serviceAccount2);
+        await seedPrincipalExecution(storage.auth, storage.executions, serviceExecutionId, serviceAccount);
         await recordUsage(storage.aiUsage, "usage-service-account", "service-account", 3, {
           executionId: serviceExecutionId,
           requesterGroupIds: []
@@ -2298,7 +2288,7 @@ function runAiLimitStorageContractSuite(label, options) {
           ["support-subject", support],
           ["engineering-subject", engineering],
           ["user-subject", user],
-          ["service-account-subject", serviceAccount2]
+          ["service-account-subject", serviceAccount]
         ]) {
           await storage.aiLimits.createPolicy({
             id,
@@ -2672,7 +2662,7 @@ import { describe as describe4, expect as expect4, test as test4 } from "bun:tes
 // src/testing/workflow-execution.ts
 async function createTestWorkflowExecution(executions, input) {
   const parentExecutionId = `test_request_execution:${input.runId}`;
-  const executionId3 = input.executionId ?? `test_workflow_execution:${input.runId}`;
+  const executionId = input.executionId ?? `test_workflow_execution:${input.runId}`;
   const primitive = {
     kind: "workflow",
     id: input.workflowId,
@@ -2680,6 +2670,7 @@ async function createTestWorkflowExecution(executions, input) {
   };
   await executions.create({
     id: parentExecutionId,
+    requesterGroupIds: input.requesterGroupIds ?? [],
     projectId: input.projectId,
     executor: { type: "request", requestId: `test_request:${input.runId}` },
     source: { type: "http", requestId: `test_request:${input.runId}` },
@@ -2688,7 +2679,8 @@ async function createTestWorkflowExecution(executions, input) {
     authorizationRef: input.requestedBy === undefined ? { type: "disabled" } : { type: "principal", principal: structuredClone(input.requestedBy) }
   });
   await executions.create({
-    id: executionId3,
+    id: executionId,
+    requesterGroupIds: input.requesterGroupIds ?? [],
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: { type: "execution", executionId: parentExecutionId },
@@ -2696,24 +2688,25 @@ async function createTestWorkflowExecution(executions, input) {
     correlationId: `test_correlation:${input.runId}`,
     authorizationRef: { type: "trustedPrimitive", primitive }
   });
-  return executionId3;
+  return executionId;
 }
 async function createTestAutomaticWorkflowExecution(executions, input) {
-  const executionId3 = input.executionId ?? `test_workflow_execution:${input.runId}`;
+  const executionId = input.executionId ?? `test_workflow_execution:${input.runId}`;
   const primitive = {
     kind: "workflow",
     id: input.workflowId,
     runId: input.runId
   };
   await executions.create({
-    id: executionId3,
+    id: executionId,
+    requesterGroupIds: [],
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: input.source ?? { type: "event", eventId: `test_event:${input.runId}` },
     correlationId: input.correlationId ?? `test_correlation:${input.runId}`,
     authorizationRef: { type: "trustedPrimitive", primitive }
   });
-  return executionId3;
+  return executionId;
 }
 
 // src/testing/ai-model-call-groups-contract.ts
@@ -2725,6 +2718,71 @@ var range = {
 };
 function runAiModelCallGroupsContractSuite(name, options) {
   describe4(name, () => {
+    test4("attributes direct calls and retries to requests, actions, and workflows", async () => {
+      const storage = await options.createStorage();
+      try {
+        await options.setup?.(storage);
+        const expected = [
+          { kind: "request", requestId: "request" },
+          { kind: "action", actionId: "summarize", actionRunId: "action" },
+          { kind: "workflow", workflowId: "summarize", workflowRunId: "workflow" }
+        ];
+        for (const attribution of expected) {
+          const kind = attribution.kind;
+          const primitive = {
+            kind: kind === "action" ? "action" : "workflow",
+            id: "summarize",
+            runId: kind
+          };
+          const execution = await storage.executions.create({
+            projectId: projectId4,
+            id: kind,
+            executor: kind === "request" ? { type: "request", requestId: kind } : { type: "primitive", kind, runId: kind },
+            source: kind === "request" ? { type: "http", requestId: kind } : { type: "event", eventId: kind },
+            correlationId: kind,
+            authorizationRef: kind === "request" ? { type: "disabled" } : { type: "trustedPrimitive", primitive }
+          });
+          for (const attempt of [1, 2]) {
+            await storage.aiUsage.recordModelCall({
+              projectId: projectId4,
+              id: `${kind}:${attempt}`,
+              executionId: execution.id,
+              attempt,
+              callId: `${kind}:${attempt}`,
+              requesterGroupIds: execution.requesterGroupIds,
+              providerId: "test",
+              requestedModelId: "small",
+              responseId: `${kind}:${attempt}`,
+              usage: { inputTokens: 2, outputTokens: 3 },
+              occurredAt: new Date("2026-09-01T12:00:00Z")
+            });
+          }
+          const calls = await storage.aiCosts.listModelCalls({
+            ...range,
+            executionId: execution.id
+          });
+          expect4(calls.total).toBe(2);
+          expect4(calls.items.map((call) => call.attribution)).toEqual([attribution, attribution]);
+        }
+        const groups = await storage.aiCosts.listModelCallGroups(range);
+        expect4(groups.total).toBe(3);
+        for (const attribution of expected) {
+          const group = groups.items.find((item) => item.executionId === attribution.kind);
+          expect4(group).toMatchObject({
+            attribution,
+            modelCallCount: 2,
+            totalTokens: 10,
+            executions: [{ attribution, modelCallCount: 2 }]
+          });
+        }
+        const overview = await storage.aiCosts.queryProjectOverview({ ...range, bucket: "day" });
+        expect4(overview.totals.modelCallCount).toBe(6);
+        expect4(overview.agents).toEqual([]);
+        expect4(overview.workflows).toMatchObject([{ workflowId: "summarize", modelCallCount: 2 }]);
+      } finally {
+        await options.cleanup?.(storage);
+      }
+    });
     test4("attributes workflow usage to step references and keeps same-named steps separate", async () => {
       const storage = await options.createStorage();
       try {
@@ -2879,8 +2937,7 @@ async function seedWorkflowCall(storage, workflowId, runId) {
     id: runId,
     workflowId,
     executionId: sourceExecutionId,
-    input: {},
-    requesterGroupIds: []
+    input: {}
   });
   await storage.workflowRuns.start({ projectId: projectId4, id: runId });
   const nodeRunId = `${runId}:node:0`;
@@ -2895,8 +2952,8 @@ async function seedWorkflowCall(storage, workflowId, runId) {
     nodeKey: "review",
     input: {}
   });
-  const actorId = workflowAgentStepActorId(workflowId, "review");
-  const executionId3 = await createTestAgentExecution(storage, {
+  const actorId = workflowAgentStepActorId2(workflowId, "review");
+  const executionId = await createTestAgentExecution(storage, {
     projectId: projectId4,
     runId: nodeRunId,
     actorId,
@@ -2905,14 +2962,14 @@ async function seedWorkflowCall(storage, workflowId, runId) {
   await storage.workflowRuns.agentNodes.create({
     projectId: projectId4,
     nodeRunId,
-    executionId: executionId3,
+    executionId,
     actorId,
     prompt: "Review the task."
   });
   const { record } = await storage.aiUsage.recordModelCall({
     projectId: projectId4,
     id: `usage:${runId}`,
-    executionId: executionId3,
+    executionId,
     attempt: 1,
     callId: runId,
     requesterGroupIds: [],
@@ -2946,7 +3003,7 @@ async function seed(storage) {
     ownerPrincipal: { type: "user", id: "user" }
   });
   for (const runId of ["parent", "second"]) {
-    const executionId3 = await createTestAgentExecution(storage, {
+    const executionId = await createTestAgentExecution(storage, {
       projectId: projectId4,
       runId,
       executionId: `exec_${runId}`,
@@ -2955,11 +3012,10 @@ async function seed(storage) {
     await storage.agents.runs.create({
       id: runId,
       projectId: projectId4,
-      executionId: executionId3,
+      executionId,
       threadId: "thread",
       triggerMessageId: `message_${runId}`,
-      spec: { model: { provider: "parent-provider", modelId: "large" } },
-      requesterGroupIds: []
+      spec: { model: { provider: "parent-provider", modelId: "large" } }
     });
     await storage.agents.runs.start({
       id: runId,
@@ -2972,7 +3028,7 @@ async function seed(storage) {
         actorId: "child",
         runId: "child",
         executionId: "exec_child",
-        sourceExecutionId: executionId3,
+        sourceExecutionId: executionId,
         authority: "inherited"
       });
       await storage.agents.runs.createSubagent({
@@ -3421,7 +3477,7 @@ function runAiUsageStorageContractSuite(label, options) {
       await withStorage(async (storage) => {
         await storage.recordModelCall(modelCallInput());
         const error = storage.recordModelCall(modelCallInput({ callId: "call_2", responseId: "response_2" }));
-        await expect5(error).rejects.toBeInstanceOf(AiUsageStorageError);
+        await expect5(error).rejects.toBeInstanceOf(AiUsageStorageError2);
         await expect5(error).rejects.toMatchObject({ code: "duplicate_id" });
         await expect5(storage.summarizeExecution({ projectId: projectId5, executionId: agentExecutionId })).resolves.toMatchObject({
           modelCallCount: 1,
@@ -3432,7 +3488,7 @@ function runAiUsageStorageContractSuite(label, options) {
     test5("rejects a model call whose durable execution does not exist", async () => {
       await withStorage(async (storage) => {
         const error = storage.recordModelCall(modelCallInput({ id: "usage_missing", executionId: "exec_missing" }));
-        await expect5(error).rejects.toBeInstanceOf(AiUsageStorageError);
+        await expect5(error).rejects.toBeInstanceOf(AiUsageStorageError2);
         await expect5(error).rejects.toMatchObject({ code: "missing_execution" });
       });
     });
@@ -3509,7 +3565,7 @@ function sessionInput(id, tokenHash = `${id}-hash`, audience = "atlas", absolute
   };
 }
 async function expectAuthError(promise, code) {
-  await expect6(promise).rejects.toBeInstanceOf(AuthStorageError);
+  await expect6(promise).rejects.toBeInstanceOf(AuthStorageError2);
   await expect6(promise).rejects.toMatchObject({ code });
 }
 async function createUser(storage, input = {}) {
@@ -3533,10 +3589,10 @@ function runAuthStorageContractSuite(label, options) {
   describe6(label, () => {
     test6("creates users with normalized email and isolates projects", async () => {
       await withStorage(async (storage) => {
-        const user2 = await createUser(storage, {
+        const user = await createUser(storage, {
           email: " Ava@Acme.COM "
         });
-        expect6(user2.email).toBe("ava@acme.com");
+        expect6(user.email).toBe("ava@acme.com");
         await expectAuthError(storage.users.create({
           id: "usr_duplicate",
           projectId: projectId6,
@@ -4036,14 +4092,14 @@ function runAuthStorageContractSuite(label, options) {
     });
     test6("manages service accounts and their group memberships", async () => {
       await withStorage(async (storage) => {
-        const serviceAccount2 = await storage.serviceAccounts.create({
+        const serviceAccount = await storage.serviceAccounts.create({
           id: "svc_ingest",
           projectId: projectId6,
           name: "Ingest worker",
           description: "Reads source data into Sixb.",
           createdAt: at4("2026-05-14T10:00:00.000Z")
         });
-        expect6(serviceAccount2).toMatchObject({
+        expect6(serviceAccount).toMatchObject({
           id: "svc_ingest",
           name: "Ingest worker",
           status: "active"
@@ -5220,7 +5276,7 @@ function runBlobStorageContractSuite(label, options) {
           logicalPath: "reports/report.bin"
         });
         expect7(fileRef.sizeBytes).toBe(13);
-        expect7(fileRef.blobId).toBe(blobIdFromDigest(fileRef.digest));
+        expect7(fileRef.blobId).toBe(blobIdFromDigest2(fileRef.digest));
         expect7(fileRef.fileName).toBe("report.bin");
         expect7(fileRef.mediaType).toBe("application/octet-stream");
         expect7(fileRef.logicalPath).toBe("reports/report.bin");
@@ -5230,7 +5286,7 @@ function runBlobStorageContractSuite(label, options) {
     test7("rejects an expected size mismatch without publishing a blob", async () => {
       await withStorage(async (storage) => {
         const bytes = encoder.encode("wrong size");
-        const blobId = blobIdFromDigest(computeBlobDigest(bytes));
+        const blobId = blobIdFromDigest2(computeBlobDigest2(bytes));
         await expect7(storage.put({ body: bytes, expectedSizeBytes: bytes.byteLength + 1 })).rejects.toThrow(`Blob size mismatch: expected ${bytes.byteLength + 1} bytes, received ${bytes.byteLength}.`);
         await expect7(storage.stat(blobId)).resolves.toBeNull();
       });
@@ -5250,7 +5306,7 @@ function runBlobStorageContractSuite(label, options) {
         const abort = new AbortController;
         let bodyCancelled = false;
         const firstChunk = encoder.encode("partial");
-        const blobId = blobIdFromDigest(computeBlobDigest(firstChunk));
+        const blobId = blobIdFromDigest2(computeBlobDigest2(firstChunk));
         const body = new ReadableStream({
           start(controller) {
             controller.enqueue(firstChunk);
@@ -5346,12 +5402,12 @@ function runBrokerContractSuite(label, options) {
             projectId: "  ",
             stream: eventsStream,
             records: [{ payload: { ok: true } }]
-          })).rejects.toBeInstanceOf(BrokerError);
+          })).rejects.toBeInstanceOf(BrokerError2);
           await expect8(appendRecords(broker, {
             projectId: "project-a",
             stream: { id: "  " },
             records: [{ payload: { ok: true } }]
-          })).rejects.toBeInstanceOf(BrokerError);
+          })).rejects.toBeInstanceOf(BrokerError2);
         });
       });
       test8("rejects payloads that are not JSON values", async () => {
@@ -5366,12 +5422,12 @@ function runBrokerContractSuite(label, options) {
                 }
               }
             ]
-          })).rejects.toBeInstanceOf(BrokerError);
+          })).rejects.toBeInstanceOf(BrokerError2);
           await expect8(appendRecords(broker, {
             projectId: "project-a",
             stream: eventsStream,
             records: [{ payload: { value: Number.NaN } }]
-          })).rejects.toBeInstanceOf(BrokerError);
+          })).rejects.toBeInstanceOf(BrokerError2);
         });
       });
       test8("requires streams to be ensured before appending records", async () => {
@@ -5380,7 +5436,7 @@ function runBrokerContractSuite(label, options) {
             projectId: "project-a",
             streamId: "missing",
             records: [{ payload: "one" }]
-          })).rejects.toBeInstanceOf(BrokerError);
+          })).rejects.toBeInstanceOf(BrokerError2);
         });
       });
     });
@@ -5594,7 +5650,7 @@ function runBrokerContractSuite(label, options) {
     describe8("subscribe", () => {
       test8("requires streams to be ensured before subscribing", async () => {
         await withBroker(async (broker) => {
-          await expect8(broker.subscribe({ projectId: "project-a", streamId: "missing" }, () => {})).rejects.toBeInstanceOf(BrokerError);
+          await expect8(broker.subscribe({ projectId: "project-a", streamId: "missing" }, () => {})).rejects.toBeInstanceOf(BrokerError2);
         });
       });
       test8("defaults to latest and receives only new records", async () => {
@@ -5746,9 +5802,9 @@ function runBrokerContractSuite(label, options) {
           await broker.append({
             projectId: "project-a",
             streamId: stream.id,
-            records: ["one", "two", "three"].map((label2) => ({
-              name: label2,
-              payload: { label: label2, body: "x".repeat(600) }
+            records: ["one", "two", "three"].map((label) => ({
+              name: label,
+              payload: { label, body: "x".repeat(600) }
             }))
           });
           const records = await broker.read({
@@ -5790,19 +5846,19 @@ function runBrokerContractSuite(label, options) {
             projectId: "project-a",
             stream: retainedStream,
             afterCursor: first?.cursor
-          })).rejects.toBeInstanceOf(BrokerError);
+          })).rejects.toBeInstanceOf(BrokerError2);
           await expect8(broker.tail({
             projectId: "project-a",
             streamId: retainedStream.id,
             beforeCursor: first?.cursor
-          })).rejects.toBeInstanceOf(BrokerError);
+          })).rejects.toBeInstanceOf(BrokerError2);
           await expect8(broker.subscribe({
             projectId: "project-a",
             streamId: retainedStream.id,
             afterCursor: first?.cursor
           }, () => {
             return;
-          })).rejects.toBeInstanceOf(BrokerError);
+          })).rejects.toBeInstanceOf(BrokerError2);
         });
       });
       test8("retains only records within maxAgeMs", async () => {
@@ -6645,12 +6701,12 @@ import { describe as describe10, expect as expect10, test as test10 } from "bun:
 
 // src/testing/materializer-fixture.ts
 function createMaterializerTestFixture(input) {
-  const projections = new ProjectionRegistry({
+  const projections = new ProjectionRegistry2({
     projections: [],
     ontology: input.ontology,
     datasetsById: new Map
   });
-  const materializer = createOntologyMaterializer({
+  const materializer = createOntologyMaterializer2({
     projectId: input.projectId,
     ontology: input.ontology,
     projections,
@@ -6687,9 +6743,9 @@ function createMaterializerTestFixture(input) {
     materializer,
     commit,
     appendTelemetry,
-    async seed(seed2) {
+    async seed(seed) {
       const operations = [];
-      for (const object of seed2.objects ?? []) {
+      for (const object of seed.objects ?? []) {
         operations.push({
           id: `seed-object:${operations.length}`,
           kind: "object.upsert",
@@ -6697,18 +6753,18 @@ function createMaterializerTestFixture(input) {
           properties: object.properties
         });
       }
-      for (const link2 of seed2.links ?? []) {
+      for (const link of seed.links ?? []) {
         operations.push({
           id: `seed-link:${operations.length}`,
           kind: "link.upsert",
-          ref: link2.ref,
-          ...link2.properties === undefined ? {} : { properties: link2.properties }
+          ref: link.ref,
+          ...link.properties === undefined ? {} : { properties: link.properties }
         });
       }
       if (operations.length > 0)
         await commit(operations);
-      if (seed2.telemetry && seed2.telemetry.length > 0) {
-        await appendTelemetry(seed2.telemetry);
+      if (seed.telemetry && seed.telemetry.length > 0) {
+        await appendTelemetry(seed.telemetry);
       }
     }
   };
@@ -6716,35 +6772,35 @@ function createMaterializerTestFixture(input) {
 
 // src/testing/effective-storage-contract.ts
 var projectId8 = "effective-storage-contract";
-var Device = defineObjectType({
+var Device = defineObjectType2({
   id: "EffectiveStorageDevice",
   name: "Device",
   properties: [
-    prop("id", "string", { primary: true, required: true }),
-    prop("name", "string", { required: true }),
-    prop("temperature", "double", { mode: "telemetry" })
+    prop2("id", "string", { primary: true, required: true }),
+    prop2("name", "string", { required: true }),
+    prop2("temperature", "double", { mode: "telemetry" })
   ],
-  links: [link.self("peers", { cardinality: "many" })]
+  links: [link2.self("peers", { cardinality: "many" })]
 });
-var OpaqueA = defineObjectType({
+var OpaqueA = defineObjectType2({
   id: "A",
   name: "Opaque A",
   properties: [
-    prop("id", "string", { primary: true, required: true }),
-    prop("name", "string", { required: true })
+    prop2("id", "string", { primary: true, required: true }),
+    prop2("name", "string", { required: true })
   ],
-  links: [link.self("D", { cardinality: "many" })]
+  links: [link2.self("D", { cardinality: "many" })]
 });
-var OpaqueAB = defineObjectType({
+var OpaqueAB = defineObjectType2({
   id: "A:B",
   name: "Opaque AB",
   properties: [
-    prop("id", "string", { primary: true, required: true }),
-    prop("name", "string", { required: true })
+    prop2("id", "string", { primary: true, required: true }),
+    prop2("name", "string", { required: true })
   ],
-  links: [link.self("D", { cardinality: "many" })]
+  links: [link2.self("D", { cardinality: "many" })]
 });
-var ontology = new OntologyRegistry({ sources: [Device, OpaqueA, OpaqueAB] });
+var ontology = new OntologyRegistry2({ sources: [Device, OpaqueA, OpaqueAB] });
 function runEffectiveStorageContractSuite(name, provider) {
   const withStorage = async (body) => {
     const storage = await provider.createStorage();
@@ -6775,7 +6831,7 @@ function runEffectiveStorageContractSuite(name, provider) {
             { objectTypeId: Device.id, primaryId: "missing" }
           ]
         });
-        expect10([...batch.keys()]).toEqual([objectBatchKey(Device.id, "a")]);
+        expect10([...batch.keys()]).toEqual([objectBatchKey2(Device.id, "a")]);
         const selectedProperties = await storage.objects.selectsObjectProperties({
           projectId: projectId8,
           items: [
@@ -6807,13 +6863,13 @@ function runEffectiveStorageContractSuite(name, provider) {
           projectId: projectId8,
           items: [{ objectTypeId: Device.id, objectId: "a", linkId: "peers" }]
         });
-        expect10(linksByScope.get(linkBatchKey(Device.id, "a", "peers"))).toHaveLength(2);
+        expect10(linksByScope.get(linkBatchKey2(Device.id, "a", "peers"))).toHaveLength(2);
         const incomingByScope = await storage.objects.listLinksBatch({
           projectId: projectId8,
           direction: "incoming",
           items: [{ objectTypeId: Device.id, objectId: "b", linkId: "peers" }]
         });
-        expect10(incomingByScope.get(linkBatchKey(Device.id, "b", "peers"))).toMatchObject([
+        expect10(incomingByScope.get(linkBatchKey2(Device.id, "b", "peers"))).toMatchObject([
           { sourceId: "a", targetId: "b" }
         ]);
         const bothDirectionsByScope = await storage.objects.listLinksBatch({
@@ -6824,8 +6880,8 @@ function runEffectiveStorageContractSuite(name, provider) {
             { objectTypeId: Device.id, objectId: "b", linkId: "peers" }
           ]
         });
-        expect10(bothDirectionsByScope.get(linkBatchKey(Device.id, "a", "peers"))).toHaveLength(2);
-        expect10(bothDirectionsByScope.get(linkBatchKey(Device.id, "b", "peers"))).toMatchObject([
+        expect10(bothDirectionsByScope.get(linkBatchKey2(Device.id, "a", "peers"))).toHaveLength(2);
+        expect10(bothDirectionsByScope.get(linkBatchKey2(Device.id, "b", "peers"))).toMatchObject([
           { sourceId: "a", targetId: "b" }
         ]);
       });
@@ -6848,7 +6904,7 @@ function runEffectiveStorageContractSuite(name, provider) {
           direction: "outgoing",
           linkId: "peers",
           endpointObjectTypeIds: [Device.id],
-          after: objectLinkCursor(first.links[0]),
+          after: objectLinkCursor2(first.links[0]),
           limit: 1
         });
         expect10(second.links.map((row) => row.targetId)).toEqual(["c"]);
@@ -6937,8 +6993,8 @@ function runEffectiveStorageContractSuite(name, provider) {
             { objectTypeId: OpaqueAB.id, primaryId: "C" }
           ]
         });
-        expect10(objects.get(objectBatchKey(OpaqueA.id, "B:C"))?.properties.name).toBe("First");
-        expect10(objects.get(objectBatchKey(OpaqueAB.id, "C"))?.properties.name).toBe("Second");
+        expect10(objects.get(objectBatchKey2(OpaqueA.id, "B:C"))?.properties.name).toBe("First");
+        expect10(objects.get(objectBatchKey2(OpaqueAB.id, "C"))?.properties.name).toBe("Second");
         const links = await storage.objects.listLinksBatch({
           projectId: opaqueProjectId,
           direction: "both",
@@ -6947,8 +7003,8 @@ function runEffectiveStorageContractSuite(name, provider) {
             { objectTypeId: OpaqueAB.id, objectId: "C", linkId: "D" }
           ]
         });
-        expect10(links.get(linkBatchKey(OpaqueA.id, "B:C", "D"))).toHaveLength(1);
-        expect10(links.get(linkBatchKey(OpaqueAB.id, "C", "D"))).toHaveLength(1);
+        expect10(links.get(linkBatchKey2(OpaqueA.id, "B:C", "D"))).toHaveLength(1);
+        expect10(links.get(linkBatchKey2(OpaqueAB.id, "C", "D"))).toHaveLength(1);
       });
     });
     test10("preserves distinct incident links when opaque ids contain delimiters", async () => {
@@ -7065,19 +7121,19 @@ function peer(sourceId, targetId) {
     }
   };
 }
-function temperature(objectId, value, at5) {
+function temperature(objectId, value, at) {
   return {
     series: {
       object: { objectTypeId: Device.id, primaryId: objectId },
       propertyId: "temperature"
     },
     value,
-    at: at5
+    at
   };
 }
 // src/testing/execution.ts
 function createTestSixb(hostOrOptions, options = {}) {
-  const host = "withScope" in hostOrOptions ? hostOrOptions : new SixbHost(hostOrOptions);
+  const host = "withScope" in hostOrOptions ? hostOrOptions : new SixbHost2(hostOrOptions);
   const sixb = host.withScope(createTestingScope({
     projectId: host.id,
     ...options.authorization === undefined ? {} : { context: options.authorization },
@@ -7088,6 +7144,10 @@ function createTestSixb(hostOrOptions, options = {}) {
   if (!isBoundSixb(sixb)) {
     throw new Error("[Sixb] Test host did not return an execution-bound Sixb SDK.");
   }
+  bindModelExecutionAttempt(sixb.models, {
+    attempt: 1,
+    signal: options.signal ?? new AbortController().signal
+  });
   return sixb;
 }
 // src/testing/execution-storage-contract.ts
@@ -7105,6 +7165,50 @@ function runExecutionStorageContractSuite(label, options) {
     }
   };
   describe11(label, () => {
+    test11("captures memberships once and inherits them independently of current authority", async () => {
+      await withStorage(async (storage) => {
+        await seedAuth(storage.auth);
+        for (const groupId of ["support", "finance"]) {
+          await storage.auth.groupMemberships.upsert({
+            projectId: projectId9,
+            userId: "user-one",
+            groupId,
+            source: "manual"
+          });
+        }
+        const parent = await storage.executions.create({
+          ...principalRequest({ id: "parent" }),
+          requesterGroupIds: undefined
+        });
+        expect11(parent.requesterGroupIds).toEqual(["finance", "support"]);
+        await storage.auth.groupMemberships.remove({
+          projectId: projectId9,
+          userId: "user-one",
+          groupId: "finance"
+        });
+        const childInput = trustedPrimitive("child", {
+          source: { type: "execution", executionId: parent.id },
+          correlationId: parent.correlationId
+        });
+        const child = await storage.executions.create({
+          ...childInput,
+          requesterGroupIds: undefined
+        });
+        expect11(child.requesterGroupIds).toEqual(["finance", "support"]);
+        child.requesterGroupIds.push("mutated");
+        await expect11(storage.executions.getById({ projectId: projectId9, id: child.id })).resolves.toMatchObject({ requesterGroupIds: ["finance", "support"] });
+        await expect11(storage.executions.create({
+          ...childInput,
+          id: "wrong-groups",
+          requesterGroupIds: ["support"]
+        })).rejects.toMatchObject({ code: "invalid_parent_execution" });
+        const next = await storage.executions.create({
+          ...principalRequest({ id: "next" }),
+          requesterGroupIds: undefined
+        });
+        expect11(next.requesterGroupIds).toEqual(["support"]);
+      });
+    });
     test11("round-trips every durable executor and authority shape", async () => {
       await withStorage(async (storage) => {
         await seedAuth(storage.auth);
@@ -7129,7 +7233,10 @@ function runExecutionStorageContractSuite(label, options) {
           const creationStartedAt = new Date;
           const created = await storage.executions.create(input);
           const { createdAt: persistedAt, ...persistedInput } = created;
-          expect11(persistedInput).toEqual(input);
+          expect11(persistedInput).toEqual({
+            ...input,
+            requesterGroupIds: input.requesterGroupIds ?? []
+          });
           expect11(Number.isFinite(persistedAt.getTime())).toBe(true);
           expect11(persistedAt.getTime()).toBeGreaterThanOrEqual(creationStartedAt.getTime());
           expect11(await storage.executions.getById({ projectId: input.projectId, id: input.id })).toEqual(created);
@@ -7399,6 +7506,7 @@ function principalRequest(input) {
     id: input.id,
     projectId: projectId9,
     requestedBy: principal,
+    requesterGroupIds: [],
     executor: { type: "request", requestId: `request-${input.id}` },
     source: { type: "http", requestId: `request-${input.id}` },
     correlationId: input.id === "parent" ? "correlation-parent" : `correlation-${input.id}`,
@@ -7413,6 +7521,7 @@ function disabledRequest(id, inputProjectId = projectId9) {
   return {
     id,
     projectId: inputProjectId,
+    requesterGroupIds: [],
     executor: { type: "request", requestId: `request-${id}` },
     source: { type: "http", requestId: `request-${id}` },
     correlationId: `correlation-${id}`,
@@ -7442,6 +7551,7 @@ function trustedPrimitive(id, overrides = {}, kind = "action") {
     id,
     projectId: projectId9,
     requestedBy: { type: "user", id: "user-one" },
+    requesterGroupIds: [],
     executor: { type: "primitive", kind, runId },
     source: trustedPrimitiveSource(kind, id),
     correlationId: `correlation-${id}`,
@@ -7482,6 +7592,7 @@ function agentExecution(id) {
     id,
     projectId: projectId9,
     requestedBy: { type: "user", id: "user-one" },
+    requesterGroupIds: [],
     executor: { type: "agent", runId: `run-${id}` },
     source: { type: "execution", executionId: "principal-request" },
     correlationId: "correlation-principal-request",
@@ -7497,6 +7608,7 @@ function kernelExecution(id) {
     id,
     projectId: projectId9,
     executor: { type: "kernel", operation },
+    requesterGroupIds: [],
     source: { type: "event", eventId: `event-${id}` },
     correlationId: `correlation-${id}`,
     authorizationRef: { type: "kernel", operation }
@@ -7507,17 +7619,17 @@ import { describe as describe13, expect as expect13, test as test13 } from "bun:
 
 // src/testing/dataset-sequence-contract.ts
 import { describe as describe12, expect as expect12, test as test12 } from "bun:test";
-var dataset = defineDataset("contract.source_order", {
+var dataset = defineDataset2("contract.source_order", {
   schema: [
-    col("id", "string"),
-    col("revision", "int64"),
-    col("name", "string"),
-    col("details", "json", { nullable: true })
+    col2("id", "string"),
+    col2("revision", "int64"),
+    col2("name", "string"),
+    col2("details", "json", { nullable: true })
   ],
   primaryKey: "id",
   sequenceBy: "revision"
 });
-var upsert = (revision, name = "Sam", id = "42") => change.upsert({ id, revision, name });
+var upsert = (revision, name = "Sam", id = "42") => change2.upsert({ id, revision, name });
 async function merge(storage, changes, definition = dataset) {
   const session = await storage.beginMerge({ dataset: definition });
   try {
@@ -7547,9 +7659,9 @@ function runDatasetSequenceContract(options) {
   describe12("source ordering", () => {
     test12("initializes empty snapshots and preserves versions across retries and reopen", async () => {
       let storage = await options.createStorage();
-      const snapshot = () => writeDataset({
+      const snapshot = () => writeDataset2({
         lakeStorage: storage,
-        blobStorage: new InMemoryBlobStorage,
+        blobStorage: new InMemoryBlobStorage2,
         dataset,
         mode: "snapshot",
         signal: new AbortController().signal,
@@ -7571,15 +7683,15 @@ function runDatasetSequenceContract(options) {
           storage = await options.reopen(storage);
         expect12(await storage.getLatestVersion(dataset.id)).toEqual(initial.version);
         expect12(await snapshot()).toMatchObject({ outcome: "unchanged", version: initial.version });
-        const concurrent = defineDataset("contract.empty_race", {
+        const concurrent = defineDataset2("contract.empty_race", {
           schema: dataset.schema.columns,
           primaryKey: "id",
           sequenceBy: "revision"
         });
         let committed;
-        const rebased = await writeDataset({
+        const rebased = await writeDataset2({
           lakeStorage: storage,
-          blobStorage: new InMemoryBlobStorage,
+          blobStorage: new InMemoryBlobStorage2,
           dataset: concurrent,
           mode: "snapshot",
           signal: new AbortController().signal,
@@ -7595,25 +7707,25 @@ function runDatasetSequenceContract(options) {
       }
     });
     test12("rejects lossy timestamps outside the ordering column before changing source state", () => withStorage(async (storage) => {
-      const timestamps = defineDataset("contract.content_timestamps", {
-        schema: [...dataset.schema.columns, col("at", "timestamp", { nullable: true })],
+      const timestamps = defineDataset2("contract.content_timestamps", {
+        schema: [...dataset.schema.columns, col2("at", "timestamp", { nullable: true })],
         primaryKey: "id",
         sequenceBy: "revision"
       });
       await storage.createDataset(timestamps);
-      const row = (at5, id = "42") => change.upsert({ id, revision: 1, name: "Sam", at: at5 });
+      const row = (at, id = "42") => change2.upsert({ id, revision: 1, name: "Sam", at });
       const initial = await merge(storage, [row("2026-09-09T10:00:00.123Z")], timestamps);
-      for (const at5 of [
+      for (const at of [
         "2026-09-09T10:00:00.123001Z",
         "2026-09-09T10:00:00.123999Z",
         "2026-09-09T10:00:00",
         "2026-02-30T00:00:00Z"
       ]) {
-        await expect12(merge(storage, [row(at5, "new")], timestamps)).rejects.toThrow("column 'at'");
+        await expect12(merge(storage, [row(at, "new")], timestamps)).rejects.toThrow("column 'at'");
         expect12(await storage.getLatestVersion(timestamps.id)).toEqual(initial.version);
       }
-      for (const at5 of ["2026-09-09T12:00:00.123+02:00", new Date("2026-09-09T10:00:00.123Z")]) {
-        expect12((await merge(storage, [row(at5)], timestamps)).outcome).toBe("unchanged");
+      for (const at of ["2026-09-09T12:00:00.123+02:00", new Date("2026-09-09T10:00:00.123Z")]) {
+        expect12((await merge(storage, [row(at)], timestamps)).outcome).toBe("unchanged");
       }
       await expect12(merge(storage, [row("2026-09-09T10:00:00.124Z")], timestamps)).rejects.toThrow("conflicting content");
       await merge(storage, [row(null, "nullable")], timestamps);
@@ -7621,17 +7733,17 @@ function runDatasetSequenceContract(options) {
     }));
     test12("ingests through the bound SDK and preserves execution provenance", async () => {
       let storage = await options.createStorage();
-      const broker = new InMemoryBroker;
+      const broker = new InMemoryBroker2;
       try {
-        const host = new SixbHost({
+        const host = new SixbHost2({
           id: "ingest-contract",
           ontology: [],
           datasets: [dataset],
           lakeStorage: storage,
           broker,
-          storage: new InMemoryStorage,
-          queues: new InMemoryQueues,
-          blobStorage: new InMemoryBlobStorage
+          storage: new InMemoryStorage2,
+          queues: new InMemoryQueues2,
+          blobStorage: new InMemoryBlobStorage2
         });
         const sixb = createTestSixb(host);
         const result = await sixb.datasets.ingest(dataset, { changes: [upsert(8)] });
@@ -7663,11 +7775,11 @@ function runDatasetSequenceContract(options) {
         expectedLatestVersionId: (await storage.getLatestVersion(dataset.id))?.versionId
       });
       await guarded.writeChanges([upsert(10)]);
-      await merge(storage, [change.delete({ id: "42" }, { sequence: 9 })]);
+      await merge(storage, [change2.delete({ id: "42" }, { sequence: 9 })]);
       await expect12(guarded.commit({ retryOnConflict: true })).rejects.toThrow("Optimistic");
       await guarded.abort();
       const staleDelete = await storage.beginMerge({ dataset });
-      await staleDelete.writeChanges([change.delete({ id: "42" }, { sequence: 9 })]);
+      await staleDelete.writeChanges([change2.delete({ id: "42" }, { sequence: 9 })]);
       await merge(storage, [upsert(10)]);
       expect12((await staleDelete.commit({ retryOnConflict: true })).outcome).toBe("unchanged");
       expect12((await storage.getLatestVersion(dataset.id))?.versionId).not.toBe(initial.version?.versionId);
@@ -7690,29 +7802,29 @@ function runDatasetSequenceContract(options) {
     test12("retains absent-key deletions and protects their version boundary", () => withStorage(async (storage) => {
       const staleSession = await storage.beginMerge({ dataset });
       await staleSession.writeChanges([upsert(8)]);
-      const deleted = await merge(storage, [change.delete({ id: "42" }, { sequence: 9 })]);
+      const deleted = await merge(storage, [change2.delete({ id: "42" }, { sequence: 9 })]);
       expect12(deleted).toMatchObject({ outcome: "created", version: { rowCount: 0 } });
       await expect12(staleSession.commit()).rejects.toThrow("Optimistic");
       await staleSession.abort();
       expect12((await merge(storage, [upsert(8)])).outcome).toBe("unchanged");
-      expect12((await merge(storage, [change.delete({ id: "42" }, { sequence: "9" })])).outcome).toBe("unchanged");
+      expect12((await merge(storage, [change2.delete({ id: "42" }, { sequence: "9" })])).outcome).toBe("unchanged");
       await expect12(merge(storage, [upsert(9)])).rejects.toThrow("conflicting content");
       await merge(storage, [upsert(10)]);
       expect12(await rows(storage)).toHaveLength(1);
-      expect12((await merge(storage, [change.delete({ id: "42" }, { sequence: 9 })])).outcome).toBe("unchanged");
-      await merge(storage, [change.delete({ id: "42" }, { sequence: 11 })]);
+      expect12((await merge(storage, [change2.delete({ id: "42" }, { sequence: 9 })])).outcome).toBe("unchanged");
+      await merge(storage, [change2.delete({ id: "42" }, { sequence: 11 })]);
       expect12(await rows(storage)).toEqual([]);
     }));
     test12("compares canonical content across JSON order and nullable representations", () => withStorage(async (storage) => {
       await merge(storage, [
-        change.upsert({ id: "42", revision: 1, name: "Sam", details: { a: 1, b: 2 } })
+        change2.upsert({ id: "42", revision: 1, name: "Sam", details: { a: 1, b: 2 } })
       ]);
       expect12((await merge(storage, [
-        change.upsert({ id: "42", revision: "01", name: "Sam", details: { b: 2, a: 1 } })
+        change2.upsert({ id: "42", revision: "01", name: "Sam", details: { b: 2, a: 1 } })
       ])).outcome).toBe("unchanged");
       await merge(storage, [upsert(2)]);
       expect12((await merge(storage, [
-        change.upsert({ id: "42", revision: "2", name: "Sam", details: null })
+        change2.upsert({ id: "42", revision: "2", name: "Sam", details: null })
       ])).outcome).toBe("unchanged");
     }));
     test12("validates integer ranges and delete sequences at the provider boundary", () => withStorage(async (storage) => {
@@ -7725,20 +7837,20 @@ function runDatasetSequenceContract(options) {
         "-9223372036854775809",
         "1e3"
       ]) {
-        await expect12(merge(storage, [change.upsert({ id: "42", revision, name: "Sam" })])).rejects.toThrow("sequence");
+        await expect12(merge(storage, [change2.upsert({ id: "42", revision, name: "Sam" })])).rejects.toThrow("sequence");
       }
-      await expect12(merge(storage, [change.delete({ id: "42" })])).rejects.toThrow("sequence");
+      await expect12(merge(storage, [change2.delete({ id: "42" })])).rejects.toThrow("sequence");
       await merge(storage, [upsert("-9223372036854775808"), upsert("9223372036854775807")]);
       expect12((await rows(storage))[0]?.revision?.toString()).toBe("9223372036854775807");
     }));
     test12("normalizes timezone-aware timestamps without discarding precision", () => withStorage(async (storage) => {
-      const timestamps = defineDataset("contract.source_timestamps", {
-        schema: [col("id", "string"), col("updated", "timestamp"), col("name", "string")],
+      const timestamps = defineDataset2("contract.source_timestamps", {
+        schema: [col2("id", "string"), col2("updated", "timestamp"), col2("name", "string")],
         primaryKey: "id",
         sequenceBy: "updated"
       });
       await storage.createDataset(timestamps);
-      const row = (updated, name = "Sam") => change.upsert({ id: "42", updated, name });
+      const row = (updated, name = "Sam") => change2.upsert({ id: "42", updated, name });
       await merge(storage, [row("2026-09-09T10:00:00.123Z")], timestamps);
       for (const updated of [
         "2026-09-09T12:00:00.123+02:00",
@@ -7754,7 +7866,7 @@ function runDatasetSequenceContract(options) {
       ]) {
         await expect12(merge(storage, [row(updated)], timestamps)).rejects.toThrow("sequence");
       }
-      await merge(storage, [change.delete({ id: "42" }, { sequence: "2026-09-09T10:00:00.124Z" })], timestamps);
+      await merge(storage, [change2.delete({ id: "42" }, { sequence: "2026-09-09T10:00:00.124Z" })], timestamps);
       expect12((await merge(storage, [row("2026-09-09T10:00:00.123Z")], timestamps)).outcome).toBe("unchanged");
     }));
     test12("round-trips immutable sequencing and rejects writes that bypass ordering", () => withStorage(async (storage) => {
@@ -7776,7 +7888,7 @@ function runDatasetSequenceContract(options) {
           await storage.createDataset(dataset);
           await merge(storage, [
             upsert(8, "visible", "visible"),
-            change.delete({ id: "42" }, { sequence: 9 })
+            change2.delete({ id: "42" }, { sequence: 9 })
           ]);
           storage = await reopen(storage);
           expect12((await storage.getDataset(dataset.id))?.sequenceBy).toBe("revision");
@@ -7792,16 +7904,16 @@ function runDatasetSequenceContract(options) {
 }
 
 // src/testing/lake-merge-storage-contract.ts
-var invoices = defineDataset("contract.merges.invoices", {
-  schema: [col("id", "string"), col("status", "string"), col("note", "string", { nullable: true })],
+var invoices = defineDataset2("contract.merges.invoices", {
+  schema: [col2("id", "string"), col2("status", "string"), col2("note", "string", { nullable: true })],
   primaryKey: "id"
 });
-var lineItems = defineDataset("contract.merges.line_items", {
-  schema: [col("invoiceId", "string"), col("lineItemId", "string"), col("description", "string")],
+var lineItems = defineDataset2("contract.merges.line_items", {
+  schema: [col2("invoiceId", "string"), col2("lineItemId", "string"), col2("description", "string")],
   primaryKey: ["invoiceId", "lineItemId"]
 });
-var unkeyed = defineDataset("contract.merges.unkeyed", {
-  schema: [col("id", "string")]
+var unkeyed = defineDataset2("contract.merges.unkeyed", {
+  schema: [col2("id", "string")]
 });
 function runLakeMergeStorageContractSuite(label, options) {
   const withStorage = async (body) => {
@@ -7817,17 +7929,17 @@ function runLakeMergeStorageContractSuite(label, options) {
     test13("creates an initial merge version from async changes", async () => {
       await withStorage(async (storage) => {
         await storage.createDataset(invoices);
-        const merge2 = await storage.beginMerge({
+        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" });
+          yield change2.upsert({ id: "inv_1", status: "open", note: null });
+          yield change2.upsert({ id: "inv_2", status: "paid", note: "settled" });
         }
-        await merge2.writeChanges(changes());
-        const result = await merge2.commit({ commitMessage: "initial invoice changes" });
+        await merge.writeChanges(changes());
+        const result = await merge.commit({ commitMessage: "initial invoice changes" });
         const version = expectCreated(result);
         expect13(version).toMatchObject({
           datasetId: invoices.id,
@@ -7846,19 +7958,19 @@ function runLakeMergeStorageContractSuite(label, options) {
     test13("inserts, updates, and deletes while preserving the parent version", async () => {
       await withStorage(async (storage) => {
         await storage.createDataset(invoices);
-        const seed2 = await storage.beginWrite({ dataset: invoices, mode: "snapshot" });
-        await seed2.writeRows([
+        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 seed2.commit();
-        const merge2 = await storage.beginMerge({ dataset: invoices });
-        await merge2.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 parent = await seed.commit();
+        const merge = await storage.beginMerge({ dataset: invoices });
+        await merge.writeChanges([
+          change2.upsert({ id: "inv_1", status: "paid", note: null }),
+          change2.delete({ id: "inv_2" }),
+          change2.upsert({ id: "inv_2_moved", status: "open", note: "moved" })
         ]);
-        const version = expectCreated(await merge2.commit());
+        const version = expectCreated(await merge.commit());
         expect13(version.parentVersionId).toBe(parent.versionId);
         expect13(version.mode).toBe("merge");
         await expect13(collectRows(storage.readRows({ datasetId: invoices.id }))).resolves.toEqual([
@@ -7874,16 +7986,16 @@ function runLakeMergeStorageContractSuite(label, options) {
     test13("applies the final change for repeated single and composite keys", async () => {
       await withStorage(async (storage) => {
         await storage.createDataset(lineItems);
-        const merge2 = await storage.beginMerge({ dataset: lineItems });
-        await merge2.writeChanges([
-          change.upsert({ invoiceId: "a|b", lineItemId: "c", description: "first" }),
-          change.upsert({ invoiceId: "a", lineItemId: "b|c", description: "other key" })
+        const merge = await storage.beginMerge({ dataset: lineItems });
+        await merge.writeChanges([
+          change2.upsert({ invoiceId: "a|b", lineItemId: "c", description: "first" }),
+          change2.upsert({ invoiceId: "a", lineItemId: "b|c", description: "other key" })
         ]);
-        await merge2.writeChanges([
-          change.delete({ invoiceId: "a|b", lineItemId: "c" }),
-          change.upsert({ invoiceId: "a|b", lineItemId: "c", description: "final" })
+        await merge.writeChanges([
+          change2.delete({ invoiceId: "a|b", lineItemId: "c" }),
+          change2.upsert({ invoiceId: "a|b", lineItemId: "c", description: "final" })
         ]);
-        expectCreated(await merge2.commit());
+        expectCreated(await merge.commit());
         await expect13(collectRows(storage.readRows({ datasetId: lineItems.id }))).resolves.toEqual([
           { invoiceId: "a|b", lineItemId: "c", description: "final" },
           { invoiceId: "a", lineItemId: "b|c", description: "other key" }
@@ -7896,23 +8008,23 @@ function runLakeMergeStorageContractSuite(label, options) {
         const empty = await storage.beginMerge({ dataset: invoices });
         expect13(await empty.commit()).toEqual({ outcome: "unchanged", version: null });
         const initialNoOp = await storage.beginMerge({ dataset: invoices });
-        await initialNoOp.writeChanges([change.delete({ id: "missing" })]);
+        await initialNoOp.writeChanges([change2.delete({ id: "missing" })]);
         expect13(await initialNoOp.commit()).toEqual({ outcome: "unchanged", version: null });
         expect13(await storage.listVersions(invoices.id)).toEqual([]);
-        const seed2 = await storage.beginMerge({ dataset: invoices });
-        await seed2.writeChanges([change.upsert({ id: "inv_1", status: "open", note: null })]);
-        const seedVersion = expectCreated(await seed2.commit());
+        const seed = await storage.beginMerge({ dataset: invoices });
+        await seed.writeChanges([change2.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 })]);
+        await identical.writeChanges([change2.upsert({ id: "inv_1", status: "open", note: null })]);
         expect13(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" })
+          change2.upsert({ id: "inv_1", status: "paid", note: null }),
+          change2.upsert({ id: "inv_1", status: "open" }),
+          change2.delete({ id: "missing" })
         ]);
         const noOpResult = await laterNoOp.commit();
         expect13(noOpResult).toMatchObject({ outcome: "unchanged" });
@@ -7925,9 +8037,9 @@ function runLakeMergeStorageContractSuite(label, options) {
         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.writeChanges([change2.upsert({ id: "inv_1", status: "open", note: null })]);
         await first.commit();
-        await stale.writeChanges([change.upsert({ id: "inv_2", status: "open" })]);
+        await stale.writeChanges([change2.upsert({ id: "inv_2", status: "open" })]);
         await expect13(stale.commit()).rejects.toThrow("Optimistic merge commit failed");
         await expect13(collectRows(storage.readRows({ datasetId: invoices.id }))).resolves.toEqual([
           { id: "inv_1", status: "open", note: null }
@@ -7937,9 +8049,9 @@ function runLakeMergeStorageContractSuite(label, options) {
     test13("checks an explicit latest-version guard against the captured merge base", async () => {
       await withStorage(async (storage) => {
         await storage.createDataset(invoices);
-        const seed2 = await storage.beginMerge({ dataset: invoices });
-        await seed2.writeChanges([change.upsert({ id: "inv_1", status: "open" })]);
-        const version = expectCreated(await seed2.commit());
+        const seed = await storage.beginMerge({ dataset: invoices });
+        await seed.writeChanges([change2.upsert({ id: "inv_1", status: "open" })]);
+        const version = expectCreated(await seed.commit());
         await expect13(storage.beginMerge({ dataset: invoices, expectedLatestVersionId: "stale-version" })).rejects.toThrow("Optimistic merge start failed");
         const guarded = await storage.beginMerge({
           dataset: invoices,
@@ -7953,8 +8065,8 @@ function runLakeMergeStorageContractSuite(label, options) {
         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" })]);
+        await left.writeChanges([change2.upsert({ id: "inv_left", status: "open" })]);
+        await right.writeChanges([change2.upsert({ id: "inv_right", status: "open" })]);
         const results = await Promise.allSettled([left.commit(), right.commit()]);
         expect13(results.filter((result) => result.status === "fulfilled")).toHaveLength(1);
         expect13(results.filter((result) => result.status === "rejected")).toHaveLength(1);
@@ -7967,11 +8079,11 @@ function runLakeMergeStorageContractSuite(label, options) {
         await storage.createDataset(unkeyed);
         await expect13(storage.beginMerge({ dataset: unkeyed })).rejects.toThrow("must define a primaryKey");
         await storage.createDataset(invoices);
-        const merge2 = await storage.beginMerge({ dataset: invoices });
-        await expect13(merge2.writeChanges([change.upsert({ id: "inv_1" })])).rejects.toThrow("missing required column 'status'");
-        await expect13(merge2.writeChanges([change.delete({})])).rejects.toThrow("missing primary-key column 'id'");
-        await expect13(merge2.writeChanges([{ kind: "delete", key: { id: "inv_1", extra: "x" } }])).rejects.toThrow("unknown column 'extra'");
-        await merge2.abort();
+        const merge = await storage.beginMerge({ dataset: invoices });
+        await expect13(merge.writeChanges([change2.upsert({ id: "inv_1" })])).rejects.toThrow("missing required column 'status'");
+        await expect13(merge.writeChanges([change2.delete({})])).rejects.toThrow("missing primary-key column 'id'");
+        await expect13(merge.writeChanges([{ kind: "delete", key: { id: "inv_1", extra: "x" } }])).rejects.toThrow("unknown column 'extra'");
+        await merge.abort();
       });
     });
     test13("enforces unique keys for snapshot and append baselines", async () => {
@@ -7983,9 +8095,9 @@ function runLakeMergeStorageContractSuite(label, options) {
           { id: "inv_1", status: "paid" }
         ])).rejects.toThrow("duplicate primary key");
         await duplicateSnapshot.abort();
-        const seed2 = await storage.beginWrite({ dataset: invoices, mode: "snapshot" });
-        await seed2.writeRows([{ id: "inv_1", status: "open" }]);
-        await seed2.commit();
+        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 expect13(conflictingAppend.commit()).rejects.toThrow("duplicate primary key");
@@ -7995,17 +8107,17 @@ function runLakeMergeStorageContractSuite(label, options) {
       await withStorage(async (storage) => {
         await storage.createDataset(invoices);
         const row = { id: "inv_1", status: "open", note: null };
-        const merge2 = await storage.beginMerge({ dataset: invoices });
-        await merge2.writeChanges([change.upsert(row)]);
+        const merge = await storage.beginMerge({ dataset: invoices });
+        await merge.writeChanges([change2.upsert(row)]);
         row.status = "paid";
-        expectCreated(await merge2.commit());
-        await merge2.abort();
-        await expect13(merge2.writeChanges([])).rejects.toThrow("already closed");
+        expectCreated(await merge.commit());
+        await merge.abort();
+        await expect13(merge.writeChanges([])).rejects.toThrow("already closed");
         await expect13(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.writeChanges([change2.delete({ id: "inv_1" })]);
         await aborted.abort();
         await aborted.abort();
         expect13(await storage.listVersions(invoices.id)).toHaveLength(1);
@@ -8020,39 +8132,39 @@ function expectCreated(result) {
   }
   return result.version;
 }
-async function collectRows(rows2) {
+async function collectRows(rows) {
   const result = [];
-  for await (const row of rows2) {
+  for await (const row of rows) {
     result.push(row);
   }
   return result;
 }
 // src/testing/lake-storage-contract.ts
 import { describe as describe14, expect as expect14, test as test14 } from "bun:test";
-var definitionDataset = defineDataset("contract.definitions.orders", {
-  schema: [col("orderId", "string"), col("customerName", "string")],
+var definitionDataset = defineDataset2("contract.definitions.orders", {
+  schema: [col2("orderId", "string"), col2("customerName", "string")],
   description: "Contract orders"
 });
-var reorderedDefinitionDataset = defineDataset("contract.definitions.orders", {
-  schema: [col("customerName", "string"), col("orderId", "string")],
+var reorderedDefinitionDataset = defineDataset2("contract.definitions.orders", {
+  schema: [col2("customerName", "string"), col2("orderId", "string")],
   description: "Contract orders"
 });
-var keyedDefinitionDataset = defineDataset("contract.definitions.keyed_orders", {
-  schema: [col("tenantId", "string"), col("orderId", "string"), col("customerName", "string")],
+var keyedDefinitionDataset = defineDataset2("contract.definitions.keyed_orders", {
+  schema: [col2("tenantId", "string"), col2("orderId", "string"), col2("customerName", "string")],
   primaryKey: ["tenantId", "orderId"],
   description: "Contract keyed orders"
 });
-var writeDataset2 = defineDataset("contract.writes.orders", {
-  schema: [col("orderId", "string"), col("customerName", "string")]
+var writeDataset = defineDataset2("contract.writes.orders", {
+  schema: [col2("orderId", "string"), col2("customerName", "string")]
 });
-var nullableWriteDataset = defineDataset("contract.writes.nullable_orders", {
-  schema: [col("orderId", "string"), col("note", "string", { nullable: true })]
+var nullableWriteDataset = defineDataset2("contract.writes.nullable_orders", {
+  schema: [col2("orderId", "string"), col2("note", "string", { nullable: true })]
 });
-var decimalWriteDataset = defineDataset("contract.writes.decimals", {
-  schema: [col("id", "string"), col("amount", "decimal", { nullable: true })]
+var decimalWriteDataset = defineDataset2("contract.writes.decimals", {
+  schema: [col2("id", "string"), col2("amount", "decimal", { nullable: true })]
 });
-var fileRefDataset = defineDataset("contract.files.documents", {
-  schema: [col("id", "string"), col("attachment", "fileRef", { nullable: true })]
+var fileRefDataset = defineDataset2("contract.files.documents", {
+  schema: [col2("id", "string"), col2("attachment", "fileRef", { nullable: true })]
 });
 var invoiceRef = {
   blobId: `blob_${"a".repeat(64)}`,
@@ -8110,11 +8222,11 @@ function runLakeStorageContractSuite(label, options) {
       });
       test14("persists compatible metadata additions", async () => {
         await withStorage(async (storage) => {
-          const minimalDataset = defineDataset("contract.definitions.metadata", {
-            schema: [col("orderId", "string"), col("orderDate", "date")]
+          const minimalDataset = defineDataset2("contract.definitions.metadata", {
+            schema: [col2("orderId", "string"), col2("orderDate", "date")]
           });
-          const documentedDataset = defineDataset("contract.definitions.metadata", {
-            schema: [col("orderId", "string"), col("orderDate", "date")],
+          const documentedDataset = defineDataset2("contract.definitions.metadata", {
+            schema: [col2("orderId", "string"), col2("orderDate", "date")],
             partitionBy: ["orderDate"],
             description: "Contract metadata"
           });
@@ -8127,26 +8239,26 @@ function runLakeStorageContractSuite(label, options) {
       });
       test14("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")],
+          const changedDataset = defineDataset2(definitionDataset.id, {
+            schema: [col2("orderId", "int64"), col2("customerName", "string")],
             description: "Contract orders"
           });
           await storage.createDataset(definitionDataset);
           await expect14(storage.assertDatasetDefinitionsCompatible([changedDataset])).rejects.toThrow("changing column 'orderId' type");
-          await expect14(storage.createDataset(changedDataset)).rejects.toBeInstanceOf(LakeStorageError);
+          await expect14(storage.createDataset(changedDataset)).rejects.toBeInstanceOf(LakeStorageError2);
           expect14(await storage.getDataset(definitionDataset.id)).toEqual(definitionDataset);
         });
       });
       test14("checks provider schema evolution policy", async () => {
         await withStorage(async (storage) => {
-          const initialDataset = defineDataset("contract.definitions.schema_evolution", {
-            schema: [col("invoiceId", "string")]
+          const initialDataset = defineDataset2("contract.definitions.schema_evolution", {
+            schema: [col2("invoiceId", "string")]
           });
-          const requestedDataset = defineDataset("contract.definitions.schema_evolution", {
-            schema: [col("currency", "string", { nullable: true }), col("invoiceId", "string")]
+          const requestedDataset = defineDataset2("contract.definitions.schema_evolution", {
+            schema: [col2("currency", "string", { nullable: true }), col2("invoiceId", "string")]
           });
-          const storedDataset = defineDataset("contract.definitions.schema_evolution", {
-            schema: [col("invoiceId", "string"), col("currency", "string", { nullable: true })]
+          const storedDataset = defineDataset2("contract.definitions.schema_evolution", {
+            schema: [col2("invoiceId", "string"), col2("currency", "string", { nullable: true })]
           });
           await storage.createDataset(initialDataset);
           if (schemaEvolution === "strict") {
@@ -8179,8 +8291,8 @@ function runLakeStorageContractSuite(label, options) {
     describe14("catalog state", () => {
       test14("reports materialized state and latest version summaries in bulk", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const write = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          await storage.createDataset(writeDataset);
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await write.writeRows([
             { orderId: "ord_1", customerName: "Ada" },
             { orderId: "ord_2", customerName: "Grace" }
@@ -8190,17 +8302,17 @@ function runLakeStorageContractSuite(label, options) {
           const version = commit;
           await storage.createDataset(definitionDataset);
           const state = await storage.listDatasetCatalogState([
-            writeDataset2.id,
+            writeDataset.id,
             definitionDataset.id,
             "contract.missing.dataset"
           ]);
           const byId = new Map(state.map((entry) => [entry.datasetId, entry]));
-          expect14(byId.get(writeDataset2.id)).toMatchObject({
-            datasetId: writeDataset2.id,
+          expect14(byId.get(writeDataset.id)).toMatchObject({
+            datasetId: writeDataset.id,
             materialized: true
           });
-          expect14(byId.get(writeDataset2.id)?.latestVersion).toMatchObject({
-            datasetId: writeDataset2.id,
+          expect14(byId.get(writeDataset.id)?.latestVersion).toMatchObject({
+            datasetId: writeDataset.id,
             versionId: version.versionId,
             mode: "snapshot",
             rowCount: 2
@@ -8226,8 +8338,8 @@ function runLakeStorageContractSuite(label, options) {
     describe14("writes and reads", () => {
       test14("keeps immutable-version row order and offsets stable", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const write = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          await storage.createDataset(writeDataset);
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           const expected = [
             { orderId: "ord_3", customerName: "Katherine" },
             { orderId: "ord_1", customerName: "Ada" },
@@ -8237,7 +8349,7 @@ function runLakeStorageContractSuite(label, options) {
           ];
           await write.writeRows(expected);
           const version = await write.commit();
-          const pinned = { datasetId: writeDataset2.id, versionId: version.versionId };
+          const pinned = { datasetId: writeDataset.id, versionId: version.versionId };
           await expect14(collectRows2(storage.readRows(pinned))).resolves.toEqual(expected);
           await expect14(collectRows2(storage.readRows(pinned))).resolves.toEqual(expected);
           for (const offset of [0, 2, expected.length, expected.length + 3]) {
@@ -8248,14 +8360,14 @@ function runLakeStorageContractSuite(label, options) {
       });
       test14("rejects writes for unknown datasets", async () => {
         await withStorage(async (storage) => {
-          await expect14(storage.beginWrite({ dataset: writeDataset2 })).rejects.toThrow("Unknown dataset");
+          await expect14(storage.beginWrite({ dataset: writeDataset })).rejects.toThrow("Unknown dataset");
         });
       });
       test14("commits snapshot and append versions with versioned reads", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
+          await storage.createDataset(writeDataset);
           const snapshotWrite = await storage.beginWrite({
-            dataset: writeDataset2,
+            dataset: writeDataset,
             mode: "snapshot",
             producer: { kind: "sync", id: "contract-sync", runId: "run_1" }
           });
@@ -8267,27 +8379,27 @@ function runLakeStorageContractSuite(label, options) {
           expect14(snapshotCommit.outcome).toBe("created");
           const version1 = snapshotCommit;
           expect14(version1).toMatchObject({
-            datasetId: writeDataset2.id,
+            datasetId: writeDataset.id,
             mode: "snapshot",
-            schema: writeDataset2.schema,
+            schema: writeDataset.schema,
             producer: { kind: "sync", id: "contract-sync", runId: "run_1" },
             rowCount: 2
           });
           expect14(version1.parentVersionId).toBeUndefined();
-          expect14(await storage.getLatestVersion(writeDataset2.id)).toMatchObject({
+          expect14(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
             versionId: version1.versionId
           });
-          expect14(await storage.getVersion(writeDataset2.id, version1.versionId)).toMatchObject({
-            datasetId: writeDataset2.id,
+          expect14(await storage.getVersion(writeDataset.id, version1.versionId)).toMatchObject({
+            datasetId: writeDataset.id,
             versionId: version1.versionId,
             mode: "snapshot",
             rowCount: 2
           });
           await Bun.sleep(2);
           const appendWrite = await storage.beginWrite({
-            dataset: writeDataset2,
+            dataset: writeDataset,
             mode: "append",
-            inputs: [{ datasetId: writeDataset2.id, versionId: version1.versionId }]
+            inputs: [{ datasetId: writeDataset.id, versionId: version1.versionId }]
           });
           await appendWrite.writeRows([{ orderId: "ord_3", customerName: "Katherine" }]);
           const appendCommit = await appendWrite.commit({
@@ -8296,144 +8408,144 @@ function runLakeStorageContractSuite(label, options) {
           expect14(appendCommit.outcome).toBe("created");
           const version2 = appendCommit;
           expect14(version2).toMatchObject({
-            datasetId: writeDataset2.id,
+            datasetId: writeDataset.id,
             parentVersionId: version1.versionId,
             mode: "append",
-            schema: writeDataset2.schema,
-            inputs: [{ datasetId: writeDataset2.id, versionId: version1.versionId }],
+            schema: writeDataset.schema,
+            inputs: [{ datasetId: writeDataset.id, versionId: version1.versionId }],
             rowCount: 3
           });
-          expect14(await storage.getLatestVersion(writeDataset2.id)).toMatchObject({
+          expect14(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
             versionId: version2.versionId
           });
-          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset2.id }))).resolves.toEqual([
+          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([
             { orderId: "ord_1", customerName: "Ada" },
             { orderId: "ord_2", customerName: "Grace" },
             { orderId: "ord_3", customerName: "Katherine" }
           ]);
-          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset2.id, versionId: version1.versionId }))).resolves.toEqual([
+          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset.id, versionId: version1.versionId }))).resolves.toEqual([
             { orderId: "ord_1", customerName: "Ada" },
             { orderId: "ord_2", customerName: "Grace" }
           ]);
           await expect14(collectRows2(storage.readRows({
-            datasetId: writeDataset2.id,
+            datasetId: writeDataset.id,
             columns: ["orderId"],
             limit: 2
           }))).resolves.toEqual([{ orderId: "ord_1" }, { orderId: "ord_2" }]);
           await expect14(collectRows2(storage.readRows({
-            datasetId: writeDataset2.id,
+            datasetId: writeDataset.id,
             columns: ["orderId"],
             limit: 1,
             offset: 1
           }))).resolves.toEqual([{ orderId: "ord_2" }]);
           await expect14(collectRows2(storage.readRows({
-            datasetId: writeDataset2.id,
+            datasetId: writeDataset.id,
             columns: ["orderId"],
             offset: 1
           }))).resolves.toEqual([{ orderId: "ord_2" }, { orderId: "ord_3" }]);
-          expect14((await storage.listVersions(writeDataset2.id)).map((version) => version.versionId)).toEqual([version2.versionId, version1.versionId]);
-          expect14((await storage.listVersions(writeDataset2.id, 1)).map((version) => version.versionId)).toEqual([version2.versionId]);
+          expect14((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([version2.versionId, version1.versionId]);
+          expect14((await storage.listVersions(writeDataset.id, 1)).map((version) => version.versionId)).toEqual([version2.versionId]);
           expect14(await storage.listVersions("missing.dataset")).toEqual([]);
           expect14(await storage.getLatestVersion("missing.dataset")).toBeNull();
-          expect14(await storage.getVersion(writeDataset2.id, missingVersionId)).toBeNull();
+          expect14(await storage.getVersion(writeDataset.id, missingVersionId)).toBeNull();
         });
       });
       test14("creates an initial empty snapshot version", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const write = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          await storage.createDataset(writeDataset);
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           const version = await write.commit();
           expect14(version).toMatchObject({
-            datasetId: writeDataset2.id,
+            datasetId: writeDataset.id,
             mode: "snapshot",
             outcome: "created",
             rowCount: 0
           });
-          expect14(await storage.getLatestVersion(writeDataset2.id)).toMatchObject({
+          expect14(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
             versionId: version.versionId
           });
-          expect14(await storage.listVersions(writeDataset2.id)).toHaveLength(1);
+          expect14(await storage.listVersions(writeDataset.id)).toHaveLength(1);
           const repeatedWrite = await storage.beginWrite({
-            dataset: writeDataset2,
+            dataset: writeDataset,
             mode: "snapshot"
           });
           const repeatedVersion = await repeatedWrite.commit();
           expect14(repeatedVersion.outcome).toBe("unchanged");
           expect14(repeatedVersion.versionId).toBe(version.versionId);
-          expect14(await storage.listVersions(writeDataset2.id)).toHaveLength(1);
-          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset2.id }))).resolves.toEqual([]);
+          expect14(await storage.listVersions(writeDataset.id)).toHaveLength(1);
+          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([]);
         });
       });
       test14("guards initial and existing versions before accepting even an unchanged write", () => withStorage(async (storage) => {
-        await storage.createDataset(writeDataset2);
-        const first = await storage.beginWrite({ dataset: writeDataset2 });
-        const stale = await storage.beginWrite({ dataset: writeDataset2 });
+        await storage.createDataset(writeDataset);
+        const first = await storage.beginWrite({ dataset: writeDataset });
+        const stale = await storage.beginWrite({ dataset: writeDataset });
         const initial = await first.commit({ expectedLatestVersionId: null });
         await expect14(stale.commit({ expectedLatestVersionId: null })).rejects.toThrow("Optimistic");
         await stale.abort();
-        const replacement = await storage.beginWrite({ dataset: writeDataset2 });
+        const replacement = await storage.beginWrite({ dataset: writeDataset });
         await replacement.writeRows([{ orderId: "ord_1", customerName: "Ada" }]);
         const next = await replacement.commit({ expectedLatestVersionId: initial.versionId });
-        const identical = await storage.beginWrite({ dataset: writeDataset2 });
+        const identical = await storage.beginWrite({ dataset: writeDataset });
         await identical.writeRows([{ orderId: "ord_1", customerName: "Ada" }]);
         await expect14(identical.commit({ expectedLatestVersionId: initial.versionId })).rejects.toThrow("Optimistic");
         await identical.abort();
-        expect14((await storage.getLatestVersion(writeDataset2.id))?.versionId).toBe(next.versionId);
+        expect14((await storage.getLatestVersion(writeDataset.id))?.versionId).toBe(next.versionId);
       }));
       test14("versions changed input lineage even when output rows are identical", () => withStorage(async (storage) => {
-        await storage.createDataset(writeDataset2);
+        await storage.createDataset(writeDataset);
         await storage.createDataset(definitionDataset);
         const sourceWrite = await storage.beginWrite({ dataset: definitionDataset });
         const source1 = await sourceWrite.commit();
-        const rows2 = [{ orderId: "ord_1", customerName: "Ada" }];
+        const rows = [{ orderId: "ord_1", customerName: "Ada" }];
         const ref1 = { datasetId: definitionDataset.id, versionId: source1.versionId };
-        const first = await storage.beginWrite({ dataset: writeDataset2, inputs: [ref1] });
-        await first.writeRows(rows2);
+        const first = await storage.beginWrite({ dataset: writeDataset, inputs: [ref1] });
+        await first.writeRows(rows);
         const initial = await first.commit({ expectedLatestVersionId: null });
-        const stale = await storage.beginWrite({ dataset: writeDataset2, inputs: [ref1] });
+        const stale = await storage.beginWrite({ dataset: writeDataset, inputs: [ref1] });
         await stale.writeRows([{ orderId: "ord_1", customerName: "Stale" }]);
         const sourceUpdate = await storage.beginWrite({ dataset: definitionDataset });
         await sourceUpdate.writeRows([{ orderId: "source", customerName: "Changed" }]);
         const source2 = await sourceUpdate.commit();
         const ref2 = { datasetId: definitionDataset.id, versionId: source2.versionId };
-        const update = await storage.beginWrite({ dataset: writeDataset2, inputs: [ref2] });
-        await update.writeRows(rows2);
+        const update = await storage.beginWrite({ dataset: writeDataset, inputs: [ref2] });
+        await update.writeRows(rows);
         const newer = await update.commit({ expectedLatestVersionId: initial.versionId });
         expect14(newer).toMatchObject({ outcome: "created", inputs: [ref2] });
         await expect14(stale.commit({ expectedLatestVersionId: initial.versionId })).rejects.toThrow("Optimistic");
         await stale.abort();
-        const same = await storage.beginWrite({ dataset: writeDataset2, inputs: [ref2] });
-        await same.writeRows(rows2);
+        const same = await storage.beginWrite({ dataset: writeDataset, inputs: [ref2] });
+        await same.writeRows(rows);
         const unchanged = await same.commit({ expectedLatestVersionId: newer.versionId });
         expect14(unchanged).toMatchObject({ outcome: "unchanged", versionId: newer.versionId });
-        expect14(await collectRows2(storage.readRows({ datasetId: writeDataset2.id }))).toEqual(rows2);
+        expect14(await collectRows2(storage.readRows({ datasetId: writeDataset.id }))).toEqual(rows);
       }));
       test14("creates an initial empty append version", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const write = await storage.beginWrite({ dataset: writeDataset2, mode: "append" });
+          await storage.createDataset(writeDataset);
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "append" });
           const version = await write.commit();
           expect14(version).toMatchObject({
-            datasetId: writeDataset2.id,
+            datasetId: writeDataset.id,
             mode: "append",
             outcome: "created"
           });
           expect14(version.parentVersionId).toBeUndefined();
-          expect14(await storage.getLatestVersion(writeDataset2.id)).toMatchObject({
+          expect14(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
             versionId: version.versionId
           });
-          expect14(await storage.listVersions(writeDataset2.id)).toHaveLength(1);
-          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset2.id }))).resolves.toEqual([]);
+          expect14(await storage.listVersions(writeDataset.id)).toHaveLength(1);
+          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([]);
         });
       });
       test14("snapshot writes replace the visible latest rows", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const firstWrite = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          await storage.createDataset(writeDataset);
+          const firstWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await firstWrite.writeRows([{ orderId: "ord_1", customerName: "Ada" }]);
           const firstVersion = await firstWrite.commit();
           const replacementWrite = await storage.beginWrite({
-            dataset: writeDataset2,
+            dataset: writeDataset,
             mode: "snapshot"
           });
           await replacementWrite.writeRows([{ orderId: "ord_9", customerName: "Dorothy" }]);
@@ -8441,14 +8553,14 @@ function runLakeStorageContractSuite(label, options) {
           expect14(replacementVersion.versionId).not.toBe(firstVersion.versionId);
           expect14(replacementVersion.parentVersionId).toBeUndefined();
           expect14(replacementVersion.rowCount).toBe(1);
-          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset2.id }))).resolves.toEqual([{ orderId: "ord_9", customerName: "Dorothy" }]);
-          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset2.id, versionId: firstVersion.versionId }))).resolves.toEqual([{ orderId: "ord_1", customerName: "Ada" }]);
+          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([{ orderId: "ord_9", customerName: "Dorothy" }]);
+          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset.id, versionId: firstVersion.versionId }))).resolves.toEqual([{ orderId: "ord_1", customerName: "Ada" }]);
         });
       });
       test14("reuses the latest version when a snapshot commits identical content", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const seedWrite = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          await storage.createDataset(writeDataset);
+          const seedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await seedWrite.writeRows([
             { orderId: "ord_1", customerName: "Ada" },
             { orderId: "ord_2", customerName: "Grace" }
@@ -8456,7 +8568,7 @@ function runLakeStorageContractSuite(label, options) {
           const seedVersion = await seedWrite.commit();
           expect14(seedVersion.outcome).toBe("created");
           const identicalWrite = await storage.beginWrite({
-            dataset: writeDataset2,
+            dataset: writeDataset,
             mode: "snapshot"
           });
           await identicalWrite.writeRows([
@@ -8466,12 +8578,12 @@ function runLakeStorageContractSuite(label, options) {
           const identicalVersion = await identicalWrite.commit();
           expect14(identicalVersion.outcome).toBe("unchanged");
           expect14(identicalVersion.versionId).toBe(seedVersion.versionId);
-          expect14((await storage.listVersions(writeDataset2.id)).map((version) => version.versionId)).toEqual([seedVersion.versionId]);
-          expect14(await storage.getLatestVersion(writeDataset2.id)).toMatchObject({
+          expect14((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([seedVersion.versionId]);
+          expect14(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
             versionId: seedVersion.versionId
           });
           await Bun.sleep(2);
-          const changedWrite = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          const changedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await changedWrite.writeRows([
             { orderId: "ord_1", customerName: "Ada" },
             { orderId: "ord_2", customerName: "Hopper" }
@@ -8479,19 +8591,19 @@ function runLakeStorageContractSuite(label, options) {
           const changedVersion = await changedWrite.commit();
           expect14(changedVersion.outcome).toBe("created");
           expect14(changedVersion.versionId).not.toBe(seedVersion.versionId);
-          expect14((await storage.listVersions(writeDataset2.id)).map((version) => version.versionId)).toEqual([changedVersion.versionId, seedVersion.versionId]);
+          expect14((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([changedVersion.versionId, seedVersion.versionId]);
         });
       });
       test14("snapshot content comparison respects row multiplicities", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
+          await storage.createDataset(writeDataset);
           const rowA = { orderId: "ord_1", customerName: "Ada" };
           const rowB = { orderId: "ord_2", customerName: "Grace" };
-          const seedWrite = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          const seedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await seedWrite.writeRows([rowA, rowA, rowB]);
           const seedVersion = await seedWrite.commit();
           await Bun.sleep(2);
-          const shiftedWrite = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          const shiftedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await shiftedWrite.writeRows([rowA, rowB, rowB]);
           const shiftedVersion = await shiftedWrite.commit();
           expect14(shiftedVersion.outcome).toBe("created");
@@ -8519,35 +8631,35 @@ function runLakeStorageContractSuite(label, options) {
       });
       test14("reuses the latest version when an append commits zero rows", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const seedWrite = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          await storage.createDataset(writeDataset);
+          const seedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await seedWrite.writeRows([{ orderId: "ord_1", customerName: "Ada" }]);
           const seedVersion = await seedWrite.commit();
-          const emptyAppend = await storage.beginWrite({ dataset: writeDataset2, mode: "append" });
+          const emptyAppend = await storage.beginWrite({ dataset: writeDataset, mode: "append" });
           const appendVersion = await emptyAppend.commit();
           expect14(appendVersion.outcome).toBe("unchanged");
           expect14(appendVersion.versionId).toBe(seedVersion.versionId);
           expect14(appendVersion.rowCount).toBe(1);
-          expect14((await storage.listVersions(writeDataset2.id)).map((version) => version.versionId)).toEqual([seedVersion.versionId]);
-          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset2.id }))).resolves.toEqual([{ orderId: "ord_1", customerName: "Ada" }]);
+          expect14((await storage.listVersions(writeDataset.id)).map((version) => version.versionId)).toEqual([seedVersion.versionId]);
+          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([{ orderId: "ord_1", customerName: "Ada" }]);
         });
       });
       test14("fails stale optimistic commits", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const seedWrite = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          await storage.createDataset(writeDataset);
+          const seedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await seedWrite.writeRows([{ orderId: "ord_1", customerName: "Ada" }]);
           const initialVersion = await seedWrite.commit();
-          const delayedWrite = await storage.beginWrite({ dataset: writeDataset2, mode: "append" });
+          const delayedWrite = await storage.beginWrite({ dataset: writeDataset, mode: "append" });
           await delayedWrite.writeRows([{ orderId: "ord_2", customerName: "Grace" }]);
           const competingWrite = await storage.beginWrite({
-            dataset: writeDataset2,
+            dataset: writeDataset,
             mode: "append"
           });
           await competingWrite.writeRows([{ orderId: "ord_3", customerName: "Katherine" }]);
           await competingWrite.commit({ expectedLatestVersionId: initialVersion.versionId });
           await expect14(delayedWrite.commit({ expectedLatestVersionId: initialVersion.versionId })).rejects.toThrow("Optimistic commit failed");
-          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset2.id }))).resolves.toEqual([
+          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([
             { orderId: "ord_1", customerName: "Ada" },
             { orderId: "ord_3", customerName: "Katherine" }
           ]);
@@ -8555,20 +8667,20 @@ function runLakeStorageContractSuite(label, options) {
       });
       test14("abort closes a write session without committing rows", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const write = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          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();
-          expect14(await storage.getLatestVersion(writeDataset2.id)).toBeNull();
-          expect14(await storage.listVersions(writeDataset2.id)).toEqual([]);
-          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset2.id }))).rejects.toThrow("No committed version found");
+          expect14(await storage.getLatestVersion(writeDataset.id)).toBeNull();
+          expect14(await storage.listVersions(writeDataset.id)).toEqual([]);
+          await expect14(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).rejects.toThrow("No committed version found");
         });
       });
       test14("commit closes a write session and leaves abort idempotent", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const write = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          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();
@@ -8577,8 +8689,8 @@ function runLakeStorageContractSuite(label, options) {
       });
       test14("rejects rows that do not match the dataset schema", async () => {
         await withStorage(async (storage) => {
-          await storage.createDataset(writeDataset2);
-          const write = await storage.beginWrite({ dataset: writeDataset2, mode: "snapshot" });
+          await storage.createDataset(writeDataset);
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
           await expect14(write.writeRows([{ orderId: "ord_1" }])).rejects.toThrow("missing required column");
           await expect14(write.writeRows([{ orderId: "ord_1", customerName: "Ada", unexpected: true }])).rejects.toThrow("unknown column");
           await write.abort();
@@ -8623,9 +8735,9 @@ function runLakeStorageContractSuite(label, options) {
     });
   });
 }
-async function collectRows2(rows2) {
+async function collectRows2(rows) {
   const result = [];
-  for await (const row of rows2) {
+  for await (const row of rows) {
     result.push(row);
   }
   return result;
@@ -8725,7 +8837,7 @@ async function commitExactObject(storage, id, options = {}) {
       propertyChanges: {}
     }
   };
-  const eventId = createEventId(header.commit.projectId, id, 0);
+  const eventId = createEventId2(header.commit.projectId, id, 0);
   const envelope = {
     ...draft,
     id: eventId,
@@ -8829,9 +8941,9 @@ function runMaterializationFailureContractSuite(label, options) {
         try {
           await options.setup?.(storage);
           const before = await options.captureState(storage);
-          const failure2 = new Error(`contract injected ${boundary}`);
-          await options.injectFailure(storage, boundary, failure2);
-          await expect15(commitExactObject(storage, `failure-${boundary}`)).rejects.toThrow(failure2.message);
+          const failure = new Error(`contract injected ${boundary}`);
+          await options.injectFailure(storage, boundary, failure);
+          await expect15(commitExactObject(storage, `failure-${boundary}`)).rejects.toThrow(failure.message);
           await options.clearFailure?.(storage);
           expect15(await options.captureState(storage)).toEqual(before);
         } finally {
@@ -8847,17 +8959,17 @@ import { expect as expect16, test as test16 } from "bun:test";
 
 // src/testing/projection-execution.ts
 async function createTestProjectionExecution(executions, input) {
-  const executionId3 = input.executionId ?? `test_projection_execution:${input.runId}`;
-  const existing = await executions.getById({ projectId: input.projectId, id: executionId3 });
+  const executionId = input.executionId ?? `test_projection_execution:${input.runId}`;
+  const existing = await executions.getById({ projectId: input.projectId, id: executionId });
   if (existing)
-    return executionId3;
+    return executionId;
   const primitive = {
     kind: "projection",
     id: input.projectionId,
     runId: input.runId
   };
   await executions.create({
-    id: executionId3,
+    id: executionId,
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: {
@@ -8868,19 +8980,19 @@ async function createTestProjectionExecution(executions, input) {
     correlationId: `test_correlation:${input.runId}`,
     authorizationRef: { type: "trustedPrimitive", primitive }
   });
-  return executionId3;
+  return executionId;
 }
 async function queueTestProjectionRun(storage, input) {
   if (!storage.projectionRuns)
     throw new Error("Projection run storage is not configured for this test.");
-  const executionId3 = await createTestProjectionExecution(storage.executions, {
+  const executionId = await createTestProjectionExecution(storage.executions, {
     projectId: input.projectId,
     projectionId: input.identity.projectionId,
     runId: input.id,
     datasetId: input.identity.datasetVersion.datasetId,
     datasetVersionId: input.identity.datasetVersion.versionId
   });
-  return storage.projectionRuns.queue({ ...input, executionId: executionId3 });
+  return storage.projectionRuns.queue({ ...input, executionId });
 }
 async function startTestProjectionRun(storage, input) {
   const projectionRuns = storage.projectionRuns;
@@ -8905,58 +9017,58 @@ async function claimTestProjectionRun(storage, input) {
 }
 
 // src/testing/materializer-storage-contract.ts
-var Device2 = defineObjectType({
+var Device2 = defineObjectType2({
   id: "StorageContractDevice",
   name: "Device",
   properties: [
-    prop("id", "string", { primary: true, required: true }),
-    prop("name", "string", { required: true }),
-    prop("temperature", "double", { mode: "telemetry" })
+    prop2("id", "string", { primary: true, required: true }),
+    prop2("name", "string", { required: true }),
+    prop2("temperature", "double", { mode: "telemetry" })
   ],
-  links: [link.self("parent", { cardinality: "one" }), link.self("peers", { cardinality: "many" })]
+  links: [link2.self("parent", { cardinality: "one" }), link2.self("peers", { cardinality: "many" })]
 });
-var devices = defineDataset("storage_contract_devices", {
+var devices = defineDataset2("storage_contract_devices", {
   schema: [
-    col("id", "string"),
-    col("name", "string"),
-    col("parent_id", "string", { nullable: true })
+    col2("id", "string"),
+    col2("name", "string"),
+    col2("parent_id", "string", { nullable: true })
   ]
 });
-var readings = defineDataset("storage_contract_readings", {
-  schema: [col("device_id", "string"), col("at", "timestamp"), col("value", "float64")]
+var readings = defineDataset2("storage_contract_readings", {
+  schema: [col2("device_id", "string"), col2("at", "timestamp"), col2("value", "float64")]
 });
-var devicePeers = defineDataset("storage_contract_device_peers", {
-  schema: [col("source_id", "string"), col("target_id", "string")]
+var devicePeers = defineDataset2("storage_contract_device_peers", {
+  schema: [col2("source_id", "string"), col2("target_id", "string")]
 });
-var ConflictDevice = defineObjectType({
+var ConflictDevice = defineObjectType2({
   id: "StorageContractConflictDevice",
   name: "Conflict device",
   properties: [
-    prop("id", "string", { primary: true, required: true }),
-    prop("name", "string", { required: true }),
-    prop("state", "string", { required: true })
+    prop2("id", "string", { primary: true, required: true }),
+    prop2("name", "string", { required: true }),
+    prop2("state", "string", { required: true })
   ]
 });
-var conflictDevices = defineDataset("storage_contract_conflict_devices", {
+var conflictDevices = defineDataset2("storage_contract_conflict_devices", {
   schema: [
-    col("id", "string"),
-    col("name", "string"),
-    col("state", "string"),
-    col("updated_at", "timestamp")
+    col2("id", "string"),
+    col2("name", "string"),
+    col2("state", "string"),
+    col2("updated_at", "timestamp")
   ]
 });
-var deviceProjection = defineProjection("storage_contract_devices", Device2).fromDataset(devices).properties({ id: "id", name: "name" }).withLinks({
+var deviceProjection = defineProjection2("storage_contract_devices", Device2).fromDataset(devices).properties({ id: "id", name: "name" }).withLinks({
   parent: {
     link: Device2.l.parent,
     sourceField: "parent_id",
     target: Device2
   }
 });
-var temperatureProjection = defineProjection("storage_contract_temperatures", Device2.p.temperature).fromDataset(readings).points({ objectId: "device_id", at: "at", value: "value" });
-var devicePeersProjection = defineProjection("storage_contract_device_peers", Device2.l.peers).fromDataset(devicePeers).sourceField("source_id").targetField("target_id");
-var conflictDeviceProjection = defineProjection("storage_contract_conflict_devices", ConflictDevice).fromDataset(conflictDevices).properties({ id: "id", name: "name", state: "state" }).resolveConflicts({ strategy: "mostRecent", sourceTimestamp: "updated_at" });
-var ontology2 = new OntologyRegistry({ sources: [Device2, ConflictDevice] });
-var projections = new ProjectionRegistry({
+var temperatureProjection = defineProjection2("storage_contract_temperatures", Device2.p.temperature).fromDataset(readings).points({ objectId: "device_id", at: "at", value: "value" });
+var devicePeersProjection = defineProjection2("storage_contract_device_peers", Device2.l.peers).fromDataset(devicePeers).sourceField("source_id").targetField("target_id");
+var conflictDeviceProjection = defineProjection2("storage_contract_conflict_devices", ConflictDevice).fromDataset(conflictDevices).properties({ id: "id", name: "name", state: "state" }).resolveConflicts({ strategy: "mostRecent", sourceTimestamp: "updated_at" });
+var ontology2 = new OntologyRegistry2({ sources: [Device2, ConflictDevice] });
+var projections = new ProjectionRegistry2({
   projections: [
     deviceProjection,
     temperatureProjection,
@@ -8976,7 +9088,7 @@ function runMaterializerStorageContractSuite(name, provider) {
     const createdStorage = await provider.createStorage();
     const storage = requireContractStorage(createdStorage);
     let materializationOrdinal = 0;
-    const materializer = createOntologyMaterializer({
+    const materializer = createOntologyMaterializer2({
       projectId: "materializer-storage-contract",
       ontology: ontology2,
       projections,
@@ -9197,7 +9309,7 @@ function runMaterializerStorageContractSuite(name, provider) {
     const storage = requireContractStorage(createdStorage);
     let materializationOrdinal = 0;
     let now = new Date("2026-02-01T00:00:10.000Z");
-    const materializer = createOntologyMaterializer({
+    const materializer = createOntologyMaterializer2({
       projectId: "materializer-storage-contract",
       ontology: ontology2,
       projections,
@@ -9210,13 +9322,13 @@ function runMaterializerStorageContractSuite(name, provider) {
     });
     const runtimeMaterializer = materializer.withScope(runtimeScope());
     const ref = { objectTypeId: ConflictDevice.id, primaryId: "one" };
-    const replace = async (versionId, sourceUpdatedAt, name2, state) => {
+    const replace = async (versionId, sourceUpdatedAt, name, state) => {
       const datasetVersion = {
         datasetId: conflictDevices.id,
         versionId,
         createdAt: sourceUpdatedAt
       };
-      const execution2 = await claim(storage, {
+      const execution = await claim(storage, {
         runId: `conflict-${versionId}`,
         projectionId: conflictDeviceProjection.id,
         protocol: "replacement",
@@ -9226,11 +9338,11 @@ function runMaterializerStorageContractSuite(name, provider) {
       await projectionMaterializerForRun.projections.replace({
         source: { projectionId: conflictDeviceProjection.id },
         datasetVersion,
-        execution: execution2,
+        execution,
         entries: entries([
           {
             root: { kind: "object", ref },
-            assertions: [{ kind: "object", ref, properties: { name: name2, state }, sourceUpdatedAt }]
+            assertions: [{ kind: "object", ref, properties: { name, state }, sourceUpdatedAt }]
           }
         ])
       });
@@ -9272,7 +9384,7 @@ function runMaterializerStorageContractSuite(name, provider) {
     const createdStorage = await provider.createStorage();
     const storage = requireContractStorage(createdStorage);
     let materializationOrdinal = 0;
-    const materializer = createOntologyMaterializer({
+    const materializer = createOntologyMaterializer2({
       projectId: "materializer-storage-contract",
       ontology: ontology2,
       projections,
@@ -9295,7 +9407,7 @@ function runMaterializerStorageContractSuite(name, provider) {
         versionId,
         createdAt: `2026-01-0${versionId.slice(1)}T00:00:00.000Z`
       };
-      const execution2 = await claim(storage, {
+      const execution = await claim(storage, {
         runId: `scope-${versionId}`,
         projectionId: deviceProjection.id,
         protocol: "replacement",
@@ -9305,7 +9417,7 @@ function runMaterializerStorageContractSuite(name, provider) {
       await projectionMaterializerForRun.projections.replace({
         source: { projectionId: deviceProjection.id },
         datasetVersion,
-        execution: execution2,
+        execution,
         entries: entries([
           sourceEntry("document", "Document", parentId),
           sourceEntry("rockland", "Rockland"),
@@ -9362,7 +9474,7 @@ function runMaterializerStorageContractSuite(name, provider) {
     const createdStorage = await provider.createStorage();
     const storage = requireContractStorage(createdStorage);
     let materializationOrdinal = 0;
-    const materializer = createOntologyMaterializer({
+    const materializer = createOntologyMaterializer2({
       projectId: "materializer-storage-contract",
       ontology: ontology2,
       projections,
@@ -9375,11 +9487,11 @@ function runMaterializerStorageContractSuite(name, provider) {
     });
     const runtimeMaterializer = materializer.withScope(runtimeScope());
     const source = { objectTypeId: Device2.id, primaryId: "source" };
-    const peer2 = (primaryId) => ({ objectTypeId: Device2.id, primaryId });
+    const peer = (primaryId) => ({ objectTypeId: Device2.id, primaryId });
     const linkRef = (targetId) => ({
       source,
       linkId: "peers",
-      target: peer2(targetId)
+      target: peer(targetId)
     });
     try {
       await runtimeMaterializer.edits.commit({
@@ -9388,7 +9500,7 @@ function runMaterializerStorageContractSuite(name, provider) {
         operations: ["source", "peer-a", "peer-b", "peer-c"].map((primaryId) => ({
           id: `create-${primaryId}`,
           kind: "object.create",
-          ref: peer2(primaryId),
+          ref: peer(primaryId),
           properties: { name: primaryId }
         })),
         expectedObjects: [],
@@ -9400,7 +9512,7 @@ function runMaterializerStorageContractSuite(name, provider) {
         versionId: "many-links-v1",
         createdAt: "2026-02-01T00:00:00.000Z"
       };
-      const execution2 = await claim(storage, {
+      const execution = await claim(storage, {
         runId: "many-links-v1",
         projectionId: devicePeersProjection.id,
         protocol: "replacement",
@@ -9410,7 +9522,7 @@ function runMaterializerStorageContractSuite(name, provider) {
       await (await projectionMaterializer(materializer, storage, devicePeersProjection.id, "many-links-v1")).projections.replace({
         source: { projectionId: devicePeersProjection.id },
         datasetVersion,
-        execution: execution2,
+        execution,
         entries: entries(projectedLinks.map((ref) => ({
           root: { kind: "link", ref },
           assertions: [{ kind: "link", ref }]
@@ -9422,7 +9534,7 @@ function runMaterializerStorageContractSuite(name, provider) {
         objectId: source.primaryId,
         linkId: "peers"
       });
-      const fingerprint = createLinkScopeFingerprint(observedLinks.map((row) => {
+      const fingerprint = createLinkScopeFingerprint2(observedLinks.map((row) => {
         if (row.lastCommitId === undefined) {
           throw new Error("Projected contract link is missing materializer provenance.");
         }
@@ -9433,7 +9545,7 @@ function runMaterializerStorageContractSuite(name, provider) {
           lastCommitId: row.lastCommitId
         };
       }));
-      const commitObservation = async (runId, name2) => {
+      const commitObservation = async (runId, name) => {
         await queueTestActionRun(storage, {
           id: runId,
           projectId: "materializer-storage-contract",
@@ -9456,7 +9568,7 @@ function runMaterializerStorageContractSuite(name, provider) {
               id: `record-${runId}`,
               kind: "object.patch",
               ref: source,
-              set: { name: name2 },
+              set: { name },
               unset: [],
               reset: []
             }
@@ -9509,14 +9621,14 @@ async function primitiveMaterializer(materializer, storage, primitive) {
     projectId: "materializer-storage-contract",
     id: primitive.runId
   });
-  const executionId3 = run?.executionId ?? `test_${primitive.kind}_execution:${primitive.runId}`;
-  const execution2 = await storage.executions.getById({
+  const executionId = run?.executionId ?? `test_${primitive.kind}_execution:${primitive.runId}`;
+  const execution = await storage.executions.getById({
     projectId: "materializer-storage-contract",
-    id: executionId3
+    id: executionId
   });
-  if (!execution2)
-    throw new Error(`Test execution '${executionId3}' is missing.`);
-  return materializer.withScope(restoreTrustedPrimitiveExecutionScope({ execution: execution2, primitive }));
+  if (!execution)
+    throw new Error(`Test execution '${executionId}' is missing.`);
+  return materializer.withScope(restoreTrustedPrimitiveExecutionScope({ execution, primitive }));
 }
 function requireContractStorage(storage) {
   if (!storage.actionRuns) {
@@ -9565,16 +9677,16 @@ async function claim(storage, input) {
     projectId: "materializer-storage-contract"
   };
   if (definition._tag === "TelemetryProjectionDefinition") {
-    const claim3 = await startTestProjectionRun(storage, {
+    const claim = await startTestProjectionRun(storage, {
       ...common,
       identity: { ...identityBase, projectionKind: "telemetry", protocol: "telemetry" },
       target: { objectTypeId: definition.objectTypeId },
       fixedBatchSize: input.fixedBatchSize ?? 1
     });
-    return claim3.execution;
+    return claim.execution;
   }
   if (definition._tag === "LinkProjectionDefinition") {
-    const claim3 = await startTestProjectionRun(storage, {
+    const claim = await startTestProjectionRun(storage, {
       ...common,
       identity: { ...identityBase, projectionKind: "link", protocol: "replacement" },
       target: {
@@ -9582,106 +9694,106 @@ async function claim(storage, input) {
         targetObjectTypeId: definition.targetObjectTypeId
       }
     });
-    return claim3.execution;
+    return claim.execution;
   }
-  const claim2 = await startTestProjectionRun(storage, {
+  const claim = await startTestProjectionRun(storage, {
     ...common,
     identity: { ...identityBase, projectionKind: "object", protocol: "replacement" },
     target: { objectTypeId: definition.objectTypeId }
   });
-  return claim2.execution;
+  return claim.execution;
 }
 // src/testing/object-query-contract.ts
 import { describe as describe16, expect as expect17, test as test17 } from "bun:test";
 var projectId10 = "object-query-contract";
-var Device3 = defineObjectType({
+var Device3 = defineObjectType2({
   id: "ContractDevice",
   name: "Contract Device",
   properties: [
-    prop("id", "string", {
+    prop2("id", "string", {
       required: true,
       primary: true,
       query: { searchable: true, filterable: true, exact: true, sortable: true }
     }),
-    prop("name", "string", {
+    prop2("name", "string", {
       query: { searchable: true, text: true, filterable: true, exact: true, sortable: true }
     })
   ],
   search: { defaultText: ["name"] }
 });
-var Room = defineObjectType({
+var Room = defineObjectType2({
   id: "ContractRoom",
   name: "Contract Room",
   properties: [
-    prop("id", "string", {
+    prop2("id", "string", {
       required: true,
       primary: true,
       query: { searchable: true, filterable: true, exact: true, sortable: true }
     }),
-    prop("name", "string", {
+    prop2("name", "string", {
       query: { searchable: true, text: true, filterable: true, exact: true, sortable: true }
     }),
-    prop("description", "string", {
+    prop2("description", "string", {
       query: { searchable: true, text: true }
     }),
-    prop("floor", "string", {
+    prop2("floor", "string", {
       nullable: true,
       query: { searchable: true, filterable: true, exact: true, sortable: true }
     }),
-    prop("capacity", "double", {
+    prop2("capacity", "double", {
       query: { searchable: true, filterable: true, sortable: true }
     }),
-    prop("occupied", "boolean", {
+    prop2("occupied", "boolean", {
       query: { searchable: true, filterable: true, exact: true, facet: true }
     }),
-    prop("status", stringEnum(["active", "paused"]), {
+    prop2("status", stringEnum2(["active", "paused"]), {
       query: { searchable: true, filterable: true, exact: true, facet: true }
     }),
-    prop("tags", { type: "array", items: "string" }, { query: { searchable: true, filterable: true } }),
-    prop("metadata", { type: "map", keySchema: "string", valueSchema: "string" }, { query: { searchable: true, filterable: true } }),
-    prop("embedding", { type: "array", items: "double" }, { query: { searchable: true, vector: true } })
+    prop2("tags", { type: "array", items: "string" }, { query: { searchable: true, filterable: true } }),
+    prop2("metadata", { type: "map", keySchema: "string", valueSchema: "string" }, { query: { searchable: true, filterable: true } }),
+    prop2("embedding", { type: "array", items: "double" }, { query: { searchable: true, vector: true } })
   ],
-  links: [link("hasDevice", Device3)],
+  links: [link2("hasDevice", Device3)],
   search: {
     defaultText: ["name", "description"],
     vector: { property: "embedding", source: ["name", "description"] }
   }
 });
-var Zone = defineObjectType({
+var Zone = defineObjectType2({
   id: "ContractZone",
   name: "Contract Zone",
-  properties: [prop("id", "string", { required: true, primary: true })],
-  links: [link("hasDevice", Device3)]
+  properties: [prop2("id", "string", { required: true, primary: true })],
+  links: [link2("hasDevice", Device3)]
 });
-var Asset = defineObjectType({
+var Asset = defineObjectType2({
   id: "ContractAsset",
   name: "Contract Asset",
-  properties: [prop("id", "string", { required: true, primary: true })]
+  properties: [prop2("id", "string", { required: true, primary: true })]
 });
-var LaptopAsset = defineObjectType({
+var LaptopAsset = defineObjectType2({
   id: "ContractLaptopAsset",
   name: "Contract Laptop Asset",
   extends: Asset,
   properties: []
 });
-var DefaultTextBase = defineObjectType({
+var DefaultTextBase = defineObjectType2({
   id: "ContractDefaultTextBase",
   name: "Contract Default Text Base",
   properties: [
-    prop("id", "string", { required: true, primary: true }),
-    prop("name", "string", { query: { searchable: true, text: true } }),
-    prop("alias", "string")
+    prop2("id", "string", { required: true, primary: true }),
+    prop2("name", "string", { query: { searchable: true, text: true } }),
+    prop2("alias", "string")
   ],
   search: { defaultText: ["name"] }
 });
-var DefaultTextChild = defineObjectType({
+var DefaultTextChild = defineObjectType2({
   id: "ContractDefaultTextChild",
   name: "Contract Default Text Child",
   extends: DefaultTextBase,
-  properties: [prop("alias", "string", { query: { searchable: true, text: true } })],
+  properties: [prop2("alias", "string", { query: { searchable: true, text: true } })],
   search: { defaultText: ["alias"] }
 });
-var objectQueryContractOntology = new OntologyRegistry({
+var objectQueryContractOntology = new OntologyRegistry2({
   sources: [Room, Device3, Zone, Asset, LaptopAsset, DefaultTextBase, DefaultTextChild]
 });
 function runObjectQueryProviderContractSuite(label, options) {
@@ -9702,7 +9814,7 @@ function runObjectQueryProviderContractSuite(label, options) {
   };
   describe16(label, () => {
     test17("normalizes query shape and resolves search profile defaults", () => {
-      const normalized = normalizeObjectQuery({
+      const normalized = normalizeObjectQuery2({
         kind: "limit",
         limit: 10,
         input: {
@@ -9732,7 +9844,7 @@ function runObjectQueryProviderContractSuite(label, options) {
       if (normalized.input.input.kind !== "text")
         return;
       expect17(normalized.input.input.fields).toEqual(["name", "description"]);
-      const validated = validateObjectQuery({ kind: "text", query: "alpha", input: { kind: "start", objectTypeId: Room.id } }, { ontology: objectQueryContractOntology });
+      const validated = validateObjectQuery2({ kind: "text", query: "alpha", input: { kind: "start", objectTypeId: Room.id } }, { ontology: objectQueryContractOntology });
       expect17(validated.query.kind).toBe("text");
       if (validated.query.kind === "text") {
         expect17(validated.query.fields).toBeUndefined();
@@ -9742,7 +9854,7 @@ function runObjectQueryProviderContractSuite(label, options) {
       }
     });
     test17("collects validation failures before provider planning", () => {
-      const issues = collectObjectQueryValidationIssues({
+      const issues = collectObjectQueryValidationIssues2({
         kind: "filter",
         predicate: { op: "eq", propertyId: "missing", value: "x" },
         input: {
@@ -9805,7 +9917,7 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("pushes down scalar predicates, boolean groups, sorting, limits, and projections", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
-        const result = await executeObjectQuery({
+        const result = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "project",
@@ -9864,7 +9976,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             objectSeed(Asset.id, issue298, { id: issue298 })
           ]
         });
-        const refs = await executeObjectQuery({
+        const refs = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "refs",
@@ -9887,7 +9999,7 @@ function runObjectQueryProviderContractSuite(label, options) {
           { objectTypeId: Room.id, primaryId: "missing" },
           { objectTypeId: Room.id, primaryId: "room-alpha" }
         ];
-        const first = await executeObjectQuery({
+        const first = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "project",
@@ -9895,7 +10007,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "page", pageSize: 2, input: { kind: "refs", refs } }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const second = await executeObjectQuery({
+        const second = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "project",
@@ -9908,7 +10020,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const count = await countObjects({ projectId: projectId10, query: { kind: "refs", refs } }, { ontology: objectQueryContractOntology, storage });
+        const count = await countObjects2({ projectId: projectId10, query: { kind: "refs", refs } }, { ontology: objectQueryContractOntology, storage });
         const expectedMode = storage.queryCapabilities().nodes?.refs === true ? "pushdown" : "fallback";
         expect17(first.plan.mode).toBe(expectedMode);
         expect17(ids(first)).toEqual(["device-sensor", "room-alpha"]);
@@ -9931,7 +10043,7 @@ function runObjectQueryProviderContractSuite(label, options) {
         if (storage.queryCapabilities().nodes?.refs !== true)
           return;
         await seedObjectQueryContractData(fixture);
-        const result = await executeObjectQuery({
+        const result = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "traverse",
@@ -9954,14 +10066,14 @@ function runObjectQueryProviderContractSuite(label, options) {
           kind: "refs",
           refs: [{ objectTypeId: Device3.id, primaryId: "device-projector" }]
         };
-        const first = await executeObjectQueryLinks({
+        const first = await executeObjectQueryLinks2({
           projectId: projectId10,
           query,
           direction: "incoming",
           includeObjects: true,
           pageSize: 1
         }, { ontology: objectQueryContractOntology, storage });
-        const second = await executeObjectQueryLinks({
+        const second = await executeObjectQueryLinks2({
           projectId: projectId10,
           query,
           direction: "incoming",
@@ -10000,7 +10112,7 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("does not admit a provider page probe into the link selector", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
-        const result = await executeObjectQueryLinks({
+        const result = await executeObjectQueryLinks2({
           projectId: projectId10,
           query: {
             kind: "page",
@@ -10021,7 +10133,7 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("matches null, missing, neq, in, and not predicate semantics", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
-        const nullable = await executeObjectQuery({
+        const nullable = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "sort",
@@ -10039,7 +10151,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const notTwoOrNull = await executeObjectQuery({
+        const notTwoOrNull = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "sort",
@@ -10057,7 +10169,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const notNullFloor = await executeObjectQuery({
+        const notNullFloor = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "sort",
@@ -10069,7 +10181,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const notFloorTwo = await executeObjectQuery({
+        const notFloorTwo = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "sort",
@@ -10104,7 +10216,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "start", objectTypeId: Room.id }
           }
         };
-        const page1 = await executeObjectQuery({
+        const page1 = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "project",
@@ -10112,7 +10224,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "page", pageSize: 2, input }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const page2 = await executeObjectQuery({
+        const page2 = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "project",
@@ -10134,17 +10246,17 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("omits totals when requested without losing hasMore", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
-        const limited = await executeObjectQuery({
+        const limited = await executeObjectQuery2({
           projectId: projectId10,
           includeTotal: false,
           query: { kind: "limit", limit: 2, input: { kind: "start", objectTypeId: Room.id } }
         }, { ontology: objectQueryContractOntology, storage });
-        const page = await executeObjectQuery({
+        const page = await executeObjectQuery2({
           projectId: projectId10,
           includeTotal: false,
           query: { kind: "page", pageSize: 2, input: { kind: "start", objectTypeId: Room.id } }
         }, { ontology: objectQueryContractOntology, storage });
-        const sortedLimited = await executeObjectQuery({
+        const sortedLimited = await executeObjectQuery2({
           projectId: projectId10,
           includeTotal: false,
           query: {
@@ -10169,7 +10281,7 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("counts matching objects without returning rows", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
-        const active = await countObjects({
+        const active = await countObjects2({
           projectId: projectId10,
           query: {
             kind: "filter",
@@ -10177,7 +10289,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "start", objectTypeId: Room.id }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const limited = await countObjects({
+        const limited = await countObjects2({
           projectId: projectId10,
           query: { kind: "limit", limit: 2, input: { kind: "start", objectTypeId: Room.id } }
         }, { ontology: objectQueryContractOntology, storage });
@@ -10189,7 +10301,7 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("checks existence without returning rows", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
-        const active = await existsObjects({
+        const active = await existsObjects2({
           projectId: projectId10,
           query: {
             kind: "filter",
@@ -10197,7 +10309,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "start", objectTypeId: Room.id }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const missing = await existsObjects({
+        const missing = await existsObjects2({
           projectId: projectId10,
           query: {
             kind: "filter",
@@ -10205,7 +10317,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "start", objectTypeId: Room.id }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const limited = await existsObjects({
+        const limited = await existsObjects2({
           projectId: projectId10,
           query: { kind: "limit", limit: 0, input: { kind: "start", objectTypeId: Room.id } }
         }, { ontology: objectQueryContractOntology, storage });
@@ -10227,8 +10339,8 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "start", objectTypeId: Room.id }
           }
         };
-        const count = await countObjects({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage });
-        const exists = await existsObjects({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage });
+        const count = await countObjects2({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage });
+        const exists = await existsObjects2({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage });
         expect17(count.plan.mode).toBe("pushdown");
         if (count.plan.mode !== "pushdown")
           return;
@@ -10244,7 +10356,7 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("counts matching objects by facetable properties without returning rows", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
-        const status = await facetObjects({
+        const status = await facetObjects2({
           projectId: projectId10,
           query: { kind: "start", objectTypeId: Room.id },
           facets: [
@@ -10252,7 +10364,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             { propertyId: "occupied", limit: 10 }
           ]
         }, { ontology: objectQueryContractOntology, storage });
-        const limited = await facetObjects({
+        const limited = await facetObjects2({
           projectId: projectId10,
           query: { kind: "limit", limit: 0, input: { kind: "start", objectTypeId: Room.id } },
           facets: [
@@ -10283,7 +10395,7 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("pushes down traversal and set operations", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
-        const outgoing = await executeObjectQuery({
+        const outgoing = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "traverse",
@@ -10296,7 +10408,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const incoming = await executeObjectQuery({
+        const incoming = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "traverse",
@@ -10305,7 +10417,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "start", objectTypeId: Device3.id }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const incomingRooms = await executeObjectQuery({
+        const incomingRooms = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "traverse",
@@ -10315,7 +10427,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "start", objectTypeId: Device3.id }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const incomingZones = await executeObjectQuery({
+        const incomingZones = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "traverse",
@@ -10325,7 +10437,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             input: { kind: "start", objectTypeId: Device3.id }
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const intersect = await executeObjectQuery({
+        const intersect = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "set",
@@ -10344,7 +10456,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             ]
           }
         }, { ontology: objectQueryContractOntology, storage });
-        const subtract = await executeObjectQuery({
+        const subtract = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "set",
@@ -10377,7 +10489,7 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("hydrates expand links identically via pushdown or bounded fallback", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
-        const outgoing = await executeObjectQuery({
+        const outgoing = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "expand",
@@ -10397,7 +10509,7 @@ function runObjectQueryProviderContractSuite(label, options) {
         expect17(outgoing.plan.mode).toBe(expandMode);
         expect17(expandedIds(outgoing, "room-alpha", "hasDevice")).toEqual(["device-projector"]);
         expect17(expandedIds(outgoing, "room-beta", "hasDevice")).toEqual(["device-sensor"]);
-        const incoming = await executeObjectQuery({
+        const incoming = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "expand",
@@ -10420,7 +10532,7 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("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({
+        const result = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "limit",
@@ -10435,7 +10547,7 @@ function runObjectQueryProviderContractSuite(label, options) {
     test17("pushes down basic text search using search profile defaults", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
-        const result = await executeObjectQuery({
+        const result = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "sort",
@@ -10465,7 +10577,7 @@ function runObjectQueryProviderContractSuite(label, options) {
             }
           ]
         });
-        const result = await executeObjectQuery({
+        const result = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "text",
@@ -10493,12 +10605,12 @@ function runObjectQueryProviderContractSuite(label, options) {
           }
         };
         if (storage.queryCapabilities().sortKinds?.relevance === true) {
-          const result = await executeObjectQuery({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage });
+          const result = await executeObjectQuery2({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage });
           expect17(result.plan.mode).toBe("pushdown");
           expect17(ids(result)).toEqual(["room-alpha"]);
           return;
         }
-        await expectPlanningIssue(executeObjectQuery({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage }), "sort_kind_not_supported");
+        await expectPlanningIssue(executeObjectQuery2({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage }), "sort_kind_not_supported");
       });
     });
     test17("executes or rejects vector search according to provider capabilities", async () => {
@@ -10512,19 +10624,19 @@ function runObjectQueryProviderContractSuite(label, options) {
           input: { kind: "start", objectTypeId: Room.id }
         };
         if (storage.queryCapabilities().nodes?.vector === true) {
-          const result = await executeObjectQuery({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage });
+          const result = await executeObjectQuery2({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage });
           expect17(result.plan.mode).toBe("pushdown");
           expect17(ids(result)).toEqual(["room-alpha", "room-beta"]);
           return;
         }
-        await expectPlanningIssue(executeObjectQuery({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage }), "query_node_not_supported");
+        await expectPlanningIssue(executeObjectQuery2({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage }), "query_node_not_supported");
       });
     });
     test17("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);
-        const result = await executeObjectQuery({
+        const result = await executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "limit",
@@ -10548,7 +10660,7 @@ function runObjectQueryProviderContractSuite(label, options) {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
         const fallbackStorage = withoutQueryPushdown(storage);
-        await expectPlanningIssue(executeObjectQuery({
+        await expectPlanningIssue(executeObjectQuery2({
           projectId: projectId10,
           query: {
             kind: "limit",
@@ -10687,8 +10799,8 @@ async function expectPlanningIssue(promise, code) {
   try {
     await promise;
   } catch (error) {
-    expect17(error).toBeInstanceOf(ObjectQueryPlanningError);
-    if (error instanceof ObjectQueryPlanningError) {
+    expect17(error).toBeInstanceOf(ObjectQueryPlanningError2);
+    if (error instanceof ObjectQueryPlanningError2) {
       expect17(error.issues.map((issue) => issue.code)).toContain(code);
     }
     return;
@@ -10699,54 +10811,54 @@ async function expectPlanningIssue(promise, code) {
 import { describe as describe17, expect as expect18, test as test18 } from "bun:test";
 var projectId11 = "object-read-scope-contract";
 var otherProjectId3 = "object-read-scope-contract-other";
-var Product = defineObjectType({
+var Product = defineObjectType2({
   id: "ScopeProduct",
   name: "Scope Product",
   properties: [
-    prop("id", "string", { required: true, primary: true }),
-    prop("name", "string", { query: { searchable: true, text: true } }),
-    prop("internal", "string")
+    prop2("id", "string", { required: true, primary: true }),
+    prop2("name", "string", { query: { searchable: true, text: true } }),
+    prop2("internal", "string")
   ],
   search: { defaultText: ["name"] }
 });
-var LineItem = defineObjectType({
+var LineItem = defineObjectType2({
   id: "ScopeLineItem",
   name: "Scope Line Item",
   properties: [
-    prop("id", "string", { required: true, primary: true }),
-    prop("name", "string", { query: { searchable: true, text: true, sortable: true } }),
-    prop("price", "double", { query: { searchable: true, filterable: true, sortable: true } }),
-    prop("reviewNote", "string"),
-    prop("internal", "string")
+    prop2("id", "string", { required: true, primary: true }),
+    prop2("name", "string", { query: { searchable: true, text: true, sortable: true } }),
+    prop2("price", "double", { query: { searchable: true, filterable: true, sortable: true } }),
+    prop2("reviewNote", "string"),
+    prop2("internal", "string")
   ],
-  links: [link("product", Product, { cardinality: "one" })],
+  links: [link2("product", Product, { cardinality: "one" })],
   search: { defaultText: ["name"] }
 });
-var Proposal = defineObjectType({
+var Proposal = defineObjectType2({
   id: "ScopeProposal",
   name: "Scope Proposal",
   properties: [
-    prop("id", "string", { required: true, primary: true }),
-    prop("title", "string", {
+    prop2("id", "string", { required: true, primary: true }),
+    prop2("title", "string", {
       query: { searchable: true, text: true, filterable: true, sortable: true }
     }),
-    prop("rank", "double", { query: { searchable: true, filterable: true, sortable: true } }),
-    prop("category", "string", { query: { searchable: true, filterable: true, facet: true } }),
-    prop("embedding", { type: "array", items: "double" }, { query: { searchable: true, vector: true } }),
-    prop("secret", "string", { query: { searchable: true, filterable: true, facet: true } })
+    prop2("rank", "double", { query: { searchable: true, filterable: true, sortable: true } }),
+    prop2("category", "string", { query: { searchable: true, filterable: true, facet: true } }),
+    prop2("embedding", { type: "array", items: "double" }, { query: { searchable: true, vector: true } }),
+    prop2("secret", "string", { query: { searchable: true, filterable: true, facet: true } })
   ],
   links: [
-    link("items", LineItem, {
-      properties: [prop("position", "double"), prop("label", "string"), prop("internal", "string")]
+    link2("items", LineItem, {
+      properties: [prop2("position", "double"), prop2("label", "string"), prop2("internal", "string")]
     }),
-    link("reviewers", LineItem),
-    link.self("related"),
-    link("aPrivate", Product),
-    link("zVisible", Product)
+    link2("reviewers", LineItem),
+    link2.self("related"),
+    link2("aPrivate", Product),
+    link2("zVisible", Product)
   ],
   search: { defaultText: ["title"] }
 });
-var objectReadScopeContractOntology = new OntologyRegistry({
+var objectReadScopeContractOntology = new OntologyRegistry2({
   sources: [Proposal, LineItem, Product]
 });
 var limits = {
@@ -10870,10 +10982,10 @@ function runObjectReadScopeContractSuite(label, options) {
         })).toMatchObject({ objects: [], total: 0 });
         const reader = createReader(harness.objectReadScopeFactory);
         const queryObjects = reader.queryObjects?.bind(reader);
-        const countObjects2 = reader.countObjects?.bind(reader);
-        const existsObjects2 = reader.existsObjects?.bind(reader);
-        const facetObjects2 = reader.facetObjects?.bind(reader);
-        if (!queryObjects || !countObjects2 || !existsObjects2 || !facetObjects2) {
+        const countObjects = reader.countObjects?.bind(reader);
+        const existsObjects = reader.existsObjects?.bind(reader);
+        const facetObjects = reader.facetObjects?.bind(reader);
+        if (!queryObjects || !countObjects || !existsObjects || !facetObjects) {
           throw new Error("Selected object-read scope contract requires every query terminal.");
         }
         const crossProjectCalls = [
@@ -10881,15 +10993,15 @@ function runObjectReadScopeContractSuite(label, options) {
             projectId: otherProjectId3,
             query: { kind: "start", objectTypeId: Proposal.id }
           }),
-          () => countObjects2({
+          () => countObjects({
             projectId: otherProjectId3,
             query: { kind: "start", objectTypeId: Proposal.id }
           }),
-          () => existsObjects2({
+          () => existsObjects({
             projectId: otherProjectId3,
             query: { kind: "start", objectTypeId: Proposal.id }
           }),
-          () => facetObjects2({
+          () => facetObjects({
             projectId: otherProjectId3,
             query: { kind: "start", objectTypeId: Proposal.id },
             facets: [{ propertyId: "category", limit: 1 }]
@@ -10977,29 +11089,29 @@ function runObjectReadScopeContractSuite(label, options) {
           ]
         });
         expect18([...objects.keys()]).toEqual([
-          objectBatchKey(Proposal.id, "proposal-1"),
-          objectBatchKey(LineItem.id, "item:opaque|1")
+          objectBatchKey2(Proposal.id, "proposal-1"),
+          objectBatchKey2(LineItem.id, "item:opaque|1")
         ]);
-        expect18(objects.get(objectBatchKey(Proposal.id, "proposal-1"))?.properties).toEqual({
+        expect18(objects.get(objectBatchKey2(Proposal.id, "proposal-1"))?.properties).toEqual({
           id: "proposal-1",
           title: "Visible proposal",
           rank: 50,
           category: "visible",
           embedding: [0, 1]
         });
-        expect18(objects.get(objectBatchKey(Proposal.id, "proposal-1"))?.links).toBeUndefined();
-        expect18(objects.get(objectBatchKey(LineItem.id, "item:opaque|1"))?.properties).toEqual({
+        expect18(objects.get(objectBatchKey2(Proposal.id, "proposal-1"))?.links).toBeUndefined();
+        expect18(objects.get(objectBatchKey2(LineItem.id, "item:opaque|1"))?.properties).toEqual({
           id: "item:opaque|1",
           name: "Visible item",
           reviewNote: "Property union"
         });
-        expect18(objects.get(objectBatchKey(LineItem.id, "item:opaque|1"))?.links).toBeUndefined();
+        expect18(objects.get(objectBatchKey2(LineItem.id, "item:opaque|1"))?.links).toBeUndefined();
         const outgoing = await reader.listLinksBatch({
           projectId: projectId11,
           direction: "outgoing",
           items: [{ objectTypeId: Proposal.id, objectId: "proposal-1", linkId: "items" }]
         });
-        const outgoingRows = outgoing.get(linkBatchKey(Proposal.id, "proposal-1", "items"));
+        const outgoingRows = outgoing.get(linkBatchKey2(Proposal.id, "proposal-1", "items"));
         expect18(outgoingRows).toHaveLength(1);
         expect18(outgoingRows?.[0]?.targetId).toBe("item:opaque|1");
         expect18(outgoingRows?.[0]?.properties).toEqual({ position: 1, label: "primary" });
@@ -11027,16 +11139,16 @@ function runObjectReadScopeContractSuite(label, options) {
           direction: "incoming",
           items: [{ objectTypeId: LineItem.id, objectId: "item:opaque|1", linkId: "items" }]
         });
-        const incomingRows = incoming.get(linkBatchKey(LineItem.id, "item:opaque|1", "items"));
+        const incomingRows = incoming.get(linkBatchKey2(LineItem.id, "item:opaque|1", "items"));
         expect18(incomingRows).toHaveLength(1);
         expect18(incomingRows?.[0]?.properties).toEqual({ position: 1, label: "primary" });
-        expect18(incoming.has(linkBatchKey(Proposal.id, "proposal-1", "items"))).toBe(false);
+        expect18(incoming.has(linkBatchKey2(Proposal.id, "proposal-1", "items"))).toBe(false);
         const selfLoop = await reader.listLinksBatch({
           projectId: projectId11,
           direction: "both",
           items: [{ objectTypeId: Proposal.id, objectId: "proposal-1", linkId: "related" }]
         });
-        expect18(selfLoop.get(linkBatchKey(Proposal.id, "proposal-1", "related"))).toHaveLength(1);
+        expect18(selfLoop.get(linkBatchKey2(Proposal.id, "proposal-1", "related"))).toHaveLength(1);
       });
     });
     test18("applies scope before query ordering, pagination, predicates, and aggregate terminals", async () => {
@@ -11172,7 +11284,7 @@ function runObjectReadScopeContractSuite(label, options) {
           objectTypeId: Product.id,
           primaryId: "product-review"
         })).toBeNull();
-        const expanded = await executeObjectQuery({
+        const expanded = await executeObjectQuery2({
           projectId: projectId11,
           query: {
             kind: "expand",
@@ -11255,11 +11367,11 @@ function runObjectReadScopeContractSuite(label, options) {
         await expect18(facetBound.facetObjects?.({
           projectId: projectId11,
           query: { kind: "start", objectTypeId: Proposal.id },
-          facets: Array.from({ length: MAX_OBJECT_READ_FACETS + 1 }, (_, index) => ({
+          facets: Array.from({ length: MAX_OBJECT_READ_FACETS2 + 1 }, (_, index) => ({
             propertyId: `facet-${index}`,
             limit: 1
           }))
-        })).rejects.toThrow(`between 0 and ${MAX_OBJECT_READ_FACETS} facets`);
+        })).rejects.toThrow(`between 0 and ${MAX_OBJECT_READ_FACETS2} facets`);
       });
     });
   });
@@ -11267,7 +11379,7 @@ function runObjectReadScopeContractSuite(label, options) {
 function createReader(factory, scope = proposalScope(), executionLimits = limits) {
   return factory.createSelectedReadScope({
     projectId: projectId11,
-    scope: compileSelectedObjectReadScope(scope),
+    scope: compileSelectedObjectReadScope2(scope),
     limits: executionLimits
   });
 }
@@ -11606,13 +11718,13 @@ function runOntologyStorageContractSuite(label, options) {
           identity,
           target: { objectTypeId: "ContractDevice" }
         });
-        const execution2 = claimed.execution;
+        const execution = claimed.execution;
         const source = { projectionId: identity.projectionId };
         await expect19(storage.ontology.sources.beginMaterialization({
           projectId: "contract-project",
           source,
           materializationId: "mismatched-candidate",
-          execution: execution2,
+          execution,
           projectionKind: "link",
           protocol: "replacement",
           datasetVersion: identity.datasetVersion,
@@ -11625,7 +11737,7 @@ function runOntologyStorageContractSuite(label, options) {
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
-          execution: execution2,
+          execution,
           projectionKind: "object",
           protocol: "replacement",
           datasetVersion: identity.datasetVersion,
@@ -11651,21 +11763,21 @@ function runOntologyStorageContractSuite(label, options) {
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
-          execution: execution2,
+          execution,
           rows: [row]
         })).toEqual({ inserted: 1, unchanged: 0 });
         expect19(await storage.ontology.sources.stageRows({
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
-          execution: execution2,
+          execution,
           rows: [row]
         })).toEqual({ inserted: 0, unchanged: 1 });
         await expect19(storage.ontology.sources.stageRows({
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
-          execution: execution2,
+          execution,
           rows: [
             {
               ...row,
@@ -11677,7 +11789,7 @@ function runOntologyStorageContractSuite(label, options) {
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
-          execution: execution2,
+          execution,
           rootCount: 1,
           assertionCount: 1,
           readyAt: "2026-01-01T00:01:00.000Z"
@@ -11693,14 +11805,14 @@ function runOntologyStorageContractSuite(label, options) {
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
-          execution: execution2,
+          execution,
           rows: []
         })).rejects.toMatchObject({ kind: "execution-lost" });
         await expect19(storage.ontology.sources.markReady({
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
-          execution: execution2,
+          execution,
           rootCount: 1,
           assertionCount: 1,
           readyAt: "2026-01-01T00:03:00.000Z"
@@ -11710,7 +11822,7 @@ function runOntologyStorageContractSuite(label, options) {
           projectId: "contract-project",
           source,
           materializationId: "staging-candidate",
-          execution: execution2,
+          execution,
           abandonedAt: "2026-01-01T00:03:00.000Z"
         })).rejects.toMatchObject({ kind: "execution-lost" });
         const abandoned = await storage.ontology.sources.abandon({
@@ -12059,13 +12171,13 @@ async function createReadyEmptyCandidate(storage, runId, materializationId, vers
     identity,
     target: { objectTypeId: "ContractDevice" }
   });
-  const execution2 = run.execution;
+  const execution = run.execution;
   const source = { projectionId: identity.projectionId };
   await storage.ontology.sources.beginMaterialization({
     projectId: run.run.projectId,
     source,
     materializationId,
-    execution: execution2,
+    execution,
     projectionKind: "object",
     protocol: "replacement",
     datasetVersion: identity.datasetVersion,
@@ -12078,12 +12190,12 @@ async function createReadyEmptyCandidate(storage, runId, materializationId, vers
     projectId: run.run.projectId,
     source,
     materializationId,
-    execution: execution2,
+    execution,
     rootCount: 0,
     assertionCount: 0,
     readyAt: new Date(Date.parse(identity.datasetVersion.createdAt) + 1000).toISOString()
   });
-  return { identity, execution: execution2, materializationId, source, executionId: run.run.executionId };
+  return { identity, execution, materializationId, source, executionId: run.run.executionId };
 }
 async function activateEmptyCandidate(storage, candidate, expectedActive, commitId, committedAt) {
   const expected = {
@@ -12166,7 +12278,7 @@ async function activateEmptyCandidate(storage, candidate, expectedActive, commit
     await tx.ontology.materializations.finalize({ session, finalization });
   });
 }
-function telemetryHeader(identity, projectionRunId, executionId3) {
+function telemetryHeader(identity, projectionRunId, executionId) {
   if (identity.protocol !== "telemetry")
     throw new Error("Expected telemetry identity");
   return {
@@ -12175,7 +12287,7 @@ function telemetryHeader(identity, projectionRunId, executionId3) {
       id: "telemetry-commit",
       idempotencyKey: "telemetry:telemetry-run:0",
       requestHash: "hash:telemetry-run:0",
-      executionId: executionId3,
+      executionId,
       origin: {
         kind: "telemetry",
         source: {
@@ -12211,34 +12323,34 @@ function telemetryHeader(identity, projectionRunId, executionId3) {
 }
 // src/testing/pipeline-execution.ts
 async function createTestPipelineExecution(executions, input) {
-  const executionId3 = input.executionId ?? `test_pipeline_execution:${input.runId}`;
-  const existing = await executions.getById({ projectId: input.projectId, id: executionId3 });
+  const executionId = input.executionId ?? `test_pipeline_execution:${input.runId}`;
+  const existing = await executions.getById({ projectId: input.projectId, id: executionId });
   if (existing)
-    return executionId3;
+    return executionId;
   const primitive = {
     kind: "pipeline",
     id: input.pipelineId,
     runId: input.runId
   };
   await executions.create({
-    id: executionId3,
+    id: executionId,
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: { type: "event", eventId: `test_event:${input.runId}` },
     correlationId: `test_correlation:${input.runId}`,
     authorizationRef: { type: "trustedPrimitive", primitive }
   });
-  return executionId3;
+  return executionId;
 }
 async function queueTestPipelineRun(storage, input) {
   if (!storage.pipelineRuns)
     throw new Error("Pipeline run storage is not configured for this test.");
-  const executionId3 = await createTestPipelineExecution(storage.executions, {
+  const executionId = await createTestPipelineExecution(storage.executions, {
     projectId: input.projectId,
     pipelineId: input.pipelineId,
     runId: input.id
   });
-  return storage.pipelineRuns.queue({ ...input, executionId: executionId3 });
+  return storage.pipelineRuns.queue({ ...input, executionId });
 }
 async function startTestPipelineRun(storage, input) {
   const { startedAt, ...queuedRun } = input;
@@ -12400,12 +12512,12 @@ function runProjectionRunStorageContractSuite(label, options) {
         const storage = context.projectionRuns;
         const input = replacementInput("identity-run");
         await admitProjectionRun(context, input);
-        const claim2 = await storage.startOrReclaim(input);
+        const claim = await storage.startOrReclaim(input);
         const changedIdentity = { ...replacementIdentity2, ownershipHash: "different-ownership" };
         await expect20(storage.startOrReclaim({ ...input, identity: changedIdentity })).rejects.toThrow("identity does not match");
         await expect20(storage.startOrReclaim({ ...input, target: { objectTypeId: "OtherDevice" } })).rejects.toThrow("target object types do not match");
         await expect20(storage.lockForMaterialization({
-          ...executionInput(claim2),
+          ...executionInput(claim),
           identity: changedIdentity
         })).rejects.toThrow("identity does not match");
       });
@@ -12414,17 +12526,17 @@ function runProjectionRunStorageContractSuite(label, options) {
       await withStorage(async (context) => {
         const storage = context.projectionRuns;
         await admitProjectionRun(context, replacementInput("progress-run"));
-        const claim2 = await storage.startOrReclaim(replacementInput("progress-run"));
-        const execution2 = executionInput(claim2);
+        const claim = await storage.startOrReclaim(replacementInput("progress-run"));
+        const execution = executionInput(claim);
         await expect20(storage.update({
-          ...execution2,
+          ...execution,
           progress: { sourceRowsRead: 1, sourceRowsSkipped: 2 }
         })).rejects.toThrow("sourceRowsSkipped must not exceed sourceRowsRead");
         await storage.update({
-          ...execution2,
+          ...execution,
           progress: { sourceRowsRead: 5, sourceRowsSkipped: 1 }
         });
-        await expect20(storage.update({ ...execution2, progress: { sourceRowsRead: 4 } })).rejects.toThrow("must not decrease");
+        await expect20(storage.update({ ...execution, progress: { sourceRowsRead: 4 } })).rejects.toThrow("must not decrease");
       });
     });
     test20("rejects immutable dataset-version metadata reuse", async () => {
@@ -12453,9 +12565,9 @@ function runProjectionRunStorageContractSuite(label, options) {
           fixedBatchSize: 3
         };
         await admitProjectionRun(context, input);
-        const claim2 = await storage.startOrReclaim(input);
-        const execution2 = executionInput(claim2);
-        expect20(claim2.run).toMatchObject({
+        const claim = await storage.startOrReclaim(input);
+        const execution = executionInput(claim);
+        expect20(claim.run).toMatchObject({
           telemetryCheckpoint: {
             fixedBatchSize: 3,
             nextBatchOrdinal: 0,
@@ -12463,30 +12575,30 @@ function runProjectionRunStorageContractSuite(label, options) {
             inputExhausted: false
           }
         });
-        await expect20(storage.update({ ...execution2, progress: { sourceRowsRead: 1 } })).rejects.toThrow("can only advance with its checkpoint");
+        await expect20(storage.update({ ...execution, progress: { sourceRowsRead: 1 } })).rejects.toThrow("can only advance with its checkpoint");
         await storage.advanceTelemetryCheckpoint({
-          ...execution2,
+          ...execution,
           batchOrdinal: 0,
           batchRowCount: 3,
           batchRowsSkipped: 1,
           inputExhausted: false
         });
         await expect20(storage.advanceTelemetryCheckpoint({
-          ...execution2,
+          ...execution,
           batchOrdinal: 2,
           batchRowCount: 1,
           batchRowsSkipped: 0,
           inputExhausted: true
         })).rejects.toThrow("expected batch ordinal 1");
         await expect20(storage.advanceTelemetryCheckpoint({
-          ...execution2,
+          ...execution,
           batchOrdinal: 1,
           batchRowCount: 1,
           batchRowsSkipped: 0,
           inputExhausted: false
         })).rejects.toThrow("partial non-final batch");
         const exhausted = await storage.advanceTelemetryCheckpoint({
-          ...execution2,
+          ...execution,
           batchOrdinal: 1,
           batchRowCount: 2,
           batchRowsSkipped: 1,
@@ -12509,8 +12621,8 @@ function runProjectionRunStorageContractSuite(label, options) {
           fixedBatchSize: 2
         };
         await admitProjectionRun(context, input);
-        const claim2 = await storage.startOrReclaim(input);
-        const execution2 = executionInput(claim2);
+        const claim = await storage.startOrReclaim(input);
+        const execution = executionInput(claim);
         const firstSeenAt = new Date("2026-06-01T12:00:00.000Z");
         const missingTarget = {
           objectTypeId: "Device",
@@ -12518,15 +12630,15 @@ function runProjectionRunStorageContractSuite(label, options) {
           batchOrdinal: 0,
           firstSeenAt
         };
-        const waiting = await storage.recordMissingTarget({ ...execution2, missingTarget });
+        const waiting = await storage.recordMissingTarget({ ...execution, missingTarget });
         expect20(waiting.missingTarget).toEqual(missingTarget);
         expect20((await storage.getById({ projectId: projectId12, id: "telemetry-missing-target-run" }))?.missingTarget).toEqual(missingTarget);
         await expect20(storage.recordMissingTarget({
-          ...execution2,
+          ...execution,
           missingTarget: { ...missingTarget, batchOrdinal: 1 }
         })).rejects.toThrow("cannot wait on batch 1");
         await expect20(storage.recordMissingTarget({
-          ...execution2,
+          ...execution,
           missingTarget: { ...missingTarget, objectTypeId: "Building" }
         })).rejects.toThrow("cannot wait on 'Building'");
         for (const partial of [
@@ -12535,17 +12647,17 @@ function runProjectionRunStorageContractSuite(label, options) {
           { firstSeenAt: new Date(Number.NaN) }
         ]) {
           await expect20(storage.recordMissingTarget({
-            ...execution2,
+            ...execution,
             missingTarget: { ...missingTarget, ...partial }
           })).rejects.toThrow();
         }
         const rerecorded = await storage.recordMissingTarget({
-          ...execution2,
+          ...execution,
           missingTarget: { ...missingTarget, firstSeenAt: new Date("2026-06-01T12:01:00.000Z") }
         });
         expect20(rerecorded.missingTarget?.firstSeenAt).toEqual(new Date("2026-06-01T12:01:00.000Z"));
         const advanced = await storage.advanceTelemetryCheckpoint({
-          ...execution2,
+          ...execution,
           batchOrdinal: 0,
           batchRowCount: 2,
           batchRowsSkipped: 0,
@@ -12565,18 +12677,18 @@ function runProjectionRunStorageContractSuite(label, options) {
           fixedBatchSize: 10
         };
         await admitProjectionRun(context, input);
-        const claim2 = await storage.startOrReclaim(input);
+        const claim = await storage.startOrReclaim(input);
         await expect20(storage.finish({
-          ...executionInput(claim2),
+          ...executionInput(claim),
           protocol: "telemetry",
           status: "succeeded"
         })).rejects.toThrow("cannot succeed before input exhaustion");
-        await expect20(storage.getById({ projectId: projectId12, id: claim2.run.id })).resolves.toMatchObject({
+        await expect20(storage.getById({ projectId: projectId12, id: claim.run.id })).resolves.toMatchObject({
           status: "running",
           telemetryCheckpoint: { inputExhausted: false }
         });
         const finished = await storage.finish({
-          ...executionInput(claim2),
+          ...executionInput(claim),
           protocol: "telemetry",
           status: "succeeded",
           inputExhausted: true
@@ -12586,16 +12698,16 @@ function runProjectionRunStorageContractSuite(label, options) {
           progress: { sourceRowsRead: 0 },
           telemetryCheckpoint: { inputExhausted: true }
         });
-        await expect20(storage.lockForMaterialization(executionInput(claim2))).rejects.toThrow("already terminal");
+        await expect20(storage.lockForMaterialization(executionInput(claim))).rejects.toThrow("already terminal");
       });
     });
     test20("validates, detaches, and persists scoped failures", async () => {
       await withStorage(async (context) => {
         const storage = context.projectionRuns;
         await admitProjectionRun(context, replacementInput("failed-run"));
-        const claim2 = await storage.startOrReclaim(replacementInput("failed-run"));
+        const claim = await storage.startOrReclaim(replacementInput("failed-run"));
         const finished = await storage.finish({
-          ...executionInput(claim2),
+          ...executionInput(claim),
           protocol: "replacement",
           status: "failed",
           finishedAt: new Date(failure2.at),
@@ -12637,9 +12749,9 @@ function runProjectionRunStorageContractSuite(label, options) {
   });
 }
 async function admitProjectionRun(context, input) {
-  const executionId3 = `execution:${input.projectId}:${input.id}`;
+  const executionId = `execution:${input.projectId}:${input.id}`;
   await context.executions.create({
-    id: executionId3,
+    id: executionId,
     projectId: input.projectId,
     executor: { type: "primitive", kind: "projection", runId: input.id },
     source: {
@@ -12655,7 +12767,7 @@ async function admitProjectionRun(context, input) {
   });
   const admission = {
     ...input,
-    executionId: executionId3,
+    executionId,
     queuedAt: new Date("2026-01-01T00:00:01.000Z")
   };
   await context.projectionRuns.queue(admission);
@@ -12664,12 +12776,12 @@ async function admitProjectionRun(context, input) {
 function replacementInput(id) {
   return { id, projectId: projectId12, identity: replacementIdentity2, target: objectTarget };
 }
-function executionInput(claim2) {
+function executionInput(claim) {
   return {
-    id: claim2.run.id,
-    projectId: claim2.run.projectId,
-    identity: claim2.run.identity,
-    executionToken: claim2.execution.executionToken
+    id: claim.run.id,
+    projectId: claim.run.projectId,
+    identity: claim.run.identity,
+    executionToken: claim.execution.executionToken
   };
 }
 // src/testing/queues-contract.ts
@@ -12779,7 +12891,7 @@ function runQueueContractSuite(label, options) {
           await expect21(queues.syncRuns.enqueue({
             projectId: "   ",
             jobs: [{ type: "sync.run.requested", payload: { runId: "sync-1" } }]
-          })).rejects.toBeInstanceOf(QueueError);
+          })).rejects.toBeInstanceOf(QueueError2);
         });
       });
     });
@@ -12826,8 +12938,8 @@ function runQueueContractSuite(label, options) {
             projectId: "project-a",
             jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }]
           });
-          await expect21(queues.syncRuns.claim({ projectId: "project-a", workerId: "w-1", leaseMs: 0 })).rejects.toBeInstanceOf(QueueError);
-          await expect21(queues.syncRuns.claim({ projectId: "project-a", workerId: "w-1", leaseMs: -1 })).rejects.toBeInstanceOf(QueueError);
+          await expect21(queues.syncRuns.claim({ projectId: "project-a", workerId: "w-1", leaseMs: 0 })).rejects.toBeInstanceOf(QueueError2);
+          await expect21(queues.syncRuns.claim({ projectId: "project-a", workerId: "w-1", leaseMs: -1 })).rejects.toBeInstanceOf(QueueError2);
         });
       });
       test21("respects delayed visibility via availableAt", async () => {
@@ -12989,14 +13101,14 @@ function runQueueContractSuite(label, options) {
             projectId: "project-a",
             jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }]
           });
-          const [claim2] = await queues.syncRuns.claim({
+          const [claim] = await queues.syncRuns.claim({
             projectId: "project-a",
             workerId: "worker-1"
           });
           await queues.syncRuns.complete({
             projectId: "project-a",
             jobId: job.id,
-            leaseId: claim2.leaseId
+            leaseId: claim.leaseId
           });
           const later = await queues.syncRuns.claim({
             projectId: "project-a",
@@ -13021,7 +13133,7 @@ function runQueueContractSuite(label, options) {
             projectId: "project-a",
             jobId: job.id,
             leaseId: "not-the-right-lease"
-          })).rejects.toBeInstanceOf(QueueError);
+          })).rejects.toBeInstanceOf(QueueError2);
         });
       });
     });
@@ -13060,7 +13172,7 @@ function runQueueContractSuite(label, options) {
             projectId: "project-a",
             jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }]
           });
-          const [claim2] = await queues.syncRuns.claim({
+          const [claim] = await queues.syncRuns.claim({
             projectId: "project-a",
             workerId: "worker-1",
             leaseMs: shortLeaseMs * 10
@@ -13068,9 +13180,9 @@ function runQueueContractSuite(label, options) {
           await expect21(queues.syncRuns.retry({
             projectId: "project-a",
             jobId: job.id,
-            leaseId: claim2.leaseId,
+            leaseId: claim.leaseId,
             availableAt: "not-a-timestamp"
-          })).rejects.toBeInstanceOf(QueueError);
+          })).rejects.toBeInstanceOf(QueueError2);
         });
       });
     });
@@ -13081,14 +13193,14 @@ function runQueueContractSuite(label, options) {
             projectId: "project-a",
             jobs: [{ type: "pipeline.run.requested", payload: { runId: "p-1" } }]
           });
-          const [claim2] = await queues.pipelines.claim({
+          const [claim] = await queues.pipelines.claim({
             projectId: "project-a",
             workerId: "pipeline-worker-1"
           });
           await queues.pipelines.fail({
             projectId: "project-a",
             jobId: job.id,
-            leaseId: claim2.leaseId,
+            leaseId: claim.leaseId,
             failure: TERMINAL_FAILURE
           });
           const later = await queues.pipelines.claim({
@@ -13107,7 +13219,7 @@ function runQueueContractSuite(label, options) {
             projectId: "project-a",
             jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }]
           });
-          const [claim2] = await queues.syncRuns.claim({
+          const [claim] = await queues.syncRuns.claim({
             projectId: "project-a",
             workerId: "worker-1",
             leaseMs: shortLeaseMs + 20
@@ -13115,12 +13227,12 @@ function runQueueContractSuite(label, options) {
           const renewed = await queues.syncRuns.renewLease?.({
             projectId: "project-a",
             jobId: job.id,
-            leaseId: claim2.leaseId,
+            leaseId: claim.leaseId,
             leaseMs: shortLeaseMs * 5
           });
           expect21(renewed?.job.id).toBe(job?.id);
-          expect21(renewed?.leaseId).toBe(claim2?.leaseId);
-          expect21(Date.parse(renewed.leaseExpiresAt)).toBeGreaterThan(Date.parse(claim2.leaseExpiresAt));
+          expect21(renewed?.leaseId).toBe(claim?.leaseId);
+          expect21(Date.parse(renewed.leaseExpiresAt)).toBeGreaterThan(Date.parse(claim.leaseExpiresAt));
         });
       });
       test21("returns null for unknown jobId", async () => {
@@ -13184,7 +13296,7 @@ function runQueueContractSuite(label, options) {
             projectId: "project-a",
             jobs: [{ type: "sync.run.requested", payload: { runId: "s-1" } }]
           });
-          const [claim2] = await queues.syncRuns.claim({
+          const [claim] = await queues.syncRuns.claim({
             projectId: "project-a",
             workerId: "worker-1",
             leaseMs: shortLeaseMs
@@ -13193,8 +13305,8 @@ function runQueueContractSuite(label, options) {
           await expect21(queues.syncRuns.complete({
             projectId: "project-a",
             jobId: job.id,
-            leaseId: claim2.leaseId
-          })).rejects.toBeInstanceOf(QueueError);
+            leaseId: claim.leaseId
+          })).rejects.toBeInstanceOf(QueueError2);
         });
       });
     });
@@ -13283,7 +13395,7 @@ function runSandboxesContractSuite(label, options) {
         try {
           await sandbox.stop();
           expect22(sandbox.status).toBe("stopped");
-          await expect22(sandbox.runCommand("echo", ["nope"])).rejects.toBeInstanceOf(SandboxNotRunningError);
+          await expect22(sandbox.runCommand("echo", ["nope"])).rejects.toBeInstanceOf(SandboxNotRunningError2);
         } finally {
           await sandbox.destroy();
         }
@@ -13292,7 +13404,7 @@ function runSandboxesContractSuite(label, options) {
         const sandbox = await factory.create();
         await sandbox.destroy();
         await sandbox.destroy();
-        await expect22(sandbox.runCommand("echo", ["x"])).rejects.toBeInstanceOf(SandboxNotRunningError);
+        await expect22(sandbox.runCommand("echo", ["x"])).rejects.toBeInstanceOf(SandboxNotRunningError2);
       });
     });
     describe21("working directory", () => {
@@ -13471,7 +13583,7 @@ echo ran
         const sandbox = await factory.create();
         await sandbox.stop();
         try {
-          await expect22(sandbox.writeFiles([{ path: `${sandbox.workingDirectory}/x.txt`, contents: "x" }])).rejects.toThrow(SandboxNotRunningError);
+          await expect22(sandbox.writeFiles([{ path: `${sandbox.workingDirectory}/x.txt`, contents: "x" }])).rejects.toThrow(SandboxNotRunningError2);
         } finally {
           await sandbox.destroy();
         }
@@ -13975,34 +14087,34 @@ function renewalInput(overrides = {}) {
 }
 // src/testing/sync-execution.ts
 async function createTestSyncExecution(executions, input) {
-  const executionId3 = input.executionId ?? `test_sync_execution:${input.runId}`;
-  const existing = await executions.getById({ projectId: input.projectId, id: executionId3 });
+  const executionId = input.executionId ?? `test_sync_execution:${input.runId}`;
+  const existing = await executions.getById({ projectId: input.projectId, id: executionId });
   if (existing)
-    return executionId3;
+    return executionId;
   const primitive = {
     kind: "sync",
     id: input.syncId,
     runId: input.runId
   };
   await executions.create({
-    id: executionId3,
+    id: executionId,
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: { type: "event", eventId: `test_event:${input.runId}` },
     correlationId: `test_correlation:${input.runId}`,
     authorizationRef: { type: "trustedPrimitive", primitive }
   });
-  return executionId3;
+  return executionId;
 }
 async function queueTestSyncRun(storage, input) {
   if (!storage.syncRuns)
     throw new Error("Sync run storage is not configured for this test.");
-  const executionId3 = await createTestSyncExecution(storage.executions, {
+  const executionId = await createTestSyncExecution(storage.executions, {
     projectId: input.projectId,
     syncId: input.syncId,
     runId: input.id
   });
-  return storage.syncRuns.queue({ ...input, executionId: executionId3 });
+  return storage.syncRuns.queue({ ...input, executionId });
 }
 async function startTestSyncRun(storage, input) {
   const { startedAt, ...queuedRun } = input;
@@ -14015,34 +14127,34 @@ async function startTestSyncRun(storage, input) {
 }
 // src/testing/webhook-execution.ts
 async function createTestWebhookExecution(executions, input) {
-  const executionId3 = input.executionId ?? `test_webhook_execution:${input.runId}`;
-  const existing = await executions.getById({ projectId: input.projectId, id: executionId3 });
+  const executionId = input.executionId ?? `test_webhook_execution:${input.runId}`;
+  const existing = await executions.getById({ projectId: input.projectId, id: executionId });
   if (existing)
-    return executionId3;
+    return executionId;
   const primitive = {
     kind: "webhook",
     id: input.route,
     runId: input.runId
   };
   await executions.create({
-    id: executionId3,
+    id: executionId,
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: { type: "webhook", deliveryId: input.runId },
     correlationId: `test_correlation:${input.runId}`,
     authorizationRef: { type: "trustedPrimitive", primitive }
   });
-  return executionId3;
+  return executionId;
 }
 async function startTestWebhookRun(storage, input) {
   if (!storage.webhookRuns)
     throw new Error("Webhook run storage is not configured for this test.");
-  const executionId3 = await createTestWebhookExecution(storage.executions, {
+  const executionId = await createTestWebhookExecution(storage.executions, {
     projectId: input.projectId,
     route: input.route,
     runId: input.id
   });
-  return storage.webhookRuns.start({ ...input, executionId: executionId3 });
+  return storage.webhookRuns.start({ ...input, executionId });
 }
 // src/testing/webhook-run-storage-contract.ts
 import { describe as describe24, expect as expect25, test as test25 } from "bun:test";
@@ -14235,57 +14347,57 @@ function disabledRequestExecution(id) {
   };
 }
 export {
-  startTestWebhookRun,
-  startTestSyncRun,
-  startTestProjectionRun,
-  startTestPipelineRun,
-  seedObjectQueryContractData,
-  seedAiUsageStorageContractExecutions,
-  seedAiLimitStorageContractExecution,
-  seedAiCostStorageContractUsage,
-  runWebhookRunStorageContractSuite,
-  runShareSessionStorageContractSuite,
-  runShareGrantStorageContractSuite,
-  runSandboxesContractSuite,
-  runQueueContractSuite,
-  runProjectionRunStorageContractSuite,
-  runOntologyStorageContractSuite,
-  runObjectReadScopeContractSuite,
-  runObjectQueryProviderContractSuite,
-  runMaterializerStorageContractSuite,
-  runMaterializationFailureContractSuite,
-  runLakeStorageContractSuite,
-  runLakeMergeStorageContractSuite,
-  runExecutionStorageContractSuite,
-  runEffectiveStorageContractSuite,
-  runConnectorConnectionStorageContractSuite,
-  runBrokerContractSuite,
-  runBlobStorageContractSuite,
-  runAuthStorageContractSuite,
-  runAiUsageStorageContractSuite,
-  runAiModelCallGroupsContractSuite,
-  runAiLimitStorageContractSuite,
-  runAiCostStorageContractSuite,
-  runAgentStorageContractSuite,
-  queueTestSyncRun,
-  queueTestProjectionRun,
-  queueTestPipelineRun,
-  queueTestActionRun,
-  objectReadScopeContractOntology,
-  objectQueryContractOntology,
-  createTestWorkflowExecution,
-  createTestWebhookExecution,
-  createTestSyncExecution,
-  createTestSixb,
-  createTestProjectionExecution,
-  createTestPipelineExecution,
-  createTestAutomaticWorkflowExecution,
-  createTestAgentExecution,
-  createTestActionExecution,
-  createShareSessionStorageContractInput,
-  createShareGrantStorageContractInput,
+  claimTestProjectionRun,
   createMaterializerTestFixture,
-  claimTestProjectionRun
+  createShareGrantStorageContractInput,
+  createShareSessionStorageContractInput,
+  createTestActionExecution,
+  createTestAgentExecution,
+  createTestAutomaticWorkflowExecution,
+  createTestPipelineExecution,
+  createTestProjectionExecution,
+  createTestSixb,
+  createTestSyncExecution,
+  createTestWebhookExecution,
+  createTestWorkflowExecution,
+  objectQueryContractOntology,
+  objectReadScopeContractOntology,
+  queueTestActionRun,
+  queueTestPipelineRun,
+  queueTestProjectionRun,
+  queueTestSyncRun,
+  runAgentStorageContractSuite,
+  runAiCostStorageContractSuite,
+  runAiLimitStorageContractSuite,
+  runAiModelCallGroupsContractSuite,
+  runAiUsageStorageContractSuite,
+  runAuthStorageContractSuite,
+  runBlobStorageContractSuite,
+  runBrokerContractSuite,
+  runConnectorConnectionStorageContractSuite,
+  runEffectiveStorageContractSuite,
+  runExecutionStorageContractSuite,
+  runLakeMergeStorageContractSuite,
+  runLakeStorageContractSuite,
+  runMaterializationFailureContractSuite,
+  runMaterializerStorageContractSuite,
+  runObjectQueryProviderContractSuite,
+  runObjectReadScopeContractSuite,
+  runOntologyStorageContractSuite,
+  runProjectionRunStorageContractSuite,
+  runQueueContractSuite,
+  runSandboxesContractSuite,
+  runShareGrantStorageContractSuite,
+  runShareSessionStorageContractSuite,
+  runWebhookRunStorageContractSuite,
+  seedAiCostStorageContractUsage,
+  seedAiLimitStorageContractExecution,
+  seedAiUsageStorageContractExecutions,
+  seedObjectQueryContractData,
+  startTestPipelineRun,
+  startTestProjectionRun,
+  startTestSyncRun,
+  startTestWebhookRun
 };
 
-//# debugId=485577425ADF420C64756E2164756E21
+//# debugId=4F3927DB98A42FED64756E2164756E21