@sixb/core 0.1.3 → 0.1.4

package/dist/testing/index.js

@@ -1,12 +1,12 @@
 // @bun
 import {
   createTestingScope
-} from "../chunk-z8j83gzd.js";
+} from "../chunk-x2yw73hy.js";
 import {
   SixbHost
-} from "../chunk-bv41fmjn.js";
+} from "../chunk-s31d0qmq.js";
 import"../chunk-9t8f5xfx.js";
-import"../chunk-wb4051cx.js";
+import"../chunk-819wnjz8.js";
 import {
   QueueError
 } from "../chunk-6gjqgd3d.js";
@@ -20,10 +20,10 @@ import"../chunk-ghteq96b.js";
 import"../chunk-z3zp0bj1.js";
 import"../chunk-zqqz8052.js";
 import"../chunk-f2rt4vkh.js";
-import"../chunk-1ywq4hzk.js";
-import"../chunk-c6cfqydk.js";
-import"../chunk-c8bw2b6c.js";
-import"../chunk-4p9rh7jj.js";
+import"../chunk-1yz3x65y.js";
+import"../chunk-sxwk41qa.js";
+import"../chunk-hbeh8j9w.js";
+import"../chunk-rs1wbvy6.js";
 import"../chunk-5sz8ta9r.js";
 import"../chunk-979ww6b3.js";
 import"../chunk-2ab72m2h.js";
@@ -39,72 +39,75 @@ import {
 } from "../chunk-wtmzkcht.js";
 import {
   isBoundSixb
-} from "../chunk-177ed2mp.js";
-import"../chunk-km4rkj4t.js";
-import"../chunk-261ag4t4.js";
-import"../chunk-3rsf30p4.js";
-import"../chunk-gqdd7508.js";
+} from "../chunk-c43qr6s0.js";
+import"../chunk-g13869yf.js";
+import"../chunk-cbkm2vam.js";
+import"../chunk-pn8n8sba.js";
+import"../chunk-4rh2m6zg.js";
 import"../chunk-xhy826cz.js";
 import {
   collectObjectQueryValidationIssues,
   countObjects,
   executeObjectQuery,
+  executeObjectQueryLinks,
   existsObjects,
   facetObjects,
   validateObjectQuery
-} from "../chunk-f1cyvnrk.js";
+} from "../chunk-7gw7mepb.js";
 import {
   ObjectQueryPlanningError,
   normalizeObjectQuery
-} from "../chunk-88ppkr54.js";
-import"../chunk-63te770v.js";
+} from "../chunk-rte5sm3z.js";
+import"../chunk-qewtks41.js";
 import {
   computeBlobDigest
 } from "../chunk-8b55ygje.js";
 import"../chunk-51fjndv0.js";
 import"../chunk-8m5ejdpn.js";
 import"../chunk-nf4r78r4.js";
-import"../chunk-ttba8x6z.js";
-import"../chunk-d6y2wsfg.js";
+import"../chunk-tycbzedm.js";
+import"../chunk-tek1qwgm.js";
 import {
   ProjectionRegistry,
   createOntologyMaterializer
-} from "../chunk-ettb0cy4.js";
+} from "../chunk-afjpa2hs.js";
 import"../chunk-96swp2wd.js";
 import {
   restoreTrustedPrimitiveExecutionScope
-} from "../chunk-4aw0jwk0.js";
+} from "../chunk-f6erf2vv.js";
 import {
   AGENT_MESSAGE_CONTENT_VERSION,
-  AiCostStorageError
-} from "../chunk-xmggaxg4.js";
+  AiCostStorageError,
+  linkBatchKey,
+  objectBatchKey,
+  objectLinkCursor
+} from "../chunk-1wk20wn3.js";
 import {
   createEventId
-} from "../chunk-fmx1sz2h.js";
+} from "../chunk-72q2y8hn.js";
 import"../chunk-xc7hq65b.js";
 import"../chunk-cy0n5dms.js";
 import"../chunk-dysw7nsm.js";
 import"../chunk-62c7t4jc.js";
 import"../chunk-ezake7g1.js";
