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

package/src/schema-definition/validate-lix-schema.test.ts

@@ -12,6 +12,7 @@ test("validateLixSchemaDefinition passes for valid Lix schema", () => {
 		properties: {
 			id: { type: "string" },
 		},
+		additionalProperties: false,
 	};
 
 	expect(() => validateLixSchemaDefinition(validSchema)).not.toThrow();
@@ -25,6 +26,7 @@ test("validateLixSchemaDefinition throws for invalid schema", () => {
 		properties: {
 			id: { type: "string" },
 		},
+		additionalProperties: false,
 		// Missing required x-lix-key
 	};
 
@@ -43,6 +45,7 @@ test("validateLixSchema validates both schema and data successfully", () => {
 			name: { type: "string" },
 		},
 		required: ["id", "name"],
+		additionalProperties: false,
 	};
 
 	const validData = {
@@ -62,6 +65,7 @@ test("validateLixSchema throws when schema is invalid", () => {
 		properties: {
 			id: { type: "string" },
 		},
+		additionalProperties: false,
 	};
 
 	const data = { id: "123" };
@@ -81,6 +85,7 @@ test("validateLixSchema throws when data doesn't match schema", () => {
 			name: { type: "string" },
 		},
 		required: ["id", "name"],
+		additionalProperties: false,
 	};
 
 	const invalidData = {
@@ -92,3 +97,97 @@ test("validateLixSchema throws when data doesn't match schema", () => {
 		"Data validation failed"
 	);
 });
+
+test("validateLixSchemaDefinition rejects when additionalProperties is missing", () => {
+	const schemaMissingAdditionalProps = {
+		"x-lix-key": "user",
+		"x-lix-version": "1.0",
+		type: "object",
+		properties: {
+			id: { type: "string" },
+		},
+		required: ["id"],
+	};
+
+	expect(() =>
+		validateLixSchemaDefinition(schemaMissingAdditionalProps)
+	).toThrow("Invalid Lix schema definition");
+});
+
+test("additional properties must be false", () => {
+	const schemaWithAdditionalProps = {
+		"x-lix-key": "user",
+		"x-lix-version": "1.0",
+		type: "object",
+		properties: {
+			id: { type: "string" },
+			name: { type: "string" },
+		},
+		required: ["id", "name"],
+		additionalProperties: true, // This should cause validation to fail
+	};
+
+	const data = {
+		id: "123",
+		name: "John Doe",
+		extraField: "not allowed", // Extra field not defined in schema
+	};
+
+	expect(() =>
+		validateLixSchemaDefinition(schemaWithAdditionalProps)
+	).toThrow();
+
+	const validSchema = {
+		"x-lix-key": "user",
+		"x-lix-version": "1.0",
+		type: "object",
+		properties: {
+			id: { type: "string" },
+			name: { type: "string" },
+		},
+		required: ["id", "name"],
+		additionalProperties: false, // Correctly set to false
+	};
+
+	expect(() => validateLixSchemaDefinition(validSchema)).not.toThrow();
+	expect(validateLixSchemaDefinition(validSchema)).toBe(true);
+
+	expect(() => validateLixSchema(validSchema, data)).toThrow(
+		"Data validation failed"
+	);
+});
+
+test("validateLixSchemaDefinition rejects missing primary key properties", () => {
+	const schema = {
+		"x-lix-key": "missing_pk",
+		"x-lix-version": "1.0",
+		type: "object",
+		properties: {
+			value: { type: "string" },
+		},
+		required: ["value"],
+		"x-lix-primary-key": ["/entity_id"],
+		additionalProperties: false,
+	};
+
+	expect(() => validateLixSchemaDefinition(schema)).toThrow(
+		"x-lix-primary-key references missing property"
+	);
+});
+
+test("validateLixSchemaDefinition rejects missing unique constraint properties", () => {
+	const schema = {
+		"x-lix-key": "missing_unique",
+		"x-lix-version": "1.0",
+		type: "object",
+		properties: {
+			value: { type: "string" },
+		},
+		"x-lix-unique": [["/entity_id", "/value"]],
+		additionalProperties: false,
+	};
+
+	expect(() => validateLixSchemaDefinition(schema)).toThrow(
+		"x-lix-unique references missing property"
+	);
+});

package/src/schema-definition/validate-lix-schema.ts

@@ -1,5 +1,7 @@
 import { Ajv } from "ajv";
+import { parse } from "@marcbachmann/cel-js";
 import { LixSchemaDefinition } from "./definition.js";
+import { parseJsonPointer } from "./json-pointer.js";
 
 const ajv = new Ajv({
 	strict: true,
@@ -7,9 +9,75 @@ const ajv = new Ajv({
 	// https://json-schema.org/blog/posts/stable-json-schema
 	strictSchema: false,
 });
+ajv.addFormat("json-pointer", {
+	type: "string",
+	validate: (value: string) => {
+		try {
+			parseJsonPointer(value);
+			return true;
+		} catch {
+			return false;
+		}
+	},
+});
+ajv.addFormat("cel", {
+	type: "string",
+	validate: (value: string) => {
+		try {
+			parse(value);
+			return true;
+		} catch {
+			return false;
+		}
+	},
+});
 
 const _validateLixSchemaDefinition = ajv.compile(LixSchemaDefinition);
 
+function assertPrimaryKeyPointers(schema: LixSchemaDefinition) {
+	const primaryKey = (schema as any)["x-lix-primary-key"];
+	if (!Array.isArray(primaryKey)) return;
+	for (const pointer of primaryKey) {
+		if (typeof pointer !== "string") continue;
+		const segments = parseJsonPointer(pointer);
+		if (!segments.length || !schemaHasProperty(schema, segments)) {
+			throw new Error(
+				`Invalid Lix schema definition: x-lix-primary-key references missing property "${pointer}".`
+			);
+		}
+	}
+}
+
+function assertUniquePointers(schema: LixSchemaDefinition) {
+	const uniqueGroups = (schema as any)["x-lix-unique"];
+	if (!Array.isArray(uniqueGroups)) return;
+	for (const group of uniqueGroups) {
+		if (!Array.isArray(group)) continue;
+		for (const pointer of group) {
+			if (typeof pointer !== "string") continue;
+			const segments = parseJsonPointer(pointer);
+			if (!segments.length || !schemaHasProperty(schema, segments)) {
+				throw new Error(
+					`Invalid Lix schema definition: x-lix-unique references missing property "${pointer}".`
+				);
+			}
+		}
+	}
+}
+
+function schemaHasProperty(current: any, segments: readonly string[]): boolean {
+	let node: any = current;
+	for (const segment of segments) {
+		if (!node || typeof node !== "object") return false;
+		const props = (node as any).properties;
+		if (!props || typeof props !== "object" || !(segment in props)) {
+			return false;
+		}
+		node = (props as any)[segment];
+	}
+	return true;
+}
+
 /**
  * Validates that a schema conforms to the LixSchemaDefinition format
  * and then validates data against that schema.
@@ -54,6 +122,8 @@ export function validateLixSchema(schema: unknown, data: unknown): boolean {
 			`Invalid Lix schema definition: ${JSON.stringify(_validateLixSchemaDefinition.errors, null, 2)}`
 		);
 	}
+	assertPrimaryKeyPointers(schema as LixSchemaDefinition);
+	assertUniquePointers(schema as LixSchemaDefinition);
 
 	// Then validate the data against the schema
 	const dataValidator = ajv.compile(schema as LixSchemaDefinition);
@@ -100,5 +170,7 @@ export function validateLixSchemaDefinition(schema: unknown): boolean {
 			`Invalid Lix schema definition: ${JSON.stringify(_validateLixSchemaDefinition.errors, null, 2)}`
 		);
 	}
+	assertPrimaryKeyPointers(schema as LixSchemaDefinition);
+	assertUniquePointers(schema as LixSchemaDefinition);
 	return valid;
 }

package/src/server-protocol-handler/environment/create-in-memory-environment.ts

@@ -59,7 +59,7 @@ export const createLspInMemoryEnvironment = (): LspEnvironment => {
 					keyValues: [{ key: "lix_sync", value: "false" }],
 				});
 
-				lix.sqlite.exec("PRAGMA foreign_keys = OFF;");
+				lix.engine!.sqlite.exec("PRAGMA foreign_keys = OFF;");
 
 				openLixes.set(args.id, lix);
 			}

package/src/server-protocol-handler/routes/get-v1.ts

@@ -2,7 +2,7 @@ import {
 	contentFromDatabase,
 	createInMemoryDatabase,
 	importDatabase,
-} from "sqlite-wasm-kysely";
+} from "../../database/sqlite/index.js";
 import type { LixServerProtocolHandlerRoute } from "../create-server-protocol-handler.js";
 
 export const route: LixServerProtocolHandlerRoute = async (context) => {
@@ -51,7 +51,9 @@ export const route: LixServerProtocolHandlerRoute = async (context) => {
 		"UPDATE key_value SET value = json('true') WHERE key = 'lix_sync'"
 	);
 
-	const blob2 = new Blob([contentFromDatabase(sqlite)]);
+	const blob2 = new Blob([
+		contentFromDatabase(sqlite) as Uint8Array<ArrayBuffer>,
+	]);
 
 	return new Response(blob2, {
 		status: 200,

package/src/server-protocol-handler/routes/pull-v1.test.ts

@@ -1,5 +1,5 @@
 import { test, expect } from "vitest";
-import type * as LixServerProtocol from "../../../../lix/server-protocol-schema/dist/schema.js";
+import type * as LixServerProtocol from "../../../../server-protocol-schema/dist/schema.js";
 import { openLix } from "../../lix/open-lix.js";
 import { createServerProtocolHandler } from "../create-server-protocol-handler.js";
 import { createLspInMemoryEnvironment } from "../environment/create-in-memory-environment.js";

package/src/server-protocol-handler/routes/pull-v1.ts

@@ -1,4 +1,4 @@
-import type * as LixServerProtocol from "../../../../lix/server-protocol-schema/dist/schema.js";
+import type * as LixServerProtocol from "../../../../server-protocol-schema/dist/schema.js";
 import type { LixServerProtocolHandlerRoute } from "../create-server-protocol-handler.js";
 import { getDiffingRows } from "../../sync/get-diffing-rows.js";
 

package/src/server-protocol-handler/routes/push-v1.test.ts

@@ -2,7 +2,7 @@
 // @ts-nocheck
 
 import { test, expect, vi } from "vitest";
-import type * as LixServerProtocol from "../../../../lix/server-protocol-schema/dist/schema.js";
+import type * as LixServerProtocol from "../../../../server-protocol-schema/dist/schema.js";
 import { openLix } from "../../lix/open-lix.js";
 import { createServerProtocolHandler } from "../create-server-protocol-handler.js";
 import type { Change } from "../../database/schema.js";
@@ -182,7 +182,7 @@ test.skip("it should detect conflicts", async () => {
 
 	const lsaHandler = await createServerProtocolHandler({ environment });
 
-	global.fetch = vi.fn((request) => lsaHandler(request));
+	vi.stubGlobal("fetch", vi.fn((request) => lsaHandler(request)) as any);
 
 	// server has/creates value0 for mock_key
 	await lixOnServer.db

package/src/server-protocol-handler/routes/push-v1.ts

@@ -1,7 +1,7 @@
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-nocheck
 
-import type * as LixServerProtocol from "../../../../lix/server-protocol-schema/dist/schema.js";
+import type * as LixServerProtocol from "../../../../server-protocol-schema/dist/schema.js";
 import type { LixServerProtocolHandlerRoute } from "../create-server-protocol-handler.js";
 import { mergeTheirState } from "../../sync/merge-state.js";
 import type { Change } from "../../database/schema.js";

package/src/services/env-variables/index.d.ts

@@ -4,7 +4,7 @@
  */
 
 /**
- * Env variables that are available at runtime.
+ * Env variables that are available at engine.
  */
 export declare const ENV_VARIABLES: {
 	LIX_SDK_POSTHOG_TOKEN?: string;

package/src/services/telemetry/capture.test.ts

@@ -2,7 +2,7 @@ import { expect, test, vi } from "vitest";
 import { capture } from "./capture.js";
 
 test("it should not capture if telemetry is off", async () => {
-	global.fetch = vi.fn(() => Promise.resolve(new Response()));
+	vi.stubGlobal("fetch", vi.fn(() => Promise.resolve(new Response())) as any);
 
 	vi.mock("../env-variables/index.js", async () => {
 		return {
@@ -19,11 +19,11 @@ test("it should not capture if telemetry is off", async () => {
 		properties: {},
 	});
 
-	expect(global.fetch).not.toHaveBeenCalled();
+	expect((globalThis as any).fetch).not.toHaveBeenCalled();
 });
 
 test("it should not capture if telemetry is NOT off", async () => {
-	global.fetch = vi.fn(() => Promise.resolve(new Response()));
+	vi.stubGlobal("fetch", vi.fn(() => Promise.resolve(new Response())) as any);
 
 	vi.mock("../env-variables/index.js", async () => {
 		return {
@@ -40,5 +40,5 @@ test("it should not capture if telemetry is NOT off", async () => {
 		properties: {},
 	});
 
-	expect(global.fetch).toHaveBeenCalled();
+	expect((globalThis as any).fetch).toHaveBeenCalled();
 });

package/src/snapshot/schema.test.ts

@@ -8,7 +8,7 @@ test("insert with default id generation", async () => {
 
 	// Insert a snapshot without specifying an id
 	await (lix.db as unknown as Kysely<LixInternalDatabaseSchema>)
-		.insertInto("internal_snapshot")
+		.insertInto("lix_internal_snapshot")
 		.values({
 			content: sql`jsonb(${JSON.stringify({ text: "Auto-generated ID test" })})`,
 		})
@@ -18,7 +18,7 @@ test("insert with default id generation", async () => {
 	const snapshots = await (
 		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
 	)
-		.selectFrom("internal_snapshot")
+		.selectFrom("lix_internal_snapshot")
 		.where(
 			"content",
 			"=",
@@ -52,7 +52,7 @@ test("handles complex JSON content", async () => {
 	};
 
 	await (lix.db as unknown as Kysely<LixInternalDatabaseSchema>)
-		.insertInto("internal_snapshot")
+		.insertInto("lix_internal_snapshot")
 		.values({
 			id: "complex",
 			content: sql`jsonb(${JSON.stringify(complexContent)})`,
@@ -62,7 +62,7 @@ test("handles complex JSON content", async () => {
 	const snapshot = await (
 		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
 	)
-		.selectFrom("internal_snapshot")
+		.selectFrom("lix_internal_snapshot")
 		.where("id", "=", "complex")
 		.select(["id", (eb) => eb.fn("json", [`content`]).as("content")])
 		.executeTakeFirstOrThrow();
@@ -77,7 +77,7 @@ test("no-content snapshot exists by default", async () => {
 	const internalNoContent = await (
 		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
 	)
-		.selectFrom("internal_snapshot")
+		.selectFrom("lix_internal_snapshot")
 		.where("id", "=", "no-content")
 		.selectAll()
 		.execute();
@@ -91,8 +91,8 @@ test("no-content snapshot is not duplicated on multiple schema applications", as
 	const lix = await openLix({});
 
 	// Apply the schema again (this happens in real usage)
-	lix.sqlite.exec(`
-			INSERT OR IGNORE INTO internal_snapshot (id, content)
+	lix.engine!.sqlite.exec(`
+			INSERT OR IGNORE INTO lix_internal_snapshot (id, content)
 			VALUES ('no-content', NULL);
 		`);
 
@@ -100,7 +100,7 @@ test("no-content snapshot is not duplicated on multiple schema applications", as
 	const noContentSnapshots = await (
 		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
 	)
-		.selectFrom("internal_snapshot")
+		.selectFrom("lix_internal_snapshot")
 		.where("id", "=", "no-content")
 		.selectAll()
 		.execute();
@@ -112,7 +112,7 @@ test("can insert null content explicitly", async () => {
 	const lix = await openLix({});
 
 	await (lix.db as unknown as Kysely<LixInternalDatabaseSchema>)
-		.insertInto("internal_snapshot")
+		.insertInto("lix_internal_snapshot")
 		.values({
 			id: "explicit-null",
 			content: null,
@@ -122,7 +122,7 @@ test("can insert null content explicitly", async () => {
 	const snapshot = await (
 		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
 	)
-		.selectFrom("internal_snapshot")
+		.selectFrom("lix_internal_snapshot")
 		.where("id", "=", "explicit-null")
 		.selectAll()
 		.executeTakeFirstOrThrow();
@@ -135,7 +135,7 @@ test("snapshot content validation - accepts JSONB", async () => {
 
 	// This should succeed - content is properly formatted as JSONB
 	await (lix.db as unknown as Kysely<LixInternalDatabaseSchema>)
-		.insertInto("internal_snapshot")
+		.insertInto("lix_internal_snapshot")
 		.values({
 			id: "valid-jsonb",
 			content: sql`jsonb(${JSON.stringify({ test: "data", value: 123 })})`,
@@ -145,7 +145,7 @@ test("snapshot content validation - accepts JSONB", async () => {
 	const snapshot = await (
 		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
 	)
-		.selectFrom("internal_snapshot")
+		.selectFrom("lix_internal_snapshot")
 		.where("id", "=", "valid-jsonb")
 		.select(["id", (eb) => eb.fn("json", [`content`]).as("content")])
 		.executeTakeFirstOrThrow();
@@ -160,7 +160,7 @@ test("snapshot content validation - rejects text JSON", async () => {
 	// SQLite's STRICT tables enforce that BLOB columns can't store TEXT
 	await expect(
 		(lix.db as unknown as Kysely<LixInternalDatabaseSchema>)
-			.insertInto("internal_snapshot")
+			.insertInto("lix_internal_snapshot")
 			.values({
 				id: "invalid-text-json",
 				content: sql`${JSON.stringify({ test: "data" })}`,
@@ -180,8 +180,8 @@ test("snapshot content validation - rejects arbitrary binary", async () => {
 	const arbitraryBytes = encoder.encode("arbitrary binary data");
 
 	await expect(async () => {
-		lix.sqlite.exec({
-			sql: `INSERT INTO internal_snapshot (id, content) VALUES (?, ?)`,
+		lix.engine!.sqlite.exec({
+			sql: `INSERT INTO lix_internal_snapshot (id, content) VALUES (?, ?)`,
 			bind: ["invalid-binary", arbitraryBytes],
 		});
 	}).rejects.toThrow(/CHECK constraint failed.*json_valid/);
@@ -198,7 +198,7 @@ test("snapshot content validation - prevents double-stringified JSON storage", a
 	// First, verify that plain text JSON is rejected by STRICT table
 	await expect(
 		(lix.db as unknown as Kysely<LixInternalDatabaseSchema>)
-			.insertInto("internal_snapshot")
+			.insertInto("lix_internal_snapshot")
 			.values({
 				id: "double-stringified",
 				content: sql`${doubleStringified}`,
@@ -212,29 +212,29 @@ test("snapshot content validation - prevents double-stringified JSON storage", a
 	// because a JSON string is valid JSON! But with our new json_type check,
 	// this should now be rejected since it's storing a string, not an object
 	expect(() => {
-		lix.sqlite.exec({
-			sql: `INSERT INTO internal_snapshot (id, content) VALUES (?, jsonb(?))`,
+		lix.engine!.sqlite.exec({
+			sql: `INSERT INTO lix_internal_snapshot (id, content) VALUES (?, jsonb(?))`,
 			bind: ["double-stringified-jsonb", doubleStringified],
 		});
 	}).toThrow(/CHECK constraint failed/);
 
 	// Also verify that storing arrays is rejected (we only want objects)
 	expect(() => {
-		lix.sqlite.exec({
-			sql: `INSERT INTO internal_snapshot (id, content) VALUES (?, jsonb(?))`,
+		lix.engine!.sqlite.exec({
+			sql: `INSERT INTO lix_internal_snapshot (id, content) VALUES (?, jsonb(?))`,
 			bind: ["array-content", JSON.stringify([1, 2, 3])],
 		});
 	}).toThrow(/CHECK constraint failed/);
 
 	// Verify the correct way: jsonb() on properly stringified JSON
-	lix.sqlite.exec({
-		sql: `INSERT INTO internal_snapshot (id, content) VALUES (?, jsonb(?))`,
+	lix.engine!.sqlite.exec({
+		sql: `INSERT INTO lix_internal_snapshot (id, content) VALUES (?, jsonb(?))`,
 		bind: ["correct-jsonb", onceStringified],
 	});
 
 	// Verify it retrieves correctly
-	const correctResult: any = lix.sqlite.exec({
-		sql: `SELECT json(content) as json_content FROM internal_snapshot WHERE id = ?`,
+	const correctResult: any = lix.engine!.sqlite.exec({
+		sql: `SELECT json(content) as json_content FROM lix_internal_snapshot WHERE id = ?`,
 		bind: ["correct-jsonb"],
 		returnValue: "resultRows",
 	});
@@ -248,7 +248,7 @@ test("snapshot ids must be unique", async () => {
 
 	// Insert first snapshot
 	await (lix.db as unknown as Kysely<LixInternalDatabaseSchema>)
-		.insertInto("internal_snapshot")
+		.insertInto("lix_internal_snapshot")
 		.values({
 			id: "duplicate",
 			content: sql`jsonb(${JSON.stringify({ first: true })})`,
@@ -258,7 +258,7 @@ test("snapshot ids must be unique", async () => {
 	// Try to insert another snapshot with the same id
 	await expect(
 		(lix.db as unknown as Kysely<LixInternalDatabaseSchema>)
-			.insertInto("internal_snapshot")
+			.insertInto("lix_internal_snapshot")
 			.values({
 				id: "duplicate",
 				content: sql`jsonb(${JSON.stringify({ second: true })})`,

package/src/snapshot/schema.ts

@@ -1,11 +1,11 @@
-import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
+import type { SqliteWasmDatabase } from "../database/sqlite/index.js";
 import type { Generated } from "kysely";
 
 export function applySnapshotDatabaseSchema(
 	sqlite: SqliteWasmDatabase
 ): SqliteWasmDatabase {
 	return sqlite.exec(`
-  CREATE TABLE IF NOT EXISTS internal_snapshot (
+  CREATE TABLE IF NOT EXISTS lix_internal_snapshot (
     id TEXT PRIMARY KEY DEFAULT (lix_uuid_v7()),
     content BLOB -- jsonb,
 
@@ -18,8 +18,12 @@ export function applySnapshotDatabaseSchema(
     CHECK (content IS NULL OR json_type(content) = 'object')
   ) STRICT;
 
-  INSERT OR IGNORE INTO internal_snapshot (id, content)
+  INSERT OR IGNORE INTO lix_internal_snapshot (id, content)
   VALUES ('no-content', NULL);
+
+  -- Index on id (explicit, though PRIMARY KEY already provides one)
+  CREATE INDEX IF NOT EXISTS idx_lix_internal_snapshot_id
+    ON lix_internal_snapshot(id);
 `);
 }
 

package/src/state/README.md

@@ -46,14 +46,14 @@ The virtual table:
 
 - **Purpose**: Accumulate multiple mutations
 - **Scope**: Multiple entities, single version
-- **Storage**: Temporary (`internal_change_in_transaction`)
+- **Storage**: Temporary (`lix_internal_transaction_state`)
 - **Rollback**: Automatic on error or explicit rollback
 
 #### 3. COMMIT Stage
 
 - **Purpose**: Persist changes permanently
 - **Scope**: All pending changes across versions
-- **Storage**: Permanent (`internal_change`, `internal_snapshot`)
+- **Storage**: Permanent (`lix_internal_change`, `lix_internal_snapshot`)
 - **Rollback**: Not possible after commit
 
 ## Virtual Table Architecture
@@ -80,10 +80,10 @@ The virtual table acts as a facade over the actual storage mechanism:
 ┌─────────────────────────────────────────────────┐
 │         Regular SQLite Tables                   │
 │                                                 │
-│  • internal_change_in_transaction               │
-│  • internal_state_cache                         │
-│  • internal_change                              │
-│  • internal_snapshot                            │
+│  • lix_internal_transaction_state                   │
+│  • lix_internal_state_cache                         │
+│  • lix_internal_change                              │
+│  • lix_internal_snapshot                            │
 └─────────────────────────────────────────────────┘
 ```
 

package/src/state/cache/builtin-schemas.ts

@@ -0,0 +1,25 @@
+import type { LixSchemaDefinition } from "../../schema-definition/definition.js";
+import { LixSchemaViewMap } from "../../database/schema-view-map.js";
+import {
+	LixVersionDescriptorSchema,
+	LixVersionTipSchema,
+} from "../../version/schema-definition.js";
+
+const registry = new Map<string, LixSchemaDefinition>();
+
+function register(definition: LixSchemaDefinition): void {
+	const key = definition["x-lix-key"];
+	if (typeof key === "string" && key.length > 0) {
+		registry.set(key, definition);
+	}
+}
+
+for (const definition of Object.values(LixSchemaViewMap)) {
+	register(definition);
+}
+
+register(LixVersionDescriptorSchema);
+register(LixVersionTipSchema);
+
+export const BUILTIN_CACHE_SCHEMAS: Record<string, LixSchemaDefinition> =
+	Object.fromEntries(registry);