@sixb/core 0.1.0 → 0.1.1

package/src/syncs/validation.ts

@@ -0,0 +1,77 @@
+import type { DatasetDefinition } from "../datasets"
+import type { PipelineDefinition } from "../pipelines"
+import type { TelemetryProjectionDefinition } from "../projections"
+import { SyncValidationError } from "./errors"
+import type { SyncDefinition } from "./types"
+
+interface DatasetWriter {
+  readonly datasetId: string
+  readonly label: string
+}
+
+export function validateKeyedDatasetWriterTopology(input: {
+  readonly datasetsById: ReadonlyMap<string, DatasetDefinition>
+  readonly syncs: readonly SyncDefinition[]
+  readonly pipelines: readonly PipelineDefinition[]
+}): void {
+  for (const sync of input.syncs) {
+    const dataset = input.datasetsById.get(sync.target.dataset.id)
+    if (sync.config.mode === "merge" && dataset?.primaryKey === undefined) {
+      throw new SyncValidationError(
+        `[Sixb] Merge sync '${sync.id}' targets dataset '${sync.target.dataset.id}', which must define a primaryKey.`
+      )
+    }
+  }
+
+  const firstWriterByDataset = new Map<string, DatasetWriter>()
+  for (const writer of datasetWriters(input.syncs, input.pipelines)) {
+    const dataset = input.datasetsById.get(writer.datasetId)
+    if (dataset?.primaryKey === undefined) continue
+
+    const first = firstWriterByDataset.get(writer.datasetId)
+    if (!first) {
+      firstWriterByDataset.set(writer.datasetId, writer)
+      continue
+    }
+
+    throw new SyncValidationError(
+      `[Sixb] Keyed dataset '${writer.datasetId}' has multiple registered writers: ${first.label} and ${writer.label}. V1 allows one writer per keyed dataset.`
+    )
+  }
+}
+
+export function validateMergeSyncProjectionSafety(input: {
+  readonly syncs: readonly SyncDefinition[]
+  readonly telemetryProjections: readonly TelemetryProjectionDefinition[]
+}): void {
+  const mergeSyncByDataset = new Map(
+    input.syncs
+      .filter((sync) => sync.config.mode === "merge")
+      .map((sync) => [sync.target.dataset.id, sync] as const)
+  )
+
+  for (const projection of input.telemetryProjections) {
+    const sync = mergeSyncByDataset.get(projection.datasetId)
+    if (!sync) continue
+    throw new SyncValidationError(
+      `[Sixb] Telemetry projection '${projection.id}' cannot read merge-written dataset '${projection.datasetId}' from sync '${sync.id}'. V1 merge syncs support object and link replacement projections only.`
+    )
+  }
+}
+
+function* datasetWriters(
+  syncs: readonly SyncDefinition[],
+  pipelines: readonly PipelineDefinition[]
+): Iterable<DatasetWriter> {
+  for (const sync of syncs) {
+    yield { datasetId: sync.target.dataset.id, label: `sync '${sync.id}'` }
+  }
+  for (const pipeline of pipelines) {
+    for (const node of pipeline.graph.nodes) {
+      yield {
+        datasetId: node.step.output.id,
+        label: `pipeline '${pipeline.id}' step '${node.step.id}'`,
+      }
+    }
+  }
+}

package/src/testing/index.ts

@@ -18,6 +18,10 @@ export {
   type EffectiveStorageContractSuiteOptions,
   runEffectiveStorageContractSuite,
 } from "./effective-storage-contract"
