@sixb/core 0.1.7 → 0.1.9

package/src/testing/dataset-sequence-contract.ts

@@ -0,0 +1,373 @@
+import { describe, expect, test } from "bun:test"
+import { InMemoryBlobStorage } from "../blob-storage"
+import { InMemoryBroker } from "../broker"
+import { change, col, type DatasetDefinition, defineDataset, type MergeChange } from "../datasets"
+import { writeDataset } from "../datasets/write"
+import type { DatasetMergeCommitResult, DatasetRow, LakeStorage } from "../lake-storage"
+import { InMemoryQueues } from "../queues"
+import { SixbHost } from "../runtime/host"
+import { InMemoryStorage } from "../storage"
+import { createTestSixb } from "./execution"
+import type { LakeMergeStorageContractSuiteOptions } from "./lake-merge-storage-contract"
+
+const dataset = defineDataset("contract.source_order", {
+  schema: [
+    col("id", "string"),
+    col("revision", "int64"),
+    col("name", "string"),
+    col("details", "json", { nullable: true }),
+  ],
+  primaryKey: "id",
+  sequenceBy: "revision",
+})
+const upsert = (revision: string | number, name = "Sam", id = "42") =>
+  change.upsert({ id, revision, name })
+
+async function merge(
+  storage: LakeStorage,
+  changes: readonly MergeChange<DatasetRow, DatasetRow>[],
+  definition: DatasetDefinition = dataset
+) {
+  const session = await storage.beginMerge({ dataset: definition })
+  try {
+    await session.writeChanges(changes)
+    return await session.commit()
+  } catch (error) {
+    await session.abort()
+    throw error
+  }
+}
+
+async function rows(storage: LakeStorage, definition: DatasetDefinition = dataset) {
+  const result: DatasetRow[] = []
+  for await (const row of storage.readRows({ datasetId: definition.id })) result.push(row)
+  return result
+}
+
+export function runDatasetSequenceContract<TStorage extends LakeStorage>(
+  options: LakeMergeStorageContractSuiteOptions<TStorage>
+): void {
+  const withStorage = async (run: (storage: TStorage) => Promise<void>) => {
+    const storage = await options.createStorage()
+    try {
+      await storage.createDataset(dataset)
+      await run(storage)
+    } finally {
+      await options.teardown?.(storage)
+    }
+  }
+
+  describe("source ordering", () => {
+    test("initializes empty snapshots and preserves versions across retries and reopen", async () => {
+      // Regression proof: remove createInitialVersion from the writer or provider; the first
+      // snapshot has no version. Ignore the rebased head and the concurrent-write assertion fails.
+      let storage = await options.createStorage()
+      const snapshot = () =>
+        writeDataset({
+          lakeStorage: storage,
+          blobStorage: new InMemoryBlobStorage(),
+          dataset,
+          mode: "snapshot",
+          signal: new AbortController().signal,
+          readValues: async () => [],
+        })
+      try {
+        await storage.createDataset(dataset)
+        expect(await merge(storage, [])).toEqual({ outcome: "unchanged", version: null })
+        const initialized = await Promise.all([snapshot(), snapshot()])
+        expect(initialized.map((result) => result.outcome).sort()).toEqual(["created", "unchanged"])
+        const initial = initialized.find((result) => result.outcome === "created")!
+        expect(initialized[0]?.version).toEqual(initialized[1]?.version)
+        expect(initial).toMatchObject({
+          outcome: "created",
+          version: { rowCount: 0, mode: "merge" },
+        })
+        expect(await rows(storage)).toEqual([])
+        if (options.reopen) storage = await options.reopen(storage)
+        expect(await storage.getLatestVersion(dataset.id)).toEqual(initial.version)
+        expect(await snapshot()).toMatchObject({ outcome: "unchanged", version: initial.version })
+
+        const concurrent = defineDataset("contract.empty_race", {
+          schema: dataset.schema.columns,
+          primaryKey: "id",
+          sequenceBy: "revision",
+        })
+        let committed: DatasetMergeCommitResult | undefined
+        const rebased = await writeDataset({
+          lakeStorage: storage,
+          blobStorage: new InMemoryBlobStorage(),
+          dataset: concurrent,
+          mode: "snapshot",
+          signal: new AbortController().signal,
+          readValues: async () => {
+            committed = await merge(storage, [upsert(8)], concurrent)
+            return []
+          },
+        })
+        expect(rebased).toMatchObject({ outcome: "unchanged", version: committed?.version })
+        expect(await rows(storage, concurrent)).toHaveLength(1)
+      } finally {
+        await options.teardown?.(storage)
+      }
+    })
+
+    test("rejects lossy timestamps outside the ordering column before changing source state", () =>
+      withStorage(async (storage) => {
+        // Regression proof: remove the sequenced timestamp check in getColumnValidationError;
+        // submillisecond content is accepted and its distinct values collapse to one digest.
+        const timestamps = defineDataset("contract.content_timestamps", {
+          schema: [...dataset.schema.columns, col("at", "timestamp", { nullable: true })],
+          primaryKey: "id",
+          sequenceBy: "revision",
+        })
+        await storage.createDataset(timestamps)
+        const row = (at: unknown, id = "42") => change.upsert({ id, revision: 1, name: "Sam", at })
+        const initial = await merge(storage, [row("2026-09-09T10:00:00.123Z")], timestamps)
+        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 expect(merge(storage, [row(at, "new")], timestamps)).rejects.toThrow("column 'at'")
+          expect(await storage.getLatestVersion(timestamps.id)).toEqual(initial.version)
+        }
+        for (const at of ["2026-09-09T12:00:00.123+02:00", new Date("2026-09-09T10:00:00.123Z")]) {
+          expect((await merge(storage, [row(at)], timestamps)).outcome).toBe("unchanged")
+        }
+        await expect(merge(storage, [row("2026-09-09T10:00:00.124Z")], timestamps)).rejects.toThrow(
+          "conflicting content"
+        )
+        await merge(storage, [row(null, "nullable")], timestamps)
+        expect((await merge(storage, [row(undefined, "nullable")], timestamps)).outcome).toBe(
+          "unchanged"
+        )
+      }))
+
+    test("ingests through the bound SDK and preserves execution provenance", async () => {
+      // Regression proof: remove ingest from DuckLake's producer parser; reopen loses provenance.
+      let storage = await options.createStorage()
+      const broker = new InMemoryBroker()
+      try {
+        const host = new SixbHost({
+          id: "ingest-contract",
+          ontology: [],
+          datasets: [dataset],
+          lakeStorage: storage,
+          broker,
+          storage: new InMemoryStorage(),
+          queues: new InMemoryQueues(),
+          blobStorage: new InMemoryBlobStorage(),
+        })
+        const sixb = createTestSixb(host)
+        const result = await sixb.datasets.ingest(dataset, { changes: [upsert(8)] })
+        expect(result.outcome).toBe("created")
+        if (options.reopen) storage = await options.reopen(storage)
+        expect((await storage.getLatestVersion(dataset.id))?.producer).toEqual({
+          kind: "ingest",
+          id: sixb.execution.id,
+        })
+        expect((await rows(storage)).map((row) => row.name)).toEqual(["Sam"])
+        expect(await host.events.read()).toMatchObject([
+          { type: "dataset.version.committed", payload: { versionId: result.version?.versionId } },
+        ])
+      } finally {
+        await options.teardown?.(storage)
+      }
+    })
+    test("rebases retained changes while preserving explicit version guards", () =>
+      withStorage(async (storage) => {
+        // Regression proof: disable retryOnConflict in retryDatasetMergeCommit; the second commit fails.
+        const first = await storage.beginMerge({ dataset })
+        const second = await storage.beginMerge({ dataset })
+        await first.writeChanges([upsert(8)])
+        await second.writeChanges([upsert(7, "stale"), upsert(1, "other", "other")])
+        const initial = await first.commit({ retryOnConflict: true })
+        await second.commit({ retryOnConflict: true })
+        expect((await rows(storage)).map((row) => row.name).sort()).toEqual(["Sam", "other"])
+        const guarded = await storage.beginMerge({
+          dataset,
+          expectedLatestVersionId: (await storage.getLatestVersion(dataset.id))?.versionId,
+        })
+        await guarded.writeChanges([upsert(10)])
+        await merge(storage, [change.delete({ id: "42" }, { sequence: 9 })])
+        await expect(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 merge(storage, [upsert(10)])
+        expect((await staleDelete.commit({ retryOnConflict: true })).outcome).toBe("unchanged")
+        expect((await storage.getLatestVersion(dataset.id))?.versionId).not.toBe(
+          initial.version?.versionId
+        )
+      }))
+    // Regression proof: bypass reconcileDatasetSequences at the provider commit boundary.
+    // The stale-write, conflict, and deletion assertions below must then fail.
+    test("orders repeated keys exactly and conflicts atomically", () =>
+      withStorage(async (storage) => {
+        const first = await merge(storage, [upsert("9007199254740993")])
+        expect((await merge(storage, [upsert("9007199254740992", "stale")])).outcome).toBe(
+          "unchanged"
+        )
+        expect((await merge(storage, [upsert("09007199254740993")])).outcome).toBe("unchanged")
+        await expect(
+          merge(storage, [upsert("1", "other", "other"), upsert("9007199254740993", "conflict")])
+        ).rejects.toThrow("conflicting content")
+        expect((await storage.getLatestVersion(dataset.id))?.versionId).toBe(
+          first.version?.versionId
+        )
+        expect(await rows(storage)).toHaveLength(1)
+        await merge(storage, [
+          upsert("9007199254740995", "newest"),
+          upsert("9007199254740994", "stale"),
+        ])
+        expect((await rows(storage))[0]?.name).toBe("newest")
+        await expect(
+          merge(storage, [upsert("9007199254740996", "a"), upsert("9007199254740996", "b")])
+        ).rejects.toThrow("conflicting content")
+        expect((await rows(storage))[0]?.name).toBe("newest")
+      }))
+
+    test("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 })])
+        expect(deleted).toMatchObject({ outcome: "created", version: { rowCount: 0 } })
+        await expect(staleSession.commit()).rejects.toThrow("Optimistic")
+        await staleSession.abort()
+        expect((await merge(storage, [upsert(8)])).outcome).toBe("unchanged")
+        expect(
+          (await merge(storage, [change.delete({ id: "42" }, { sequence: "9" })])).outcome
+        ).toBe("unchanged")
+        await expect(merge(storage, [upsert(9)])).rejects.toThrow("conflicting content")
+        await merge(storage, [upsert(10)])
+        expect(await rows(storage)).toHaveLength(1)
+        expect((await merge(storage, [change.delete({ id: "42" }, { sequence: 9 })])).outcome).toBe(
+          "unchanged"
+        )
+        await merge(storage, [change.delete({ id: "42" }, { sequence: 11 })])
+        expect(await rows(storage)).toEqual([])
+      }))
+
+    test("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 } }),
+        ])
+        expect(
+          (
+            await merge(storage, [
+              change.upsert({ id: "42", revision: "01", name: "Sam", details: { b: 2, a: 1 } }),
+            ])
+          ).outcome
+        ).toBe("unchanged")
+        await merge(storage, [upsert(2)])
+        expect(
+          (
+            await merge(storage, [
+              change.upsert({ id: "42", revision: "2", name: "Sam", details: null }),
+            ])
+          ).outcome
+        ).toBe("unchanged")
+      }))
+
+    test("validates integer ranges and delete sequences at the provider boundary", () =>
+      withStorage(async (storage) => {
+        for (const revision of [
+          null,
+          undefined,
+          1.5,
+          Number.MAX_SAFE_INTEGER + 1,
+          "9223372036854775808",
+          "-9223372036854775809",
+          "1e3",
+        ]) {
+          await expect(
+            merge(storage, [change.upsert({ id: "42", revision, name: "Sam" })])
+          ).rejects.toThrow("sequence")
+        }
+        await expect(merge(storage, [change.delete({ id: "42" })])).rejects.toThrow("sequence")
+        await merge(storage, [upsert("-9223372036854775808"), upsert("9223372036854775807")])
+        expect((await rows(storage))[0]?.revision?.toString()).toBe("9223372036854775807")
+      }))
+
+    test("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")],
+          primaryKey: "id",
+          sequenceBy: "updated",
+        })
+        await storage.createDataset(timestamps)
+        const row = (updated: unknown, name = "Sam") => change.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",
+          new Date("2026-09-09T10:00:00.123Z"),
+        ]) {
+          expect((await merge(storage, [row(updated)], timestamps)).outcome).toBe("unchanged")
+        }
+        for (const updated of [
+          "2026-09-09T10:00:00.1234Z",
+          "2026-09-09T10:00:00",
+          "2026-02-30T00:00:00Z",
+          new Date(Number.NaN),
+        ]) {
+          await expect(merge(storage, [row(updated)], timestamps)).rejects.toThrow("sequence")
+        }
+        await merge(
+          storage,
+          [change.delete({ id: "42" }, { sequence: "2026-09-09T10:00:00.124Z" })],
+          timestamps
+        )
+        expect((await merge(storage, [row("2026-09-09T10:00:00.123Z")], timestamps)).outcome).toBe(
+          "unchanged"
+        )
+      }))
+
+    test("round-trips immutable sequencing and rejects writes that bypass ordering", () =>
+      withStorage(async (storage) => {
+        expect((await storage.getDataset(dataset.id))?.sequenceBy).toBe("revision")
+        expect(
+          (await storage.listDatasets()).find((item) => item.id === dataset.id)?.sequenceBy
+        ).toBe("revision")
+        const { sequenceBy: _, ...unsequenced } = dataset
+        await expect(storage.createDataset(unsequenced)).rejects.toThrow("immutable")
+        await storage.createDataset({ ...unsequenced, id: "legacy" })
+        await expect(storage.createDataset({ ...dataset, id: "legacy" })).rejects.toThrow(
+          "immutable"
+        )
+        await expect(
+          storage.createDataset({ ...dataset, id: "invalid", primaryKey: undefined })
+        ).rejects.toThrow("sequenceBy")
+        await expect(
+          storage.createDataset({ ...dataset, id: "invalid", sequenceBy: "name" })
+        ).rejects.toThrow("sequenceBy")
+        await expect(storage.beginWrite({ dataset })).rejects.toThrow("beginMerge")
+      }))
+
+    const reopen = options.reopen
+    if (reopen)
+      test("preserves source state after reopen", async () => {
+        let storage = await options.createStorage()
+        try {
+          await storage.createDataset(dataset)
+          await merge(storage, [
+            upsert(8, "visible", "visible"),
+            change.delete({ id: "42" }, { sequence: 9 }),
+          ])
+          storage = await reopen(storage)
+          expect((await storage.getDataset(dataset.id))?.sequenceBy).toBe("revision")
+          expect((await merge(storage, [upsert(8), upsert(7, "stale", "visible")])).outcome).toBe(
+            "unchanged"
+          )
+          expect(await rows(storage)).toHaveLength(1)
+          await merge(storage, [upsert(10)])
+          expect(await rows(storage)).toHaveLength(2)
+        } finally {
+          await options.teardown?.(storage)
+        }
+      })
+  })
+}