-import"../chunk-pxtrxm3p.js";
+import"../chunk-a09jx26t.js";
 import"../chunk-htq0qh7z.js";
 import"../chunk-xkthy56g.js";
 import {
   AgentStorageError
-} from "../chunk-qer6am8w.js";
+} from "../chunk-xdf9yswn.js";
 import {
   agentServiceAccountId
-} from "../chunk-n5x5y80a.js";
+} from "../chunk-nzw7sm3b.js";
 import"../chunk-t9xghkva.js";
 import {
   AiUsageStorageError
-} from "../chunk-kqxgf6kv.js";
+} from "../chunk-drjqm1aa.js";
 import"../chunk-5gd7tpv6.js";
 import"../chunk-h9kxd41f.js";
 import"../chunk-9dzba0f2.js";
 import"../chunk-vybf6pkp.js";
 import"../chunk-ry24jbr1.js";
-import"../chunk-6wetht33.js";
 import {
   OntologyRegistry,
   defineObjectType,
@@ -117,24 +120,24 @@ import"../chunk-zcnhxkvd.js";
 import"../chunk-1evzqhks.js";
 import"../chunk-dsrkgtnh.js";
 import"../chunk-bhxaq2nn.js";
-import"../chunk-rnshztfq.js";
-import"../chunk-04b07a9q.js";
-import"../chunk-dktq02ne.js";
-import {
-  blobIdFromDigest
-} from "../chunk-zqysyfjt.js";
 import"../chunk-yt8wphsx.js";
 import"../chunk-rdeagz6b.js";
-import"../chunk-zpw39qhj.js";
+import"../chunk-dm72y8wt.js";
 import"../chunk-t0jjkep3.js";
 import {
   AuthStorageError
-} from "../chunk-d2adj15j.js";
+} from "../chunk-tkdscva6.js";
 import"../chunk-rhrbz7d4.js";
 import"../chunk-xwnf87e1.js";
 import {
   defineProjection
-} from "../chunk-4z3n1dzt.js";
+} from "../chunk-f83ka50g.js";
+import"../chunk-rnshztfq.js";
+import"../chunk-04b07a9q.js";
+import"../chunk-dktq02ne.js";
+import {
+  blobIdFromDigest
+} from "../chunk-zqysyfjt.js";
 import"../chunk-0172wgm9.js";
 import"../chunk-t8t39h7v.js";
 import"../chunk-y64skrwp.js";
@@ -1024,6 +1027,14 @@ function runAgentStorageContractSuite(label, options) {
         expect(await storage.checkpoints.getLatest({ projectId, threadId: "thr_1" })).toEqual(created);
         expect(await storage.checkpoints.getLatest({ projectId: otherProjectId, threadId: "thr_1" })).toBeNull();
         expect(await storage.checkpoints.getLatest({ projectId, threadId: "thr_2" })).toBeNull();
+        await expect(storage.checkpoints.getByRunIds({
+          projectId,
+          runIds: ["run_2", "missing", "run_2"]
+        })).resolves.toEqual([created]);
+        await expect(storage.checkpoints.getByRunIds({
+          projectId: otherProjectId,
+          runIds: ["run_2"]
+        })).resolves.toEqual([]);
         const retained = await storage.messages.list({
           projectId,
           threadId: "thr_1",
@@ -1533,6 +1544,28 @@ function runAiUsageStorageContractSuite(label, options) {
         });
       });
     });
