@lix-js/sdk 0.5.0-preview.0 → 0.5.0

package/src/version/schema.test.ts

@@ -1,13 +1,25 @@
 import { expect, test } from "vitest";
 import { openLix } from "../lix/open-lix.js";
 import { createVersion } from "./create-version.js";
-
-test("insert, update, delete on the version view", async () => {
+import type { LixSchemaDefinition } from "../schema-definition/definition.js";
+
+const testStateSchema = {
+	"x-lix-key": "test_schema",
+	"x-lix-version": "1.0",
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		foo: { type: "string" },
+	},
+	required: ["foo"],
+} as const satisfies LixSchemaDefinition;
+
+test("insert, update, delete on version descriptor", async () => {
 	const lix = await openLix({});
 
 	// Create required change sets first
 	await lix.db
-		.insertInto("change_set_all")
+		.insertInto("change_set_by_version")
 		.values([
 			{ id: "change_set_id_0", lixcol_version_id: "global" },
 			{ id: "change_set_id_1", lixcol_version_id: "global" },
@@ -16,22 +28,51 @@ test("insert, update, delete on the version view", async () => {
 		])
 		.execute();
 
+	// Create required commits
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "commit_id_0",
+				change_set_id: "change_set_id_0",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "commit_id_1",
+				change_set_id: "change_set_id_1",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "working_commit_0",
+				change_set_id: "working_cs_0",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "working_commit_1",
+				change_set_id: "working_cs_1",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
 	await lix.db
-		.insertInto("version_all")
+		.insertInto("version_by_version")
 		.values([
 			{
 				id: "version0",
 				name: "version0",
-				change_set_id: "change_set_id_0",
-				working_change_set_id: "working_cs_0",
+				// descriptor-only insert: no commit_id here
+				working_commit_id: "working_commit_0",
 				lixcol_version_id: "global",
+				inherits_from_version_id: "global",
 			},
 			{
 				id: "version1",
 				name: "version1",
-				change_set_id: "change_set_id_1",
-				working_change_set_id: "working_cs_1",
+				// descriptor-only insert: no commit_id here
+				working_commit_id: "working_commit_1",
 				lixcol_version_id: "global",
+				inherits_from_version_id: "global",
 			},
 		])
 		.execute();
@@ -43,21 +84,15 @@ test("insert, update, delete on the version view", async () => {
 		.selectAll()
 		.execute();
 
-	expect(viewAfterInsert).toMatchObject([
-		{
-			name: "version0",
-			change_set_id: "change_set_id_0",
-		},
-		{
-			name: "version1",
-			change_set_id: "change_set_id_1",
-		},
+	expect(viewAfterInsert.map((v) => ({ name: v.name }))).toMatchObject([
+		{ name: "version0" },
+		{ name: "version1" },
 	]);
 
 	await lix.db
 		.updateTable("version")
 		.where("name", "=", "version0")
-		.set({ change_set_id: "change_set_id_1" })
+		.set({ name: "version0_renamed" })
 		.execute();
 
 	const viewAfterUpdate = await lix.db
@@ -67,15 +102,9 @@ test("insert, update, delete on the version view", async () => {
 		.selectAll()
 		.execute();
 
-	expect(viewAfterUpdate).toMatchObject([
-		{
-			name: "version0",
-			change_set_id: "change_set_id_1",
-		},
-		{
-			name: "version1",
-			change_set_id: "change_set_id_1",
-		},
+	expect(viewAfterUpdate.map((v) => ({ name: v.name }))).toMatchObject([
+		{ name: "version0_renamed" },
+		{ name: "version1" },
 	]);
 
 	await lix.db.deleteFrom("version").where("id", "=", "version0").execute();
@@ -91,39 +120,24 @@ test("insert, update, delete on the version view", async () => {
 		{
 			id: "version1",
 			name: "version1",
-			change_set_id: "change_set_id_1",
-			working_change_set_id: "working_cs_1",
+			working_commit_id: "working_commit_1",
 			inherits_from_version_id: "global",
 		},
 	]);
 
+	// Assert descriptor changes (no tip writes since commit_id not provided)
 	const changes = await lix.db
 		.selectFrom("change")
-
-		.where("schema_key", "=", "lix_version")
+		.where("schema_key", "=", "lix_version_descriptor")
 		.where("entity_id", "in", ["version0", "version1"])
 		.orderBy("change.created_at", "asc")
 		.selectAll("change")
-
 		.execute();
 
-	expect(changes.map((change) => change.snapshot_content)).toMatchObject([
-		// version 0's insert
-		{
-			name: "version0",
-			change_set_id: "change_set_id_0",
-		},
-		// version 0's insert
-		{
-			name: "version1",
-			change_set_id: "change_set_id_1",
-		},
-		{
-			// version 0's update
-			name: "version0",
-			change_set_id: "change_set_id_1",
-		},
-		// version 0's delete
+	expect(changes.map((c) => c.snapshot_content)).toMatchObject([
+		{ name: "version0" },
+		{ name: "version1" },
+		{ name: "version0_renamed" },
 		null,
 	]);
 });
@@ -133,7 +147,7 @@ test("querying by id", async () => {
 
 	// Create required change sets first
 	await lix.db
-		.insertInto("change_set_all")
+		.insertInto("change_set_by_version")
 		.values([
 			{ id: "change_set_id_0", lixcol_version_id: "global" },
 			{ id: "change_set_id_1", lixcol_version_id: "global" },
@@ -142,20 +156,45 @@ test("querying by id", async () => {
 		])
 		.execute();
 
+	// Create required commits
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "commit_id_0",
+				change_set_id: "change_set_id_0",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "commit_id_1",
+				change_set_id: "change_set_id_1",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "working_commit_0",
+				change_set_id: "working_cs_0",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "working_commit_1",
+				change_set_id: "working_cs_1",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
 	await lix.db
 		.insertInto("version")
 		.values([
 			{
 				id: "version0",
 				name: "version0",
-				change_set_id: "change_set_id_0",
-				working_change_set_id: "working_cs_0",
+				working_commit_id: "working_commit_0",
 			},
 			{
 				id: "version1",
 				name: "version1",
-				change_set_id: "change_set_id_1",
-				working_change_set_id: "working_cs_1",
+				working_commit_id: "working_commit_1",
 			},
 		])
 		.execute();
@@ -175,8 +214,24 @@ test("update active version view", async () => {
 
 	// Create required change sets and version first
 	await lix.db
-		.insertInto("change_set_all")
-		.values([{ id: "cs1", lixcol_version_id: "global" }])
+		.insertInto("change_set_by_version")
+		.values([
+			{ id: "cs1", lixcol_version_id: "global" },
+			{ id: "working_cs1", lixcol_version_id: "global" },
+		])
+		.execute();
+
+	// Create required commits
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{ id: "commit_cs1", change_set_id: "cs1", lixcol_version_id: "global" },
+			{
+				id: "working_commit_1",
+				change_set_id: "working_cs1",
+				lixcol_version_id: "global",
+			},
+		])
 		.execute();
 
 	await lix.db
@@ -184,8 +239,7 @@ test("update active version view", async () => {
 		.values({
 			id: "version_id_1",
 			name: "test_version",
-			change_set_id: "cs1",
-			working_change_set_id: "cs1",
+			working_commit_id: "working_commit_1",
 		})
 		.execute();
 
@@ -204,6 +258,58 @@ test("update active version view", async () => {
 			version_id: "version_id_1",
 		},
 	]);
+
+	await lix.close();
+});
+
+test("active_version update succeeds via raw SQLite trigger", async () => {
+	const lix = await openLix({});
+
+	// Prepare change sets and commits identical to the preprocessor-driven path.
+	await lix.db
+		.insertInto("change_set_by_version")
+		.values([
+			{ id: "cs2", lixcol_version_id: "global" },
+			{ id: "working_cs2", lixcol_version_id: "global" },
+		])
+		.execute();
+
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{ id: "commit_cs2", change_set_id: "cs2", lixcol_version_id: "global" },
+			{
+				id: "working_commit_2",
+				change_set_id: "working_cs2",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
+	await lix.db
+		.insertInto("version")
+		.values({
+			id: "version_id_2",
+			name: "raw_update_version",
+			working_commit_id: "working_commit_2",
+		})
+		.execute();
+
+	// Execute the update directly through SQLite so the INSTEAD OF trigger handles it.
+	lix.engine!.sqlite.exec({
+		sql: `UPDATE active_version SET version_id = ?`,
+		bind: ["version_id_2"],
+	});
+
+	const rawResult = lix.engine!.sqlite.exec({
+		sql: `SELECT version_id FROM active_version`,
+		returnValue: "resultRows",
+		rowMode: "object",
+	});
+
+	expect(rawResult).toEqual([{ version_id: "version_id_2" }]);
+
+	await lix.close();
 });
 
 test("applying the schema should create an initial 'main' version", async () => {
@@ -237,33 +343,21 @@ test("applying the schema should set the initial active version to 'main'", asyn
 
 test("should use default id and name if not provided", async () => {
 	const lix = await openLix({});
-	// Pre-populate change_set table
-	await lix.db
-		.insertInto("change_set_all")
-		.values([{ id: "cs1", lixcol_version_id: "global" }])
-		.execute();
 
-	// Insert a version providing only change_set_id
-	await lix.db
-		.insertInto("version")
-		.values({
-			change_set_id: "cs1",
-			working_change_set_id: "cs1",
-		})
-		.execute();
+	// Insert a version providing only working_commit_id (no id/name provided)
+	await lix.db.insertInto("version").defaultValues().execute();
 
 	// Verify the inserted data (id and name should be defaulted)
 	const version = await lix.db
 		.selectFrom("version")
 		.selectAll()
-		.where("change_set_id", "=", "cs1")
 		.executeTakeFirstOrThrow();
 
 	expect(version?.id).toBeTypeOf("string");
 	expect(version?.id.length).toBeGreaterThan(0);
 	expect(version?.name).toBeTypeOf("string");
 	expect(version?.name?.length).toBeGreaterThan(0);
-	expect(version?.change_set_id).toBe("cs1");
+	// commit_id (tip) is not set via version view; defaults handled elsewhere
 
 	await lix.db
 		.updateTable("version")
@@ -282,58 +376,61 @@ test("should use default id and name if not provided", async () => {
 	expect(updatedVersion?.name).toBe("new_name");
 });
 
-test("should enforce foreign key constraint on change_set_id", async () => {
+test.skip("should enforce foreign key constraint on working_commit_id", async () => {
 	const lix = await openLix({});
 
-	// Attempt to insert version with non-existent change_set_id
-	await expect(
-		lix.db
-			.insertInto("version")
-			.values({
-				id: "version1",
-				name: "test_version",
-				change_set_id: "cs_nonexistent",
-				working_change_set_id: "cs_nonexistent",
-			})
-			.execute()
-	).rejects.toThrow(/Foreign key constraint violation/i);
-});
-
-test("should enforce foreign key constraint on working_change_set_id", async () => {
-	const lix = await openLix({});
-
-	// Create valid change set for change_set_id
+	// Create valid change set for commit_id
 	await lix.db
-		.insertInto("change_set_all")
+		.insertInto("change_set_by_version")
 		.values({ id: "cs1", lixcol_version_id: "global" })
 		.execute();
 
-	// Attempt to insert version with non-existent working_change_set_id
+	// Create required commit
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{ id: "commit_cs1", change_set_id: "cs1", lixcol_version_id: "global" },
+		])
+		.execute();
+
+	// Attempt to insert version with non-existent working_commit_id
 	await expect(
 		lix.db
 			.insertInto("version")
 			.values({
 				id: "version1",
 				name: "test_version",
-				change_set_id: "cs1",
-				working_change_set_id: "cs_nonexistent",
+				working_commit_id: "commit_nonexistent",
 			})
 			.execute()
-	).rejects.toThrow(/Foreign key constraint violation/i);
+	).rejects.toThrow();
 });
 
-test("should allow version insertion with valid change set references", async () => {
+test("should allow version insertion with valid working commit reference", async () => {
 	const lix = await openLix({});
 
 	// Create valid change sets
 	await lix.db
-		.insertInto("change_set_all")
+		.insertInto("change_set_by_version")
 		.values([
 			{ id: "cs1", lixcol_version_id: "global" },
 			{ id: "cs2", lixcol_version_id: "global" },
 		])
 		.execute();
 
+	// Create valid commits
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{ id: "commit_cs1", change_set_id: "cs1", lixcol_version_id: "global" },
+			{
+				id: "working_commit_cs2",
+				change_set_id: "cs2",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
 	// This should succeed with valid foreign key references
 	await expect(
 		lix.db
@@ -341,15 +438,14 @@ test("should allow version insertion with valid change set references", async ()
 			.values({
 				id: "version1",
 				name: "test_version",
-				change_set_id: "cs1",
-				working_change_set_id: "cs2",
+				working_commit_id: "working_commit_cs2",
 			})
 			.execute()
 	).resolves.toBeDefined();
 });
 
 // having the active_version as regular table is easier
-test.skip("should enforce foreign key constraint on active_version.version_id", async () => {
+test("should enforce FK on active_version.version_id against descriptor", async () => {
 	const lix = await openLix({});
 
 	// Now attempt to update active_version with non-existent version_id
@@ -366,17 +462,36 @@ test("should allow active_version update with valid version_id", async () => {
 
 	// Create valid change set and version
 	await lix.db
-		.insertInto("change_set_all")
+		.insertInto("change_set_by_version")
 		.values({ id: "cs1", lixcol_version_id: "global" })
 		.execute();
 
+	// Create required commit
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{ id: "commit_cs1", change_set_id: "cs1", lixcol_version_id: "global" },
+		])
+		.execute();
+
+	// Create working commit
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "working_commit_cs1",
+				change_set_id: "cs1",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
 	await lix.db
 		.insertInto("version")
 		.values({
 			id: "version1",
 			name: "test_version",
-			change_set_id: "cs1",
-			working_change_set_id: "cs1",
+			working_commit_id: "working_commit_cs1",
 		})
 		.execute();
 
@@ -394,7 +509,7 @@ test("versions should be globally accessible regardless of version context", asy
 
 	// Create required change sets
 	await lix.db
-		.insertInto("change_set_all")
+		.insertInto("change_set_by_version")
 		.values([
 			{ id: "cs_a", lixcol_version_id: "global" },
 			{ id: "cs_b", lixcol_version_id: "global" },
@@ -402,6 +517,41 @@ test("versions should be globally accessible regardless of version context", asy
 		])
 		.execute();
 
+	// Create working change sets
+	await lix.db
+		.insertInto("change_set_by_version")
+		.values([
+			{ id: "working_cs_a", lixcol_version_id: "global" },
+			{ id: "working_cs_b", lixcol_version_id: "global" },
+			{ id: "working_cs_c", lixcol_version_id: "global" },
+		])
+		.execute();
+
+	// Create required commits
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{ id: "commit_a", change_set_id: "cs_a", lixcol_version_id: "global" },
+			{ id: "commit_b", change_set_id: "cs_b", lixcol_version_id: "global" },
+			{ id: "commit_c", change_set_id: "cs_c", lixcol_version_id: "global" },
+			{
+				id: "working_commit_a",
+				change_set_id: "working_cs_a",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "working_commit_b",
+				change_set_id: "working_cs_b",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "working_commit_c",
+				change_set_id: "working_cs_c",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
 	// Create versions using the version view (simulating creation from different version contexts)
 	await lix.db
 		.insertInto("version")
@@ -409,20 +559,17 @@ test("versions should be globally accessible regardless of version context", asy
 			{
 				id: "version_a",
 				name: "Version A",
-				change_set_id: "cs_a",
-				working_change_set_id: "cs_a",
+				working_commit_id: "working_commit_a",
 			},
 			{
 				id: "version_b",
 				name: "Version B",
-				change_set_id: "cs_b",
-				working_change_set_id: "cs_b",
+				working_commit_id: "working_commit_b",
 			},
 			{
 				id: "version_c",
 				name: "Version C",
-				change_set_id: "cs_c",
-				working_change_set_id: "cs_c",
+				working_commit_id: "working_commit_c",
 			},
 		])
 		.execute();
@@ -458,7 +605,7 @@ test("mutation of a version's state should NOT lead to duplicate version entries
 		.selectFrom("version")
 		.where("id", "=", versionA.id)
 		.groupBy("id")
-		.select(["id", "name", "change_set_id", "working_change_set_id"])
+		.select(["id", "name", "commit_id", "working_commit_id"])
 		.execute();
 
 	expect(versionsBeforeMutation).toHaveLength(1);
@@ -466,12 +613,17 @@ test("mutation of a version's state should NOT lead to duplicate version entries
 	expect(versionsBeforeMutation[0]).toMatchObject({
 		id: versionA.id,
 		name: "versionA",
-		change_set_id: expect.any(String),
-		working_change_set_id: expect.any(String),
+		commit_id: expect.any(String),
+		working_commit_id: expect.any(String),
 	});
 
 	await lix.db
-		.insertInto("state_all")
+		.insertInto("stored_schema")
+		.values({ value: testStateSchema })
+		.execute();
+
+	await lix.db
+		.insertInto("state_by_version")
 		.values({
 			entity_id: "test_entity",
 			version_id: versionA.id,
@@ -487,15 +639,13 @@ test("mutation of a version's state should NOT lead to duplicate version entries
 		.selectFrom("version")
 		.where("id", "=", versionA.id)
 		.groupBy("id")
-		.select(["id", "name", "change_set_id", "working_change_set_id"])
+		.select(["id", "name", "commit_id", "working_commit_id"])
 		.execute();
 
 	expect(versionAAfterMutation).toHaveLength(1);
 
 	// The changeset should have advanced due to the state mutation
-	expect(versionAAfterMutation[0]?.change_set_id).not.toEqual(
-		versionA.change_set_id
-	);
+	expect(versionAAfterMutation[0]?.commit_id).not.toEqual(versionA.commit_id);
 });
 
 test("direct mutation of a version shouldn't lead to duplicate entries", async () => {
@@ -523,8 +673,8 @@ test("direct mutation of a version shouldn't lead to duplicate entries", async (
 		{
 			id: versionA.id,
 			name: "versionA",
-			change_set_id: expect.any(String),
-			working_change_set_id: expect.any(String),
+			commit_id: expect.any(String),
+			working_commit_id: expect.any(String),
 		},
 	]);
 
@@ -552,29 +702,29 @@ test("direct mutation of a version shouldn't lead to duplicate entries", async (
 		{
 			id: versionA.id,
 			name: "new name",
-			change_set_id: expect.any(String),
-			working_change_set_id: expect.any(String),
+			commit_id: expect.any(String),
+			working_commit_id: expect.any(String),
 		},
 	]);
 
 	// the version was updated in the global version aka
 	// the versions change set did not change itself
-	expect(versionsAfterMutation[0]?.change_set_id).toEqual(
-		versionABeforeMutation[0]?.change_set_id
+	expect(versionsAfterMutation[0]?.commit_id).toEqual(
+		versionABeforeMutation[0]?.commit_id
 	);
 
-	// but the global version's change set id should have changed
-	expect(globalVersionAfterMutation.change_set_id).not.toEqual(
-		globalVersionBeforeMutation.change_set_id
+	// but the global version's commit id should have changed
+	expect(globalVersionAfterMutation.commit_id).not.toEqual(
+		globalVersionBeforeMutation.commit_id
 	);
 });
 
-test("should enforce UNIQUE constraint on working_change_set_id", async () => {
+test("should enforce UNIQUE constraint on working_commit_id", async () => {
 	const lix = await openLix({});
 
 	// Insert necessary change sets to satisfy foreign keys
 	await lix.db
-		.insertInto("change_set_all")
+		.insertInto("change_set_by_version")
 		.values([
 			{ id: "cs1", lixcol_version_id: "global" },
 			{ id: "cs2", lixcol_version_id: "global" },
@@ -583,14 +733,32 @@ test("should enforce UNIQUE constraint on working_change_set_id", async () => {
 		])
 		.execute();
 
-	// Insert first version referencing workingCs1
+	// Create required commits
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{ id: "commit_cs1", change_set_id: "cs1", lixcol_version_id: "global" },
+			{ id: "commit_cs2", change_set_id: "cs2", lixcol_version_id: "global" },
+			{
+				id: "working_commit_1",
+				change_set_id: "workingCs1",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "working_commit_2",
+				change_set_id: "workingCs2",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
+	// Insert first version referencing working_commit_1
 	await lix.db
 		.insertInto("version")
 		.values({
 			id: "v1",
 			name: "version one",
-			change_set_id: "cs1",
-			working_change_set_id: "workingCs1",
+			working_commit_id: "working_commit_1",
 		})
 		.execute();
 
@@ -601,30 +769,28 @@ test("should enforce UNIQUE constraint on working_change_set_id", async () => {
 			.values({
 				id: "v2",
 				name: "version two",
-				change_set_id: "cs2", // Different historical point is fine
-				working_change_set_id: "workingCs1", // <<< Same working_change_set_id
+				working_commit_id: "working_commit_1", // <<< Same working_commit_id
 			})
 			.execute()
 	).rejects.toThrow(
-		/Unique constraint violation.*working_change_set_id.*workingCs1/i
+		/Unique constraint violation.*working_commit_id.*working_commit_1/i
 	);
 
-	// Inserting another version with a DIFFERENT working_change_set_id should succeed
+	// Inserting another version with a DIFFERENT working_commit_id should succeed
 	await expect(
 		lix.db
 			.insertInto("version")
 			.values({
 				id: "v3",
 				name: "version three",
-				change_set_id: "cs1", // Can branch from same historical point
-				working_change_set_id: "workingCs2", // <<< Different working_change_set_id
+				working_commit_id: "working_commit_2", // <<< Different working_commit_id
 			})
 			.execute()
 	).resolves.toBeDefined();
 });
 
 // there was a bug that wiped the cache, leading to a missing change_set
-test("initial version's change_set_id and working_change_set_id should exist in the change_set table", async () => {
+test("initial version's commit_id and working_commit_id should exist in the tables", async () => {
 	const lix = await openLix({});
 
 	// Get the initial 'main' version
@@ -634,25 +800,25 @@ test("initial version's change_set_id and working_change_set_id should exist in
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	// Verify change_set_id exists in change_set table
-	const changeSet = await lix.db
-		.selectFrom("change_set")
-		.where("id", "=", mainVersion.change_set_id)
+	// Verify commit_id exists in commit table
+	const commit = await lix.db
+		.selectFrom("commit")
+		.where("id", "=", mainVersion.commit_id)
 		.selectAll()
 		.executeTakeFirst();
 
-	expect(changeSet).toBeDefined();
-	expect(changeSet?.id).toBe(mainVersion.change_set_id);
+	expect(commit).toBeDefined();
+	expect(commit?.id).toBe(mainVersion.commit_id);
 
-	// Verify working_change_set_id exists in change_set table
-	const workingChangeSet = await lix.db
-		.selectFrom("change_set")
-		.where("id", "=", mainVersion.working_change_set_id)
+	// Verify working_commit_id exists in commit table
+	const workingCommit = await lix.db
+		.selectFrom("commit")
+		.where("id", "=", mainVersion.working_commit_id)
 		.selectAll()
 		.executeTakeFirst();
 
-	expect(workingChangeSet).toBeDefined();
-	expect(workingChangeSet?.id).toBe(mainVersion.working_change_set_id);
+	expect(workingCommit).toBeDefined();
+	expect(workingCommit?.id).toBe(mainVersion.working_commit_id);
 });
 
 test("inherits_from_version_id should default to global", async () => {
@@ -660,20 +826,36 @@ test("inherits_from_version_id should default to global", async () => {
 
 	// Create required change sets first
 	await lix.db
-		.insertInto("change_set_all")
+		.insertInto("change_set_by_version")
 		.values([
 			{ id: "change_set_1", lixcol_version_id: "global" },
 			{ id: "working_change_set_1", lixcol_version_id: "global" },
 		])
 		.execute();
 
+	// Create required commits
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "commit_1",
+				change_set_id: "change_set_1",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "working_commit_1",
+				change_set_id: "working_change_set_1",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
 	await lix.db
 		.insertInto("version")
 		.values({
 			id: "test_version",
 			name: "Test Version",
-			change_set_id: "change_set_1",
-			working_change_set_id: "working_change_set_1",
+			working_commit_id: "working_commit_1",
 			inherits_from_version_id: undefined, // Should default to 'global'
 		})
 		.execute();
@@ -706,21 +888,37 @@ test("versions should have hidden property defaulting to false", async () => {
 
 	// Create required change sets first
 	await lix.db
-		.insertInto("change_set_all")
+		.insertInto("change_set_by_version")
 		.values([
 			{ id: "cs_test", lixcol_version_id: "global" },
 			{ id: "working_cs_test", lixcol_version_id: "global" },
 		])
 		.execute();
 
+	// Create required commits
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "commit_test",
+				change_set_id: "cs_test",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "working_commit_test",
+				change_set_id: "working_cs_test",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
 	// Insert a version without specifying hidden
 	await lix.db
 		.insertInto("version")
 		.values({
 			id: "test_version",
 			name: "Test Version",
-			change_set_id: "cs_test",
-			working_change_set_id: "working_cs_test",
+			working_commit_id: "working_commit_test",
 		})
 		.execute();
 
@@ -765,21 +963,37 @@ test("can explicitly set hidden to true", async () => {
 
 	// Create required change sets first
 	await lix.db
-		.insertInto("change_set_all")
+		.insertInto("change_set_by_version")
 		.values([
 			{ id: "cs_hidden", lixcol_version_id: "global" },
 			{ id: "working_cs_hidden", lixcol_version_id: "global" },
 		])
 		.execute();
 
+	// Create required commits
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "commit_hidden",
+				change_set_id: "cs_hidden",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "working_commit_hidden",
+				change_set_id: "working_cs_hidden",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
 	// Insert a version with hidden explicitly set to true
 	await lix.db
 		.insertInto("version")
 		.values({
 			id: "hidden_version",
 			name: "Hidden Version",
-			change_set_id: "cs_hidden",
-			working_change_set_id: "working_cs_hidden",
+			working_commit_id: "working_commit_hidden",
 			hidden: true,
 		})
 		.execute();
@@ -792,3 +1006,251 @@ test("can explicitly set hidden to true", async () => {
 
 	expect(version.hidden).toBe(1);
 });
+
+// V2 unified view tests (merged)
+
+test("insert via version writes descriptor + tip when commit_id provided", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("change_set_by_version")
+		.values([
+			{ id: "cs_unified_1", lixcol_version_id: "global" },
+			{ id: "wcs_unified_1", lixcol_version_id: "global" },
+		])
+		.execute();
+
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "c_unified_1",
+				change_set_id: "cs_unified_1",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "wc_unified_1",
+				change_set_id: "wcs_unified_1",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
+	await lix.db
+		.insertInto("version")
+		.values({
+			id: "v_unified_1",
+			name: "v_unified_1",
+			working_commit_id: "wc_unified_1",
+			commit_id: "c_unified_1",
+		})
+		.execute();
+
+	const v = await lix.db
+		.selectFrom("version")
+		.where("id", "=", "v_unified_1")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(v.name).toBe("v_unified_1");
+	expect(v.working_commit_id).toBe("wc_unified_1");
+	expect(v.commit_id).toBe("c_unified_1");
+
+	const changes = await lix.db
+		.selectFrom("change")
+		.where("entity_id", "=", "v_unified_1")
+		.orderBy("created_at", "asc")
+		.selectAll()
+		.execute();
+
+	const byKey = new Map(
+		changes.map((c) => [
+			c.schema_key,
+			typeof c.snapshot_content === "string"
+				? JSON.parse(c.snapshot_content)
+				: c.snapshot_content,
+		])
+	);
+	expect(byKey.get("lix_version_descriptor")).toMatchObject({
+		id: "v_unified_1",
+		name: "v_unified_1",
+	});
+	expect(byKey.get("lix_version_tip")).toMatchObject({
+		id: "v_unified_1",
+		commit_id: "c_unified_1",
+		working_commit_id: "wc_unified_1",
+	});
+});
+
+test("insert via version without commit_id auto-inserts a tip", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("change_set_by_version")
+		.values([{ id: "wcs_unified_2", lixcol_version_id: "global" }])
+		.execute();
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "wc_unified_2",
+				change_set_id: "wcs_unified_2",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
+	await lix.db
+		.insertInto("version")
+		.values({
+			id: "v_unified_2",
+			name: "v_unified_2",
+			working_commit_id: "wc_unified_2",
+		})
+		.execute();
+
+	const v = await lix.db
+		.selectFrom("version")
+		.where("id", "=", "v_unified_2")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(typeof v.commit_id).toBe("string");
+	expect((v.commit_id as string).length).toBeGreaterThan(0);
+
+	const tipRows = await lix.db
+		.selectFrom("change")
+		.where("entity_id", "=", "v_unified_2")
+		.where("schema_key", "=", "lix_version_tip")
+		.selectAll()
+		.execute();
+	expect(tipRows.length).toBe(1);
+});
+
+test("insert via version_by_version writes descriptor + tip in scoped version", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("change_set_by_version")
+		.values([
+			{ id: "cs_unified_3", lixcol_version_id: "global" },
+			{ id: "wcs_unified_3", lixcol_version_id: "global" },
+		])
+		.execute();
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "c_unified_3",
+				change_set_id: "cs_unified_3",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "wc_unified_3",
+				change_set_id: "wcs_unified_3",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
+	await lix.db
+		.insertInto("version_by_version")
+		.values({
+			id: "v_unified_3",
+			name: "v_unified_3",
+			working_commit_id: "wc_unified_3",
+			commit_id: "c_unified_3",
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	const v = await lix.db
+		.selectFrom("version")
+		.where("id", "=", "v_unified_3")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+	expect(v.commit_id).toBe("c_unified_3");
+});
+
+test("commit_id FK uses materialized mode (lenient on insert)", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("change_set_by_version")
+		.values([{ id: "wcs_unified_6", lixcol_version_id: "global" }])
+		.execute();
+
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "wc_unified_6",
+				change_set_id: "wcs_unified_6",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
+	await expect(
+		lix.db
+			.insertInto("version")
+			.values({
+				id: "v_unified_6",
+				name: "v_unified_6",
+				working_commit_id: "wc_unified_6",
+				commit_id: "does_not_exist",
+			})
+			.execute()
+	).resolves.toBeDefined();
+});
+
+test("delete via version writes descriptor + tip tombstones", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("change_set_by_version")
+		.values([
+			{ id: "cs_unified_7", lixcol_version_id: "global" },
+			{ id: "wcs_unified_7", lixcol_version_id: "global" },
+		])
+		.execute();
+	await lix.db
+		.insertInto("commit_by_version")
+		.values([
+			{
+				id: "c_unified_7",
+				change_set_id: "cs_unified_7",
+				lixcol_version_id: "global",
+			},
+			{
+				id: "wc_unified_7",
+				change_set_id: "wcs_unified_7",
+				lixcol_version_id: "global",
+			},
+		])
+		.execute();
+
+	await lix.db
+		.insertInto("version")
+		.values({
+			id: "v_unified_7",
+			name: "v_unified_7",
+			working_commit_id: "wc_unified_7",
+			commit_id: "c_unified_7",
+		})
+		.execute();
+
+	await lix.db.deleteFrom("version").where("id", "=", "v_unified_7").execute();
+
+	const changes = await lix.db
+		.selectFrom("change")
+		.where("entity_id", "=", "v_unified_7")
+		.orderBy("created_at", "asc")
+		.selectAll()
+		.execute();
+
+	const tombstones = changes.filter(
+		(c) => c.snapshot_content === null || c.snapshot_content === undefined
+	);
+	expect(tombstones.length).toBeGreaterThanOrEqual(2);
+});