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

package/dist/state/schema.js

@@ -1,789 +1,35 @@
-import { validateStateMutation } from "./validate-state-mutation.js";
-import { sql } from "kysely";
-import { insertTransactionState } from "./insert-transaction-state.js";
-import { executeSync } from "../database/execute-sync.js";
 import { applyMaterializeStateSchema } from "./materialize-state.js";
-import { applyResolvedStateView } from "./resolved-state-view.js";
-import { applyStateCacheSchema } from "./cache/schema.js";
-import { isStaleStateCache } from "./cache/is-stale-state-cache.js";
-import { markStateCacheAsFresh } from "./cache/mark-state-cache-as-stale.js";
 import { applyUntrackedStateSchema } from "./untracked/schema.js";
-import { commit } from "./commit.js";
-import { parseStatePk, serializeStatePk } from "./primary-key.js";
-import { uuidV7 } from "../deterministic/uuid-v7.js";
-import { LixLogSchema } from "../log/schema.js";
-import { shouldLog } from "../log/create-lix-own-log.js";
-import { populateStateCache } from "./cache/populate-state-cache.js";
-// import { createLixOwnLogSync } from "../log/create-lix-own-log.js";
-// Virtual table schema definition
-const VTAB_CREATE_SQL = `CREATE TABLE x(
-	_pk HIDDEN TEXT NOT NULL PRIMARY KEY,
-	entity_id TEXT,
-	schema_key TEXT,
-	file_id TEXT,
-	version_id TEXT,
-	plugin_key TEXT,
-	snapshot_content TEXT,
-	schema_version TEXT,
-	created_at TEXT,
-	updated_at TEXT,
-	inherited_from_version_id TEXT,
-	change_id TEXT,
-	untracked INTEGER,
-	commit_id TEXT
-) WITHOUT ROWID;`;
-export function applyStateDatabaseSchema(sqlite, db, hooks) {
-    applyMaterializeStateSchema(sqlite);
-    applyStateCacheSchema({ sqlite });
-    applyUntrackedStateSchema({ sqlite });
-    applyResolvedStateView({ sqlite, db });
-    sqlite.createFunction({
-        name: "validate_snapshot_content",
-        deterministic: true,
-        arity: 5,
-        // @ts-expect-error - type mismatch
-        xFunc: (_ctxPtr, ...args) => {
-            return validateStateMutation({
-                lix: { sqlite, db: db },
-                schema: args[0] ? JSON.parse(args[0]) : null,
-                snapshot_content: JSON.parse(args[1]),
-                operation: args[2] || undefined,
-                entity_id: args[3] || undefined,
-                version_id: args[4],
-            });
-        },
-    });
-    // Create virtual table using the proper SQLite WASM API (following vtab-experiment pattern)
-    const capi = sqlite.sqlite3.capi;
-    const module = new capi.sqlite3_module();
-    // Store cursor state
-    const cursorStates = new Map();
-    // Guard flag to prevent recursion when logging
-    let loggingIsInProgress = false;
-    /**
-     * Flag to prevent recursion when updating cache state.
-     *
-     * The guard ensures that while we're marking cache as fresh, any nested state queries
-     * bypass the cache and use materialized state directly, preventing recursion.
-     *
-     * Why is this needed is unclear. Queries are executed in sync. Why concurrent
-     * reads simultaneously update the cache is not clear. Given that state
-     * materialization is rare, this workaround has been deemed sufficient.
-     *
-     * This is a temporary fix and should be revisited in the future.
-     */
-    let isUpdatingCacheState = false;
-    module.installMethods({
-        xCreate: (dbHandle, _pAux, _argc, _argv, pVTab) => {
-            const result = capi.sqlite3_declare_vtab(dbHandle, VTAB_CREATE_SQL);
-            if (result !== capi.SQLITE_OK) {
-                return result;
-            }
-            sqlite.sqlite3.vtab.xVtab.create(pVTab);
-            return capi.SQLITE_OK;
-        },
-        xConnect: (dbHandle, _pAux, _argc, _argv, pVTab) => {
-            const result = capi.sqlite3_declare_vtab(dbHandle, VTAB_CREATE_SQL);
-            if (result !== capi.SQLITE_OK) {
-                return result;
-            }
-            // wiping all rows on connect simulates a temp table for internal_change_in_transaction.
-            // we need to clear any existing changes on connect in case a transaction remained open.
-            // otherwise, the lix can't boot up properly and will throw an error.
-            //
-            // an open transaction can happen if the storage layer crashes or is not properly shut down.
-            //
-            // PS internal_change_in_transaction is not a temp table because sqlite
-            // prohibits access to temp tables from virtual tables
-            executeSync({
-                lix: { sqlite },
-                query: db.deleteFrom("internal_change_in_transaction"),
-            });
-            sqlite.sqlite3.vtab.xVtab.create(pVTab);
-            return capi.SQLITE_OK;
-        },
-        xBegin: () => {
-            // TODO comment in after all internal v-table logic uses underlying state view
-            // // assert that we are not already in a transaction (the internal_change_in_transaction table is empty)
-            // const existingChangesInTransaction = executeSync({
-            // 	lix: { sqlite },
-            // 	query: db.selectFrom("internal_change_in_transaction").selectAll(),
-            // });
-            // if (existingChangesInTransaction.length > 0) {
-            // 	const errorMessage = "Transaction already in progress";
-            // 	if (canLog()) {
-            // 		createLixOwnLogSync({
-            // 			lix: { sqlite, db: db as any },
-            // 			key: "lix_state_xbegin_error",
-            // 			level: "error",
-            // 			message: `xBegin error: ${errorMessage}`,
-            // 		});
-            // 	}
-            // 	throw new Error(errorMessage);
-            // }
-        },
-        xCommit: () => {
-            return commit({ lix: { sqlite, db: db, hooks } });
-        },
-        xRollback: () => {
-            sqlite.exec({
-                sql: "DELETE FROM internal_change_in_transaction",
-                returnValue: "resultRows",
-            });
-        },
-        xBestIndex: (pVTab, pIdxInfo) => {
-            const idxInfo = sqlite.sqlite3.vtab.xIndexInfo(pIdxInfo);
-            // Track which columns have equality constraints
-            const usableConstraints = [];
-            let argIndex = 0;
-            // Column mapping (matching the CREATE TABLE order in xCreate/xConnect)
-            const columnMap = [
-                "_pk", // 0 (HIDDEN column)
-                "entity_id", // 1
-                "schema_key", // 2
-                "file_id", // 3
-                "version_id", // 4
-                "plugin_key", // 5
-                "snapshot_content", // 6
-                "schema_version", // 7
-                "created_at", // 8
-                "updated_at", // 9
-                "inherited_from_version_id", // 10
-                "change_id", // 11
-                "untracked", // 12
-                "commit_id", // 13
-            ];
-            // Process constraints
-            // @ts-expect-error - idxInfo.$nConstraint is not defined in the type
-            for (let i = 0; i < idxInfo.$nConstraint; i++) {
-                // @ts-expect-error - idxInfo.nthConstraint is not defined in the type
-                const constraint = idxInfo.nthConstraint(i);
-                // Only handle equality constraints that are usable
-                if (constraint.$op === capi.SQLITE_INDEX_CONSTRAINT_EQ &&
-                    constraint.$usable) {
-                    const columnName = columnMap[constraint.$iColumn];
-                    if (columnName) {
-                        usableConstraints.push(columnName);
-                        // Mark this constraint as used
-                        // @ts-expect-error - idxInfo.nthConstraintUsage is not defined in the type
-                        idxInfo.nthConstraintUsage(i).$argvIndex = ++argIndex;
-                    }
-                }
-            }
-            const fullTableCost = 1000000; // Default cost for full table scan
-            const fullTableRows = 10000000;
-            // Set the index string to pass column names to xFilter
-            if (usableConstraints.length > 0) {
-                const idxStr = usableConstraints.join(",");
-                // @ts-expect-error - idxInfo.$idxStr is not defined in the type
-                idxInfo.$idxStr = sqlite.sqlite3.wasm.allocCString(idxStr, false);
-                // @ts-expect-error - idxInfo.$needToFreeIdxStr is not defined in the type
-                idxInfo.$needToFreeIdxStr = 1; // We don't need SQLite to free this string
-                // Lower cost when we can use filters (more selective)
-                // @ts-expect-error - idxInfo.$estimatedCost is not defined in the type
-                idxInfo.$estimatedCost =
-                    fullTableCost / (usableConstraints.length + 1);
-                // @ts-expect-error - idxInfo.$estimatedRows is not defined in the type
-                idxInfo.$estimatedRows = Math.ceil(fullTableRows / (usableConstraints.length + 1));
-            }
-            else {
-                // @ts-expect-error - idxInfo.$needToFreeIdxStr is not defined in the type
-                idxInfo.$needToFreeIdxStr = 0;
-                // Higher cost for full table scan
-                // @ts-expect-error - idxInfo.$estimatedCost is not defined in the type
-                idxInfo.$estimatedCost = fullTableCost;
-                // @ts-expect-error - idxInfo.$estimatedRows is not defined in the type
-                idxInfo.$estimatedRows = fullTableRows;
-            }
-            return capi.SQLITE_OK;
-        },
-        xDisconnect: () => {
-            return capi.SQLITE_OK;
-        },
-        xDestroy: () => {
-            return capi.SQLITE_OK;
-        },
-        xOpen: (_pVTab, pCursor) => {
-            const cursor = sqlite.sqlite3.vtab.xCursor.create(pCursor);
-            cursorStates.set(cursor.pointer, {
-                results: [],
-                rowIndex: 0,
-            });
-            return capi.SQLITE_OK;
-        },
-        xClose: (pCursor) => {
-            cursorStates.delete(pCursor);
-            return capi.SQLITE_OK;
-        },
-        xFilter: (pCursor, idxNum, idxStrPtr, argc, argv) => {
-            const cursorState = cursorStates.get(pCursor);
-            const idxStr = sqlite.sqlite3.wasm.cstrToJs(idxStrPtr);
-            // Debug: Track recursion depth
-            const recursionKey = "_vtab_recursion_depth";
-            // @ts-expect-error - using global for debugging
-            const currentDepth = (globalThis[recursionKey] || 0) + 1;
-            // @ts-expect-error - using global for debugging
-            globalThis[recursionKey] = currentDepth;
-            if (currentDepth > 10) {
-                // @ts-expect-error - using global for debugging
-                globalThis[recursionKey] = 0; // Reset
-                throw new Error(`Virtual table recursion depth exceeded: ${currentDepth}`);
-            }
-            try {
-                // Extract filter arguments if provided
-                const filters = {};
-                if (argc > 0 && argv) {
-                    const args = sqlite.sqlite3.capi.sqlite3_values_to_js(argc, argv);
-                    // Parse idxStr to understand which columns are being filtered
-                    // idxStr format: "column1,column2,..."
-                    if (idxStr) {
-                        const columns = idxStr.split(",").filter((c) => c.length > 0);
-                        for (let i = 0; i < Math.min(columns.length, args.length); i++) {
-                            if (args[i] !== null) {
-                                filters[columns[i]] = args[i]; // Keep original type
-                            }
-                        }
-                    }
-                }
-                // If we're updating cache state, we must use resolved state view directly to avoid recursion
-                if (isUpdatingCacheState) {
-                    // Query directly from resolved state view which handles inheritance correctly
-                    let query = db
-                        .selectFrom("internal_resolved_state_all")
-                        .selectAll();
-                    // Apply filters
-                    for (const [column, value] of Object.entries(filters)) {
-                        query = query.where(column, "=", value);
-                    }
-                    const stateResults = executeSync({
-                        lix: { sqlite },
-                        query,
-                    });
-                    cursorState.results = stateResults || [];
-                    cursorState.rowIndex = 0;
-                    return capi.SQLITE_OK;
-                }
-                // Normal path: check cache staleness
-                const cacheIsStale = isStaleStateCache({
-                    lix: { sqlite, db: db },
-                });
-                // Try cache first - but only if it's not stale
-                let cacheResults = null;
-                if (!cacheIsStale) {
-                    // Select directly from resolved state view using Kysely
-                    let query = db
-                        .selectFrom("internal_resolved_state_all")
-                        .selectAll();
-                    // Apply filters
-                    for (const [column, value] of Object.entries(filters)) {
-                        query = query.where(column, "=", value);
-                    }
-                    cacheResults = executeSync({
-                        lix: { sqlite },
-                        query,
-                    });
-                }
-                cursorState.results = cacheResults || [];
-                cursorState.rowIndex = 0;
-                if (cacheIsStale) {
-                    // Populate cache directly with materialized state
-                    populateStateCache(sqlite);
-                    // Log the cache miss
-                    insertVTableLog({
-                        sqlite,
-                        db: db,
-                        key: "lix_state_cache_miss",
-                        level: "debug",
-                        message: `Cache miss detected - materialized state`,
-                    });
-                    // Mark cache as fresh after population
-                    isUpdatingCacheState = true;
-                    try {
-                        markStateCacheAsFresh({ lix: { sqlite, db: db } });
-                    }
-                    finally {
-                        isUpdatingCacheState = false;
-                    }
-                    let query = db
-                        .selectFrom("internal_resolved_state_all")
-                        .selectAll();
-                    // Apply filters
-                    for (const [column, value] of Object.entries(filters)) {
-                        query = query.where(column, "=", value);
-                    }
-                    const newResults = executeSync({
-                        lix: { sqlite },
-                        query,
-                    });
-                    cursorState.results = newResults || [];
-                }
-                return capi.SQLITE_OK;
-            }
-            finally {
-                // Always decrement recursion depth
-                // @ts-expect-error - using global for debugging
-                globalThis[recursionKey] = currentDepth - 1;
-            }
-        },
-        xNext: (pCursor) => {
-            const cursorState = cursorStates.get(pCursor);
-            cursorState.rowIndex++;
-            return capi.SQLITE_OK;
-        },
-        xEof: (pCursor) => {
-            const cursorState = cursorStates.get(pCursor);
-            return cursorState.rowIndex >= cursorState.results.length ? 1 : 0;
-        },
-        xColumn: (pCursor, pContext, iCol) => {
-            const cursorState = cursorStates.get(pCursor);
-            const row = cursorState.results[cursorState.rowIndex];
-            if (!row) {
-                capi.sqlite3_result_null(pContext);
-                return capi.SQLITE_OK;
-            }
-            // Handle primary key column (_pk)
-            if (iCol === 0) {
-                if (Array.isArray(row)) {
-                    // For array results, _pk is at index 0
-                    capi.sqlite3_result_js(pContext, row[0]);
-                }
-                else if (row._pk) {
-                    // If row already has _pk, use it
-                    capi.sqlite3_result_js(pContext, row._pk);
-                }
-                else {
-                    // Generate primary key from row data
-                    const tag = row.untracked ? "U" : "C";
-                    const primaryKey = serializeStatePk(tag, row.file_id, row.entity_id, row.version_id);
-                    capi.sqlite3_result_js(pContext, primaryKey);
-                }
-                return capi.SQLITE_OK;
-            }
-            // Handle array-style results from SQLite exec
-            let value;
-            if (Array.isArray(row)) {
-                // For array results, composite_key is at index 0, so we use iCol directly
-                value = row[iCol];
-            }
-            else {
-                const columnName = getColumnName(iCol);
-                value = row[columnName];
-            }
-            // Handle special cases for null values that might be stored as strings
-            if (value === "null" &&
-                getColumnName(iCol) === "inherited_from_version_id") {
-                capi.sqlite3_result_null(pContext);
-                return capi.SQLITE_OK;
-            }
-            if (value === null) {
-                capi.sqlite3_result_null(pContext);
-            }
-            else {
-                capi.sqlite3_result_js(pContext, value);
-            }
-            return capi.SQLITE_OK;
-        },
-        xRowid: () => {
-            // For WITHOUT ROWID tables, xRowid should not be called
-            // But if it is, we return an error
-            return capi.SQLITE_ERROR;
-        },
-        xUpdate: (_pVTab, nArg, ppArgv) => {
-            try {
-                // Extract arguments using the proper SQLite WASM API
-                const args = sqlite.sqlite3.capi.sqlite3_values_to_js(nArg, ppArgv);
-                // DELETE operation: nArg = 1, args[0] = old primary key
-                if (nArg === 1) {
-                    const oldPk = args[0];
-                    if (!oldPk) {
-                        throw new Error("Missing primary key for DELETE operation");
-                    }
-                    // Use handleStateDelete for all cases - it handles both tracked and untracked
-                    handleStateDelete(sqlite, oldPk, db);
-                    return capi.SQLITE_OK;
-                }
-                // INSERT operation: nArg = N+2, args[0] = NULL, args[1] = new primary key
-                // UPDATE operation: nArg = N+2, args[0] = old primary key, args[1] = new primary key
-                const isInsert = args[0] === null;
-                const isUpdate = args[0] !== null;
-                if (!isInsert && !isUpdate) {
-                    throw new Error("Invalid xUpdate operation");
-                }
-                // Extract column values (args[2] through args[N+1])
-                // Column order: _pk, entity_id, schema_key, file_id, version_id, plugin_key,
-                //               snapshot_content, schema_version, created_at, updated_at, inherited_from_version_id, change_id, untracked
-                const entity_id = args[3];
-                const schema_key = args[4];
-                const file_id = args[5];
-                const version_id = args[6];
-                const plugin_key = args[7];
-                // this is an update where we have a snapshot_content
-                // the snapshot_content is a JSON string as returned by SQlite
-                const snapshot_content = args[8];
-                const schema_version = args[9];
-                // Skip created_at (args[10]), updated_at (args[11]), inherited_from_version_id (args[12]), change_id (args[13])
-                const untracked = args[14] ?? false;
-                // assert required fields
-                if (!entity_id || !schema_key || !file_id || !plugin_key) {
-                    throw new Error("Missing required fields for state mutation");
-                }
-                if (!version_id) {
-                    throw new Error("version_id is required for state mutation");
-                }
-                // Call validation function (same logic as triggers)
-                const storedSchema = getStoredSchema(sqlite, db, schema_key);
-                validateStateMutation({
-                    lix: { sqlite, db: db },
-                    schema: storedSchema ? JSON.parse(storedSchema) : null,
-                    snapshot_content: JSON.parse(snapshot_content),
-                    operation: isInsert ? "insert" : "update",
-                    entity_id: String(entity_id),
-                    version_id: String(version_id),
-                    untracked: Boolean(untracked),
-                });
-                // Use insertTransactionState which handles both tracked and untracked entities
-                insertTransactionState({
-                    lix: { sqlite, db },
-                    data: {
-                        entity_id: String(entity_id),
-                        schema_key: String(schema_key),
-                        file_id: String(file_id),
-                        plugin_key: String(plugin_key),
-                        snapshot_content,
-                        schema_version: String(schema_version),
-                        version_id: String(version_id),
-                        untracked: Boolean(untracked),
-                    },
-                });
-                // TODO: This cache copying logic is a temporary workaround for shared commits.
-                // The proper solution requires improving cache miss logic to handle commit sharing
-                // without duplicating entries. See: https://github.com/opral/lix-sdk/issues/309
-                //
-                // Handle cache copying for new versions that share commits
-                if (isInsert && String(schema_key) === "lix_version") {
-                    const versionData = JSON.parse(snapshot_content);
-                    const newVersionId = versionData.id;
-                    const commitId = versionData.commit_id;
-                    if (newVersionId && commitId) {
-                        // Find other versions that point to the same commit
-                        const existingVersionsWithSameCommit = sqlite.exec({
-                            sql: `
-									SELECT json_extract(snapshot_content, '$.id') as version_id
-									FROM internal_state_cache 
-									WHERE schema_key = 'lix_version' 
-									  AND json_extract(snapshot_content, '$.commit_id') = ?
-									  AND json_extract(snapshot_content, '$.id') != ?
-								`,
-                            bind: [commitId, newVersionId],
-                            returnValue: "resultRows",
-                        });
-                        // If there are existing versions with the same commit, copy their cache entries
-                        if (existingVersionsWithSameCommit &&
-                            existingVersionsWithSameCommit.length > 0) {
-                            const sourceVersionId = existingVersionsWithSameCommit[0][0]; // Take first existing version
-                            // Copy cache entries from source version to new version
-                            // IMPORTANT: When copying cache entries, we need to mark them as inherited
-                            // if they don't have an inherited_from_version_id already
-                            sqlite.exec({
-                                sql: `
-										INSERT OR IGNORE INTO internal_state_cache 
-										(entity_id, schema_key, file_id, version_id, plugin_key, snapshot_content, schema_version, created_at, updated_at, inherited_from_version_id, inheritance_delete_marker, change_id, commit_id)
-										SELECT 
-											entity_id, schema_key, file_id, ?, plugin_key, snapshot_content, schema_version, created_at, updated_at, 
-											CASE 
-												WHEN inherited_from_version_id IS NULL THEN ?
-												ELSE inherited_from_version_id
-											END as inherited_from_version_id,
-											inheritance_delete_marker, change_id, commit_id
-										FROM internal_state_cache
-										WHERE version_id = ? AND schema_key != 'lix_version'
-									`,
-                                bind: [newVersionId, sourceVersionId, sourceVersionId],
-                            });
-                        }
-                    }
-                }
-                return capi.SQLITE_OK;
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                // Log error for debugging
-                insertVTableLog({
-                    sqlite,
-                    db: db,
-                    key: "lix_state_xupdate_error",
-                    level: "error",
-                    message: `xUpdate error: ${errorMessage}`,
-                });
-                throw error; // Re-throw to propagate error
-            }
-        },
-    }, false);
-    capi.sqlite3_create_module(sqlite.pointer, "state_vtab", module, 0);
-    // Create the virtual table as 'state' directly (no more _impl suffix or view layer)
-    sqlite.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS state_all USING state_vtab();`);
-    // Create state view that filters to active version only
-    sqlite.exec(`
-		CREATE VIEW IF NOT EXISTS state AS
-		SELECT 
-			entity_id,
-			schema_key,
-			file_id,
-			plugin_key,
-			snapshot_content,
-			schema_version,
-			created_at,
-			updated_at,
-			inherited_from_version_id,
-			change_id,
-			untracked,
-			commit_id
-		FROM state_all
-		WHERE version_id IN (SELECT version_id FROM active_version);
-
-		-- Add INSTEAD OF triggers for state that forward to state virtual table
-		CREATE TRIGGER IF NOT EXISTS state_insert
-		INSTEAD OF INSERT ON state
-		BEGIN
-			INSERT INTO state_all (
-				entity_id,
-				schema_key,
-				file_id,
-				version_id,
-				plugin_key,
-				snapshot_content,
-				schema_version,
-				created_at,
-				updated_at,
-				inherited_from_version_id,
-				change_id,
-				untracked,
-				commit_id
-			) VALUES (
-				NEW.entity_id,
-				NEW.schema_key,
-				NEW.file_id,
-				(SELECT version_id FROM active_version),
-				NEW.plugin_key,
-				NEW.snapshot_content,
-				NEW.schema_version,
-				NEW.created_at,
-				NEW.updated_at,
-				NEW.inherited_from_version_id,
-				NEW.change_id,
-				NEW.untracked,
-				NEW.commit_id
-			);
-		END;
-
-		CREATE TRIGGER IF NOT EXISTS state_update
-		INSTEAD OF UPDATE ON state	
-		BEGIN
-			UPDATE state_all
-			SET
-				entity_id = NEW.entity_id,
-				schema_key = NEW.schema_key,
-				file_id = NEW.file_id,
-				version_id = (SELECT version_id FROM active_version),
-				plugin_key = NEW.plugin_key,
-				snapshot_content = NEW.snapshot_content,
-				schema_version = NEW.schema_version,
-				created_at = NEW.created_at,
-				updated_at = NEW.updated_at,
-				inherited_from_version_id = NEW.inherited_from_version_id,
-				change_id = NEW.change_id,
-				untracked = NEW.untracked,
-				commit_id = NEW.commit_id
-			WHERE
-				entity_id = OLD.entity_id
-				AND schema_key = OLD.schema_key
-				AND file_id = OLD.file_id
-				AND version_id = (SELECT version_id FROM active_version);
-		END;
+import { applyStateCacheSchema } from "./cache/schema.js";
+import { applyStateByVersionView } from "./views/state-by-version.js";
+import { applyStateWithTombstonesView } from "./views/state-with-tombstones.js";
+import { applyStateView } from "./views/state.js";
+import { applyStateVTable } from "./vtable/vtable.js";
+export function applyStateDatabaseSchema(args) {
+    const { engine } = args;
+    applyMaterializeStateSchema({ engine });
+    applyStateCacheSchema({ engine });
+    applyUntrackedStateSchema({ engine });
+    // Writer metadata table: stores last writer per (file, version, entity, schema).
+    // No NULL storage policy: absence of row = unknown writer.
+    engine.sqlite.exec(`
+	  CREATE TABLE IF NOT EXISTS lix_internal_state_writer (
+	    file_id    TEXT NOT NULL,
+	    version_id TEXT NOT NULL,
+	    entity_id  TEXT NOT NULL,
+	    schema_key TEXT NOT NULL,
+	    writer_key TEXT NULL,
+	    PRIMARY KEY (file_id, version_id, entity_id, schema_key)
+	  ) WITHOUT ROWID;
 
-		CREATE TRIGGER IF NOT EXISTS state_delete
-		INSTEAD OF DELETE ON state
-		BEGIN
-			-- Delete from state_all (handles both tracked and untracked entities)
-			DELETE FROM state_all
-			WHERE 
-				entity_id = OLD.entity_id
-				AND schema_key = OLD.schema_key
-				AND file_id = OLD.file_id
-				AND version_id = (SELECT version_id FROM active_version);
-		END;
+	  CREATE INDEX IF NOT EXISTS idx_lix_internal_state_writer_fvw
+	    ON lix_internal_state_writer(file_id, version_id, writer_key);
 	`);
-    /**
-     * Insert a log entry directly using insertTransactionState to avoid recursion
-     * when logging from within the virtual table methods.
-     */
-    function insertVTableLog(args) {
-        if (loggingIsInProgress) {
-            return;
-        }
-        // preventing recursivly logging that we inserted a log entry
-        // with this flag
-        loggingIsInProgress = true;
-        // Check log levels directly from internal state tables to avoid recursion
-        const logLevelsResult = executeSync({
-            lix: { sqlite: args.sqlite },
-            query: args.db
-                .selectFrom("internal_resolved_state_all")
-                .select(sql `json_extract(snapshot_content, '$.value')`.as("value"))
-                .where("schema_key", "=", "lix_key_value")
-                .where(sql `json_extract(snapshot_content, '$.key')`, "=", "lix_log_levels")
-                .limit(1),
-        });
-        const logLevelsValue = logLevelsResult[0]?.value;
-        // Check if the level is allowed
-        if (!shouldLog(logLevelsValue, args.level)) {
-            return;
-        }
-        // Create log entry data
-        const lix = { sqlite: args.sqlite, db: args.db };
-        const logData = {
-            id: uuidV7({ lix }),
-            key: args.key,
-            message: args.message,
-            level: args.level,
-        };
-        // Insert log using insertTransactionState
-        insertTransactionState({
-            lix,
-            data: {
-                entity_id: logData.id,
-                schema_key: LixLogSchema["x-lix-key"],
-                file_id: "lix",
-                plugin_key: "lix_own_entity",
-                snapshot_content: JSON.stringify(logData),
-                schema_version: LixLogSchema["x-lix-version"],
-                // Using global and untracked for vtable logs.
-                // if we need to track them, we can change this later
-                version_id: "global",
-                untracked: true,
-            },
-        });
-        loggingIsInProgress = false;
-    }
-}
-export function handleStateDelete(sqlite, primaryKey, db) {
-    // Query the row to delete using the resolved state view with Kysely
-    const rowToDelete = executeSync({
-        lix: { sqlite },
-        query: db
-            .selectFrom("internal_resolved_state_all")
-            .select([
-            "entity_id",
-            "schema_key",
-            "file_id",
-            "version_id",
-            "plugin_key",
-            "snapshot_content",
-            "schema_version",
-            "untracked",
-            "inherited_from_version_id",
-        ])
-            .where("_pk", "=", primaryKey),
-    })[0];
-    if (!rowToDelete) {
-        throw new Error(`Row not found for primary key: ${primaryKey}`);
-    }
-    const entity_id = rowToDelete.entity_id;
-    const schema_key = rowToDelete.schema_key;
-    const file_id = rowToDelete.file_id;
-    const version_id = rowToDelete.version_id;
-    const plugin_key = rowToDelete.plugin_key;
-    const snapshot_content = rowToDelete.snapshot_content;
-    const schema_version = rowToDelete.schema_version;
-    const untracked = rowToDelete.untracked;
-    // If entity is untracked, handle differently based on whether it's inherited
-    if (untracked) {
-        // Parse the primary key to check if it's inherited untracked (UI tag)
-        const parsed = parseStatePk(primaryKey);
-        if (parsed.tag === "UI") {
-            // For inherited untracked, create a tombstone to block inheritance
-            insertTransactionState({
-                lix: { sqlite, db },
-                data: {
-                    entity_id: String(entity_id),
-                    schema_key: String(schema_key),
-                    file_id: String(file_id),
-                    plugin_key: String(plugin_key),
-                    snapshot_content: null, // Deletion tombstone
-                    schema_version: String(schema_version),
-                    version_id: String(version_id),
-                    untracked: true,
-                },
-            });
-        }
-        else {
-            // For direct untracked (U tag), just delete from untracked table
-            executeSync({
-                lix: { sqlite },
-                query: db
-                    .deleteFrom("internal_state_all_untracked")
-                    .where("entity_id", "=", String(entity_id))
-                    .where("schema_key", "=", String(schema_key))
-                    .where("file_id", "=", String(file_id))
-                    .where("version_id", "=", String(version_id)),
-            });
-        }
-        return;
-    }
-    const storedSchema = getStoredSchema(sqlite, db, schema_key);
-    validateStateMutation({
-        lix: { sqlite, db: db },
-        schema: storedSchema ? JSON.parse(storedSchema) : null,
-        snapshot_content: JSON.parse(snapshot_content),
-        operation: "delete",
-        entity_id: String(entity_id),
-        version_id: String(version_id),
-    });
-    insertTransactionState({
-        lix: { sqlite, db },
-        data: {
-            entity_id: String(entity_id),
-            schema_key: String(schema_key),
-            file_id: String(file_id),
-            plugin_key: String(plugin_key),
-            snapshot_content: null, // No snapshot content for DELETE
-            schema_version: String(schema_version),
-            version_id: String(version_id),
-            untracked: false, // tracked entity
-        },
-    });
-}
-// Helper functions for the virtual table
-function getStoredSchema(sqlite, db, schemaKey) {
-    // Query directly from internal_resolved_state_all to avoid vtable recursion
-    const result = executeSync({
-        lix: { sqlite },
-        query: db
-            .selectFrom("internal_resolved_state_all")
-            .select(sql `json_extract(snapshot_content, '$.value')`.as("value"))
-            .where("schema_key", "=", "lix_stored_schema")
-            .where(sql `json_extract(snapshot_content, '$.key')`, "=", String(schemaKey))
-            .limit(1),
-    });
-    return result && result.length > 0 ? result[0].value : null;
-}
-function getColumnName(columnIndex) {
-    const columns = [
-        "_pk",
-        "entity_id",
-        "schema_key",
-        "file_id",
-        "version_id",
-        "plugin_key",
-        "snapshot_content",
-        "schema_version",
-        "created_at",
-        "updated_at",
-        "inherited_from_version_id",
-        "change_id",
-        "untracked",
-        "commit_id",
-    ];
-    return columns[columnIndex] || "unknown";
+    // Apply the virtual table (binds to the in-process engine)
+    applyStateVTable(engine);
+    // Public views over the internal vtable
+    applyStateView({ engine });
+    applyStateByVersionView({ engine });
+    applyStateWithTombstonesView({ engine });
 }
 //# sourceMappingURL=schema.js.map