@sixb/core 0.1.10 → 0.1.12

package/dist/testing/index.js

@@ -3,19 +3,20 @@ import {
   defineProjection2,
   agentServiceAccountId2,
   MAX_OBJECT_READ_FACETS2
-} from "../chunk-dz5h08xv.js";
-import"../chunk-f4w3yp4f.js";
+} from "../chunk-bbaa1fet.js";
+import"../chunk-hzw7yv5g.js";
+import"../chunk-z3y5kg1x.js";
 import {
   compileSelectedObjectReadScope2
 } from "../chunk-v4jbb3rs.js";
-import"../chunk-ms2tmn1k.js";
+import"../chunk-vsg0g7h9.js";
 import {
   AuthStorageError2,
   SYSTEM_PRINCIPAL2
-} from "../chunk-g00bfdq6.js";
+} from "../chunk-2cxv584m.js";
 import"../chunk-q5gz3g2j.js";
 import"../chunk-pqajwytd.js";
-import"../chunk-e0d1rzef.js";
+import"../chunk-2h63nrde.js";
 import"../chunk-gfdh9kqa.js";
 import {
   computeBlobDigest2,
@@ -23,24 +24,27 @@ import {
 } from "../chunk-39tqv9hz.js";
 import {
   AgentStorageError2
-} from "../chunk-7bs40fe1.js";
+} from "../chunk-69266efg.js";
 import {
   AiUsageStorageError2
-} from "../chunk-g53f0e4j.js";
-import"../chunk-b19g04jk.js";
-import"../chunk-vsj3mdfj.js";
+} from "../chunk-xnx96gfy.js";
+import"../chunk-3h7ctayx.js";
+import"../chunk-fc5zfxy1.js";
 import {
   aiLimitCalendarMonth2
 } from "../chunk-jgwb25gc.js";
-import"../chunk-8vj0rjgs.js";
-import"../chunk-93csa55g.js";
+import"../chunk-wjffn5m4.js";
+import"../chunk-axndsymr.js";
 import {
   OntologyRegistry2,
   defineObjectType2,
   prop2,
   link2,
   stringEnum2
-} from "../chunk-ap0g1g74.js";
+} from "../chunk-eyjzgav0.js";
+import {
+  createEventId2
+} from "../chunk-hkw8rykk.js";
 import {
   AGENT_MESSAGE_CONTENT_VERSION2,
   AiCostStorageError2,
@@ -48,36 +52,34 @@ import {
   linkBatchKey2,
   objectLinkCursor2,
   InMemoryStorage2
-} from "../chunk-p6a4npdx.js";
-import"../chunk-c5rkjrgp.js";
-import {
-  createEventId2
-} from "../chunk-gqh45d2n.js";
-import"../chunk-z30bv4ga.js";
+} from "../chunk-ybhz3j9g.js";
+import"../chunk-7ytf06d3.js";
+import"../chunk-yxb4c62x.js";
 import"../chunk-mmagke4x.js";
 import"../chunk-qma80ych.js";
-import"../chunk-358caqf5.js";
+import"../chunk-bfjv1adk.js";
 import"../chunk-jmfet9r4.js";
 import"../chunk-qf954wje.js";
-import"../chunk-pr2h4bv4.js";
+import"../chunk-tg4g4zh0.js";
 import {
   ProjectionRegistry2,
   createLinkScopeFingerprint2,
   createOntologyMaterializer2
-} from "../chunk-ftv470j8.js";
+} from "../chunk-m7cx05vp.js";
 import {
   bindModelExecutionAttempt,
   isBoundSixb
-} from "../chunk-5p1v802y.js";
+} from "../chunk-nzsy3xrp.js";
 import"../chunk-5a4a52tq.js";
 import {
   SixbHost2
-} from "../chunk-r7fj830t.js";
-import"../chunk-7apz6hg4.js";
-import"../chunk-nt99sxd6.js";
+} from "../chunk-b768c93y.js";
+import"../chunk-bet1rb9h.js";
+import"../chunk-x9tmx3fc.js";
 import"../chunk-r2y23egw.js";
 import"../chunk-dfm066qg.js";
 import {
+  planObjectQuery2,
   validateObjectQuery2,
   collectObjectQueryValidationIssues2,
   executeObjectQuery2,
@@ -85,35 +87,37 @@ import {
   existsObjects2,
   facetObjects2,
   executeObjectQueryLinks2
-} from "../chunk-g7knyczr.js";
-import"../chunk-nmbxcaqx.js";
+} from "../chunk-6ma8dvzc.js";
+import"../chunk-g50nxqs5.js";
 import"../chunk-3qms4nax.js";
