@lix-js/sdk 0.5.0-preview.1 → 0.5.1

package/src/state/materialize-state.test.ts

@@ -1,14 +1,55 @@
 import { describe, expect } from "vitest";
+import { sql } from "kysely";
 import { selectActiveVersion } from "../version/select-active-version.js";
 import { createVersion } from "../version/create-version.js";
-import { timestamp } from "../deterministic/timestamp.js";
+import { getTimestamp } from "../engine/functions/timestamp.js";
 import {
 	simulationTest,
 	normalSimulation,
 	outOfOrderSequenceSimulation,
 } from "../test-utilities/simulation-test/simulation-test.js";
-
-describe("internal_materialization_version_tips", () => {
+import {
+	LixVersionTipSchema,
+	type LixVersionTip,
+} from "../version/schema-definition.js";
+import type { LixSchemaDefinition } from "../schema-definition/definition.js";
+
+function stripWriterKey<T extends Record<string, any> | null | undefined>(
+	row: T
+): T {
+	if (!row) return row;
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	const { writer_key, metadata, ...rest } = row as any;
+	return rest as T;
+}
+
+const testEntitySchema = {
+	"x-lix-key": "test_entity",
+	"x-lix-version": "1.0",
+	type: "object",
+	nullable: true,
+	additionalProperties: false,
+	properties: {
+		id: { type: "string" },
+		name: { type: "string" },
+		value: { type: "string" },
+		status: { type: "string" },
+		data: { type: "string" },
+		active: { type: "boolean" },
+	},
+	required: ["id"],
+} as const satisfies LixSchemaDefinition;
+
+async function storeMaterializationTestSchemas(lix: {
+	db: any;
+}): Promise<void> {
+	await lix.db
+		.insertInto("stored_schema")
+		.values({ value: testEntitySchema })
+		.execute();
+}
+
+describe("lix_internal_materialization_version_tips", () => {
 	simulationTest(
 		"includes all versions with state, even if other versions branch from them",
 		async ({ openSimulatedLix }) => {
@@ -18,18 +59,19 @@ describe("internal_materialization_version_tips", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create base version with state
 			await createVersion({ lix, id: "base-version" });
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "base-entity",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "base-version",
@@ -55,10 +97,10 @@ describe("internal_materialization_version_tips", () => {
 
 			// Add state to version A (this will create a new commit, making base-version no longer a "tip")
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-a",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "version-a",
@@ -77,10 +119,10 @@ describe("internal_materialization_version_tips", () => {
 
 			// Add state to version B
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-b",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "version-b",
@@ -94,7 +136,7 @@ describe("internal_materialization_version_tips", () => {
 
 			// Query version tips - should include ALL versions with state, not just leaf tips
 			const tips = await lix.db
-				.selectFrom("internal_materialization_version_tips" as any)
+				.selectFrom("lix_internal_materialization_version_tips" as any)
 				.selectAll()
 				.where("version_id", "in", ["base-version", "version-a", "version-b"])
 				.orderBy("version_id")
@@ -116,7 +158,7 @@ describe("internal_materialization_version_tips", () => {
 
 			// Verify that the base version's state can be materialized (not excluded from materialization pipeline)
 			const baseMaterializedState = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "base-version")
 				.where("entity_id", "=", "base-entity")
@@ -140,17 +182,18 @@ describe("internal_materialization_version_tips", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			const activeVersion =
 				await selectActiveVersion(lix).executeTakeFirstOrThrow();
 
 			// Query the view
 			const results = await lix.db
-				.selectFrom("internal_materialization_version_tips" as any)
+				.selectFrom("lix_internal_materialization_version_tips" as any)
 				.where("version_id", "=", activeVersion.id)
 				.selectAll()
 				.execute();
@@ -172,17 +215,18 @@ describe("internal_materialization_version_tips", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			const activeVersion =
 				await selectActiveVersion(lix).executeTakeFirstOrThrow();
 
 			// Get initial tip
 			const initialResults = await lix.db
-				.selectFrom("internal_materialization_version_tips" as any)
+				.selectFrom("lix_internal_materialization_version_tips" as any)
 				.where("version_id", "=", activeVersion.id)
 				.selectAll()
 				.execute();
@@ -194,7 +238,7 @@ describe("internal_materialization_version_tips", () => {
 				.insertInto("state")
 				.values({
 					entity_id: "entity-1",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					plugin_key: "mock-plugin",
@@ -204,7 +248,7 @@ describe("internal_materialization_version_tips", () => {
 
 			// Get updated tip
 			const updatedResults = await lix.db
-				.selectFrom("internal_materialization_version_tips" as any)
+				.selectFrom("lix_internal_materialization_version_tips" as any)
 				.where("version_id", "=", activeVersion.id)
 				.selectAll()
 				.execute();
@@ -228,10 +272,11 @@ describe("internal_materialization_version_tips", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create two versions
 			await createVersion({ lix, id: "version-1" });
@@ -239,10 +284,10 @@ describe("internal_materialization_version_tips", () => {
 
 			// Add state to version1 to create a commit
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-1",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "version-1",
@@ -253,10 +298,10 @@ describe("internal_materialization_version_tips", () => {
 
 			// Add state to version2 to create a commit
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-2",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "version-2",
@@ -267,7 +312,7 @@ describe("internal_materialization_version_tips", () => {
 
 			// Get tips for both versions
 			const tips = await lix.db
-				.selectFrom("internal_materialization_version_tips" as any)
+				.selectFrom("lix_internal_materialization_version_tips" as any)
 				.selectAll()
 				.where("version_id", "in", ["version-1", "version-2"])
 				.orderBy("version_id")
@@ -284,10 +329,10 @@ describe("internal_materialization_version_tips", () => {
 
 			// Add more state to version1 to move its tip
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-3",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "version-1",
@@ -301,7 +346,7 @@ describe("internal_materialization_version_tips", () => {
 
 			// Get updated tips
 			const updatedTips = await lix.db
-				.selectFrom("internal_materialization_version_tips" as any)
+				.selectFrom("lix_internal_materialization_version_tips" as any)
 				.selectAll()
 				.orderBy("version_id")
 				.execute();
@@ -323,7 +368,177 @@ describe("internal_materialization_version_tips", () => {
 	);
 });
 
-describe("internal_materialization_commit_graph", () => {
+simulationTest(
+	"materializes change_author from commit.author_account_ids",
+	async ({ openSimulatedLix, expectDeterministic }) => {
+		const lix = await openSimulatedLix({
+			account: {
+				id: "materialization-test-account",
+				name: "Materialization Test User",
+			},
+			keyValues: [
+				{
+					key: "lix_deterministic_mode",
+					value: { enabled: true },
+					lixcol_version_id: "global",
+				},
+			],
+		});
+		await storeMaterializationTestSchemas(lix);
+
+		// Insert a tracked key_value on active version to trigger a commit
+		const kvKey = "kv_for_author_mat";
+		await lix.db
+			.insertInto("key_value")
+			.values({ key: kvKey, value: "v1" })
+			.execute();
+
+		// Domain change id for that key_value
+		const kvChange = await lix.db
+			.selectFrom("change")
+			.where("schema_key", "=", "lix_key_value")
+			.where("entity_id", "=", kvKey)
+			.orderBy("created_at", "desc")
+			.select(["id"]) // domain change id
+			.executeTakeFirstOrThrow();
+
+		// Authors should appear in lix_internal_materialization_latest_visible_state
+		const authorRows = await lix.db
+			.selectFrom("lix_internal_materialization_latest_visible_state" as any)
+			.selectAll()
+			.where("schema_key", "=", "lix_change_author")
+			.where(
+				sql`json_extract(snapshot_content, '$.change_id')`,
+				"=",
+				kvChange.id
+			)
+			.execute();
+
+		expectDeterministic(authorRows.length).toBe(1);
+
+		// Verify account and lineage
+		const active = await lix.db
+			.selectFrom("active_account")
+			.selectAll()
+			.execute();
+		const activeAccountId = active[0]!.account_id;
+		expectDeterministic(
+			(authorRows[0] as any)?.snapshot_content?.account_id
+		).toBe(activeAccountId);
+
+		// The materializer uses the commit change row id as 'change_id' column for provenance
+		const commitChangeId = (authorRows[0] as any)?.change_id;
+		const commitRow = await lix.db
+			.selectFrom("change")
+			.where("schema_key", "=", "lix_commit")
+			.where("id", "=", commitChangeId)
+			.selectAll()
+			.executeTakeFirst();
+
+		expectDeterministic(!!commitRow).toBe(true);
+	}
+);
+
+// Ensures version tip equals the lix_version_tip snapshot commit_id in the materializer
+simulationTest(
+	"version tip matches lix_version_tip snapshot commit_id",
+	async ({ openSimulatedLix, expectDeterministic }) => {
+		const lix = await openSimulatedLix({
+			keyValues: [
+				{
+					key: "lix_deterministic_mode",
+					value: { enabled: true },
+					lixcol_version_id: "global",
+				},
+			],
+		});
+		await storeMaterializationTestSchemas(lix);
+
+		// Create a new version from the current global tip
+		const { id: versionId } = await createVersion({
+			lix,
+			name: "tip-vs-snapshot",
+		});
+
+		const tips = await (lix.db as any)
+			.selectFrom("lix_internal_materialization_version_tips" as any)
+			.selectAll()
+			.where("version_id", "=", versionId)
+			.execute();
+
+		expectDeterministic(tips.length).toBe(1);
+
+		const matRows = await (lix.db as any)
+			.selectFrom("lix_internal_state_materializer" as any)
+			.select(sql`json_extract(snapshot_content,'$.commit_id')`.as("commit_id"))
+			.where("schema_key", "=", "lix_version_tip")
+			.where("version_id", "=", "global")
+			.where("entity_id", "=", versionId)
+			.execute();
+
+		expectDeterministic(matRows.length).toBe(1);
+		expectDeterministic(matRows[0]!.commit_id).toBe(tips[0]!.tip_commit_id);
+	}
+);
+
+// Regression: materializer tip for a version must match tips view after a commit on that version
+simulationTest(
+	"materializer tip equals tips view after committing on a version",
+	async ({ openSimulatedLix, expectDeterministic }) => {
+		const lix = await openSimulatedLix({
+			keyValues: [
+				{
+					key: "lix_deterministic_mode",
+					value: { enabled: true },
+					lixcol_version_id: "global",
+					lixcol_untracked: true,
+				},
+			],
+		});
+		await storeMaterializationTestSchemas(lix);
+
+		// Create version A
+		const versionA = await createVersion({ lix, id: "mat-tip-version-a" });
+
+		// Insert tracked state into version A to trigger a real commit
+		await lix.db
+			.insertInto("state_by_version")
+			.values({
+				entity_id: "mat-entity-1",
+				schema_key: "test_entity",
+				schema_version: "1.0",
+				file_id: "mat-file",
+				version_id: versionA.id,
+				plugin_key: "mock-plugin",
+				snapshot_content: { id: "mat-entity-1", name: "Mat Entity" },
+			})
+			.execute();
+
+		// Read tip from materializer tips view via Kysely on internal view
+		const tips = await (lix.db as any)
+			.selectFrom("lix_internal_materialization_version_tips" as any)
+			.selectAll()
+			.where("version_id", "=", versionA.id)
+			.execute();
+
+		expectDeterministic(tips.length).toBe(1);
+		expectDeterministic(tips[0]!.tip_commit_id).not.toEqual(versionA.commit_id);
+
+		// Read tip from lix_internal_state_materializer via Kysely with expression select
+		const matRows = await (lix.db as any)
+			.selectFrom("lix_internal_state_materializer" as any)
+			.select(sql`json_extract(snapshot_content,'$.commit_id')`.as("commit_id"))
+			.where("schema_key", "=", "lix_version_tip")
+			.where("version_id", "=", "global")
+			.where("entity_id", "=", versionA.id)
+			.execute();
+
+		expectDeterministic(matRows.length).toBe(1);
+		expectDeterministic(matRows[0]!.commit_id).toBe(tips[0]!.tip_commit_id);
+	}
+);
+
+describe("lix_internal_materialization_commit_graph", () => {
 	simulationTest(
 		"builds linear commit history with correct depths",
 		async ({ openSimulatedLix }) => {
@@ -333,10 +548,13 @@ describe("internal_materialization_commit_graph", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
+						lixcol_untracked: true,
+						lixcol_version_id: "global",
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create a version
 			const initialVersion = await createVersion({
@@ -346,10 +564,10 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Create commit 1 (will be at depth 2)
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-1",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "linear-test-version",
@@ -371,10 +589,10 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Create commit 2 (will be at depth 1)
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-2",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "linear-test-version",
@@ -396,10 +614,10 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Create commit 3 (will be at depth 0 - tip)
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-3",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "linear-test-version",
@@ -422,7 +640,7 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Query the commit graph view
 			const graph = await lix.db
-				.selectFrom("internal_materialization_commit_graph" as any)
+				.selectFrom("lix_internal_materialization_commit_graph" as any)
 				.selectAll()
 				.where("version_id", "=", "linear-test-version")
 				.orderBy("depth")
@@ -480,10 +698,13 @@ describe("internal_materialization_commit_graph", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
+						lixcol_untracked: true,
+						lixcol_version_id: "global",
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create two versions that branch from a common commit
 			await createVersion({ lix, id: "branch-version-1" });
@@ -491,10 +712,10 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Create a common commit in version1
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "common-entity",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "branch-version-1",
@@ -523,10 +744,10 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Create diverging commits in version1
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "branch1-entity",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "branch-version-1",
@@ -537,10 +758,10 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Create diverging commits in version2
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "branch2-entity",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "branch-version-2",
@@ -551,7 +772,7 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Query the commit graph for version1
 			const graph1 = await lix.db
-				.selectFrom("internal_materialization_commit_graph" as any)
+				.selectFrom("lix_internal_materialization_commit_graph" as any)
 				.selectAll()
 				.where("version_id", "=", "branch-version-1")
 				.orderBy("depth")
@@ -559,7 +780,7 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Query the commit graph for version2
 			const graph2 = await lix.db
-				.selectFrom("internal_materialization_commit_graph" as any)
+				.selectFrom("lix_internal_materialization_commit_graph" as any)
 				.selectAll()
 				.where("version_id", "=", "branch-version-2")
 				.orderBy("depth")
@@ -620,10 +841,11 @@ describe("internal_materialization_commit_graph", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create version A
 			await createVersion({ lix, id: "merge-version-a" });
@@ -633,10 +855,10 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Add unique changes to version A
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-a",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "merge-version-a",
@@ -647,10 +869,10 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Add unique changes to version B
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-b",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "merge-version-b",
@@ -662,7 +884,7 @@ describe("internal_materialization_commit_graph", () => {
 			// Get both version tips
 			const versionATip = await lix.db
 				.selectFrom("version")
-				.select("commit_id")
+				.selectAll()
 				.where("id", "=", "merge-version-a")
 				.executeTakeFirstOrThrow();
 
@@ -673,72 +895,61 @@ describe("internal_materialization_commit_graph", () => {
 				.executeTakeFirstOrThrow();
 
 			// Create a merge commit manually with two parent edges
-			const ts = timestamp({ lix });
+			const ts = await getTimestamp({ lix });
 			const mergeCommitId = `merge-${ts}`;
 			const mergeChangeSetId = `cs-${mergeCommitId}`;
 
 			// Create the change set first
 			await lix.db
-				.insertInto("change_set_all")
+				.insertInto("change_set_by_version")
 				.values({
 					id: mergeChangeSetId,
 					lixcol_version_id: "global",
 				})
 				.execute();
 
-			// Create the merge commit in commit_all (global version)
+			// Insert a commit change with parent_commit_ids (changes-only materializer)
+			const mergeCommitChangeId = `chg-${mergeCommitId}`;
 			await lix.db
-				.insertInto("commit_all")
+				.insertInto("change")
 				.values({
-					id: mergeCommitId,
-					change_set_id: mergeChangeSetId,
-					lixcol_version_id: "global",
+					id: mergeCommitChangeId,
+					entity_id: mergeCommitId,
+					schema_key: "lix_commit",
+					schema_version: "1.0",
+					file_id: "lix",
+					plugin_key: "lix_sdk",
+					snapshot_content: {
+						id: mergeCommitId,
+						change_set_id: mergeChangeSetId,
+						parent_commit_ids: [versionATip.commit_id, versionBTip.commit_id],
+					},
+					created_at: ts,
 				})
 				.execute();
 
-			// Create edges to both parents
+			// Update version A tip via version_tip (commit-anchored pointer)
 			await lix.db
 				.insertInto("change")
-				.values([
-					{
-						id: `edge-1-${mergeCommitId}`,
-						entity_id: `edge-${mergeCommitId}-${versionATip.commit_id}`,
-						schema_key: "lix_commit_edge",
-						schema_version: "1.0",
-						file_id: "lix-file",
-						plugin_key: "lix",
-						snapshot_content: {
-							parent_id: versionATip.commit_id,
-							child_id: mergeCommitId,
-						},
-						created_at: ts,
-					},
-					{
-						id: `edge-2-${mergeCommitId}`,
-						entity_id: `edge-${mergeCommitId}-${versionBTip.commit_id}`,
-						schema_key: "lix_commit_edge",
-						schema_version: "1.0",
-						file_id: "lix-file",
-						plugin_key: "lix",
-						snapshot_content: {
-							parent_id: versionBTip.commit_id,
-							child_id: mergeCommitId,
-						},
-						created_at: ts,
-					},
-				])
-				.execute();
-
-			// Update version A to point to the merge commit
-			await lix.db
-				.updateTable("version")
-				.set({ commit_id: mergeCommitId })
-				.where("id", "=", "merge-version-a")
+				.values({
+					id: `vt-${mergeCommitId}`,
+					entity_id: "merge-version-a",
+					schema_key: LixVersionTipSchema["x-lix-key"],
+					schema_version: LixVersionTipSchema["x-lix-version"],
+					file_id: "lix",
+					plugin_key: "lix_sdk",
+					snapshot_content: {
+						id: "merge-version-a",
+						commit_id: mergeCommitId,
+						working_commit_id: versionATip.working_commit_id,
+					} satisfies LixVersionTip,
+					created_at: ts,
+				})
 				.execute();
 
 			// Query the commit graph for the merged version
 			const graph = await lix.db
-				.selectFrom("internal_materialization_commit_graph" as any)
+				.selectFrom("lix_internal_materialization_commit_graph" as any)
 				.selectAll()
 				.where("version_id", "=", "merge-version-a")
 				.orderBy("depth")
@@ -798,22 +1009,23 @@ describe("internal_materialization_commit_graph", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create three versions
-			await createVersion({ lix, id: "version-cycle-a" });
-			await createVersion({
+			const versionA = await createVersion({ lix, id: "version-cycle-a" });
+			const versionB = await createVersion({
 				lix,
 				id: "version-cycle-b",
-				inherits_from_version_id: "version-cycle-a",
+				inheritsFrom: versionA,
 			});
 			await createVersion({
 				lix,
 				id: "version-cycle-c",
-				inherits_from_version_id: "version-cycle-b",
+				inheritsFrom: versionB,
 			});
 
 			// Manually create a cycle by updating version A to inherit from C
@@ -828,7 +1040,7 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Query version ancestry - should not hang due to cycle detection
 			const ancestry = await lix.db
-				.selectFrom("internal_materialization_version_ancestry" as any)
+				.selectFrom("lix_internal_materialization_version_ancestry" as any)
 				.selectAll()
 				.where("version_id", "=", "version-cycle-a")
 				.execute();
@@ -865,10 +1077,13 @@ describe("internal_materialization_commit_graph", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
+						lixcol_untracked: true,
+						lixcol_version_id: "global",
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create three versions
 			await createVersion({ lix, id: "version-x" });
@@ -877,10 +1092,10 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Add commits to each version
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-x",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "version-x",
@@ -890,10 +1105,10 @@ describe("internal_materialization_commit_graph", () => {
 				.execute();
 
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-y",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "version-y",
@@ -904,19 +1119,19 @@ describe("internal_materialization_commit_graph", () => {
 
 			// Query graphs for each version
 			const graphX = await lix.db
-				.selectFrom("internal_materialization_commit_graph" as any)
+				.selectFrom("lix_internal_materialization_commit_graph" as any)
 				.selectAll()
 				.where("version_id", "=", "version-x")
 				.execute();
 
 			const graphY = await lix.db
-				.selectFrom("internal_materialization_commit_graph" as any)
+				.selectFrom("lix_internal_materialization_commit_graph" as any)
 				.selectAll()
 				.where("version_id", "=", "version-y")
 				.execute();
 
 			const graphZ = await lix.db
-				.selectFrom("internal_materialization_commit_graph" as any)
+				.selectFrom("lix_internal_materialization_commit_graph" as any)
 				.selectAll()
 				.where("version_id", "=", "version-z")
 				.execute();
@@ -960,7 +1175,222 @@ describe("internal_materialization_commit_graph", () => {
 	);
 });
 
-describe("internal_materialization_latest_visible_state", () => {
+// Ensure commit edges are projected by the materializer from commit.parent_commit_ids
+simulationTest(
+	"materializer emits commit_edge rows from commit parent ids",
+	async ({ openSimulatedLix, expectDeterministic }) => {
+		const lix = await openSimulatedLix({
+			keyValues: [
+				{
+					key: "lix_deterministic_mode",
+					value: { enabled: true },
+				},
+			],
+		});
+		await storeMaterializationTestSchemas(lix);
+
+		// Create two versions and commit one change in each to produce parent commits
+		const vA = await createVersion({ lix, id: "edge-test-a" });
+		const vB = await createVersion({ lix, id: "edge-test-b" });
+
+		await lix.db
+			.insertInto("state_by_version")
+			.values({
+				entity_id: "edge-entity-a",
+				schema_key: "test_entity",
+				schema_version: "1.0",
+				file_id: "edge-file",
+				version_id: vA.id,
+				plugin_key: "mock-plugin",
+				snapshot_content: { id: "edge-entity-a", name: "A" },
+			})
+			.execute();
+
+		await lix.db
+			.insertInto("state_by_version")
+			.values({
+				entity_id: "edge-entity-b",
+				schema_key: "test_entity",
+				schema_version: "1.0",
+				file_id: "edge-file",
+				version_id: vB.id,
+				plugin_key: "mock-plugin",
+				snapshot_content: { id: "edge-entity-b", name: "B" },
+			})
+			.execute();
+
+		const tipA = await lix.db
+			.selectFrom("version")
+			.select("commit_id")
+			.where("id", "=", vA.id)
+			.executeTakeFirstOrThrow();
+		const tipB = await lix.db
+			.selectFrom("version")
+			.select("commit_id")
+			.where("id", "=", vB.id)
+			.executeTakeFirstOrThrow();
+
+		// Create a new commit that has both tips as parents
+		const ts = await getTimestamp({ lix });
+		const mergeCommitId = `edge-merge-${ts}`;
+		const mergeChangeSetId = `cs-${mergeCommitId}`;
+
+		// Ensure a changeset entity exists (not strictly required for edges but keeps commit snapshot coherent)
+		await lix.db
+			.insertInto("change_set_by_version")
+			.values({ id: mergeChangeSetId, lixcol_version_id: "global" })
+			.execute();
+
+		await lix.db
+			.insertInto("change")
+			.values({
+				id: `chg-${mergeCommitId}`,
+				entity_id: mergeCommitId,
+				schema_key: "lix_commit",
+				schema_version: "1.0",
+				file_id: "lix",
+				plugin_key: "lix_sdk",
+				snapshot_content: {
+					id: mergeCommitId,
+					change_set_id: mergeChangeSetId,
+					parent_commit_ids: [tipA.commit_id, tipB.commit_id],
+				},
+				created_at: ts,
+			})
+			.execute();
+
+		// Point version A to the merge commit so the graph seeds include it
+		await lix.db
+			.insertInto("change")
+			.values({
+				id: `vt-${mergeCommitId}`,
+				entity_id: vA.id,
+				schema_key: LixVersionTipSchema["x-lix-key"],
+				schema_version: LixVersionTipSchema["x-lix-version"],
+				file_id: "lix",
+				plugin_key: "lix_sdk",
+				snapshot_content: { id: vA.id, commit_id: mergeCommitId },
+				created_at: ts,
+			})
+			.execute();
+
+		// Read edges from the materializer for this merge commit (global scope)
+		const edges = await lix.db
+			.selectFrom("lix_internal_state_materializer" as any)
+			.select([
+				sql`json_extract(snapshot_content, '$.parent_id')`.as("parent_id"),
+				sql`json_extract(snapshot_content, '$.child_id')`.as("child_id"),
+			])
+			.where("schema_key", "=", "lix_commit_edge")
+			.where("version_id", "=", "global")
+			.where(
+				sql`json_extract(snapshot_content, '$.child_id')`,
+				"=",
+				mergeCommitId as any
+			)
+			.execute();
+
+		// Exactly two parent edges (counts should be deterministic across simulations)
+		expectDeterministic(edges.length).toBe(2);
+
+		// Parents themselves can vary between simulations; assert membership within each run
+		const parents = new Set(edges.map((e: any) => e.parent_id));
+		expect(parents.has(tipA.commit_id)).toBe(true);
+		expect(parents.has(tipB.commit_id)).toBe(true);
+	}
+);
+
+// Ensure change set elements are materialized for domain changes
+simulationTest(
+	"materializer emits change_set_elements for commit.change_ids",
+	async ({ openSimulatedLix, expectDeterministic }) => {
+		const lix = await openSimulatedLix({
+			keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
+		});
+		await storeMaterializationTestSchemas(lix);
+
+		// Create a version and make two domain changes in a single statement
+		const v = await createVersion({ lix, id: "cse-dom-version" });
+
+		await lix.db
+			.insertInto("state_by_version")
+			.values([
+				{
+					entity_id: "dom-1",
+					schema_key: "test_entity",
+					schema_version: "1.0",
+					file_id: "cse-file",
+					version_id: v.id,
+					plugin_key: "mock-plugin",
+					snapshot_content: { id: "dom-1", name: "one" },
+				},
+				{
+					entity_id: "dom-2",
+					schema_key: "test_entity",
+					schema_version: "1.0",
+					file_id: "cse-file",
+					version_id: v.id,
+					plugin_key: "mock-plugin",
+					snapshot_content: { id: "dom-2", name: "two" },
+				},
+			])
+			.execute();
+
+		// Read the commit and its change_set_id
+		const ver = await lix.db
+			.selectFrom("version")
+			.selectAll()
+			.where("id", "=", v.id)
+			.executeTakeFirstOrThrow();
+
+		const commitRow = await lix.db
+			.selectFrom("change")
+			.select([sql`json(snapshot_content)`.as("snapshot")])
+			.where("schema_key", "=", "lix_commit")
+			.where(
+				sql`json_extract(snapshot_content, '$.id')`,
+				"=",
+				ver.commit_id as any
+			)
+			.executeTakeFirstOrThrow();
+
+		const changeSetId = (commitRow as any).snapshot.change_set_id as string;
+
+		// Query materializer for CSE rows for this change set (domain-only)
+		const cseRows = await lix.db
+			.selectFrom("lix_internal_state_materializer" as any)
+			.select([
+				sql`json_extract(snapshot_content, '$.change_set_id')`.as(
+					"change_set_id"
+				),
+				sql`json_extract(snapshot_content, '$.change_id')`.as("change_id"),
+				sql`json_extract(snapshot_content, '$.entity_id')`.as("entity_id"),
+				sql`json_extract(snapshot_content, '$.schema_key')`.as("schema_key"),
+			])
+			.where("schema_key", "=", "lix_change_set_element")
+			.where("version_id", "=", "global")
+			.where(
+				sql`json_extract(snapshot_content, '$.change_set_id')`,
+				"=",
+				changeSetId as any
+			)
+			.where(
+				sql`json_extract(snapshot_content, '$.schema_key')`,
+				"=",
+				"test_entity" as any
+			)
+			.execute();
+
+		// Expect exactly two domain CSEs (for dom-1 and dom-2)
+		expectDeterministic(cseRows.length).toBe(2);
+
+		const ids = new Set(cseRows.map((r: any) => r.entity_id));
+		expect(ids.has("dom-1")).toBe(true);
+		expect(ids.has("dom-2")).toBe(true);
+	}
+);
+
+describe("lix_internal_materialization_latest_visible_state", () => {
 	simulationTest(
 		"finds latest change for each entity in a single version",
 		async ({ openSimulatedLix }) => {
@@ -970,10 +1400,11 @@ describe("internal_materialization_latest_visible_state", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create a version
 			await createVersion({ lix, id: "latest-test-version" });
@@ -981,49 +1412,61 @@ describe("internal_materialization_latest_visible_state", () => {
 			// Create multiple changes to the same entity
 			// First change - create entity
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-1",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "latest-test-version",
 					plugin_key: "mock-plugin",
-					snapshot_content: { id: "entity-1", name: "Initial Name", value: 1 },
+					snapshot_content: {
+						id: "entity-1",
+						name: "Initial Name",
+						value: "1",
+					},
 				})
 				.execute();
 
 			// Second change - update entity
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-1",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "latest-test-version",
 					plugin_key: "mock-plugin",
-					snapshot_content: { id: "entity-1", name: "Updated Name", value: 2 },
+					snapshot_content: {
+						id: "entity-1",
+						name: "Updated Name",
+						value: "2",
+					},
 				})
 				.execute();
 
 			// Third change - another update
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-1",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "latest-test-version",
 					plugin_key: "mock-plugin",
-					snapshot_content: { id: "entity-1", name: "Final Name", value: 3 },
+					snapshot_content: {
+						id: "entity-1",
+						name: "Final Name",
+						value: "3",
+					},
 				})
 				.execute();
 
 			// Query the latest visible state view
 			const latestState = await lix.db
-				.selectFrom("internal_materialization_latest_visible_state" as any)
+				.selectFrom("lix_internal_materialization_latest_visible_state" as any)
 				.selectAll()
 				.where("version_id", "=", "latest-test-version")
 				.where("entity_id", "=", "entity-1")
@@ -1038,7 +1481,7 @@ describe("internal_materialization_latest_visible_state", () => {
 			expect(state.snapshot_content).toEqual({
 				id: "entity-1",
 				name: "Final Name",
-				value: 3,
+				value: "3",
 			});
 			expect(state.depth).toBe(0); // Latest commit is at depth 0
 
@@ -1067,60 +1510,61 @@ describe("internal_materialization_latest_visible_state", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create a version
 			await createVersion({ lix, id: "multi-entity-version" });
 
 			// Entity 1: Three changes
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-1",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "multi-entity-version",
 					plugin_key: "mock-plugin",
-					snapshot_content: { id: "entity-1", version: 1 },
+					snapshot_content: { id: "entity-1", value: "v1" },
 				})
 				.execute();
 
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-1",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "multi-entity-version",
 					plugin_key: "mock-plugin",
-					snapshot_content: { id: "entity-1", version: 2 },
+					snapshot_content: { id: "entity-1", value: "v2" },
 				})
 				.execute();
 
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-1",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "multi-entity-version",
 					plugin_key: "mock-plugin",
-					snapshot_content: { id: "entity-1", version: 3 },
+					snapshot_content: { id: "entity-1", value: "v3" },
 				})
 				.execute();
 
 			// Entity 2: Two changes
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-2",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "multi-entity-version",
@@ -1130,10 +1574,10 @@ describe("internal_materialization_latest_visible_state", () => {
 				.execute();
 
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-2",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "multi-entity-version",
@@ -1144,10 +1588,10 @@ describe("internal_materialization_latest_visible_state", () => {
 
 			// Entity 3: Single change
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-3",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "multi-entity-version",
@@ -1158,10 +1602,10 @@ describe("internal_materialization_latest_visible_state", () => {
 
 			// Query the latest visible state view
 			const latestStates = await lix.db
-				.selectFrom("internal_materialization_latest_visible_state" as any)
+				.selectFrom("lix_internal_materialization_latest_visible_state" as any)
 				.selectAll()
 				.where("version_id", "=", "multi-entity-version")
-				.where("schema_key", "=", "mock_entity")
+				.where("schema_key", "=", "test_entity")
 				.orderBy("entity_id")
 				.execute();
 
@@ -1182,7 +1626,7 @@ describe("internal_materialization_latest_visible_state", () => {
 			expect(entity1State).toBeDefined();
 			expect(entity1State!.snapshot_content).toEqual({
 				id: "entity-1",
-				version: 3,
+				value: "v3",
 			});
 
 			expect(entity2State).toBeDefined();
@@ -1236,20 +1680,21 @@ describe("internal_materialization_latest_visible_state", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create a version
 			await createVersion({ lix, id: "deletion-test-version" });
 
 			// Create an entity
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-to-delete",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "deletion-test-version",
@@ -1264,10 +1709,10 @@ describe("internal_materialization_latest_visible_state", () => {
 
 			// Update the entity
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-to-delete",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "deletion-test-version",
@@ -1282,10 +1727,10 @@ describe("internal_materialization_latest_visible_state", () => {
 
 			// Delete the entity by inserting NULL snapshot
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-to-delete",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "deletion-test-version",
@@ -1297,7 +1742,7 @@ describe("internal_materialization_latest_visible_state", () => {
 
 			// Query the latest visible state view
 			const latestState = await lix.db
-				.selectFrom("internal_materialization_latest_visible_state" as any)
+				.selectFrom("lix_internal_materialization_latest_visible_state" as any)
 				.selectAll()
 				.where("version_id", "=", "deletion-test-version")
 				.where("entity_id", "=", "entity-to-delete")
@@ -1314,15 +1759,15 @@ describe("internal_materialization_latest_visible_state", () => {
 			expect(deletionState.depth).toBe(0); // Latest commit
 
 			// Verify it's tracking the deletion, not earlier states
-			expect(deletionState.schema_key).toBe("mock_entity");
+			expect(deletionState.schema_key).toBe("test_entity");
 			expect(deletionState.file_id).toBe("mock-file");
 
 			// Create another entity that is NOT deleted to verify filtering
 			await lix.db
-				.insertInto("state_all")
+				.insertInto("state_by_version")
 				.values({
 					entity_id: "entity-still-exists",
-					schema_key: "mock_entity",
+					schema_key: "test_entity",
 					schema_version: "1.0",
 					file_id: "mock-file",
 					version_id: "deletion-test-version",
@@ -1336,10 +1781,10 @@ describe("internal_materialization_latest_visible_state", () => {
 
 			// Query all latest states for this version
 			const allStates = await lix.db
-				.selectFrom("internal_materialization_latest_visible_state" as any)
+				.selectFrom("lix_internal_materialization_latest_visible_state" as any)
 				.selectAll()
 				.where("version_id", "=", "deletion-test-version")
-				.where("schema_key", "=", "mock_entity")
+				.where("schema_key", "=", "test_entity")
 				.orderBy("entity_id")
 				.execute();
 
@@ -1367,7 +1812,7 @@ describe("internal_materialization_latest_visible_state", () => {
 	);
 });
 
-describe("internal_materialization_version_ancestry", () => {
+describe("lix_internal_materialization_version_ancestry", () => {
 	simulationTest(
 		"version is its own ancestor at depth 0",
 		async ({ openSimulatedLix }) => {
@@ -1377,17 +1822,18 @@ describe("internal_materialization_version_ancestry", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create a standalone version
 			await createVersion({ lix, id: "standalone-version" });
 
 			// Query the version ancestry view
 			const ancestry = await lix.db
-				.selectFrom("internal_materialization_version_ancestry" as any)
+				.selectFrom("lix_internal_materialization_version_ancestry" as any)
 				.selectAll()
 				.where("version_id", "=", "standalone-version")
 				.execute();
@@ -1426,10 +1872,11 @@ describe("internal_materialization_version_ancestry", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create parent version A
 			await createVersion({ lix, id: "version-a" });
@@ -1438,12 +1885,12 @@ describe("internal_materialization_version_ancestry", () => {
 			await createVersion({
 				lix,
 				id: "version-b",
-				inherits_from_version_id: "version-a",
+				inheritsFrom: { id: "version-a" },
 			});
 
 			// Query ancestry for version B
 			const ancestry = await lix.db
-				.selectFrom("internal_materialization_version_ancestry" as any)
+				.selectFrom("lix_internal_materialization_version_ancestry" as any)
 				.selectAll()
 				.where("version_id", "=", "version-b")
 				.orderBy("inheritance_depth", "asc")
@@ -1485,10 +1932,11 @@ describe("internal_materialization_version_ancestry", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create inheritance chain: global → A → B → C → D
 			await createVersion({ lix, id: "version-a" });
@@ -1496,24 +1944,24 @@ describe("internal_materialization_version_ancestry", () => {
 			await createVersion({
 				lix,
 				id: "version-b",
-				inherits_from_version_id: "version-a",
+				inheritsFrom: { id: "version-a" },
 			});
 
 			await createVersion({
 				lix,
 				id: "version-c",
-				inherits_from_version_id: "version-b",
+				inheritsFrom: { id: "version-b" },
 			});
 
 			await createVersion({
 				lix,
 				id: "version-d",
-				inherits_from_version_id: "version-c",
+				inheritsFrom: { id: "version-c" },
 			});
 
 			// Query ancestry for version D
 			const ancestry = await lix.db
-				.selectFrom("internal_materialization_version_ancestry" as any)
+				.selectFrom("lix_internal_materialization_version_ancestry" as any)
 				.selectAll()
 				.where("version_id", "=", "version-d")
 				.orderBy("inheritance_depth", "asc")
@@ -1564,10 +2012,11 @@ describe("internal_materialization_version_ancestry", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create diamond pattern:
 			//     global
@@ -1587,25 +2036,25 @@ describe("internal_materialization_version_ancestry", () => {
 			await createVersion({
 				lix,
 				id: "version-b",
-				inherits_from_version_id: "version-a",
+				inheritsFrom: { id: "version-a" },
 			});
 
 			await createVersion({
 				lix,
 				id: "version-c",
-				inherits_from_version_id: "version-a",
+				inheritsFrom: { id: "version-a" },
 			});
 
 			// D inherits from B (not from both B and C)
 			await createVersion({
 				lix,
 				id: "version-d",
-				inherits_from_version_id: "version-b",
+				inheritsFrom: { id: "version-b" },
 			});
 
 			// Query ancestry for version D
 			const ancestryD = await lix.db
-				.selectFrom("internal_materialization_version_ancestry" as any)
+				.selectFrom("lix_internal_materialization_version_ancestry" as any)
 				.selectAll()
 				.where("version_id", "=", "version-d")
 				.orderBy("inheritance_depth", "asc")
@@ -1640,7 +2089,7 @@ describe("internal_materialization_version_ancestry", () => {
 
 			// Verify C also sees A as ancestor
 			const ancestryC = await lix.db
-				.selectFrom("internal_materialization_version_ancestry" as any)
+				.selectFrom("lix_internal_materialization_version_ancestry" as any)
 				.selectAll()
 				.where("version_id", "=", "version-c")
 				.orderBy("inheritance_depth", "asc")
@@ -1662,21 +2111,22 @@ describe("internal_materialization_version_ancestry", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create a version that explicitly does NOT inherit from global
 			await createVersion({
 				lix,
 				id: "standalone-version",
-				inherits_from_version_id: null,
+				inheritsFrom: null,
 			});
 
 			// Query ancestry
 			const ancestry = await lix.db
-				.selectFrom("internal_materialization_version_ancestry" as any)
+				.selectFrom("lix_internal_materialization_version_ancestry" as any)
 				.selectAll()
 				.where("version_id", "=", "standalone-version")
 				.orderBy("inheritance_depth", "asc")
@@ -1703,23 +2153,24 @@ describe("internal_materialization_version_ancestry", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create version A that will later point to B
 			await createVersion({
 				lix,
 				id: "version-a",
-				inherits_from_version_id: null, // Start with no inheritance
+				inheritsFrom: null, // Start with no inheritance
 			});
 
 			// Create version B that inherits from A
 			await createVersion({
 				lix,
 				id: "version-b",
-				inherits_from_version_id: "version-a",
+				inheritsFrom: { id: "version-a" },
 			});
 
 			// Now update A to inherit from B, creating a cycle
@@ -1732,7 +2183,7 @@ describe("internal_materialization_version_ancestry", () => {
 
 			// Query ancestry for version A with DISTINCT to remove duplicates
 			const ancestryA = await lix.db
-				.selectFrom("internal_materialization_version_ancestry" as any)
+				.selectFrom("lix_internal_materialization_version_ancestry" as any)
 				.selectAll()
 				.where("version_id", "=", "version-a")
 				.distinct()
@@ -1758,7 +2209,7 @@ describe("internal_materialization_version_ancestry", () => {
 
 			// Query ancestry for version B
 			const ancestryB = await lix.db
-				.selectFrom("internal_materialization_version_ancestry" as any)
+				.selectFrom("lix_internal_materialization_version_ancestry" as any)
 				.selectAll()
 				.where("version_id", "=", "version-b")
 				.distinct()
@@ -1787,7 +2238,7 @@ describe("internal_materialization_version_ancestry", () => {
 	);
 });
 
-describe("internal_state_materializer", () => {
+describe("lix_internal_state_materializer", () => {
 	simulationTest(
 		"shows entity from own version",
 		async ({ openSimulatedLix }) => {
@@ -1795,17 +2246,18 @@ describe("internal_state_materializer", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create a version
 			await createVersion({ lix, id: "version-1" });
 
 			// Insert an entity directly to version-1
 			await lix.db
-				.insertInto("key_value_all")
+				.insertInto("key_value_by_version")
 				.values({
 					key: "test-key",
 					value: "test-value",
@@ -1815,14 +2267,14 @@ describe("internal_state_materializer", () => {
 
 			// Query the materializer for version-1
 			const materializedState = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "version-1")
 				.where("entity_id", "=", "test-key")
 				.executeTakeFirst();
 
 			const cachedState = await lix.db
-				.selectFrom("state_all")
+				.selectFrom("state_by_version")
 				.selectAll()
 				.where("version_id", "=", "version-1")
 				.where("entity_id", "=", "test-key")
@@ -1835,7 +2287,9 @@ describe("internal_state_materializer", () => {
 			});
 			expect(materializedState!.inherited_from_version_id).toBeNull(); // Not inherited
 
-			expect(materializedState).toEqual(cachedState);
+			expect(stripWriterKey(materializedState)).toEqual(
+				stripWriterKey(cachedState)
+			);
 		},
 		{
 			simulations: [normalSimulation, outOfOrderSequenceSimulation],
@@ -1849,22 +2303,23 @@ describe("internal_state_materializer", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create parent and child versions
 			await createVersion({ lix, id: "parent-version" });
 			await createVersion({
 				lix,
 				id: "child-version",
-				inherits_from_version_id: "parent-version",
+				inheritsFrom: { id: "parent-version" },
 			});
 
 			// Add entity to parent version
 			await lix.db
-				.insertInto("key_value_all")
+				.insertInto("key_value_by_version")
 				.values({
 					key: "inherited-key",
 					value: "parent-value",
@@ -1874,14 +2329,14 @@ describe("internal_state_materializer", () => {
 
 			// Query the materializer for child version
 			const materializedState = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "child-version")
 				.where("entity_id", "=", "inherited-key")
 				.executeTakeFirst();
 
 			const cachedState = await lix.db
-				.selectFrom("state_all")
+				.selectFrom("state_by_version")
 				.selectAll()
 				.where("version_id", "=", "child-version")
 				.where("entity_id", "=", "inherited-key")
@@ -1897,7 +2352,9 @@ describe("internal_state_materializer", () => {
 				"parent-version"
 			);
 
-			expect(materializedState).toEqual(cachedState);
+			expect(stripWriterKey(materializedState)).toEqual(
+				stripWriterKey(cachedState)
+			);
 		},
 		{
 			simulations: [normalSimulation, outOfOrderSequenceSimulation],
@@ -1911,22 +2368,23 @@ describe("internal_state_materializer", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create parent and child versions
 			await createVersion({ lix, id: "parent-version" });
 			await createVersion({
 				lix,
 				id: "child-version",
-				inherits_from_version_id: "parent-version",
+				inheritsFrom: { id: "parent-version" },
 			});
 
 			// Add entity to parent version
 			await lix.db
-				.insertInto("key_value_all")
+				.insertInto("key_value_by_version")
 				.values({
 					key: "shared-key",
 					value: "parent-value",
@@ -1936,24 +2394,24 @@ describe("internal_state_materializer", () => {
 
 			// Update the inherited entity in child version
 			await lix.db
-				.updateTable("key_value_all")
-				.set({
+				.insertInto("key_value_by_version")
+				.values({
+					key: "shared-key",
 					value: "child-value",
+					lixcol_version_id: "child-version",
 				})
-				.where("key", "=", "shared-key")
-				.where("lixcol_version_id", "=", "child-version")
 				.execute();
 
 			// Query the materializer for child version
 			const materializedState = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "child-version")
 				.where("entity_id", "=", "shared-key")
 				.executeTakeFirst();
 
 			const cachedState = await lix.db
-				.selectFrom("state_all")
+				.selectFrom("state_by_version")
 				.selectAll()
 				.where("version_id", "=", "child-version")
 				.where("entity_id", "=", "shared-key")
@@ -1967,7 +2425,9 @@ describe("internal_state_materializer", () => {
 			});
 			expect(materializedState!.inherited_from_version_id).toBeNull(); // Not inherited
 
-			expect(materializedState).toEqual(cachedState);
+			expect(stripWriterKey(materializedState)).toEqual(
+				stripWriterKey(cachedState)
+			);
 		},
 		{
 			simulations: [normalSimulation, outOfOrderSequenceSimulation],
@@ -1981,29 +2441,30 @@ describe("internal_state_materializer", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create inheritance chain: A -> B -> C
 			await createVersion({ lix, id: "version-a" });
 			await createVersion({
 				lix,
 				id: "version-b",
-				inherits_from_version_id: "version-a",
+				inheritsFrom: { id: "version-a" },
 			});
 			await createVersion({
 				lix,
 				id: "version-c",
-				inherits_from_version_id: "version-b",
+				inheritsFrom: { id: "version-b" },
 			});
 
 			// Add entity to version A
 			await lix.db
-				.insertInto("key_value_all")
+				.insertInto("key_value_by_version")
 				.values({
-					key: "deep-key",
+					key: "key-from-a",
 					value: "value-from-a",
 					lixcol_version_id: "version-a",
 				})
@@ -2011,7 +2472,7 @@ describe("internal_state_materializer", () => {
 
 			// Add different entity to version B
 			await lix.db
-				.insertInto("key_value_all")
+				.insertInto("key_value_by_version")
 				.values({
 					key: "b-only-key",
 					value: "value-from-b",
@@ -2021,11 +2482,11 @@ describe("internal_state_materializer", () => {
 
 			// Query materializer for version C
 			const materializedStates = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "version-c")
 				.where("schema_key", "=", "lix_key_value")
-				.where("entity_id", "in", ["deep-key", "b-only-key"])
+				.where("entity_id", "in", ["key-from-a", "b-only-key"])
 				.orderBy("entity_id")
 				.execute();
 
@@ -2033,15 +2494,17 @@ describe("internal_state_materializer", () => {
 			expect(materializedStates).toHaveLength(2);
 
 			// Check inherited from A (through B)
-			const deepKey = materializedStates.find(
-				(s: any) => s.entity_id === "deep-key"
+			const keyFromA = materializedStates.find(
+				(s: any) => s.entity_id === "key-from-a"
 			);
-			expect(deepKey).toBeDefined();
-			expect(deepKey!.snapshot_content).toEqual({
-				key: "deep-key",
+			expect(keyFromA).toBeDefined();
+			expect(keyFromA!.snapshot_content).toEqual({
+				key: "key-from-a",
 				value: "value-from-a",
 			});
-			expect(deepKey!.inherited_from_version_id).toBe("version-a");
+			expect(keyFromA!.inherited_from_version_id).toBe("version-a");
+			// CRITICAL: version_id should be version-c (the viewing version), not version-a
+			expect(keyFromA!.version_id).toBe("version-c");
 
 			// Check inherited from B
 			const bKey = materializedStates.find(
@@ -2053,6 +2516,8 @@ describe("internal_state_materializer", () => {
 				value: "value-from-b",
 			});
 			expect(bKey!.inherited_from_version_id).toBe("version-b");
+			// CRITICAL: version_id should be version-c (the viewing version), not version-b
+			expect(bKey!.version_id).toBe("version-c");
 		},
 		{
 			simulations: [normalSimulation, outOfOrderSequenceSimulation],
@@ -2066,17 +2531,18 @@ describe("internal_state_materializer", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create a version
 			await createVersion({ lix, id: "version-1" });
 
 			// Insert an entity
 			await lix.db
-				.insertInto("key_value_all")
+				.insertInto("key_value_by_version")
 				.values({
 					key: "entity-to-delete",
 					value: "initial-value",
@@ -2086,14 +2552,14 @@ describe("internal_state_materializer", () => {
 
 			// Delete the entity (update to NULL snapshot)
 			await lix.db
-				.deleteFrom("key_value_all")
+				.deleteFrom("key_value_by_version")
 				.where("key", "=", "entity-to-delete")
 				.where("lixcol_version_id", "=", "version-1")
 				.execute();
 
 			// Query the materializer - should return deleted entities as tombstones
 			const materializedState = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "version-1")
 				.where("entity_id", "=", "entity-to-delete")
@@ -2107,7 +2573,7 @@ describe("internal_state_materializer", () => {
 
 			// But the latest visible state should still have it with NULL
 			const latestVisible = await lix.db
-				.selectFrom("internal_materialization_latest_visible_state" as any)
+				.selectFrom("lix_internal_materialization_latest_visible_state" as any)
 				.selectAll()
 				.where("version_id", "=", "version-1")
 				.where("entity_id", "=", "entity-to-delete")
@@ -2128,22 +2594,23 @@ describe("internal_state_materializer", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create parent and child versions
 			await createVersion({ lix, id: "parent-version" });
 			await createVersion({
 				lix,
 				id: "child-version",
-				inherits_from_version_id: "parent-version",
+				inheritsFrom: { id: "parent-version" },
 			});
 
 			// Add entity to parent version
 			await lix.db
-				.insertInto("key_value_all")
+				.insertInto("key_value_by_version")
 				.values({
 					key: "entity-to-override",
 					value: "parent-value",
@@ -2153,27 +2620,38 @@ describe("internal_state_materializer", () => {
 
 			// Delete the inherited entity in child version
 			await lix.db
-				.deleteFrom("key_value_all")
+				.insertInto("key_value_by_version")
+				.values({
+					key: "entity-to-override",
+					value: "child-value",
+					lixcol_version_id: "child-version",
+				})
+				.execute();
+
+			await lix.db
+				.deleteFrom("key_value_by_version")
 				.where("key", "=", "entity-to-override")
 				.where("lixcol_version_id", "=", "child-version")
 				.execute();
 
 			// Query materializer for parent - should see the entity
 			const parentState = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "parent-version")
 				.where("entity_id", "=", "entity-to-override")
 				.executeTakeFirst();
 
 			const parentCachedState = await lix.db
-				.selectFrom("state_all")
+				.selectFrom("state_by_version")
 				.selectAll()
 				.where("version_id", "=", "parent-version")
 				.where("entity_id", "=", "entity-to-override")
 				.executeTakeFirst();
 
-			expect(parentCachedState).toEqual(parentState);
+			expect(stripWriterKey(parentCachedState)).toEqual(
+				stripWriterKey(parentState)
+			);
 
 			expect(parentState).toBeDefined();
 			expect(parentState!.snapshot_content).toEqual({
@@ -2183,7 +2661,7 @@ describe("internal_state_materializer", () => {
 
 			// Query materializer for child - should see the entity as a tombstone (deleted)
 			const childState = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "child-version")
 				.where("entity_id", "=", "entity-to-override")
@@ -2197,7 +2675,7 @@ describe("internal_state_materializer", () => {
 
 			// But the latest visible state for child should have NULL snapshot
 			const childLatestVisible = await lix.db
-				.selectFrom("internal_materialization_latest_visible_state" as any)
+				.selectFrom("lix_internal_materialization_latest_visible_state" as any)
 				.selectAll()
 				.where("version_id", "=", "child-version")
 				.where("entity_id", "=", "entity-to-override")
@@ -2218,10 +2696,11 @@ describe("internal_state_materializer", () => {
 				keyValues: [
 					{
 						key: "lix_deterministic_mode",
-						value: { enabled: true, bootstrap: true },
+						value: { enabled: true },
 					},
 				],
 			});
+			await storeMaterializationTestSchemas(lix);
 
 			// Create diamond inheritance pattern:
 			//       A (root)
@@ -2237,22 +2716,22 @@ describe("internal_state_materializer", () => {
 			await createVersion({
 				lix,
 				id: "version-b",
-				inherits_from_version_id: "version-a",
+				inheritsFrom: { id: "version-a" },
 			});
 			await createVersion({
 				lix,
 				id: "version-c",
-				inherits_from_version_id: "version-a",
+				inheritsFrom: { id: "version-a" },
 			});
 			await createVersion({
 				lix,
 				id: "version-d",
-				inherits_from_version_id: "version-b",
+				inheritsFrom: { id: "version-b" },
 			});
 
 			// Add entity to root version A
 			await lix.db
-				.insertInto("key_value_all")
+				.insertInto("key_value_by_version")
 				.values({
 					key: "shared-entity",
 					value: "value-from-a",
@@ -2260,29 +2739,29 @@ describe("internal_state_materializer", () => {
 				})
 				.execute();
 
-			// Override the entity in version B
+			// Override the entity in version B by inserting a local copy
 			await lix.db
-				.updateTable("key_value_all")
-				.set({
+				.insertInto("key_value_by_version")
+				.values({
+					key: "shared-entity",
 					value: "value-from-b",
+					lixcol_version_id: "version-b",
 				})
-				.where("key", "=", "shared-entity")
-				.where("lixcol_version_id", "=", "version-b")
 				.execute();
 
-			// Also override the entity in version C
+			// Also override the entity in version C via direct insert
 			await lix.db
-				.updateTable("key_value_all")
-				.set({
+				.insertInto("key_value_by_version")
+				.values({
+					key: "shared-entity",
 					value: "value-from-c",
+					lixcol_version_id: "version-c",
 				})
-				.where("key", "=", "shared-entity")
-				.where("lixcol_version_id", "=", "version-c")
 				.execute();
 
 			// Query materializer for version D
 			const dState = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "version-d")
 				.where("entity_id", "=", "shared-entity")
@@ -2298,7 +2777,7 @@ describe("internal_state_materializer", () => {
 
 			// Verify that B sees its own value
 			const bState = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "version-b")
 				.where("entity_id", "=", "shared-entity")
@@ -2313,7 +2792,7 @@ describe("internal_state_materializer", () => {
 
 			// Verify that C sees its own value
 			const cState = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "version-c")
 				.where("entity_id", "=", "shared-entity")
@@ -2328,7 +2807,7 @@ describe("internal_state_materializer", () => {
 
 			// Test inheritance ranking - add a different entity only in A
 			await lix.db
-				.insertInto("key_value_all")
+				.insertInto("key_value_by_version")
 				.values({
 					key: "root-only-entity",
 					value: "only-in-a",
@@ -2338,7 +2817,7 @@ describe("internal_state_materializer", () => {
 
 			// D should inherit it through B (depth 2 from D's perspective)
 			const dRootEntity = await lix.db
-				.selectFrom("internal_state_materializer" as any)
+				.selectFrom("lix_internal_state_materializer" as any)
 				.selectAll()
 				.where("version_id", "=", "version-d")
 				.where("entity_id", "=", "root-only-entity")