+    test3("returns the latest completed call for one execution", async () => {
+      await withStorage(async (storage) => {
+        await expect3(storage.getLatestForExecution({ projectId: projectId3, executionId: agentExecutionId })).resolves.toBeNull();
+        await storage.recordModelCall(modelCallInput({
+          id: "usage_later",
+          callId: "call_later",
+          responseId: "response_later",
+          occurredAt: at2("2026-06-23T10:02:00.000Z")
+        }));
+        await storage.recordModelCall(modelCallInput({
+          id: "usage_earlier",
+          callId: "call_earlier",
+          responseId: "response_earlier",
+          occurredAt: at2("2026-06-23T10:01:00.000Z")
+        }));
+        await expect3(storage.getLatestForExecution({ projectId: projectId3, executionId: agentExecutionId })).resolves.toMatchObject({ id: "usage_later", responseId: "response_later" });
+        await expect3(storage.getLatestForExecution({
+          projectId: "other-project",
+          executionId: agentExecutionId
+        })).resolves.toBeNull();
+      });
+    });
     test3("bills the same call and response IDs again on a later delivery attempt", async () => {
       await withStorage(async (storage) => {
         await storage.recordModelCall(modelCallInput());
@@ -4994,7 +5027,25 @@ var Device = defineObjectType({
   ],
   links: [link.self("peers", { cardinality: "many" })]
 });
-var ontology = new OntologyRegistry({ sources: [Device] });
+var OpaqueA = defineObjectType({
+  id: "A",
+  name: "Opaque A",
+  properties: [
+    prop("id", "string", { primary: true, required: true }),
+    prop("name", "string", { required: true })
+  ],
+  links: [link.self("D", { cardinality: "many" })]
+});
+var OpaqueAB = defineObjectType({
+  id: "A:B",
+  name: "Opaque AB",
+  properties: [
+    prop("id", "string", { primary: true, required: true }),
+    prop("name", "string", { required: true })
+  ],
+  links: [link.self("D", { cardinality: "many" })]
+});
+var ontology = new OntologyRegistry({ sources: [Device, OpaqueA, OpaqueAB] });
 function runEffectiveStorageContractSuite(name, provider) {
   const withStorage = async (body) => {
     const storage = await provider.createStorage();
@@ -5025,7 +5076,7 @@ function runEffectiveStorageContractSuite(name, provider) {
             { objectTypeId: Device.id, primaryId: "missing" }
           ]
         });
-        expect8([...batch.keys()]).toEqual([`${Device.id}:a`]);
+        expect8([...batch.keys()]).toEqual([objectBatchKey(Device.id, "a")]);
       });
     });
     test8("reads Materializer-owned links", async () => {
@@ -5047,7 +5098,163 @@ function runEffectiveStorageContractSuite(name, provider) {
           projectId: projectId6,
           items: [{ objectTypeId: Device.id, objectId: "a", linkId: "peers" }]
         });
-        expect8(linksByScope.get(`${Device.id}:a:peers`)).toHaveLength(2);
+        expect8(linksByScope.get(linkBatchKey(Device.id, "a", "peers"))).toHaveLength(2);
+      });
+    });
+    test8("pages and filters incident links in the provider", async () => {
+      await withStorage(async (storage) => {
+        const first = await storage.objects.queryLinks({
+          projectId: projectId6,
+          objectRefs: [{ objectTypeId: Device.id, primaryId: "a" }],
+          direction: "outgoing",
+          linkId: "peers",
+          endpointObjectTypeIds: [Device.id],
+          limit: 1
+        });
+        expect8(first.links.map((row) => row.targetId)).toEqual(["b"]);
+        expect8(first.hasMore).toBe(true);
+        const second = await storage.objects.queryLinks({
+          projectId: projectId6,
+          objectRefs: [{ objectTypeId: Device.id, primaryId: "a" }],
+          direction: "outgoing",
+          linkId: "peers",
+          endpointObjectTypeIds: [Device.id],
+          after: objectLinkCursor(first.links[0]),
+          limit: 1
+        });
+        expect8(second.links.map((row) => row.targetId)).toEqual(["c"]);
+        expect8(second.hasMore).toBe(false);
+        const duplicateRefs = await storage.objects.queryLinks({
+          projectId: projectId6,
+          objectRefs: [
+            { objectTypeId: Device.id, primaryId: "a" },
+            { objectTypeId: Device.id, primaryId: "a" }
+          ],
+          direction: "outgoing",
+          limit: 10
+        });
+        expect8(duplicateRefs.links.map((row) => row.targetId)).toEqual(["b", "c"]);
+        const incoming = await storage.objects.queryLinks({
+          projectId: projectId6,
+          objectRefs: [{ objectTypeId: Device.id, primaryId: "b" }],
+          direction: "incoming",
+          limit: 10
+        });
+        expect8(incoming.links.map((row) => [row.sourceId, row.targetId])).toEqual([["a", "b"]]);
+        const bothDirections = await storage.objects.queryLinks({
+          projectId: projectId6,
+          objectRefs: [
+            { objectTypeId: Device.id, primaryId: "a" },
+            { objectTypeId: Device.id, primaryId: "b" }
+          ],
+          direction: "both",
+          endpointObjectTypeIds: [Device.id],
+          limit: 10
+        });
+        expect8(bothDirections.links.map((row) => [row.sourceId, row.targetId])).toEqual([
+          ["a", "b"],
+          ["a", "c"]
+        ]);
+        const unauthorized = await storage.objects.queryLinks({
+          projectId: projectId6,
+          objectRefs: [{ objectTypeId: Device.id, primaryId: "a" }],
+          direction: "both",
+          endpointObjectTypeIds: [],
+          limit: 10
+        });
+        expect8(unauthorized).toEqual({ links: [], hasMore: false });
+      });
+    });
+    test8("keeps delimiter-bearing object and batch-link identities distinct", async () => {
+      await withStorage(async (storage) => {
+        const opaqueProjectId = `${projectId6}-opaque-batch-keys`;
+        const fixture = createMaterializerTestFixture({
+          projectId: opaqueProjectId,
+          ontology,
+          storage
+        });
+        await fixture.seed({
+          objects: [
+            {
+              ref: { objectTypeId: OpaqueA.id, primaryId: "B:C" },
+              properties: { id: "B:C", name: "First" }
+            },
+            {
+              ref: { objectTypeId: OpaqueAB.id, primaryId: "C" },
+              properties: { id: "C", name: "Second" }
+            }
+          ],
+          links: [
+            {
+              ref: {
+                source: { objectTypeId: OpaqueA.id, primaryId: "B:C" },
+                linkId: "D",
+                target: { objectTypeId: OpaqueA.id, primaryId: "B:C" }
+              }
+            },
+            {
+              ref: {
+                source: { objectTypeId: OpaqueAB.id, primaryId: "C" },
+                linkId: "D",
+                target: { objectTypeId: OpaqueAB.id, primaryId: "C" }
+              }
+            }
+          ]
+        });
+        const objects = await storage.objects.getByPrimaryIdBatch({
+          projectId: opaqueProjectId,
+          items: [
+            { objectTypeId: OpaqueA.id, primaryId: "B:C" },
+            { objectTypeId: OpaqueAB.id, primaryId: "C" }
+          ]
+        });
+        expect8(objects.get(objectBatchKey(OpaqueA.id, "B:C"))?.properties.name).toBe("First");
+        expect8(objects.get(objectBatchKey(OpaqueAB.id, "C"))?.properties.name).toBe("Second");
+        const links = await storage.objects.listLinksBatch({
+          projectId: opaqueProjectId,
+          items: [
+            { objectTypeId: OpaqueA.id, objectId: "B:C", linkId: "D" },
+            { objectTypeId: OpaqueAB.id, objectId: "C", linkId: "D" }
+          ]
+        });
+        expect8(links.get(linkBatchKey(OpaqueA.id, "B:C", "D"))).toHaveLength(1);
+        expect8(links.get(linkBatchKey(OpaqueAB.id, "C", "D"))).toHaveLength(1);
+      });
+    });
+    test8("preserves distinct incident links when opaque ids contain delimiters", async () => {
+      await withStorage(async (storage) => {
+        const opaqueIdsProjectId = `${projectId6}-opaque-link-ids`;
+        const firstSourceId = "opaque:source";
+        const firstTargetId = `target:peers:${Device.id}:opaque:end`;
+        const secondSourceId = `${firstSourceId}:peers:${Device.id}:target`;
+        const secondTargetId = "opaque:end";
+        const fixture = createMaterializerTestFixture({
+          projectId: opaqueIdsProjectId,
+          ontology,
+          storage
+        });
+        await fixture.seed({
+          objects: [
+            device(firstSourceId, "First source"),
+            device(firstTargetId, "First target"),
+            device(secondSourceId, "Second source"),
+            device(secondTargetId, "Second target")
+          ],
+          links: [peer(firstSourceId, firstTargetId), peer(secondSourceId, secondTargetId)]
+        });
+        const incident = await storage.objects.listIncidentLinksBatch({
+          projectId: opaqueIdsProjectId,
+          items: [
+            { objectTypeId: Device.id, objectId: firstSourceId },
+            { objectTypeId: Device.id, objectId: secondSourceId }
+          ]
+        });
+        const matching = incident.filter((row) => row.sourceId === firstSourceId || row.sourceId === secondSourceId);
+        expect8(matching.map((row) => [row.sourceId, row.linkId, row.targetId])).toEqual(expect8.arrayContaining([
+          [firstSourceId, "peers", firstTargetId],
+          [secondSourceId, "peers", secondTargetId]
+        ]));
+        expect8(matching).toHaveLength(2);
       });
     });
     test8("pages Materializer-owned objects with a stable cursor", async () => {
@@ -6045,6 +6252,50 @@ function runLakeStorageContractSuite(label, options) {
           expect11(await storage.getVersion(writeDataset.id, missingVersionId)).toBeNull();
         });
       });