-import"../chunk-1824gssz.js";
+import"../chunk-f85hpqnm.js";
+import"../chunk-5tetw4hn.js";
+import"../chunk-r5zythxp.js";
+import"../chunk-gswwr35f.js";
+import"../chunk-p6r1ex7t.js";
 import"../chunk-fb3feg1e.js";
 import"../chunk-z5rnrmz1.js";
 import"../chunk-85cd7e8c.js";
 import"../chunk-wr8qp979.js";
-import"../chunk-p5vcsw9c.js";
-import"../chunk-skz0hst3.js";
+import"../chunk-qm535afa.js";
+import"../chunk-7c2g3sz9.js";
 import {
   col2,
   defineDataset2,
   change2
-} from "../chunk-860dwwy0.js";
+} from "../chunk-cd234ba4.js";
 import"../chunk-e1c18xjx.js";
-import"../chunk-awbhdqyc.js";
+import"../chunk-3ghw2t5q.js";
 import"../chunk-9vx5e9g1.js";
 import"../chunk-dmn70ztd.js";
-import"../chunk-v2vcg0w6.js";
+import"../chunk-xtfryrfb.js";
 import {
   writeDataset2
-} from "../chunk-mrp7k0pw.js";
-import"../chunk-g6cke204.js";
-import"../chunk-0y39rgsb.js";
-import"../chunk-92vk7gta.js";
+} from "../chunk-91kcnbf0.js";
+import"../chunk-gzt6v1ja.js";
 import {
   workflowAgentStepActorId2
-} from "../chunk-t1f4f1ve.js";
+} from "../chunk-sfypc7mk.js";
 import {
   BrokerError2,
   InMemoryBroker2
@@ -121,38 +125,40 @@ import {
 import {
   QueueError2,
   InMemoryQueues2
-} from "../chunk-aa6z4a19.js";
-import"../chunk-qyeptdyv.js";
+} from "../chunk-hgqpcmyr.js";
+import"../chunk-mdnw7nj8.js";
 import {
   SandboxNotRunningError2
-} from "../chunk-z3y411fq.js";
-import"../chunk-bn138h9w.js";
-import"../chunk-rtk71jzp.js";
+} from "../chunk-y0v18c2j.js";
+import"../chunk-t7dzd1tm.js";
+import"../chunk-3bnt2wna.js";
 import"../chunk-7n30ybym.js";
-import"../chunk-agbbygvh.js";
+import"../chunk-xn686q2e.js";
 import {
   createTestingScope
-} from "../chunk-38zv5rkr.js";
+} from "../chunk-g2gezsg5.js";
 import"../chunk-x9v4cx1d.js";
-import"../chunk-5c7ga8zz.js";
-import"../chunk-976rxdpx.js";
-import"../chunk-b0ec55a1.js";
-import"../chunk-28ja2cjs.js";
+import"../chunk-jjwhy3rs.js";
+import"../chunk-4ph94nhd.js";
+import"../chunk-7qnvhtcd.js";
+import"../chunk-bg2bs62d.js";
+import"../chunk-kept9cdd.js";
+import"../chunk-e1f1sqba.js";
 import {
   LakeStorageError2
-} from "../chunk-9qsh3p5y.js";
+} from "../chunk-rb143ggb.js";
 import {
   ObjectQueryPlanningError2,
   normalizeObjectQuery2
-} from "../chunk-5hz0fnca.js";
+} from "../chunk-4k53sm9e.js";
 import {
   restoreTrustedPrimitiveExecutionScope
-} from "../chunk-17kfctj6.js";
+} from "../chunk-0mza4xb2.js";
 import"../chunk-br3k6qbf.js";
 import"../chunk-s3csryxe.js";
