@sixb/core 0.1.11 → 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-jsy70480.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-gqm76kse.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-gq8vhakp.js";
+} from "../chunk-nzsy3xrp.js";
 import"../chunk-5a4a52tq.js";
 import {
   SixbHost2
-} from "../chunk-4zhmdsx6.js";
-import"../chunk-7apz6hg4.js";
-import"../chunk-wf88w4kp.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-a0e6x5hd.js";
-import"../chunk-01kj2pbh.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-sepyxgpc.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-3ckk0xfj.js";
+} from "../chunk-sfypc7mk.js";
 import {
   BrokerError2,
   InMemoryBroker2
@@ -121,38 +125,40 @@ import {
 import {
   QueueError2,
   InMemoryQueues2
-} from "../chunk-aa6z4a19.js";
-import"../chunk-z0271qkp.js";
+} from "../chunk-hgqpcmyr.js";
+import"../chunk-mdnw7nj8.js";
 import {
   SandboxNotRunningError2
-} from "../chunk-z3y411fq.js";
-import"../chunk-x9m9x2eq.js";
-import"../chunk-1yefycb1.js";
+} from "../chunk-y0v18c2j.js";
+import"../chunk-t7dzd1tm.js";
+import"../chunk-3bnt2wna.js";
 import"../chunk-7n30ybym.js";
-import"../chunk-fh8kgex1.js";
+import"../chunk-xn686q2e.js";
 import {
   createTestingScope
-} from "../chunk-38zv5rkr.js";
+} from "../chunk-g2gezsg5.js";
 import"../chunk-x9v4cx1d.js";
-import"../chunk-cfvakeax.js";
-import"../chunk-z0s4axeh.js";
-import"../chunk-g91qxjj0.js";
-import"../chunk-d63nnr5b.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";
@@ -10245,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({
@@ -11107,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 () => {
@@ -11338,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: [
@@ -13341,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) => {
@@ -14936,4 +15315,4 @@ export {
   startTestWebhookRun
 };
 
-//# debugId=B0D482CC6149C58064756E2164756E21
+//# debugId=9673644F573B835964756E2164756E21