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

package/dist/state/materialize-state.test.js

@@ -1,9 +1,40 @@
 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, } from "../version/schema-definition.js";
+function stripWriterKey(row) {
+    if (!row)
+        return row;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { writer_key, metadata, ...rest } = row;
+    return rest;
+}
+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"],
+};
+async function storeMaterializationTestSchemas(lix) {
+    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 }) => {
         // Test the rule: "if a version entity exists, the version is active.
         // even if other versions 'build' on this version by branching away from the commit"
@@ -11,17 +42,18 @@ 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",
@@ -44,10 +76,10 @@ describe("internal_materialization_version_tips", () => {
             .execute();
         // 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",
@@ -64,10 +96,10 @@ describe("internal_materialization_version_tips", () => {
             .execute();
         // 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",
@@ -79,7 +111,7 @@ describe("internal_materialization_version_tips", () => {
         // so it's no longer a "tip" commit. But it still has important state that should be materialized.
         // Query version tips - should include ALL versions with state, not just leaf tips
         const tips = await lix.db
-            .selectFrom("internal_materialization_version_tips")
+            .selectFrom("lix_internal_materialization_version_tips")
             .selectAll()
             .where("version_id", "in", ["base-version", "version-a", "version-b"])
             .orderBy("version_id")
@@ -95,7 +127,7 @@ describe("internal_materialization_version_tips", () => {
         expect(versionBTip).toBeDefined();
         // Verify that the base version's state can be materialized (not excluded from materialization pipeline)
         const baseMaterializedState = await lix.db
-            .selectFrom("internal_state_materializer")
+            .selectFrom("lix_internal_state_materializer")
             .selectAll()
             .where("version_id", "=", "base-version")
             .where("entity_id", "=", "base-entity")
@@ -113,14 +145,15 @@ 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")
+            .selectFrom("lix_internal_materialization_version_tips")
             .where("version_id", "=", activeVersion.id)
             .selectAll()
             .execute();
@@ -136,14 +169,15 @@ 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")
+            .selectFrom("lix_internal_materialization_version_tips")
             .where("version_id", "=", activeVersion.id)
             .selectAll()
             .execute();
@@ -153,7 +187,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",
@@ -162,7 +196,7 @@ describe("internal_materialization_version_tips", () => {
             .execute();
         // Get updated tip
         const updatedResults = await lix.db
-            .selectFrom("internal_materialization_version_tips")
+            .selectFrom("lix_internal_materialization_version_tips")
             .where("version_id", "=", activeVersion.id)
             .selectAll()
             .execute();
@@ -179,19 +213,20 @@ 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" });
         await createVersion({ lix, id: "version-2" });
         // 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",
@@ -201,10 +236,10 @@ describe("internal_materialization_version_tips", () => {
             .execute();
         // 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",
@@ -214,7 +249,7 @@ describe("internal_materialization_version_tips", () => {
             .execute();
         // Get tips for both versions
         const tips = await lix.db
-            .selectFrom("internal_materialization_version_tips")
+            .selectFrom("lix_internal_materialization_version_tips")
             .selectAll()
             .where("version_id", "in", ["version-1", "version-2"])
             .orderBy("version_id")
@@ -228,10 +263,10 @@ describe("internal_materialization_version_tips", () => {
         expect(v1Tip?.tip_commit_id).not.toBe(v2Tip?.tip_commit_id);
         // 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",
@@ -244,7 +279,7 @@ describe("internal_materialization_version_tips", () => {
             .execute();
         // Get updated tips
         const updatedTips = await lix.db
-            .selectFrom("internal_materialization_version_tips")
+            .selectFrom("lix_internal_materialization_version_tips")
             .selectAll()
             .orderBy("version_id")
             .execute();
@@ -257,7 +292,141 @@ describe("internal_materialization_version_tips", () => {
         simulations: [normalSimulation, outOfOrderSequenceSimulation],
     });
 });
-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")
+        .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]?.snapshot_content?.account_id).toBe(activeAccountId);
+    // The materializer uses the commit change row id as 'change_id' column for provenance
+    const commitChangeId = authorRows[0]?.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
+        .selectFrom("lix_internal_materialization_version_tips")
+        .selectAll()
+        .where("version_id", "=", versionId)
+        .execute();
+    expectDeterministic(tips.length).toBe(1);
+    const matRows = await lix.db
+        .selectFrom("lix_internal_state_materializer")
+        .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
+        .selectFrom("lix_internal_materialization_version_tips")
+        .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
+        .selectFrom("lix_internal_state_materializer")
+        .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 }) => {
         // Linear history: initial -> commit1 -> commit2 -> commit3 (tip)
         // Expected depths:    3          2          1          0
@@ -265,10 +434,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({
             lix,
@@ -276,10 +448,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",
@@ -299,10 +471,10 @@ describe("internal_materialization_commit_graph", () => {
         const commit1Id = commits1[0].id;
         // 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",
@@ -322,10 +494,10 @@ describe("internal_materialization_commit_graph", () => {
         const commit2Id = commits2[0].id;
         // 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",
@@ -345,7 +517,7 @@ describe("internal_materialization_commit_graph", () => {
         const commit3Id = commits3[0].id;
         // Query the commit graph view
         const graph = await lix.db
-            .selectFrom("internal_materialization_commit_graph")
+            .selectFrom("lix_internal_materialization_commit_graph")
             .selectAll()
             .where("version_id", "=", "linear-test-version")
             .orderBy("depth")
@@ -392,19 +564,22 @@ 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" });
         await createVersion({ lix, id: "branch-version-2" });
         // 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",
@@ -430,10 +605,10 @@ describe("internal_materialization_commit_graph", () => {
             .execute();
         // 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",
@@ -443,10 +618,10 @@ describe("internal_materialization_commit_graph", () => {
             .execute();
         // 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",
@@ -456,14 +631,14 @@ describe("internal_materialization_commit_graph", () => {
             .execute();
         // Query the commit graph for version1
         const graph1 = await lix.db
-            .selectFrom("internal_materialization_commit_graph")
+            .selectFrom("lix_internal_materialization_commit_graph")
             .selectAll()
             .where("version_id", "=", "branch-version-1")
             .orderBy("depth")
             .execute();
         // Query the commit graph for version2
         const graph2 = await lix.db
-            .selectFrom("internal_materialization_commit_graph")
+            .selectFrom("lix_internal_materialization_commit_graph")
             .selectAll()
             .where("version_id", "=", "branch-version-2")
             .orderBy("depth")
@@ -511,20 +686,21 @@ 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" });
         // Create version B that will diverge
         await createVersion({ lix, id: "merge-version-b" });
         // 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",
@@ -534,10 +710,10 @@ describe("internal_materialization_commit_graph", () => {
             .execute();
         // 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",
@@ -548,7 +724,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();
         const versionBTip = await lix.db
@@ -557,67 +733,57 @@ describe("internal_materialization_commit_graph", () => {
             .where("id", "=", "merge-version-b")
             .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,
+            .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,
             },
-        ])
-            .execute();
-        // Update version A to point to the merge commit
-        await lix.db
-            .updateTable("version")
-            .set({ commit_id: mergeCommitId })
-            .where("id", "=", "merge-version-a")
+            created_at: ts,
+        })
             .execute();
         // Query the commit graph for the merged version
         const graph = await lix.db
-            .selectFrom("internal_materialization_commit_graph")
+            .selectFrom("lix_internal_materialization_commit_graph")
             .selectAll()
             .where("version_id", "=", "merge-version-a")
             .orderBy("depth")
@@ -662,21 +828,22 @@ 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
         // This simulates data corruption: A -> B -> C -> A
@@ -689,7 +856,7 @@ describe("internal_materialization_commit_graph", () => {
             .execute();
         // Query version ancestry - should not hang due to cycle detection
         const ancestry = await lix.db
-            .selectFrom("internal_materialization_version_ancestry")
+            .selectFrom("lix_internal_materialization_version_ancestry")
             .selectAll()
             .where("version_id", "=", "version-cycle-a")
             .execute();
@@ -715,20 +882,23 @@ 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" });
         await createVersion({ lix, id: "version-y" });
         await createVersion({ lix, id: "version-z" });
         // 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",
@@ -737,10 +907,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",
@@ -750,17 +920,17 @@ describe("internal_materialization_commit_graph", () => {
             .execute();
         // Query graphs for each version
         const graphX = await lix.db
-            .selectFrom("internal_materialization_commit_graph")
+            .selectFrom("lix_internal_materialization_commit_graph")
             .selectAll()
             .where("version_id", "=", "version-x")
             .execute();
         const graphY = await lix.db
-            .selectFrom("internal_materialization_commit_graph")
+            .selectFrom("lix_internal_materialization_commit_graph")
             .selectAll()
             .where("version_id", "=", "version-y")
             .execute();
         const graphZ = await lix.db
-            .selectFrom("internal_materialization_commit_graph")
+            .selectFrom("lix_internal_materialization_commit_graph")
             .selectAll()
             .where("version_id", "=", "version-z")
             .execute();
@@ -789,7 +959,177 @@ describe("internal_materialization_commit_graph", () => {
         simulations: [normalSimulation, outOfOrderSequenceSimulation],
     });
 });
-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")
+        .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)
+        .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) => 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)
+        .executeTakeFirstOrThrow();
+    const changeSetId = commitRow.snapshot.change_set_id;
+    // Query materializer for CSE rows for this change set (domain-only)
+    const cseRows = await lix.db
+        .selectFrom("lix_internal_state_materializer")
+        .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)
+        .where(sql `json_extract(snapshot_content, '$.schema_key')`, "=", "test_entity")
+        .execute();
+    // Expect exactly two domain CSEs (for dom-1 and dom-2)
+    expectDeterministic(cseRows.length).toBe(2);
+    const ids = new Set(cseRows.map((r) => 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 }) => {
         // Create version with multiple changes to same entity
         // Verify only the latest (closest to tip) change is visible
@@ -797,55 +1137,68 @@ 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" });
         // 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")
+            .selectFrom("lix_internal_materialization_latest_visible_state")
             .selectAll()
             .where("version_id", "=", "latest-test-version")
             .where("entity_id", "=", "entity-1")
@@ -858,7 +1211,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
         // Verify it selected the change from the newest commit
@@ -880,55 +1233,56 @@ 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",
@@ -937,10 +1291,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",
@@ -950,10 +1304,10 @@ describe("internal_materialization_latest_visible_state", () => {
             .execute();
         // 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",
@@ -963,10 +1317,10 @@ describe("internal_materialization_latest_visible_state", () => {
             .execute();
         // Query the latest visible state view
         const latestStates = await lix.db
-            .selectFrom("internal_materialization_latest_visible_state")
+            .selectFrom("lix_internal_materialization_latest_visible_state")
             .selectAll()
             .where("version_id", "=", "multi-entity-version")
-            .where("schema_key", "=", "mock_entity")
+            .where("schema_key", "=", "test_entity")
             .orderBy("entity_id")
             .execute();
         // Should have exactly 3 entries (one per entity)
@@ -978,7 +1332,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();
         expect(entity2State.snapshot_content).toEqual({
@@ -1016,18 +1370,19 @@ 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",
@@ -1041,10 +1396,10 @@ describe("internal_materialization_latest_visible_state", () => {
             .execute();
         // 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",
@@ -1058,10 +1413,10 @@ describe("internal_materialization_latest_visible_state", () => {
             .execute();
         // 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",
@@ -1072,7 +1427,7 @@ describe("internal_materialization_latest_visible_state", () => {
             .execute();
         // Query the latest visible state view
         const latestState = await lix.db
-            .selectFrom("internal_materialization_latest_visible_state")
+            .selectFrom("lix_internal_materialization_latest_visible_state")
             .selectAll()
             .where("version_id", "=", "deletion-test-version")
             .where("entity_id", "=", "entity-to-delete")
@@ -1085,14 +1440,14 @@ describe("internal_materialization_latest_visible_state", () => {
         expect(deletionState.snapshot_content).toBeNull();
         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",
@@ -1105,10 +1460,10 @@ describe("internal_materialization_latest_visible_state", () => {
             .execute();
         // Query all latest states for this version
         const allStates = await lix.db
-            .selectFrom("internal_materialization_latest_visible_state")
+            .selectFrom("lix_internal_materialization_latest_visible_state")
             .selectAll()
             .where("version_id", "=", "deletion-test-version")
-            .where("schema_key", "=", "mock_entity")
+            .where("schema_key", "=", "test_entity")
             .orderBy("entity_id")
             .execute();
         // Should have both entities
@@ -1126,7 +1481,7 @@ describe("internal_materialization_latest_visible_state", () => {
         simulations: [normalSimulation, outOfOrderSequenceSimulation],
     });
 });
-describe("internal_materialization_version_ancestry", () => {
+describe("lix_internal_materialization_version_ancestry", () => {
     simulationTest("version is its own ancestor at depth 0", async ({ openSimulatedLix }) => {
         // Create a version and verify it appears as its own ancestor
         // at inheritance depth 0
@@ -1134,15 +1489,16 @@ 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")
+            .selectFrom("lix_internal_materialization_version_ancestry")
             .selectAll()
             .where("version_id", "=", "standalone-version")
             .execute();
@@ -1169,21 +1525,22 @@ 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" });
         // Create child version B that inherits from A
         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")
+            .selectFrom("lix_internal_materialization_version_ancestry")
             .selectAll()
             .where("version_id", "=", "version-b")
             .orderBy("inheritance_depth", "asc")
@@ -1216,30 +1573,31 @@ 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" });
         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")
+            .selectFrom("lix_internal_materialization_version_ancestry")
             .selectAll()
             .where("version_id", "=", "version-d")
             .orderBy("inheritance_depth", "asc")
@@ -1279,10 +1637,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
         //        |
@@ -1298,22 +1657,22 @@ 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")
+            .selectFrom("lix_internal_materialization_version_ancestry")
             .selectAll()
             .where("version_id", "=", "version-d")
             .orderBy("inheritance_depth", "asc")
@@ -1342,7 +1701,7 @@ describe("internal_materialization_version_ancestry", () => {
         });
         // Verify C also sees A as ancestor
         const ancestryC = await lix.db
-            .selectFrom("internal_materialization_version_ancestry")
+            .selectFrom("lix_internal_materialization_version_ancestry")
             .selectAll()
             .where("version_id", "=", "version-c")
             .orderBy("inheritance_depth", "asc")
@@ -1358,19 +1717,20 @@ 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")
+            .selectFrom("lix_internal_materialization_version_ancestry")
             .selectAll()
             .where("version_id", "=", "standalone-version")
             .orderBy("inheritance_depth", "asc")
@@ -1390,21 +1750,22 @@ 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
         // This would create A -> B -> A -> B -> ...
@@ -1415,7 +1776,7 @@ describe("internal_materialization_version_ancestry", () => {
             .execute();
         // Query ancestry for version A with DISTINCT to remove duplicates
         const ancestryA = await lix.db
-            .selectFrom("internal_materialization_version_ancestry")
+            .selectFrom("lix_internal_materialization_version_ancestry")
             .selectAll()
             .where("version_id", "=", "version-a")
             .distinct()
@@ -1437,7 +1798,7 @@ describe("internal_materialization_version_ancestry", () => {
         });
         // Query ancestry for version B
         const ancestryB = await lix.db
-            .selectFrom("internal_materialization_version_ancestry")
+            .selectFrom("lix_internal_materialization_version_ancestry")
             .selectAll()
             .where("version_id", "=", "version-b")
             .distinct()
@@ -1460,21 +1821,22 @@ describe("internal_materialization_version_ancestry", () => {
         simulations: [normalSimulation, outOfOrderSequenceSimulation],
     });
 });
-describe("internal_state_materializer", () => {
+describe("lix_internal_state_materializer", () => {
     simulationTest("shows entity from own version", async ({ openSimulatedLix }) => {
         const lix = await openSimulatedLix({
             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",
@@ -1483,13 +1845,13 @@ describe("internal_state_materializer", () => {
             .execute();
         // Query the materializer for version-1
         const materializedState = await lix.db
-            .selectFrom("internal_state_materializer")
+            .selectFrom("lix_internal_state_materializer")
             .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")
@@ -1500,7 +1862,7 @@ describe("internal_state_materializer", () => {
             value: "test-value",
         });
         expect(materializedState.inherited_from_version_id).toBeNull(); // Not inherited
-        expect(materializedState).toEqual(cachedState);
+        expect(stripWriterKey(materializedState)).toEqual(stripWriterKey(cachedState));
     }, {
         simulations: [normalSimulation, outOfOrderSequenceSimulation],
     });
@@ -1509,20 +1871,21 @@ 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",
@@ -1531,13 +1894,13 @@ describe("internal_state_materializer", () => {
             .execute();
         // Query the materializer for child version
         const materializedState = await lix.db
-            .selectFrom("internal_state_materializer")
+            .selectFrom("lix_internal_state_materializer")
             .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")
@@ -1549,7 +1912,7 @@ describe("internal_state_materializer", () => {
             value: "parent-value",
         });
         expect(materializedState.inherited_from_version_id).toBe("parent-version");
-        expect(materializedState).toEqual(cachedState);
+        expect(stripWriterKey(materializedState)).toEqual(stripWriterKey(cachedState));
     }, {
         simulations: [normalSimulation, outOfOrderSequenceSimulation],
     });
@@ -1558,20 +1921,21 @@ 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",
@@ -1580,22 +1944,22 @@ describe("internal_state_materializer", () => {
             .execute();
         // 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")
+            .selectFrom("lix_internal_state_materializer")
             .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")
@@ -1607,7 +1971,7 @@ describe("internal_state_materializer", () => {
             value: "child-value",
         });
         expect(materializedState.inherited_from_version_id).toBeNull(); // Not inherited
-        expect(materializedState).toEqual(cachedState);
+        expect(stripWriterKey(materializedState)).toEqual(stripWriterKey(cachedState));
     }, {
         simulations: [normalSimulation, outOfOrderSequenceSimulation],
     });
@@ -1616,34 +1980,35 @@ 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",
         })
             .execute();
         // 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",
@@ -1652,23 +2017,25 @@ describe("internal_state_materializer", () => {
             .execute();
         // Query materializer for version C
         const materializedStates = await lix.db
-            .selectFrom("internal_state_materializer")
+            .selectFrom("lix_internal_state_materializer")
             .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();
         // C should see both entities
         expect(materializedStates).toHaveLength(2);
         // Check inherited from A (through B)
-        const deepKey = materializedStates.find((s) => s.entity_id === "deep-key");
-        expect(deepKey).toBeDefined();
-        expect(deepKey.snapshot_content).toEqual({
-            key: "deep-key",
+        const keyFromA = materializedStates.find((s) => s.entity_id === "key-from-a");
+        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((s) => s.entity_id === "b-only-key");
         expect(bKey).toBeDefined();
@@ -1677,6 +2044,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],
     });
@@ -1685,15 +2054,16 @@ 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",
@@ -1702,13 +2072,13 @@ describe("internal_state_materializer", () => {
             .execute();
         // 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")
+            .selectFrom("lix_internal_state_materializer")
             .selectAll()
             .where("version_id", "=", "version-1")
             .where("entity_id", "=", "entity-to-delete")
@@ -1720,7 +2090,7 @@ describe("internal_state_materializer", () => {
         expect(materializedState.version_id).toBe("version-1");
         // But the latest visible state should still have it with NULL
         const latestVisible = await lix.db
-            .selectFrom("internal_materialization_latest_visible_state")
+            .selectFrom("lix_internal_materialization_latest_visible_state")
             .selectAll()
             .where("version_id", "=", "version-1")
             .where("entity_id", "=", "entity-to-delete")
@@ -1735,20 +2105,21 @@ 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",
@@ -1757,24 +2128,32 @@ describe("internal_state_materializer", () => {
             .execute();
         // 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")
+            .selectFrom("lix_internal_state_materializer")
             .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({
             key: "entity-to-override",
@@ -1782,7 +2161,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")
+            .selectFrom("lix_internal_state_materializer")
             .selectAll()
             .where("version_id", "=", "child-version")
             .where("entity_id", "=", "entity-to-override")
@@ -1794,7 +2173,7 @@ describe("internal_state_materializer", () => {
         expect(childState.inherited_from_version_id).toBeNull(); // Direct deletion in child
         // But the latest visible state for child should have NULL snapshot
         const childLatestVisible = await lix.db
-            .selectFrom("internal_materialization_latest_visible_state")
+            .selectFrom("lix_internal_materialization_latest_visible_state")
             .selectAll()
             .where("version_id", "=", "child-version")
             .where("entity_id", "=", "entity-to-override")
@@ -1809,10 +2188,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)
         //      / \
@@ -1826,48 +2206,48 @@ 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",
             lixcol_version_id: "version-a",
         })
             .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")
+            .selectFrom("lix_internal_state_materializer")
             .selectAll()
             .where("version_id", "=", "version-d")
             .where("entity_id", "=", "shared-entity")
@@ -1881,7 +2261,7 @@ describe("internal_state_materializer", () => {
         expect(dState.inherited_from_version_id).toBe("version-b");
         // Verify that B sees its own value
         const bState = await lix.db
-            .selectFrom("internal_state_materializer")
+            .selectFrom("lix_internal_state_materializer")
             .selectAll()
             .where("version_id", "=", "version-b")
             .where("entity_id", "=", "shared-entity")
@@ -1894,7 +2274,7 @@ describe("internal_state_materializer", () => {
         expect(bState.inherited_from_version_id).toBeNull(); // B has its own value
         // Verify that C sees its own value
         const cState = await lix.db
-            .selectFrom("internal_state_materializer")
+            .selectFrom("lix_internal_state_materializer")
             .selectAll()
             .where("version_id", "=", "version-c")
             .where("entity_id", "=", "shared-entity")
@@ -1907,7 +2287,7 @@ describe("internal_state_materializer", () => {
         expect(cState.inherited_from_version_id).toBeNull(); // C has its own value
         // 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",
@@ -1916,7 +2296,7 @@ describe("internal_state_materializer", () => {
             .execute();
         // D should inherit it through B (depth 2 from D's perspective)
         const dRootEntity = await lix.db
-            .selectFrom("internal_state_materializer")
+            .selectFrom("lix_internal_state_materializer")
             .selectAll()
             .where("version_id", "=", "version-d")
             .where("entity_id", "=", "root-only-entity")