-import"../chunk-653vwrzr.js";
-import"../chunk-72w2pxk7.js";
-import"../chunk-f0rwz2vh.js";
+import"../chunk-y1ahv8b7.js";
+import"../chunk-y3ev53cq.js";
+import"../chunk-vpxss818.js";
 import {
   blobIdFromDigest2
 } from "../chunk-h3v76ams.js";
@@ -466,6 +472,200 @@ function runAgentStorageContractSuite(label, options) {
     }
   };
   describe(label, () => {
+    test("replaces lost state only under its current execution fence", async () => {
+      await withStorage(async (storage, fixture) => {
+        await storage.threads.create(threadInput({ sandboxParams: {} }));
+        const run = runInput({ execution: execution("first", new Date("2099-01-01")) });
+        await createAndStartRun(storage, fixture, run);
+        const acquire = {
+          projectId,
+          id: "thr_1",
+          action: "acquire",
+          runId: run.id,
+          executionToken: "first",
+          name: "name-1",
+          sourceFingerprint: "a".repeat(64)
+        };
+        await storage.threads.transitionSandbox(acquire);
+        const replace = { ...acquire, action: "replace", nextName: "name-2" };
+        await expectAgentError(storage.threads.transitionSandbox(replace), "invalid_state");
+        await storage.threads.transitionSandbox({
+          ...acquire,
+          action: "settle",
+          status: "ready",
+          initialized: true
+        });
+        await expectAgentError(storage.threads.transitionSandbox(replace), "invalid_state");
+        await storage.threads.transitionSandbox(acquire);
+        for (const nextName of ["name-1", "../invalid", ""]) {
+          await expectAgentError(storage.threads.transitionSandbox({ ...replace, nextName }), "invalid_state");
+        }
+        await expectAgentError(storage.threads.transitionSandbox({ ...replace, executionToken: "stale" }), "execution_lost");
+        const replacement = await storage.threads.transitionSandbox(replace);
+        const resetAt = replacement.resetAt;
+        expect(replacement).toMatchObject({
+          name: "name-2",
+          status: "busy",
+          initialized: false,
+          owner: { runId: run.id, executionToken: "first" },
+          sourceFingerprint: acquire.sourceFingerprint,
+          resetAt: expect.any(String)
+        });
+        await expectAgentError(storage.threads.transitionSandbox(replace), "invalid_state");
+        await expectAgentError(storage.threads.transitionSandbox({
+          ...acquire,
+          action: "settle",
+          status: "ready",
+          initialized: true
+        }), "invalid_state");
+        await storage.threads.transitionSandbox({
+          ...acquire,
+          name: "name-2",
+          action: "settle",
+          status: "ready",
+          initialized: true
+        });
+        const resumed = await storage.threads.transitionSandbox({
+          ...acquire,
+          name: "name-2"
+        });
+        expect(resumed.resetAt).toBe(resetAt);
+        expect((await storage.threads.getById({ projectId, id: "thr_1" }))?.sandboxState).toEqual(resumed);
+      });
+    });
+    test("fences workspace ownership across reclamation and explicit recreation", async () => {
+      await withStorage(async (storage, fixture) => {
+        await storage.threads.create(threadInput({ sandboxParams: {} }));
+        const input = runInput({ execution: execution("first", new Date("2099-01-01")) });
+        await createTestAgentExecution(fixture, {
+          projectId,
+          runId: input.id,
+          executionId: input.executionId,
+          authority: "inherited"
+        });
+        await storage.runs.create(input);
+        await storage.runs.start(input);
+        const acquire = {
+          projectId,
+          id: "thr_1",
+          action: "acquire",
+          runId: input.id,
+          executionToken: "first",
+          name: "name-1",
+          sourceFingerprint: "a".repeat(64)
+        };
+        const attempts = await Promise.allSettled([
+          storage.threads.transitionSandbox(acquire),
+          storage.threads.transitionSandbox(acquire)
+        ]);
+        expect(attempts.filter((attempt) => attempt.status === "fulfilled")).toHaveLength(1);
+        expect((await storage.threads.getById({ projectId, id: "thr_1" }))?.sandboxState).toMatchObject({ status: "busy", initialized: false });
+        await expectAgentError(storage.threads.transitionSandbox(acquire), "invalid_state");
+        await storage.runs.reclaim({
+          projectId,
+          id: input.id,
+          execution: execution("second", new Date("2099-01-01"))
+        });
+        await expectAgentError(storage.threads.transitionSandbox({
+          ...acquire,
+          executionToken: "second"
+        }), "invalid_state");
+        await expectAgentError(storage.threads.transitionSandbox({
+          ...acquire,
+          action: "settle",
+          status: "ready",
+          initialized: true
+        }), "execution_lost");
+        const recreate = {
+          projectId,
+          id: "thr_1",
+          action: "recreate",
+          expectedSandboxName: "name-1",
+          name: "name-2"
+        };
+        await expectAgentError(storage.threads.transitionSandbox(recreate), "invalid_state");
+        await storage.runs.finish({
+          projectId,
+          id: input.id,
+          executionToken: "second",
+          status: "failed"
+        });
+        expect(await storage.threads.transitionSandbox(recreate)).toEqual({
+          name: "name-2",
+          status: "new",
+          initialized: false,
+          resetAt: expect.any(String)
+        });
+        await expectAgentError(storage.threads.transitionSandbox(recreate), "invalid_state");
+      });
+    });
+    test("resumes only confirmed workspace state with the pinned source", async () => {
+      await withStorage(async (storage, fixture) => {
+        await storage.threads.create(threadInput({ sandboxParams: {} }));
+        const input = runInput({ execution: execution("owner", new Date("2099-01-01")) });
+        await createTestAgentExecution(fixture, {
+          projectId,
+          runId: input.id,
+          executionId: input.executionId,
+          authority: "inherited"
+        });
+        await storage.runs.create(input);
+        await storage.runs.start(input);
+        const acquire = {
+          projectId,
+          id: "thr_1",
+          action: "acquire",
+          runId: input.id,
+          executionToken: "owner",
+          name: "name",
+          sourceFingerprint: "b".repeat(64)
+        };
+        await storage.threads.transitionSandbox(acquire);
+        await storage.threads.transitionSandbox({
+          ...acquire,
+          action: "settle",
+          status: "ready",
+          initialized: true
+        });
+        await expectAgentError(storage.threads.transitionSandbox({
+          ...acquire,
+          sourceFingerprint: "c".repeat(64)
+        }), "invalid_state");
+        expect(await storage.threads.transitionSandbox(acquire)).toMatchObject({
+          status: "busy",
+          initialized: true
+        });
+      });
+    });
+    test("snapshots workspace bindings without accepting runtime state or credentials", async () => {
+      await withStorage(async (storage) => {
+        const sandboxParams = { clientId: "acme", nested: { branch: "main" } };
+        const record = await storage.threads.create(threadInput({ sandboxParams }));
+        sandboxParams.nested.branch = "changed";
+        const read = await storage.threads.getById({ projectId, id: record.id });
+        expect(read?.sandboxParams).toEqual({ clientId: "acme", nested: { branch: "main" } });
+        const mutable = record.sandboxParams?.nested;
+        if (mutable && typeof mutable === "object" && !Array.isArray(mutable))
+          mutable.branch = "tampered";
+        expect((await storage.threads.list({ projectId })).threads[0]?.sandboxParams).toEqual(read?.sandboxParams);
+        await expectAgentError(storage.threads.create(threadInput({
+          id: "unsafe",
+          sandboxParams: []
+        })), "invalid_input");
+        await expectAgentError(storage.threads.create(threadInput({
+          id: "non-json",
+          sandboxParams: { at: new Date }
+        })), "invalid_input");
+      });
+    });
+    test("keeps delimiter-containing project and sandbox thread ids distinct", async () => {
+      await withStorage(async (storage) => {
+        await storage.threads.create(threadInput({ projectId: "a:b", id: "c", sandboxParams: { repo: "one" } }));
+        await storage.threads.create(threadInput({ projectId: "a", id: "b:c", sandboxParams: { repo: "two" } }));
+        expect((await storage.threads.getById({ projectId: "a:b", id: "c" }))?.sandboxParams?.repo).toBe("one");
+        expect((await storage.threads.getById({ projectId: "a", id: "b:c" }))?.sandboxParams?.repo).toBe("two");
+      });
+    });
     test("creates threads, isolates projects, and rejects duplicate ids", async () => {
       await withStorage(async (storage) => {
         const thread = await storage.threads.create(threadInput({ title: "Q3 pipeline" }));
@@ -1559,8 +1759,22 @@ function runAiCostStorageContractSuite(name, options) {
             inputTokens: 15,
             outputTokens: 12,
             totalTokens: 27,
+            uncachedInputTokens: 12,
+            cacheReadInputTokens: 0,
             reportingStatus: "complete"
           },
+          usageCoverage: {
+            completeCallCount: 3,
+            fieldCallCounts: {
+              inputTokens: 3,
+              outputTokens: 3,
+              uncachedInputTokens: 1,
+              cacheReadInputTokens: 1,
+              cacheWriteInputTokens: 0,
+              textOutputTokens: 0,
+              reasoningOutputTokens: 0
+            }
+          },
           costs: {
             amounts: [{ currency: "USD", amountNanos: "95000" }],
             ratedCallCount: 1,
@@ -1606,6 +1820,77 @@ function runAiCostStorageContractSuite(name, options) {
         await options.cleanup?.(storage);
       }
     });
+    test2("retains known tokens and coverage across incomplete periods", async () => {
+      const storage = await fixture();
+      try {
+        for (const [index, currency] of ["USD", "EUR"].entries()) {
+          await storage.recordModelCallCost(ratedCost(`partial_16_${index}`, {
+            components: [],
+            money: { currency, amountNanos: "1" },
+            priceSource: { ...priceSource(`partial_${index}`), sourceId: "provider-reported" }
+          }));
+        }
+        const overview = await storage.queryProjectOverview({
+          projectId: projectId2,
+          from: new Date("2026-09-16"),
+          to: new Date("2026-09-19"),
+          bucket: "day"
+        });
+        expect2(overview.series.map((period) => ({
+          calls: period.modelCallCount,
+          total: period.usage.totalTokens,
+          complete: period.usageCoverage.completeCallCount
+        }))).toEqual([
+          { calls: 87, total: 4013782, complete: 84 },
+          { calls: 0, total: undefined, complete: 0 },
+          { calls: 29, total: 334815, complete: 28 }
+        ]);
+        for (const aggregate of [overview.totals, ...overview.models, ...overview.workflows]) {
+          expect2(aggregate.usage).toEqual({
+            inputTokens: 4348597,
+            outputTokens: 0,
+            totalTokens: 4348597,
+            reportingStatus: "partial"
+          });
+          expect2(aggregate.usageCoverage).toMatchObject({
+            completeCallCount: 112,
+            fieldCallCounts: { inputTokens: 112, outputTokens: 112, cacheReadInputTokens: 0 }
+          });
+        }
+        expect2(overview.totals.costs.amounts).toEqual([
+          { currency: "EUR", amountNanos: "1" },
+          { currency: "USD", amountNanos: "1" }
+        ]);
+        const edges = await storage.queryProjectOverview({
+          projectId: projectId2,
+          from: new Date("2026-09-19"),
+          to: new Date("2026-09-22"),
+          bucket: "day",
+          providerId: "gateway",
+          modelId: "partial/model"
+        });
+        expect2(edges.series[0]).toMatchObject({
+          usage: { inputTokens: 3, outputTokens: 4, totalTokens: 7, reportingStatus: "partial" },
+          usageCoverage: {
+            completeCallCount: 0,
+            fieldCallCounts: { inputTokens: 1, outputTokens: 1 }
+          }
+        });
+        expect2(edges.series[1]).toMatchObject({
+          modelCallCount: 1,
+          usage: { reportingStatus: "unavailable" },
+          usageCoverage: { completeCallCount: 0 }
+        });
+        expect2(edges.series[1]?.usage.totalTokens).toBeUndefined();
+        expect2(edges.series[2]).toMatchObject({
+          usage: { inputTokens: 0, totalTokens: 0, reportingStatus: "partial" },
+          usageCoverage: { completeCallCount: 0 }
+        });
+        expect2(edges.series[2]?.usage.outputTokens).toBeUndefined();
+      } finally {
+        await options.cleanup?.(storage);
+      }
+    });
     test2("rejects missing usage and mismatched billed quantities", async () => {
       const storage = await fixture();
       try {
@@ -1708,6 +1993,46 @@ async function seedAiCostStorageContractUsage(executions, usage) {
     occurredAt: new Date("2026-08-03T12:00:00.000Z"),
     recordedAt: new Date("2026-08-03T12:00:00.100Z")
   });
+  for (const [day, calls, complete, tokens] of [
+    [16, 87, 84, 4013782],
+    [18, 29, 28, 334815]
+  ]) {
+    for (let index = 0;index < calls; index++) {
+      await usage.recordModelCall({
+        id: `partial_${day}_${index}`,
+        projectId: projectId2,
+        executionId: otherExecutionId,
+        attempt: 1,
+        callId: `partial_${day}_${index}`,
+        responseId: `response_partial_${day}_${index}`,
+        requesterGroupIds: [],
+        providerId: "gateway",
+        requestedModelId: "partial/model",
+        usage: index < complete ? { inputTokens: index === 0 ? tokens : 0, outputTokens: 0 } : {},
+        occurredAt: new Date(`2026-09-${day}T12:00:00Z`)
+      });
+    }
+  }
+  for (const [index, day, counts] of [
+    [0, 19, { inputTokens: 3 }],
+    [1, 19, { outputTokens: 4 }],
+    [2, 20, {}],
+    [3, 21, { inputTokens: 0 }]
+  ]) {
+    await usage.recordModelCall({
+      id: `edge_${index}`,
+      projectId: projectId2,
+      executionId: otherExecutionId,
+      attempt: 1,
+      callId: `edge_${index}`,
+      responseId: `response_edge_${index}`,
+      requesterGroupIds: [],
+      providerId: "gateway",
+      requestedModelId: "partial/model",
+      usage: counts,
+      occurredAt: new Date(`2026-09-${day}T12:00:00Z`)
+    });
+  }
 }
 // src/testing/ai-limit-storage-contract.ts
 import { describe as describe3, expect as expect3, test as test3 } from "bun:test";
@@ -6335,19 +6660,19 @@ function runConnectorConnectionStorageContractSuite(label, options) {
         expect9(await storage.getAuthorization(authorizationKey(duplicateId.id))).toEqual(duplicateId);
       });
     });
-    test9("commits expiry cleanup before rejecting account selection", async () => {
+    test9("allows account selection after its legacy deadline", async () => {
       await withStorage(async (storage, root) => {
         const authorization = await createAuthorization(storage, "authorization-a", "account-a");
-        await options.advanceTime(root, 60000);
-        await expect9(connect(storage, authorization, "connection-a", "account-a")).rejects.toThrow("selectable authorization");
-        await expect9(storage.getAuthorization(authorizationKey(authorization.id))).resolves.toMatchObject({ status: "revocation_pending" });
+        await options.advanceTime(root, 365 * 24 * 60 * 60000);
+        await expect9(connect(storage, authorization, "connection-a", "account-a")).resolves.toMatchObject({ connection: { status: "connected" } });
+        await expect9(storage.getAuthorization(authorizationKey(authorization.id))).resolves.toMatchObject({ status: "active" });
       });
     });
-    test9("commits lazy run expiry before rejecting a late selection", async () => {
+    test9("keeps account-selection runs selectable after their legacy deadline", async () => {
       await withStorage(async (storage, root) => {
         const authorization = await createAuthorization(storage, "authorization-a", "account-a");
         await createSelectionRun(storage, authorization);
-        await options.advanceTime(root, 60000);
+        await options.advanceTime(root, 365 * 24 * 60 * 60000);
         await expect9(storage.putConnectionFromRun({
           id: "connection-a",
           projectId: projectId7,
@@ -6355,9 +6680,9 @@ function runConnectorConnectionStorageContractSuite(label, options) {
           runId: "run-a",
           account: { id: "account-a", label: "Account A" },
           replace: false
-        })).rejects.toThrow("invalid, expired, or already used");
-        await expect9(storage.getConnectionRun({ projectId: projectId7, connectorId, runId: "run-a" })).resolves.toMatchObject({ status: "expired" });
-        await expect9(storage.getAuthorization(authorizationKey(authorization.id))).resolves.toMatchObject({ status: "revocation_pending" });
+        })).resolves.toMatchObject({ run: { status: "succeeded" } });
+        await expect9(storage.getConnectionRun({ projectId: projectId7, connectorId, runId: "run-a" })).resolves.toMatchObject({ status: "succeeded" });
+        await expect9(storage.getAuthorization(authorizationKey(authorization.id))).resolves.toMatchObject({ status: "active" });
       });
     });
     test9("scopes direct record reads by project and connector", async () => {
@@ -8662,6 +8987,27 @@ function runLakeStorageContractSuite(label, options) {
       });
     });
     describe15("writes and reads", () => {
+      test15("cancels reads before starting and between rows", async () => {
+        await withStorage(async (storage) => {
+          await storage.createDataset(writeDataset);
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
+          await write.writeRows([
+            { orderId: "1", customerName: "first" },
+            { orderId: "2", customerName: "second" }
+          ]);
+          await write.commit();
+          const controller = new AbortController;
+          const rows = storage.readRows({ datasetId: writeDataset.id, signal: controller.signal })[Symbol.asyncIterator]();
+          try {
+            expect15((await rows.next()).done).toBe(false);
+            controller.abort(new Error("cancel dataset read"));
+            await expect15(rows.next()).rejects.toThrow("cancel dataset read");
+            await expect15(collectRows2(storage.readRows({ datasetId: writeDataset.id, signal: controller.signal }))).rejects.toThrow("cancel dataset read");
+          } finally {
+            await rows.return?.();
+          }
+        });
+      });
       test15("keeps immutable-version row order and offsets stable", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
@@ -10224,12 +10570,11 @@ var Room = defineObjectType2({
     }),
     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 } })
+    prop2("embedding", { type: "array", items: "double" }, { query: { searchable: true } })
   ],
   links: [link2("hasDevice", Device3)],
   search: {
-    defaultText: ["name", "description"],
-    vector: { property: "embedding", source: ["name", "description"] }
+    defaultText: ["name", "description"]
   }
 });
 var Zone = defineObjectType2({
@@ -11086,23 +11431,51 @@ function runObjectQueryProviderContractSuite(label, options) {
         await expectPlanningIssue(executeObjectQuery2({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage }), "sort_kind_not_supported");
       });
     });