package/src/testing/effective-storage-contract.ts

@@ -75,6 +75,17 @@ export function runEffectiveStorageContractSuite<TStorage extends Storage>(
           ],
         })
         expect([...batch.keys()]).toEqual([objectBatchKey(Device.id, "a")])
+
+        const selectedProperties = await storage.objects.selectsObjectProperties({
+          projectId,
+          items: [
+            { objectTypeId: Device.id, primaryId: "a", propertyId: "name" },
+            { objectTypeId: Device.id, primaryId: "a", propertyId: "not-materialized" },
+            { objectTypeId: Device.id, primaryId: "missing", propertyId: "name" },
+            { objectTypeId: Device.id, primaryId: "a", propertyId: "name" },
+          ],
+        })
+        expect(selectedProperties).toEqual([true, true, false, true])
       })
     })
 
@@ -100,6 +111,28 @@ export function runEffectiveStorageContractSuite<TStorage extends Storage>(
           items: [{ objectTypeId: Device.id, objectId: "a", linkId: "peers" }],
         })
         expect(linksByScope.get(linkBatchKey(Device.id, "a", "peers"))).toHaveLength(2)
+
+        const incomingByScope = await storage.objects.listLinksBatch({
+          projectId,
+          direction: "incoming",
+          items: [{ objectTypeId: Device.id, objectId: "b", linkId: "peers" }],
+        })
+        expect(incomingByScope.get(linkBatchKey(Device.id, "b", "peers"))).toMatchObject([
+          { sourceId: "a", targetId: "b" },
+        ])
+
+        const bothDirectionsByScope = await storage.objects.listLinksBatch({
+          projectId,
+          direction: "both",
+          items: [
+            { objectTypeId: Device.id, objectId: "a", linkId: "peers" },
+            { objectTypeId: Device.id, objectId: "b", linkId: "peers" },
+          ],
+        })
+        expect(bothDirectionsByScope.get(linkBatchKey(Device.id, "a", "peers"))).toHaveLength(2)
+        expect(bothDirectionsByScope.get(linkBatchKey(Device.id, "b", "peers"))).toMatchObject([
+          { sourceId: "a", targetId: "b" },
+        ])
       })
     })
 