+export {
+  type LakeMergeStorageContractSuiteOptions,
+  runLakeMergeStorageContractSuite,
+} from "./lake-merge-storage-contract"
 export {
   type LakeStorageContractSuiteOptions,
   type LakeStorageSchemaEvolutionCapability,

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

@@ -0,0 +1,302 @@
+import { describe, expect, test } from "bun:test"
+import { change, col, defineDataset } from "../datasets"
+import type { DatasetMergeCommitResult, DatasetRow, LakeStorage } from "../lake-storage"
+
+export interface LakeMergeStorageContractSuiteOptions<TStorage extends LakeStorage = LakeStorage> {
+  readonly createStorage: () => TStorage | Promise<TStorage>
+  readonly teardown?: (storage: TStorage) => void | Promise<void>
+}
+
+const invoices = defineDataset("contract.merges.invoices", {
+  schema: [col("id", "string"), col("status", "string"), col("note", "string", { nullable: true })],
+  primaryKey: "id",
+})
+
+const lineItems = defineDataset("contract.merges.line_items", {
+  schema: [col("invoiceId", "string"), col("lineItemId", "string"), col("description", "string")],
+  primaryKey: ["invoiceId", "lineItemId"],
+})
+
+const unkeyed = defineDataset("contract.merges.unkeyed", {
+  schema: [col("id", "string")],
+})
+
+export function runLakeMergeStorageContractSuite<TStorage extends LakeStorage>(
+  label: string,
+  options: LakeMergeStorageContractSuiteOptions<TStorage>
+): void {
+  const withStorage = async (body: (storage: TStorage) => Promise<void>): Promise<void> => {
+    const storage = await options.createStorage()
+    try {
+      await body(storage)
+    } finally {
+      await options.teardown?.(storage)
+    }
+  }
+
+  describe(label, () => {
+    test("creates an initial merge version from async changes", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices)
+        const merge = await storage.beginMerge({
+          dataset: invoices,
+          producer: { kind: "sync", id: "sync-invoices", runId: "run_1" },
+          inputs: [{ datasetId: "source.events", versionId: "cursor_1" }],
+        })
+
+        async function* changes() {
+          yield change.upsert({ id: "inv_1", status: "open", note: null })
+          yield change.upsert({ id: "inv_2", status: "paid", note: "settled" })
+        }
+
+        await merge.writeChanges(changes())
+        const result = await merge.commit({ commitMessage: "initial invoice changes" })
+        const version = expectCreated(result)
+
+        expect(version).toMatchObject({
+          datasetId: invoices.id,
+          mode: "merge",
+          rowCount: 2,
+          producer: { kind: "sync", id: "sync-invoices", runId: "run_1" },
+          inputs: [{ datasetId: "source.events", versionId: "cursor_1" }],
+        })
+        expect(version.parentVersionId).toBeUndefined()
+        await expect(collectRows(storage.readRows({ datasetId: invoices.id }))).resolves.toEqual([
+          { id: "inv_1", status: "open", note: null },
+          { id: "inv_2", status: "paid", note: "settled" },
+        ])
+      })
+    })
+
+    test("inserts, updates, and deletes while preserving the parent version", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices)
+        const seed = await storage.beginWrite({ dataset: invoices, mode: "snapshot" })
+        await seed.writeRows([
+          { id: "inv_1", status: "open", note: null },
+          { id: "inv_2", status: "open", note: null },
+        ])
+        const parent = await seed.commit()
+
+        const merge = await storage.beginMerge({ dataset: invoices })
+        await merge.writeChanges([
+          change.upsert({ id: "inv_1", status: "paid", note: null }),
+          // Primary keys are immutable, so moving a row is an old-key delete plus a complete row.
+          change.delete({ id: "inv_2" }),
+          change.upsert({ id: "inv_2_moved", status: "open", note: "moved" }),
+        ])
+        const version = expectCreated(await merge.commit())
+
+        expect(version.parentVersionId).toBe(parent.versionId)
+        expect(version.mode).toBe("merge")
+        await expect(collectRows(storage.readRows({ datasetId: invoices.id }))).resolves.toEqual([
+          { id: "inv_1", status: "paid", note: null },
+          { id: "inv_2_moved", status: "open", note: "moved" },
+        ])
+        await expect(
+          collectRows(storage.readRows({ datasetId: invoices.id, versionId: parent.versionId }))
+        ).resolves.toEqual([
+          { id: "inv_1", status: "open", note: null },
+          { id: "inv_2", status: "open", note: null },
+        ])
+      })
+    })
+
+    test("applies the final change for repeated single and composite keys", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(lineItems)
+        const merge = await storage.beginMerge({ dataset: lineItems })
+        await merge.writeChanges([
+          change.upsert({ invoiceId: "a|b", lineItemId: "c", description: "first" }),
+          change.upsert({ invoiceId: "a", lineItemId: "b|c", description: "other key" }),
+        ])
+        await merge.writeChanges([
+          change.delete({ invoiceId: "a|b", lineItemId: "c" }),
+          change.upsert({ invoiceId: "a|b", lineItemId: "c", description: "final" }),
+        ])
+        expectCreated(await merge.commit())
+
+        await expect(collectRows(storage.readRows({ datasetId: lineItems.id }))).resolves.toEqual([
+          { invoiceId: "a|b", lineItemId: "c", description: "final" },
+          { invoiceId: "a", lineItemId: "b|c", description: "other key" },
+        ])
+      })
+    })
+
+    test("does not create versions when visible rows do not change", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices)
+
+        const empty = await storage.beginMerge({ dataset: invoices })
+        expect(await empty.commit()).toEqual({ outcome: "unchanged", version: null })
+
+        const initialNoOp = await storage.beginMerge({ dataset: invoices })
+        await initialNoOp.writeChanges([change.delete({ id: "missing" })])
+        expect(await initialNoOp.commit()).toEqual({ outcome: "unchanged", version: null })
+        expect(await storage.listVersions(invoices.id)).toEqual([])
+
+        const seed = await storage.beginMerge({ dataset: invoices })
+        await seed.writeChanges([change.upsert({ id: "inv_1", status: "open", note: null })])
+        const seedVersion = expectCreated(await seed.commit())
+
+        const identical = await storage.beginMerge({ dataset: invoices })
+        await identical.writeChanges([change.upsert({ id: "inv_1", status: "open", note: null })])
+        expect(await identical.commit()).toMatchObject({
+          outcome: "unchanged",
+          version: { versionId: seedVersion.versionId },
+        })
+
+        const laterNoOp = await storage.beginMerge({ dataset: invoices })
+        await laterNoOp.writeChanges([
+          change.upsert({ id: "inv_1", status: "paid", note: null }),
+          change.upsert({ id: "inv_1", status: "open" }),
+          change.delete({ id: "missing" }),
+        ])
+        const noOpResult = await laterNoOp.commit()
+
+        expect(noOpResult).toMatchObject({ outcome: "unchanged" })
+        expect(noOpResult.version?.versionId).toBe(seedVersion.versionId)
+        expect(await storage.listVersions(invoices.id)).toHaveLength(1)
+      })
+    })
+
+    test("automatically rejects stale merge sessions, including an absent base", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices)
+        const first = await storage.beginMerge({ dataset: invoices })
+        const stale = await storage.beginMerge({ dataset: invoices })
+
+        await first.writeChanges([change.upsert({ id: "inv_1", status: "open", note: null })])
+        await first.commit()
+        await stale.writeChanges([change.upsert({ id: "inv_2", status: "open" })])
+
+        await expect(stale.commit()).rejects.toThrow("Optimistic merge commit failed")
+        await expect(collectRows(storage.readRows({ datasetId: invoices.id }))).resolves.toEqual([
+          { id: "inv_1", status: "open", note: null },
+        ])
+      })
+    })
+
+    test("checks an explicit latest-version guard against the captured merge base", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices)
+        const seed = await storage.beginMerge({ dataset: invoices })
+        await seed.writeChanges([change.upsert({ id: "inv_1", status: "open" })])
+        const version = expectCreated(await seed.commit())
+
+        await expect(
+          storage.beginMerge({ dataset: invoices, expectedLatestVersionId: "stale-version" })
+        ).rejects.toThrow("Optimistic merge start failed")
+
+        const guarded = await storage.beginMerge({
+          dataset: invoices,
+          expectedLatestVersionId: version.versionId,
+        })
+        await guarded.abort()
+      })
+    })
+
+    test("serializes concurrent commits from the same base", async () => {
+      // Regression guard: bypassing a provider's per-dataset commit lock lets both commits create
+      // versions from the same base and makes the fulfilled-count assertion fail.
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices)
+        const left = await storage.beginMerge({ dataset: invoices })
+        const right = await storage.beginMerge({ dataset: invoices })
+        await left.writeChanges([change.upsert({ id: "inv_left", status: "open" })])
+        await right.writeChanges([change.upsert({ id: "inv_right", status: "open" })])
+
+        const results = await Promise.allSettled([left.commit(), right.commit()])
+
+        expect(results.filter((result) => result.status === "fulfilled")).toHaveLength(1)
+        expect(results.filter((result) => result.status === "rejected")).toHaveLength(1)
+        expect(await storage.listVersions(invoices.id)).toHaveLength(1)
+        expect(await collectRows(storage.readRows({ datasetId: invoices.id }))).toHaveLength(1)
+      })
+    })
+
+    test("rejects unkeyed datasets and malformed changes", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(unkeyed)
+        await expect(storage.beginMerge({ dataset: unkeyed })).rejects.toThrow(
+          "must define a primaryKey"
+        )
+
+        await storage.createDataset(invoices)
+        const merge = await storage.beginMerge({ dataset: invoices })
+        await expect(merge.writeChanges([change.upsert({ id: "inv_1" })])).rejects.toThrow(
+          "missing required column 'status'"
+        )
+        await expect(merge.writeChanges([change.delete({})])).rejects.toThrow(
+          "missing primary-key column 'id'"
+        )
+        await expect(
+          merge.writeChanges([{ kind: "delete", key: { id: "inv_1", extra: "x" } }])
+        ).rejects.toThrow("unknown column 'extra'")
+        await merge.abort()
+      })
+    })
+
+    test("enforces unique keys for snapshot and append baselines", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices)
+
+        const duplicateSnapshot = await storage.beginWrite({ dataset: invoices, mode: "snapshot" })
+        await expect(
+          duplicateSnapshot.writeRows([
+            { id: "inv_1", status: "open" },
+            { id: "inv_1", status: "paid" },
+          ])
+        ).rejects.toThrow("duplicate primary key")
+        await duplicateSnapshot.abort()
+
+        const seed = await storage.beginWrite({ dataset: invoices, mode: "snapshot" })
+        await seed.writeRows([{ id: "inv_1", status: "open" }])
+        await seed.commit()
+
+        const conflictingAppend = await storage.beginWrite({ dataset: invoices, mode: "append" })
+        await conflictingAppend.writeRows([{ id: "inv_1", status: "paid" }])
+        await expect(conflictingAppend.commit()).rejects.toThrow("duplicate primary key")
+      })
+    })
+
+    test("clones staged changes and enforces the session lifecycle", async () => {
+      await withStorage(async (storage) => {
+        await storage.createDataset(invoices)
+        const row = { id: "inv_1", status: "open", note: null }
+        const merge = await storage.beginMerge({ dataset: invoices })
+        await merge.writeChanges([change.upsert(row)])
+        row.status = "paid"
+        expectCreated(await merge.commit())
+        await merge.abort()
+
+        await expect(merge.writeChanges([])).rejects.toThrow("already closed")
+        await expect(collectRows(storage.readRows({ datasetId: invoices.id }))).resolves.toEqual([
+          { id: "inv_1", status: "open", note: null },
+        ])
+
+        const aborted = await storage.beginMerge({ dataset: invoices })
+        await aborted.writeChanges([change.delete({ id: "inv_1" })])
+        await aborted.abort()
+        await aborted.abort()
+        expect(await storage.listVersions(invoices.id)).toHaveLength(1)
+      })
+    })
+  })
+}
+
+function expectCreated(result: DatasetMergeCommitResult) {
+  expect(result.outcome).toBe("created")
+  if (result.outcome !== "created") {
+    throw new Error("Expected merge to create a dataset version")
+  }
+  return result.version
+}
+
+async function collectRows(rows: AsyncIterable<DatasetRow>): Promise<DatasetRow[]> {
+  const result: DatasetRow[] = []
+  for await (const row of rows) {
+    result.push(row)
+  }
+  return result
+}

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