+      test11("creates an initial empty snapshot version", async () => {
+        await withStorage(async (storage) => {
+          await storage.createDataset(writeDataset);
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "snapshot" });
+          const version = await write.commit();
+          expect11(version).toMatchObject({
+            datasetId: writeDataset.id,
+            mode: "snapshot",
+            outcome: "created",
+            rowCount: 0
+          });
+          expect11(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
+            versionId: version.versionId
+          });
+          expect11(await storage.listVersions(writeDataset.id)).toHaveLength(1);
+          const repeatedWrite = await storage.beginWrite({
+            dataset: writeDataset,
+            mode: "snapshot"
+          });
+          const repeatedVersion = await repeatedWrite.commit();
+          expect11(repeatedVersion.outcome).toBe("unchanged");
+          expect11(repeatedVersion.versionId).toBe(version.versionId);
+          expect11(await storage.listVersions(writeDataset.id)).toHaveLength(1);
+          await expect11(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([]);
+        });
+      });
+      test11("creates an initial empty append version", async () => {
+        await withStorage(async (storage) => {
+          await storage.createDataset(writeDataset);
+          const write = await storage.beginWrite({ dataset: writeDataset, mode: "append" });
+          const version = await write.commit();
+          expect11(version).toMatchObject({
+            datasetId: writeDataset.id,
+            mode: "append",
+            outcome: "created"
+          });
+          expect11(version.parentVersionId).toBeUndefined();
+          expect11(await storage.getLatestVersion(writeDataset.id)).toMatchObject({
+            versionId: version.versionId
+          });
+          expect11(await storage.listVersions(writeDataset.id)).toHaveLength(1);
+          await expect11(collectRows2(storage.readRows({ datasetId: writeDataset.id }))).resolves.toEqual([]);
+        });
+      });
       test11("snapshot writes replace the visible latest rows", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset);
