@sixb/core 0.1.7 → 0.1.8

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<
@@ -42,6 +46,7 @@ export function runExecutionStorageContractSuite<TStorage extends ExecutionStora
     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 +59,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"),
@@ -169,6 +175,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 +186,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 +357,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 }
@@ -356,6 +417,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">> = {},

package/src/testing/index.ts

@@ -90,6 +90,12 @@ export {
   runObjectQueryProviderContractSuite,
   seedObjectQueryContractData,
 } from "./object-query-contract"
+export {
+  type ObjectReadScopeContractHarness,
+  type ObjectReadScopeContractSuiteOptions,
+  objectReadScopeContractOntology,
+  runObjectReadScopeContractSuite,
+} from "./object-read-scope-contract"
 export {
   type OntologyStorageContractStorage,
   type OntologyStorageContractSuiteOptions,
@@ -119,6 +125,16 @@ export {
   type SandboxesContractCapabilities,
   type SandboxesContractSuiteOptions,
 } from "./sandboxes-contract"
+export {
+  createShareGrantStorageContractInput,
+  runShareGrantStorageContractSuite,
+  type ShareGrantStorageContractSuiteOptions,
+} from "./share-grant-storage-contract"
+export {
+  createShareSessionStorageContractInput,
+  runShareSessionStorageContractSuite,
+  type ShareSessionStorageContractSuiteOptions,
+} from "./share-session-storage-contract"
 export {
   createTestSyncExecution,
   queueTestSyncRun,

package/src/testing/lake-merge-storage-contract.ts

@@ -1,10 +1,12 @@
 import { describe, expect, test } from "bun:test"
 import { change, col, defineDataset } from "../datasets"
 import type { DatasetMergeCommitResult, DatasetRow, LakeStorage } from "../lake-storage"
+import { runDatasetSequenceContract } from "./dataset-sequence-contract"
 
 export interface LakeMergeStorageContractSuiteOptions<TStorage extends LakeStorage = LakeStorage> {
   readonly createStorage: () => TStorage | Promise<TStorage>
   readonly teardown?: (storage: TStorage) => void | Promise<void>
+  readonly reopen?: (storage: TStorage) => TStorage | Promise<TStorage>
 }
 
 const invoices = defineDataset("contract.merges.invoices", {
@@ -35,6 +37,7 @@ export function runLakeMergeStorageContractSuite<TStorage extends LakeStorage>(
   }
 
   describe(label, () => {
+    runDatasetSequenceContract(options)
     test("creates an initial merge version from async changes", async () => {
       await withStorage(async (storage) => {
         await storage.createDataset(invoices)

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

@@ -471,6 +471,64 @@ export function runLakeStorageContractSuite<TStorage extends LakeStorage>(
         })
       })
 
+      test("guards initial and existing versions before accepting even an unchanged write", () =>
+        withStorage(async (storage) => {
+          // Regression proof: treat null like undefined or move the version guard after no-op
+          // detection. An old writer then succeeds after a competing version has committed.
+          await storage.createDataset(writeDataset)
+          const first = await storage.beginWrite({ dataset: writeDataset })
+          const stale = await storage.beginWrite({ dataset: writeDataset })
+          const initial = await first.commit({ expectedLatestVersionId: null })
+          await expect(stale.commit({ expectedLatestVersionId: null })).rejects.toThrow(
+            "Optimistic"
+          )
+          await stale.abort()
+          const replacement = await storage.beginWrite({ dataset: writeDataset })
+          await replacement.writeRows([{ orderId: "ord_1", customerName: "Ada" }])
+          const next = await replacement.commit({ expectedLatestVersionId: initial.versionId })
+          const identical = await storage.beginWrite({ dataset: writeDataset })
+          await identical.writeRows([{ orderId: "ord_1", customerName: "Ada" }])
+          await expect(
+            identical.commit({ expectedLatestVersionId: initial.versionId })
+          ).rejects.toThrow("Optimistic")
+          await identical.abort()
+          expect((await storage.getLatestVersion(writeDataset.id))?.versionId).toBe(next.versionId)
+        }))
+
+      test("versions changed input lineage even when output rows are identical", () =>
+        withStorage(async (storage) => {
+          // Regression proof: omit hasDatasetInputChanges in the provider's no-op branch.
+          // The updated input reference is lost and the stale writer is no longer fenced.
+          await storage.createDataset(writeDataset)
+          await storage.createDataset(definitionDataset)
+          const sourceWrite = await storage.beginWrite({ dataset: definitionDataset })
+          const source1 = await sourceWrite.commit()
+          const rows = [{ orderId: "ord_1", customerName: "Ada" }]
+          const ref1 = { datasetId: definitionDataset.id, versionId: source1.versionId }
+          const first = await storage.beginWrite({ dataset: writeDataset, inputs: [ref1] })
+          await first.writeRows(rows)
+          const initial = await first.commit({ expectedLatestVersionId: null })
+          const stale = await storage.beginWrite({ dataset: writeDataset, inputs: [ref1] })
+          await stale.writeRows([{ orderId: "ord_1", customerName: "Stale" }])
+          const sourceUpdate = await storage.beginWrite({ dataset: definitionDataset })
+          await sourceUpdate.writeRows([{ orderId: "source", customerName: "Changed" }])
+          const source2 = await sourceUpdate.commit()
+          const ref2 = { datasetId: definitionDataset.id, versionId: source2.versionId }
+          const update = await storage.beginWrite({ dataset: writeDataset, inputs: [ref2] })
+          await update.writeRows(rows)
+          const newer = await update.commit({ expectedLatestVersionId: initial.versionId })
+          expect(newer).toMatchObject({ outcome: "created", inputs: [ref2] })
+          await expect(
+            stale.commit({ expectedLatestVersionId: initial.versionId })
+          ).rejects.toThrow("Optimistic")
+          await stale.abort()
+          const same = await storage.beginWrite({ dataset: writeDataset, inputs: [ref2] })
+          await same.writeRows(rows)
+          const unchanged = await same.commit({ expectedLatestVersionId: newer.versionId })
+          expect(unchanged).toMatchObject({ outcome: "unchanged", versionId: newer.versionId })
+          expect(await collectRows(storage.readRows({ datasetId: writeDataset.id }))).toEqual(rows)
+        }))
+
       test("creates an initial empty append version", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(writeDataset)