@@ -34,6 +34,12 @@ const reorderedDefinitionDataset = defineDataset("contract.definitions.orders",
   description: "Contract orders",
 })
 
+const keyedDefinitionDataset = defineDataset("contract.definitions.keyed_orders", {
+  schema: [col("tenantId", "string"), col("orderId", "string"), col("customerName", "string")],
+  primaryKey: ["tenantId", "orderId"],
+  description: "Contract keyed orders",
+})
+
 const writeDataset = defineDataset("contract.writes.orders", {
   schema: [col("orderId", "string"), col("customerName", "string")],
 })
@@ -101,6 +107,23 @@ export function runLakeStorageContractSuite<TStorage extends LakeStorage>(
         })
       })
 
+      test("round-trips keyed definitions through create, get, list, and reuse", async () => {
+        // Regression guard: omitting primaryKey from mergeDatasetDefinition makes reuse lose
+        // the key and fails this contract case.
+        await withStorage(async (storage) => {
+          const created = await storage.createDataset(keyedDefinitionDataset)
+          const repeated = await storage.createDataset(keyedDefinitionDataset)
+
+          expect(created).toEqual(keyedDefinitionDataset)
+          expect(repeated).toEqual(keyedDefinitionDataset)
+          expect(await storage.getDataset(keyedDefinitionDataset.id)).toEqual(
+            keyedDefinitionDataset
+          )
+          expect(await storage.listDatasets()).toEqual([keyedDefinitionDataset])
+          expect(await storage.listVersions(keyedDefinitionDataset.id)).toEqual([])
+        })
+      })
+
       test("treats same-column declaration reorders as a no-op", async () => {
         await withStorage(async (storage) => {
           await storage.createDataset(definitionDataset)

package/src/workflows/snapshot.ts

@@ -1,5 +1,5 @@
 import type { ActionSubject } from "../actions"
-import type { JsonValue } from "../json"
+import { isPlainRecord, type JsonValue } from "../json"
 import { isObjectRefSchema, type Schema, type SchemaOrRef, type ValueType } from "../ontology"
 import { WorkflowValidationError } from "./errors"
 import type {
@@ -372,12 +372,3 @@ function cannotSerialize(path: string): WorkflowValidationError {
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value)
 }
-
-function isPlainRecord(value: unknown): value is Record<string, unknown> {
-  if (!isRecord(value)) {
-    return false
-  }
-
-  const prototype = Object.getPrototypeOf(value)
-  return prototype === Object.prototype || prototype === null
-}

package/dist/chunk-1vffvydj.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/json.ts"],
-  "sourcesContent": [
-    "export type JsonPrimitive = string | number | boolean | null\nexport type JsonObject = { [key: string]: JsonValue }\nexport type JsonArray = JsonValue[]\nexport type JsonValue = JsonPrimitive | JsonObject | JsonArray\n\nexport function isJsonValue(value: unknown): value is JsonValue {\n  return getInvalidJsonValueReason(value) === undefined\n}\n\nexport function assertJsonValue(value: unknown, label = \"value\"): asserts value is JsonValue {\n  const reason = getInvalidJsonValueReason(value, label)\n  if (reason) {\n    throw new Error(`[Sixb] ${label} must be a JSON value; ${reason}`)\n  }\n}\n\nexport function cloneJsonValue(value: JsonValue): JsonValue {\n  assertJsonValue(value)\n  return JSON.parse(JSON.stringify(value)) as JsonValue\n}\n\nexport function jsonValuesEqual(left: unknown, right: unknown): boolean {\n  return stableJsonStringify(left) === stableJsonStringify(right)\n}\n\nexport function stableJsonStringify(value: unknown): string {\n  if (value === undefined) return \"undefined\"\n  if (value === null || typeof value !== \"object\") return JSON.stringify(value)\n  if (Array.isArray(value)) return `[${value.map(stableJsonStringify).join(\",\")}]`\n  return `{${Object.entries(value as Record<string, unknown>)\n    .sort(([left], [right]) => compareStrings(left, right))\n    .map(([key, entry]) => `${JSON.stringify(key)}:${stableJsonStringify(entry)}`)\n    .join(\",\")}}`\n}\n\nexport function compareStrings(left: string, right: string): number {\n  if (left < right) return -1\n  if (left > right) return 1\n  return 0\n}\n\nexport function getInvalidJsonValueReason(\n  value: unknown,\n  label = \"value\",\n  seen: Set<object> = new Set()\n): string | undefined {\n  if (value === null || typeof value === \"string\" || typeof value === \"boolean\") {\n    return undefined\n  }\n\n  if (typeof value === \"number\") {\n    return Number.isFinite(value) ? undefined : `${label} is not a finite number`\n  }\n\n  if (Array.isArray(value)) {\n    if (seen.has(value)) {\n      return `${label} contains a circular reference`\n    }\n\n    seen.add(value)\n    for (let index = 0; index < value.length; index += 1) {\n      if (!Object.hasOwn(value, index)) {\n        seen.delete(value)\n        return `${label}[${index}] is a sparse array slot`\n      }\n\n      const reason = getInvalidJsonValueReason(value[index], `${label}[${index}]`, seen)\n      if (reason) {\n        seen.delete(value)\n        return reason\n      }\n    }\n    seen.delete(value)\n    return undefined\n  }\n\n  if (isPlainObject(value)) {\n    if (seen.has(value)) {\n      return `${label} contains a circular reference`\n    }\n\n    const symbolKeys = Object.getOwnPropertySymbols(value).filter((key) =>\n      Object.prototype.propertyIsEnumerable.call(value, key)\n    )\n    if (symbolKeys.length > 0) {\n      return `${label} has an enumerable symbol key`\n    }\n\n    seen.add(value)\n    for (const [key, entry] of Object.entries(value)) {\n      const reason = getInvalidJsonValueReason(entry, jsonChildPath(label, key), seen)\n      if (reason) {\n        seen.delete(value)\n        return reason\n      }\n    }\n    seen.delete(value)\n    return undefined\n  }\n\n  return `${label} is ${describeNonJsonValue(value)}`\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    return false\n  }\n\n  const prototype = Object.getPrototypeOf(value)\n  return prototype === Object.prototype || prototype === null\n}\n\nfunction jsonChildPath(parent: string, key: string): string {\n  return /^[A-Za-z_$][\\w$]*$/.test(key) ? `${parent}.${key}` : `${parent}[${JSON.stringify(key)}]`\n}\n\nfunction describeNonJsonValue(value: unknown): string {\n  if (value === undefined) {\n    return \"undefined\"\n  }\n\n  if (value instanceof Date) {\n    return \"a Date\"\n  }\n\n  const type = typeof value\n  if (type === \"bigint\" || type === \"function\" || type === \"symbol\") {\n    return `a ${type}`\n  }\n\n  if (typeof value === \"object\" && value !== null) {\n    const name = value.constructor?.name\n    return name ? `a ${name}` : \"a non-plain object\"\n  }\n\n  return type\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "2AE4FE38572586A064756E2164756E21",
-  "names": []
-}

package/dist/chunk-2s6sydsh.js.map

@@ -1,12 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/lake-storage/errors.ts", "../src/lake-storage/definition-updates.ts", "../src/lake-storage/in-memory.ts"],
-  "sourcesContent": [
-    "/**\n * Error for lake-storage invariants and invalid lake operations.\n */\nexport class LakeStorageError extends Error {\n  readonly name = \"LakeStorageError\"\n}\n",
-    "import type { DatasetColumnDefinition, DatasetDefinition } from \"../datasets\"\nimport { LakeStorageError } from \"./errors\"\nimport type { LakeStorage } from \"./types\"\n\nexport type DatasetSchemaUpdatePlan =\n  | { readonly kind: \"none\" }\n  | {\n      readonly kind: \"addNullableColumns\"\n      readonly columns: readonly DatasetColumnDefinition[]\n    }\n\nexport interface DatasetMetadataUpdatePlan {\n  readonly descriptionChanged: boolean\n  readonly partitionByChanged: boolean\n}\n\nexport interface DatasetDefinitionUpdatePlan {\n  readonly existing: DatasetDefinition\n  readonly requested: DatasetDefinition\n  readonly definition: DatasetDefinition\n  readonly schema: DatasetSchemaUpdatePlan\n  readonly metadata: DatasetMetadataUpdatePlan\n  readonly changed: boolean\n}\n\nconst SCHEMA_UPDATE_V1_POLICY =\n  \"Dataset definition updates V1 support only adding nullable columns.\"\n\n/**\n * Build a provider-neutral update plan for two versions of the same dataset\n * definition. Core owns the definition diff; storage providers own how much of\n * the plan they can apply.\n */\nexport function planDatasetDefinitionUpdate(\n  existing: DatasetDefinition,\n  requested: DatasetDefinition\n): DatasetDefinitionUpdatePlan {\n  assertSameDataset(existing, requested)\n\n  const addedColumns = getAddedColumnsAfterValidatingExistingColumns(existing, requested)\n  assertAddedColumnsAreNullable(requested.id, addedColumns)\n\n  const schema = toSchemaUpdatePlan(addedColumns)\n  const definition = mergeDatasetDefinition(existing, requested, addedColumns)\n  const metadata: DatasetMetadataUpdatePlan = {\n    descriptionChanged: existing.description !== definition.description,\n    partitionByChanged: !areStringArraysEqual(existing.partitionBy, definition.partitionBy),\n  }\n\n  return {\n    existing: structuredClone(existing),\n    requested: structuredClone(requested),\n    definition,\n    schema,\n    metadata,\n    changed: schema.kind !== \"none\" || metadata.descriptionChanged || metadata.partitionByChanged,\n  }\n}\n\n/**\n * Strict providers can use this helper when they do not support schema\n * evolution. Metadata-only compatible additions are still merged.\n */\nexport function mergeStrictDatasetDefinition(options: {\n  readonly existing?: DatasetDefinition | null\n  readonly next: DatasetDefinition\n}): DatasetDefinition {\n  if (!options.existing) {\n    return structuredClone(options.next)\n  }\n\n  const plan = planDatasetDefinitionUpdate(options.existing, options.next)\n  if (plan.schema.kind !== \"none\") {\n    throw new LakeStorageError(\n      `[SixbLake] Dataset '${options.next.id}' cannot be redefined with an incompatible schema.`\n    )\n  }\n\n  return structuredClone(plan.definition)\n}\n\nexport interface AssertLakeDatasetDefinitionsCompatibleOptions {\n  readonly lakeStorage: LakeStorage\n  readonly definitions: readonly DatasetDefinition[]\n}\n\nexport async function assertLakeDatasetDefinitionsCompatible(\n  options: AssertLakeDatasetDefinitionsCompatibleOptions\n): Promise<void> {\n  await options.lakeStorage.assertDatasetDefinitionsCompatible(options.definitions)\n}\n\nfunction assertSameDataset(existing: DatasetDefinition, requested: DatasetDefinition): void {\n  if (existing.id !== requested.id) {\n    throw new LakeStorageError(\n      `[SixbLake] Cannot update dataset '${existing.id}' with definition for '${requested.id}'.`\n    )\n  }\n}\n\nfunction getAddedColumnsAfterValidatingExistingColumns(\n  existing: DatasetDefinition,\n  requested: DatasetDefinition\n): readonly DatasetColumnDefinition[] {\n  const existingColumns = existing.schema.columns\n  const requestedColumnsByName = new Map(\n    requested.schema.columns.map((column) => [column.name, column])\n  )\n\n  // Existing columns are matched by name, not position. Developers can reorder\n  // declarations for readability without implying a storage-level schema change.\n  for (const existingColumn of existingColumns) {\n    const requestedColumn = requestedColumnsByName.get(existingColumn.name)\n    if (requestedColumn === undefined) {\n      throwUnsupportedSchemaUpdate(\n        requested.id,\n        `dropping column '${existingColumn.name}' is not supported`\n      )\n    }\n\n    assertExistingColumnUnchanged(requested.id, existingColumn, requestedColumn)\n  }\n\n  const existingColumnNames = new Set(existingColumns.map((column) => column.name))\n  return requested.schema.columns.filter((column) => !existingColumnNames.has(column.name))\n}\n\nfunction assertAddedColumnsAreNullable(\n  datasetId: string,\n  addedColumns: readonly DatasetColumnDefinition[]\n): void {\n  for (const column of addedColumns) {\n    // Existing rows have no value for a new column. Until DatasetDefinition\n    // supports defaults or backfills, only nullable columns are safe to add.\n    if (!isNullable(column)) {\n      throwUnsupportedSchemaUpdate(\n        datasetId,\n        `adding required column '${column.name}' is not supported`\n      )\n    }\n  }\n}\n\nfunction assertExistingColumnUnchanged(\n  datasetId: string,\n  existing: DatasetColumnDefinition,\n  requested: DatasetColumnDefinition\n): void {\n  if (existing.type !== requested.type) {\n    throwUnsupportedSchemaUpdate(\n      datasetId,\n      `changing column '${existing.name}' type from '${existing.type}' to '${requested.type}' is not supported`\n    )\n  }\n\n  if (isNullable(existing) !== isNullable(requested)) {\n    throwUnsupportedSchemaUpdate(\n      datasetId,\n      `changing column '${existing.name}' nullability is not supported`\n    )\n  }\n}\n\nfunction toSchemaUpdatePlan(\n  addedColumns: readonly DatasetColumnDefinition[]\n): DatasetSchemaUpdatePlan {\n  if (addedColumns.length === 0) {\n    return { kind: \"none\" }\n  }\n\n  return {\n    kind: \"addNullableColumns\",\n    columns: cloneColumns(addedColumns),\n  }\n}\n\nfunction mergeDatasetDefinition(\n  existing: DatasetDefinition,\n  requested: DatasetDefinition,\n  addedColumns: readonly DatasetColumnDefinition[]\n): DatasetDefinition {\n  assertCompatibleMetadataField(\n    requested.id,\n    \"description\",\n    existing.description,\n    requested.description\n  )\n  assertCompatibleMetadataField(\n    requested.id,\n    \"partitionBy\",\n    existing.partitionBy,\n    requested.partitionBy\n  )\n\n  const columns = [...cloneColumns(existing.schema.columns), ...cloneColumns(addedColumns)]\n  const partitionBy = requested.partitionBy ?? existing.partitionBy\n  const description = requested.description ?? existing.description\n\n  return {\n    kind: \"dataset\",\n    id: requested.id,\n    schema: { columns },\n    ...(partitionBy !== undefined ? { partitionBy: [...partitionBy] } : {}),\n    ...(description !== undefined ? { description } : {}),\n  }\n}\n\nfunction assertCompatibleMetadataField(\n  datasetId: string,\n  field: \"description\" | \"partitionBy\",\n  existing: string | readonly string[] | undefined,\n  requested: string | readonly string[] | undefined\n): void {\n  if (\n    existing === undefined ||\n    requested === undefined ||\n    areDefinitionValuesEqual(existing, requested)\n  ) {\n    return\n  }\n\n  throw new LakeStorageError(\n    `[SixbLake] Dataset '${datasetId}' cannot be redefined with an incompatible ${field}.`\n  )\n}\n\nfunction areStringArraysEqual(\n  left: readonly string[] | undefined,\n  right: readonly string[] | undefined\n): boolean {\n  if (left === undefined || right === undefined) {\n    return left === right\n  }\n\n  return left.length === right.length && left.every((value, index) => value === right[index])\n}\n\nfunction areDefinitionValuesEqual(\n  left: string | readonly string[],\n  right: string | readonly string[]\n): boolean {\n  if (typeof left === \"string\" || typeof right === \"string\") {\n    return left === right\n  }\n\n  return areStringArraysEqual(left, right)\n}\n\nfunction isNullable(column: DatasetColumnDefinition): boolean {\n  return column.nullable === true\n}\n\nfunction cloneColumns(\n  columns: readonly DatasetColumnDefinition[]\n): readonly DatasetColumnDefinition[] {\n  return columns.map((column) => ({ ...column }))\n}\n\nfunction throwUnsupportedSchemaUpdate(datasetId: string, detail: string): never {\n  throw new LakeStorageError(\n    `[SixbLake] Dataset '${datasetId}' cannot apply schema update because ${detail}. ${SCHEMA_UPDATE_V1_POLICY}`\n  )\n}\n",
-    "import { randomUUID } from \"node:crypto\"\nimport type { DatasetDefinition, DatasetSchema } from \"../datasets\"\nimport { getDatasetRowValidationError } from \"../datasets/validation\"\nimport { mergeStrictDatasetDefinition } from \"./definition-updates\"\nimport { LakeStorageError } from \"./errors\"\nimport type {\n  BeginDatasetWriteInput,\n  CommitDatasetWriteInput,\n  DatasetCatalogState,\n  DatasetRow,\n  DatasetVersion,\n  DatasetWriteCommitResult,\n  DatasetWriteMode,\n  LakeStorage,\n  LakeWriteSession,\n  ReadDatasetRowsInput,\n} from \"./types\"\n\nfunction cloneDatasetDefinition(definition: DatasetDefinition): DatasetDefinition {\n  return structuredClone(definition)\n}\n\nfunction cloneDatasetVersion(version: DatasetVersion): DatasetVersion {\n  return {\n    ...structuredClone(version),\n    createdAt: new Date(version.createdAt),\n  }\n}\n\nfunction cloneRow(row: DatasetRow): DatasetRow {\n  return structuredClone(row)\n}\n\nfunction selectColumns(row: DatasetRow, columns?: readonly string[]): DatasetRow {\n  if (!columns || columns.length === 0) {\n    return cloneRow(row)\n  }\n\n  const selected: Record<string, unknown> = {}\n  for (const column of columns) {\n    selected[column] = row[column]\n  }\n  return selected\n}\n\n// Canonical content key for unchanged-write detection. JSON.stringify\n// serializes Date values via toJSON, matching how rows persist as JSON;\n// missing and undefined nullable values normalize to null. The unchanged-write\n// semantics are pinned by the shared lake-storage contract suite.\nfunction rowContentKey(row: DatasetRow, schema: DatasetSchema): string {\n  return JSON.stringify(schema.columns.map((column) => row[column.name] ?? null))\n}\n\n// Order-insensitive multiset equality over canonical row keys.\nfunction sameRowContent(left: readonly string[], right: readonly string[]): boolean {\n  if (left.length !== right.length) {\n    return false\n  }\n\n  const sortedLeft = [...left].sort()\n  const sortedRight = [...right].sort()\n  return sortedLeft.every((key, index) => key === sortedRight[index])\n}\n\nfunction assertDatasetId(datasetId: string): void {\n  if (datasetId.trim().length === 0) {\n    throw new LakeStorageError(\"[LakeStorage] Dataset id must not be empty\")\n  }\n}\n\nfunction errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error)\n}\n\nclass InMemoryLakeWriteSession implements LakeWriteSession {\n  private readonly rows: DatasetRow[] = []\n  private closed = false\n\n  constructor(\n    private readonly storage: InMemoryLakeStorage,\n    private readonly input: BeginDatasetWriteInput\n  ) {}\n\n  async writeRows(rows: Iterable<DatasetRow> | AsyncIterable<DatasetRow>): Promise<void> {\n    this.assertOpen()\n\n    for await (const row of rows) {\n      const validationError = getDatasetRowValidationError(row, this.input.dataset)\n      if (validationError) {\n        throw new LakeStorageError(`[LakeStorage] ${validationError}`)\n      }\n\n      this.rows.push(cloneRow(row))\n    }\n  }\n\n  async commit(input?: CommitDatasetWriteInput): Promise<DatasetWriteCommitResult> {\n    this.assertOpen()\n    this.closed = true\n    return this.storage.commitWrite({\n      write: this.input,\n      rows: this.rows,\n      commit: input,\n    })\n  }\n\n  async abort(): Promise<void> {\n    this.closed = true\n    this.rows.length = 0\n  }\n\n  private assertOpen(): void {\n    if (this.closed) {\n      throw new LakeStorageError(\"[LakeStorage] Write session is already closed\")\n    }\n  }\n}\n\nexport class InMemoryLakeStorage implements LakeStorage {\n  private readonly datasets = new Map<string, DatasetDefinition>()\n  private readonly versionsByDataset = new Map<string, DatasetVersion[]>()\n  private readonly rowsByVersionId = new Map<string, readonly DatasetRow[]>()\n  private readonly latestVersionIdByDataset = new Map<string, string>()\n\n  async createDataset(definition: DatasetDefinition): Promise<DatasetDefinition> {\n    assertDatasetId(definition.id)\n    const existing = this.datasets.get(definition.id)\n    const stored = mergeStrictDatasetDefinition({\n      existing,\n      next: definition,\n    })\n    this.datasets.set(definition.id, stored)\n    return cloneDatasetDefinition(stored)\n  }\n\n  async assertDatasetDefinitionsCompatible(\n    definitions: readonly DatasetDefinition[]\n  ): Promise<void> {\n    const failures: string[] = []\n\n    for (const definition of definitions) {\n      try {\n        assertDatasetId(definition.id)\n        const existing = this.datasets.get(definition.id)\n        if (!existing) {\n          continue\n        }\n\n        mergeStrictDatasetDefinition({\n          existing,\n          next: definition,\n        })\n      } catch (error) {\n        failures.push(`- ${definition.id}: ${errorMessage(error)}`)\n      }\n    }\n\n    if (failures.length > 0) {\n      const details = failures.join(\"\\n\")\n      throw new LakeStorageError(\n        `[SixbLake] Lake dataset definition check failed for ${failures.length} dataset(s).\\n${details}`\n      )\n    }\n  }\n\n  async getDataset(datasetId: string): Promise<DatasetDefinition | null> {\n    const definition = this.datasets.get(datasetId)\n    return definition ? cloneDatasetDefinition(definition) : null\n  }\n\n  async listDatasets(): Promise<readonly DatasetDefinition[]> {\n    return [...this.datasets.values()].map((definition) => cloneDatasetDefinition(definition))\n  }\n\n  async listDatasetCatalogState(\n    datasetIds: readonly string[]\n  ): Promise<readonly DatasetCatalogState[]> {\n    return Promise.all(\n      datasetIds.map(async (datasetId) => {\n        if (!this.datasets.has(datasetId)) {\n          return { datasetId, materialized: false, latestVersion: null }\n        }\n\n        const latest = await this.getLatestVersion(datasetId)\n        return {\n          datasetId,\n          materialized: true,\n          latestVersion: latest\n            ? {\n                datasetId: latest.datasetId,\n                versionId: latest.versionId,\n                mode: latest.mode,\n                createdAt: latest.createdAt,\n                ...(latest.rowCount !== undefined ? { rowCount: latest.rowCount } : {}),\n              }\n            : null,\n        }\n      })\n    )\n  }\n\n  async listVersions(datasetId: string, limit?: number): Promise<readonly DatasetVersion[]> {\n    const versions = [...(this.versionsByDataset.get(datasetId) ?? [])]\n      .sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime())\n      .map((version) => cloneDatasetVersion(version))\n\n    return limit === undefined ? versions : versions.slice(0, Math.max(0, limit))\n  }\n\n  async beginWrite(input: BeginDatasetWriteInput): Promise<LakeWriteSession> {\n    const definition = await this.getDataset(input.dataset.id)\n    if (!definition) {\n      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.dataset.id}'`)\n    }\n\n    return new InMemoryLakeWriteSession(this, {\n      ...input,\n      dataset: definition,\n      mode: input.mode ?? \"snapshot\",\n    })\n  }\n\n  async getLatestVersion(datasetId: string): Promise<DatasetVersion | null> {\n    const latestVersionId = this.latestVersionIdByDataset.get(datasetId)\n    if (!latestVersionId) {\n      return null\n    }\n\n    return this.getVersion(datasetId, latestVersionId)\n  }\n\n  async getVersion(datasetId: string, versionId: string): Promise<DatasetVersion | null> {\n    const versions = this.versionsByDataset.get(datasetId) ?? []\n    const version = versions.find((candidate) => candidate.versionId === versionId)\n    return version ? cloneDatasetVersion(version) : null\n  }\n\n  async *readRows(input: ReadDatasetRowsInput): AsyncIterable<DatasetRow> {\n    const definition = this.datasets.get(input.datasetId)\n    if (!definition) {\n      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.datasetId}'`)\n    }\n\n    const version =\n      input.versionId === undefined\n        ? await this.getLatestVersion(input.datasetId)\n        : await this.getVersion(input.datasetId, input.versionId)\n\n    if (!version) {\n      throw new LakeStorageError(\n        `[LakeStorage] No committed version found for dataset '${input.datasetId}'`\n      )\n    }\n\n    const offset = Math.max(0, input.offset ?? 0)\n    const limit = input.limit === undefined ? undefined : Math.max(0, input.limit)\n    const rows = this.rowsByVersionId\n      .get(version.versionId)\n      ?.slice(offset, limit === undefined ? undefined : offset + limit)\n\n    for (const row of rows ?? []) {\n      yield selectColumns(row, input.columns)\n    }\n  }\n\n  async commitWrite(options: {\n    write: BeginDatasetWriteInput\n    rows: readonly DatasetRow[]\n    commit?: CommitDatasetWriteInput\n  }): Promise<DatasetWriteCommitResult> {\n    const definition = this.datasets.get(options.write.dataset.id)\n    if (!definition) {\n      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${options.write.dataset.id}'`)\n    }\n\n    const mode = options.write.mode ?? \"snapshot\"\n    const latestVersion = await this.getLatestVersion(options.write.dataset.id)\n\n    if (options.commit?.expectedLatestVersionId !== undefined) {\n      const actual = latestVersion?.versionId\n      if (actual !== options.commit.expectedLatestVersionId) {\n        throw new LakeStorageError(\n          `[LakeStorage] Optimistic commit failed for dataset '${options.write.dataset.id}': expected latest version '${options.commit.expectedLatestVersionId}', found '${actual ?? \"none\"}'`\n        )\n      }\n    }\n\n    // Content-identical snapshots and empty appends reuse the latest version\n    // instead of creating a new one.\n    if (\n      latestVersion &&\n      this.isUnchangedWrite(mode, latestVersion, options.rows, definition.schema)\n    ) {\n      return { ...latestVersion, outcome: \"unchanged\" }\n    }\n\n    const versionId = `ver_${randomUUID()}`\n    const visibleRows =\n      mode === \"append\"\n        ? [...(this.rowsByVersionId.get(latestVersion?.versionId ?? \"\") ?? []), ...options.rows]\n        : [...options.rows]\n\n    const sizeBytes = new TextEncoder().encode(\n      visibleRows.map((row) => JSON.stringify(row)).join(\"\\n\")\n    ).byteLength\n\n    const version: DatasetVersion = {\n      datasetId: options.write.dataset.id,\n      versionId,\n      parentVersionId: mode === \"append\" ? latestVersion?.versionId : undefined,\n      mode,\n      createdAt: new Date(),\n      schema: definition.schema,\n      producer: options.write.producer ? structuredClone(options.write.producer) : undefined,\n      inputs: options.write.inputs ? structuredClone(options.write.inputs) : undefined,\n      rowCount: visibleRows.length,\n      sizeBytes,\n    }\n\n    const versions = this.versionsByDataset.get(options.write.dataset.id) ?? []\n    versions.push(version)\n    this.versionsByDataset.set(options.write.dataset.id, versions)\n    this.rowsByVersionId.set(\n      versionId,\n      visibleRows.map((row) => cloneRow(row))\n    )\n    this.latestVersionIdByDataset.set(options.write.dataset.id, versionId)\n\n    return { ...cloneDatasetVersion(version), outcome: \"created\" }\n  }\n\n  private isUnchangedWrite(\n    mode: DatasetWriteMode,\n    latestVersion: DatasetVersion,\n    rows: readonly DatasetRow[],\n    schema: DatasetSchema\n  ): boolean {\n    if (mode === \"append\") {\n      return rows.length === 0\n    }\n\n    const previousRows = this.rowsByVersionId.get(latestVersion.versionId) ?? []\n    return sameRowContent(\n      rows.map((row) => rowContentKey(row, schema)),\n      previousRows.map((row) => rowContentKey(row, schema))\n    )\n  }\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "ABB8A17B04F411C364756E2164756E21",
-  "names": []
-}