@@ -7336,6 +7587,170 @@ function runObjectQueryProviderContractSuite(label, options) {
         expect14(result.hasMore).toBe(false);
       });
     });
+    test14("queries opaque ids through canonical exact refs", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        const issue297 = "github:issue:sixb-ai/sixb#297";
+        const issue298 = "github:issue:sixb-ai/sixb#298";
+        await fixture.seed({
+          objects: [
+            objectSeed(Asset.id, issue297, { id: issue297 }),
+            objectSeed(Asset.id, issue298, { id: issue298 })
+          ]
+        });
+        const refs = await executeObjectQuery({
+          projectId: projectId8,
+          query: {
+            kind: "refs",
+            refs: [
+              { objectTypeId: Asset.id, primaryId: issue298 },
+              { objectTypeId: Asset.id, primaryId: issue297 }
+            ]
+          }
+        }, { ontology: objectQueryContractOntology, storage });
+        expect14(refs.plan.mode).toBe(storage.queryCapabilities().nodes?.refs === true ? "pushdown" : "fallback");
+        expect14(ids(refs)).toEqual([issue297, issue298]);
+      });
+    });
+    test14("executes canonical heterogeneous refs with pagination and projection", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        await seedObjectQueryContractData(fixture);
+        const refs = [
+          { objectTypeId: Device3.id, primaryId: "device-sensor" },
+          { objectTypeId: Room.id, primaryId: "room-gamma" },
+          { objectTypeId: Room.id, primaryId: "missing" },
+          { objectTypeId: Room.id, primaryId: "room-alpha" }
+        ];
+        const first = await executeObjectQuery({
+          projectId: projectId8,
+          query: {
+            kind: "project",
+            properties: ["id"],
+            input: { kind: "page", pageSize: 2, input: { kind: "refs", refs } }
+          }
+        }, { ontology: objectQueryContractOntology, storage });
+        const second = await executeObjectQuery({
+          projectId: projectId8,
+          query: {
+            kind: "project",
+            properties: ["id"],
+            input: {
+              kind: "page",
+              pageSize: 2,
+              pageToken: first.nextPageToken,
+              input: { kind: "refs", refs }
+            }
+          }
+        }, { ontology: objectQueryContractOntology, storage });
+        const count = await countObjects({ projectId: projectId8, query: { kind: "refs", refs } }, { ontology: objectQueryContractOntology, storage });
+        const expectedMode = storage.queryCapabilities().nodes?.refs === true ? "pushdown" : "fallback";
+        expect14(first.plan.mode).toBe(expectedMode);
+        expect14(ids(first)).toEqual(["device-sensor", "room-alpha"]);
+        expect14(first.objects.map((row) => row.properties)).toEqual([
+          { id: "device-sensor" },
+          { id: "room-alpha" }
+        ]);
+        expect14(first.total).toBe(3);
+        expect14(first.hasMore).toBe(true);
+        expect14(first.nextPageToken).toBeTruthy();
+        expect14(second.plan.mode).toBe(expectedMode);
+        expect14(ids(second)).toEqual(["room-gamma"]);
+        expect14(second.hasMore).toBe(false);
+        expect14(count.plan.mode).toBe(expectedMode);
+        expect14(count.count).toBe(3);
+      });
+    });
+    test14("composes refs with traversal in provider pushdown", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        if (storage.queryCapabilities().nodes?.refs !== true)
+          return;
+        await seedObjectQueryContractData(fixture);
+        const result = await executeObjectQuery({
+          projectId: projectId8,
+          query: {
+            kind: "traverse",
+            direction: "outgoing",
+            linkId: "hasDevice",
+            input: {
+              kind: "refs",
+              refs: [{ objectTypeId: Room.id, primaryId: "room-alpha" }]
+            }
+          }
+        }, { ontology: objectQueryContractOntology, storage });
+        expect14(result.plan.mode).toBe("pushdown");
+        expect14(ids(result)).toEqual(["device-projector"]);
+      });
+    });
+    test14("queries and paginates incident links over a provider-backed object set", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        await seedObjectQueryContractData(fixture);
+        const query = {
+          kind: "refs",
+          refs: [{ objectTypeId: Device3.id, primaryId: "device-projector" }]
+        };
+        const first = await executeObjectQueryLinks({
+          projectId: projectId8,
+          query,
+          direction: "incoming",
+          includeObjects: true,
+          pageSize: 1
+        }, { ontology: objectQueryContractOntology, storage });
+        const second = await executeObjectQueryLinks({
+          projectId: projectId8,
+          query,
+          direction: "incoming",
+          includeObjects: true,
+          pageSize: 1,
+          pageToken: first.nextPageToken
+        }, { ontology: objectQueryContractOntology, storage });
+        expect14(first.links).toEqual([
+          expect14.objectContaining({
+            sourceTypeId: Room.id,
+            sourceId: "room-alpha",
+            linkId: "hasDevice",
+            targetTypeId: Device3.id,
+            targetId: "device-projector"
+          })
+        ]);
+        expect14(first.objects.map((row) => row.primaryId)).toEqual([
+          "device-projector",
+          "room-alpha"
+        ]);
+        expect14(first.hasMore).toBe(true);
+        expect14(first.nextPageToken).toBeTruthy();
+        expect14(second.links).toEqual([
+          expect14.objectContaining({
+            sourceTypeId: Zone.id,
+            sourceId: "zone-one",
+            linkId: "hasDevice",
+            targetTypeId: Device3.id,
+            targetId: "device-projector"
+          })
+        ]);
+        expect14(second.objects.map((row) => row.primaryId)).toEqual(["device-projector", "zone-one"]);
+        expect14(second.hasMore).toBe(false);
+      });
+    });
+    test14("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({
+          projectId: projectId8,
+          query: {
+            kind: "page",
+            pageSize: 1,
+            input: {
+              kind: "sort",
+              fields: [{ kind: "property", propertyId: "id", direction: "asc" }],
+              input: { kind: "start", objectTypeId: Room.id }
+            }
+          },
+          direction: "outgoing"
+        }, { ontology: objectQueryContractOntology, storage });
+        expect14(result.links).toEqual([
+          expect14.objectContaining({ sourceId: "room-alpha", targetId: "device-projector" })
+        ]);
+      });
+    });
     test14("matches null, missing, neq, in, and not predicate semantics", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture);
@@ -10413,4 +10828,4 @@ export {
   claimTestProjectionRun
 };
 
-//# debugId=DFF2C1EA53F70F2164756E2164756E21
+//# debugId=18CDE018B0AEEC3264756E2164756E21