-    test18("executes or rejects vector search according to provider capabilities", async () => {
-      await withStorage(async ({ objects: storage, fixture }) => {
-        await seedObjectQueryContractData(fixture);
+    test18("plans or rejects vector search according to provider capabilities", async () => {
+      await withStorage(async ({ objects: storage }) => {
+        const ontology = new OntologyRegistry2({
+          sources: [
+            Device3,
+            defineObjectType2({
+              ...Room,
+              search: {
+                vectors: {
+                  content: {
+                    source: ["name", "description"],
+                    model: {
+                      providerId: "test",
+                      modelId: "embedding",
+                      definition: {
+                        kind: "embedding",
+                        providerId: "test",
+                        modelId: "embedding",
+                        dimensions: 2
+                      }
+                    }
+                  }
+                }
+              }
+            })
+          ]
+        });
         const query = {
           kind: "vector",
-          propertyId: "embedding",
+          profile: "content",
           vector: [1, 0],
           k: 2,
           input: { kind: "start", objectTypeId: Room.id }
         };
+        const validated = validateObjectQuery2(query, { ontology });
+        const plan = planObjectQuery2(validated.query, {
+          capabilities: storage.queryCapabilities(),
+          hasQueryObjects: typeof storage.queryObjects === "function"
+        });
         if (storage.queryCapabilities().nodes?.vector === true) {
-          const result = await executeObjectQuery2({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage });
-          expect18(result.plan.mode).toBe("pushdown");
-          expect18(ids(result)).toEqual(["room-alpha", "room-beta"]);
-          return;
+          expect18(plan.mode).toBe("pushdown");
+        } else {
+          expect18(plan.mode).toBe("rejected");
+          expect18(plan.issues.map((issue) => issue.code)).toContain("query_node_not_supported");
         }
-        await expectPlanningIssue(executeObjectQuery2({ projectId: projectId10, query }, { ontology: objectQueryContractOntology, storage }), "query_node_not_supported");
       });
     });
     test18("executes bounded fallback when pushdown is disabled for a safe query", async () => {
@@ -11317,7 +11690,7 @@ var Proposal = defineObjectType2({
     }),
     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("embedding", { type: "array", items: "double" }, { query: { searchable: true } }),
     prop2("secret", "string", { query: { searchable: true, filterable: true, facet: true } })
   ],
   links: [
@@ -12519,7 +12892,10 @@ function runOntologyStorageContractSuite(label, options) {
         })).toBe(1);
       });
     });