@@ -222,6 +255,7 @@ export function runEffectiveStorageContractSuite<TStorage extends Storage>(
 
         const links = await storage.objects.listLinksBatch({
           projectId: opaqueProjectId,
+          direction: "both",
           items: [
             { objectTypeId: OpaqueA.id, objectId: "B:C", linkId: "D" },
             { objectTypeId: OpaqueAB.id, objectId: "C", linkId: "D" },

package/src/testing/execution-storage-contract.ts

@@ -5,11 +5,15 @@ import type {
   ExecutionStorage,
   TrustedPrimitiveKind,
 } from "../storage/executions"
+import type { ShareGrantStorage } from "../storage/share-grants"
+import type { ShareSessionStorage } from "../storage/share-sessions"
 import type { Storage } from "../storage/types"
 
 export type ExecutionStorageContractStorage = Storage & {
   readonly auth: AuthStorage
   readonly executions: ExecutionStorage
+  readonly shareGrants: ShareGrantStorage
+  readonly shareSessions: ShareSessionStorage
 }
 
 export interface ExecutionStorageContractSuiteOptions<
@@ -39,9 +43,60 @@ export function runExecutionStorageContractSuite<TStorage extends ExecutionStora
   }
 
   describe(label, () => {
+    test("captures memberships once and inherits them independently of current authority", async () => {
+      // Removal proof: skip prepareExecutionRecord's membership capture or parent inheritance.
+      await withStorage(async (storage) => {
+        await seedAuth(storage.auth)
+        for (const groupId of ["support", "finance"]) {
+          await storage.auth.groupMemberships.upsert({
+            projectId,
+            userId: "user-one",
+            groupId,
+            source: "manual",
+          })
+        }
+        const parent = await storage.executions.create({
+          ...principalRequest({ id: "parent" }),
+          requesterGroupIds: undefined,
+        })
+        expect(parent.requesterGroupIds).toEqual(["finance", "support"])
+        await storage.auth.groupMemberships.remove({
+          projectId,
+          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,
+        })
+        expect(child.requesterGroupIds).toEqual(["finance", "support"])
+        ;(child.requesterGroupIds as string[]).push("mutated")
+        await expect(
+          storage.executions.getById({ projectId, id: child.id })
+        ).resolves.toMatchObject({ requesterGroupIds: ["finance", "support"] })
+        await expect(
+          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,
+        })
+        expect(next.requesterGroupIds).toEqual(["support"])
+      })
+    })
+
     test("round-trips every durable executor and authority shape", async () => {
       await withStorage(async (storage) => {
         await seedAuth(storage.auth)
+        await seedSharedSession(storage)
 
         const records = [
           principalRequest({
@@ -54,6 +109,7 @@ export function runExecutionStorageContractSuite<TStorage extends ExecutionStora
             credential: { type: "accessToken", id: "token-service" },
           }),
           disabledRequest("disabled-request"),
+          delegatedRequest("delegated-request"),
           ...trustedPrimitiveKinds.map((kind) => trustedPrimitive(`${kind}-execution`, {}, kind)),
           agentExecution("agent-execution"),
           kernelExecution("kernel-execution"),
@@ -63,7 +119,10 @@ export function runExecutionStorageContractSuite<TStorage extends ExecutionStora
           const creationStartedAt = new Date()
           const created = await storage.executions.create(input)
           const { createdAt: persistedAt, ...persistedInput } = created
-          expect(persistedInput).toEqual(input)
+          expect(persistedInput).toEqual({
+            ...input,
+            requesterGroupIds: input.requesterGroupIds ?? [],
+          })
           expect(Number.isFinite(persistedAt.getTime())).toBe(true)
           expect(persistedAt.getTime()).toBeGreaterThanOrEqual(creationStartedAt.getTime())
           expect(
@@ -169,6 +228,7 @@ export function runExecutionStorageContractSuite<TStorage extends ExecutionStora
     test("requires every principal and verifies credential ownership", async () => {
       await withStorage(async (storage) => {
         await seedAuth(storage.auth)
+        await seedSharedSession(storage)
 
         await expect(
           storage.executions.create(
@@ -179,6 +239,34 @@ export function runExecutionStorageContractSuite<TStorage extends ExecutionStora
           )
         ).rejects.toMatchObject({ code: "missing_principal" })
 
+        await expect(
+          storage.executions.create({
+            ...delegatedRequest("missing-shared-session"),
+            authorizationRef: {
+              type: "delegated",
+              delegation: {
+                kind: "share",
+                grantId: "grant-one",
+                sessionId: "missing-shared-session",
+              },
+            },
+          })
+        ).rejects.toMatchObject({ code: "missing_credential" })
+
+        await expect(
+          storage.executions.create({
+            ...delegatedRequest("wrong-shared-grant"),
+            authorizationRef: {
+              type: "delegated",
+              delegation: {
+                kind: "share",
+                grantId: "grant-two",
+                sessionId: "share-session-one",
+              },
+            },
+          })
+        ).rejects.toMatchObject({ code: "invalid_credential" })
+
         await expect(
           storage.executions.create(
             principalRequest({
@@ -322,6 +410,32 @@ async function seedAuth(auth: AuthStorage): Promise<void> {
   })
 }
 
+async function seedSharedSession(storage: ExecutionStorageContractStorage): Promise<void> {
+  for (const id of ["grant-one", "grant-two"] as const) {
+    await storage.shareGrants.create({
+      id,
+      projectId,
+      definitionId: "contract-share",
+      target: { objectTypeId: "ContractObject", primaryId: id },
+      issuedBy: { type: "user", id: "user-one" },
+      authoritySnapshot: { version: 1, access: { grants: [] } },
+      tokenHash: id === "grant-one" ? "a".repeat(64) : "b".repeat(64),
+      destinationPath: `/contract/${id}`,
+      createdAt,
+      expiresAt,
+    })
+  }
+  await storage.shareSessions.create({
+    id: "share-session-one",
+    projectId,
+    grantId: "grant-one",
+    tokenHash: "c".repeat(64),
+    createdAt,
+    expiresAt,
+    absoluteExpiresAt: expiresAt,
+  })
+}
+
 function principalRequest(input: {
   readonly id: string
   readonly principal?: { readonly type: "user" | "serviceAccount"; readonly id: string }
@@ -334,6 +448,7 @@ function principalRequest(input: {
     id: input.id,
     projectId,
     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}`,
@@ -349,6 +464,7 @@ function disabledRequest(id: string, inputProjectId = projectId): CreateExecutio
   return {
     id,
     projectId: inputProjectId,
+    requesterGroupIds: [],
     executor: { type: "request", requestId: `request-${id}` },
     source: { type: "http", requestId: `request-${id}` },
     correlationId: `correlation-${id}`,
@@ -356,6 +472,24 @@ function disabledRequest(id: string, inputProjectId = projectId): CreateExecutio
   }
 }
 
+function delegatedRequest(id: string): CreateExecutionInput {
+  return {
+    id,
+    projectId,
+    executor: { type: "request", requestId: `request-${id}` },
+    source: { type: "http", requestId: `request-${id}` },
+    correlationId: `correlation-${id}`,
+    authorizationRef: {
+      type: "delegated",
+      delegation: {
+        kind: "share",
+        grantId: "grant-one",
+        sessionId: "share-session-one",
+      },
+    },
+  }
+}
+
 function trustedPrimitive(
   id: string,
   overrides: Partial<Pick<CreateExecutionInput, "correlationId" | "requestedBy" | "source">> = {},
@@ -366,6 +500,7 @@ function trustedPrimitive(
     id,
     projectId,
     requestedBy: { type: "user", id: "user-one" },
+    requesterGroupIds: [],
     executor: { type: "primitive", kind, runId },
     source: trustedPrimitiveSource(kind, id),
     correlationId: `correlation-${id}`,
@@ -412,6 +547,7 @@ function agentExecution(id: string): CreateExecutionInput {
     id,
     projectId,
     requestedBy: { type: "user", id: "user-one" },
+    requesterGroupIds: [],
     executor: { type: "agent", runId: `run-${id}` },
     source: { type: "execution", executionId: "principal-request" },
     correlationId: "correlation-principal-request",
@@ -428,6 +564,7 @@ function kernelExecution(id: string): CreateExecutionInput {
     id,
     projectId,
     executor: { type: "kernel", operation },
+    requesterGroupIds: [],
     source: { type: "event", eventId: `event-${id}` },
     correlationId: `correlation-${id}`,
     authorizationRef: { type: "kernel", operation },

package/src/testing/execution.ts

@@ -1,6 +1,7 @@
 import type { AuthorizationContext } from "../authorization"
 import { createTestingScope } from "../execution/scopes"
 import type { ExecutionScope } from "../execution/types"
+import { bindModelExecutionAttempt } from "../models/execution/binding"
 import type { OntologySource } from "../ontology"
 import { SixbHost, type SixbHostOptions } from "../runtime/host"
 import { isBoundSixb, type Sixb } from "../runtime/sixb"
@@ -8,6 +9,7 @@ import { isBoundSixb, type Sixb } from "../runtime/sixb"
 export type { AuthorizationContext } from "../authorization"
 
 export interface TestExecutionOptions {
+  readonly signal?: AbortSignal
   readonly authorization?: AuthorizationContext
   readonly executionId?: string
   readonly requestId?: string
@@ -44,5 +46,9 @@ export function createTestSixb<
   if (!isBoundSixb<TOntologySources>(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
 }