-    test20("keeps batch outbox settlement atomic when callers catch a stale lease", async () => {
+    test20.each([
+      "root",
+      "transaction"
+    ])("keeps %s batch outbox settlement atomic when callers catch a stale lease", async (boundary) => {
       await withStorage(async (storage) => {
         await commitExactObject(storage, "lease-atomic-a");
         await commitExactObject(storage, "lease-atomic-b");
@@ -12540,7 +12916,7 @@ function runOntologyStorageContractSuite(label, options) {
         });
         const untouched = claimed.find((row) => row.envelope.id !== reclaimed.envelope.id);
         let conflict;
-        await storage.transaction(async (tx) => {
+        const settle = async (tx) => {
           try {
             await tx.ontology.outbox.markPublished({
               projectId: "contract-project",
@@ -12551,7 +12927,11 @@ function runOntologyStorageContractSuite(label, options) {
           } catch (error) {
             conflict = error;
           }
-        });
+        };
+        if (boundary === "transaction")
+          await storage.transaction(settle);
+        else
+          await settle(storage);
         expect20(conflict).toMatchObject({ kind: "outbox-lease" });
         await storage.ontology.outbox.markPublished({
           projectId: "contract-project",
@@ -13313,6 +13693,33 @@ function runQueueContractSuite(label, options) {
     }
   };
   describe21(label, () => {
+    test22("vector indexing has independent delivery capacity and idempotent generation ids", async () => {
+      await withQueues(async (queues) => {
+        const jobs = [
+          {
+            id: "generation-1",
+            type: "vector.index.requested",
+            payload: { indexingId: "generation-1" }
+          }
+        ];
+        await queues.vectorIndexing.enqueue({ projectId: "project-a", jobs });
+        await queues.vectorIndexing.enqueue({ projectId: "project-a", jobs });
+        expect22(await queues.projections.claim({ projectId: "project-a", workerId: "projection" })).toHaveLength(0);
+        const claimed = await queues.vectorIndexing.claim({
+          projectId: "project-a",
+          workerId: "indexing",
+          limit: 2
+        });
+        expect22(claimed).toHaveLength(1);
+        expect22(claimed[0].job.payload).toEqual({ indexingId: "generation-1" });
+        await queues.vectorIndexing.complete({
+          projectId: "project-a",
+          jobId: claimed[0].job.id,
+          leaseId: claimed[0].leaseId
+        });
+        expect22(await queues.vectorIndexing.claim({ projectId: "project-a", workerId: "indexing" })).toHaveLength(0);
+      });
+    });
     describe21("enqueue", () => {
       test22("returns envelopes with generated id, createdAt, availableAt, attempt=0", async () => {
         await withQueues(async (queues) => {
@@ -14908,4 +15315,4 @@ export {
   startTestWebhookRun
 };
 
-//# debugId=29763EF5A28C28D864756E2164756E21
+//# debugId=9673644F573B835964756E2164756E21