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

package/src/hooks/create-hooks.test.ts

@@ -1,5 +1,23 @@
 import { expect, test, vi } from "vitest";
 import { createHooks } from "./create-hooks.js";
+import { openLix } from "../lix/open-lix.js";
+import { createVersion } from "../version/create-version.js";
+import type { StateCommitChange } from "./create-hooks.js";
+import type { LixSchemaDefinition } from "../schema-definition/definition.js";
+import { withWriterKey } from "../state/writer.js";
+const testHooksSchema = {
+	"x-lix-key": "test_entity",
+	"x-lix-version": "1.0",
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		id: { type: "string" },
+		name: { type: "string" },
+	},
+	required: ["id"],
+} as const satisfies LixSchemaDefinition;
+
+const emptyChangesPayload = { changes: [] as StateCommitChange[] };
 
 test("should create hooks with onStateCommit method", () => {
 	const hooks = createHooks();
@@ -15,7 +33,7 @@ test("should call handler when state_commit event is emitted", () => {
 	const handler = vi.fn();
 
 	hooks.onStateCommit(handler);
-	hooks._emit("state_commit");
+	hooks._emit("state_commit", emptyChangesPayload);
 
 	expect(handler).toHaveBeenCalledTimes(1);
 });
@@ -27,7 +45,7 @@ test("should call multiple handlers when state_commit event is emitted", () => {
 
 	hooks.onStateCommit(handler1);
 	hooks.onStateCommit(handler2);
-	hooks._emit("state_commit");
+	hooks._emit("state_commit", emptyChangesPayload);
 
 	expect(handler1).toHaveBeenCalledTimes(1);
 	expect(handler2).toHaveBeenCalledTimes(1);
@@ -40,12 +58,12 @@ test("should return unsubscribe function that removes the handler", () => {
 	const unsubscribe = hooks.onStateCommit(handler);
 
 	// Emit event - handler should be called
-	hooks._emit("state_commit");
+	hooks._emit("state_commit", emptyChangesPayload);
 	expect(handler).toHaveBeenCalledTimes(1);
 
 	// Unsubscribe and emit again - handler should not be called
 	unsubscribe();
-	hooks._emit("state_commit");
+	hooks._emit("state_commit", emptyChangesPayload);
 	expect(handler).toHaveBeenCalledTimes(1);
 });
 
@@ -60,14 +78,14 @@ test("should handle multiple subscriptions and unsubscriptions correctly", () =>
 	const unsubscribe3 = hooks.onStateCommit(handler3);
 
 	// All handlers should be called
-	hooks._emit("state_commit");
+	hooks._emit("state_commit", emptyChangesPayload);
 	expect(handler1).toHaveBeenCalledTimes(1);
 	expect(handler2).toHaveBeenCalledTimes(1);
 	expect(handler3).toHaveBeenCalledTimes(1);
 
 	// Remove handler2
 	unsubscribe2();
-	hooks._emit("state_commit");
+	hooks._emit("state_commit", emptyChangesPayload);
 	expect(handler1).toHaveBeenCalledTimes(2);
 	expect(handler2).toHaveBeenCalledTimes(1); // Still 1
 	expect(handler3).toHaveBeenCalledTimes(2);
@@ -75,28 +93,18 @@ test("should handle multiple subscriptions and unsubscriptions correctly", () =>
 	// Remove handler1 and handler3
 	unsubscribe1();
 	unsubscribe3();
-	hooks._emit("state_commit");
+	hooks._emit("state_commit", emptyChangesPayload);
 	expect(handler1).toHaveBeenCalledTimes(2); // Still 2
 	expect(handler2).toHaveBeenCalledTimes(1); // Still 1
 	expect(handler3).toHaveBeenCalledTimes(2); // Still 2
 });
 
-test("should not call handlers for different event types", () => {
-	const hooks = createHooks();
-	const handler = vi.fn();
-
-	hooks.onStateCommit(handler);
-	hooks._emit("other_event");
-
-	expect(handler).not.toHaveBeenCalled();
-});
-
 test("should handle async handlers without issues", async () => {
 	const hooks = createHooks();
 	const handler = vi.fn().mockResolvedValue(undefined);
 
 	hooks.onStateCommit(handler);
-	hooks._emit("state_commit");
+	hooks._emit("state_commit", emptyChangesPayload);
 
 	// Wait a bit to ensure async handler has time to run
 	await new Promise((resolve) => setTimeout(resolve, 0));
@@ -114,12 +122,119 @@ test("should create independent hook instances", () => {
 	hooks2.onStateCommit(handler2);
 
 	// Emit on hooks1 - only handler1 should be called
-	hooks1._emit("state_commit");
+	hooks1._emit("state_commit", emptyChangesPayload);
 	expect(handler1).toHaveBeenCalledTimes(1);
 	expect(handler2).not.toHaveBeenCalled();
 
 	// Emit on hooks2 - only handler2 should be called
-	hooks2._emit("state_commit");
+	hooks2._emit("state_commit", emptyChangesPayload);
 	expect(handler1).toHaveBeenCalledTimes(1);
 	expect(handler2).toHaveBeenCalledTimes(1);
 });
+
+test("onStateCommit emits state-shaped changes with version_id and commit_id", async () => {
+	const lix = await openLix({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true },
+				lixcol_version_id: "global",
+			},
+		],
+	});
+	await lix.db
+		.insertInto("stored_schema")
+		.values({ value: testHooksSchema })
+		.execute();
+
+	const v = await createVersion({ lix, name: "hook-test" });
+
+	const events: StateCommitChange[][] = [];
+	const unsubscribe = lix.hooks.onStateCommit(({ changes }) => {
+		events.push(changes);
+	});
+
+	await lix.db
+		.insertInto("state_by_version")
+		.values({
+			entity_id: "hook-entity",
+			schema_key: "test_entity",
+			schema_version: "1.0",
+			file_id: "hook-file",
+			version_id: v.id,
+			plugin_key: "test_plugin",
+			snapshot_content: { id: "hook-entity", name: "Hello" },
+		})
+		.execute();
+
+	await new Promise((r) => setTimeout(r, 0));
+
+	expect(events.length).toBeGreaterThan(0);
+	const flat = events.flat();
+	const domain = flat.find(
+		(c) => c.schema_key === "test_entity" && c.entity_id === "hook-entity"
+	);
+	expect(domain).toBeDefined();
+	expect(domain!.version_id).toBe(v.id);
+	expect(typeof domain!.commit_id).toBe("string");
+	expect((domain!.commit_id ?? "").length).toBeGreaterThan(0);
+	expect(domain!.untracked ?? 0).toBe(0);
+
+	unsubscribe();
+	await lix.close();
+});
+
+test("onStateCommit exposes writer_key for state changes", async () => {
+	const lix = await openLix({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true },
+				lixcol_version_id: "global",
+			},
+		],
+	});
+
+	const mockSchema: LixSchemaDefinition = {
+		"x-lix-key": "test_schema_writer_hook",
+		"x-lix-version": "1.0",
+		type: "object",
+		additionalProperties: false,
+		properties: { value: { type: "string" } },
+	};
+	await lix.db
+		.insertInto("stored_schema")
+		.values({ value: mockSchema })
+		.execute();
+
+	const WRITER = "testapp:hooks#writer";
+	const events: any[][] = [];
+	const unsubscribe = lix.hooks.onStateCommit(({ changes }) => {
+		events.push(changes as any);
+	});
+
+	await withWriterKey(lix.db, WRITER, async (trx) => {
+		await trx
+			.insertInto("state")
+			.values({
+				entity_id: "w1",
+				file_id: "f1",
+				schema_key: mockSchema["x-lix-key"],
+				schema_version: mockSchema["x-lix-version"],
+				plugin_key: "test_plugin",
+				snapshot_content: { value: "A" } as any,
+			})
+			.execute();
+	});
+
+	const flat = events.flat();
+	const change = flat.find(
+		(c: any) =>
+			c?.entity_id === "w1" && c?.schema_key === mockSchema["x-lix-key"]
+	);
+	expect(change).toBeDefined();
+	expect(change.writer_key).toBe(WRITER);
+
+	unsubscribe();
+	await lix.close();
+});

package/src/hooks/create-hooks.ts

@@ -1,4 +1,49 @@
-import type { Change } from "../change/index.js";
+/**
+ * State-committed row emitted to `onStateCommit` subscribers.
+ *
+ * These are state-shaped (not low-level change rows) and include operational columns such as
+ * `version_id`, `commit_id`, optional `untracked`, and `writer_key`.
+ *
+ * Untracked rows (like derived change-set elements or log-style inserts) surface with
+ * `untracked: 1` and a sentinel `commit_id: "untracked"` because they do not belong to a
+ * materialized commit yet. Observers should treat the pair `(untracked === 1, commit_id === "untracked")`
+ * as “ephemeral” data and avoid dereferencing the commit.
+ *
+ * The `writer_key` identifies the writer responsible for the materialized state row and enables
+ * echo suppression in UIs (filter out your own writes while reacting to external ones). When no
+ * explicit writer is provided (the default), the value is `null`.
+ *
+ * See the writer key guide for patterns and pitfalls.
+ */
+export type StateCommitChange = {
+	id: string;
+	entity_id: string;
+	schema_key: string;
+	schema_version: string;
+	file_id: string;
+	plugin_key: string;
+	created_at: string;
+	snapshot_content: Record<string, any> | null;
+	version_id: string;
+	commit_id: string;
+	/** 0 for tracked, 1 for untracked */
+	untracked?: number;
+	/** Arbitrary metadata attached to the originating change, if any. */
+	metadata?: Record<string, any> | null;
+	/**
+	 * Writer identity that produced this state row, if known.
+	 *
+	 * Used for echo suppression (ignore my own writes; react to external ones).
+	 * See docs: https://lix.dev/guide/writer-key
+	 */
+	writer_key: string | null;
+};
+
+/**
+ * Change data passed to state commit hooks.
+ * Extends the standard Change type with tracking information.
+ */
+// (No longer extends Change; state commits carry state-level operational columns.)
 
 /**
  * Lix hooks system for listening to database lifecycle events.
@@ -6,6 +51,12 @@ import type { Change } from "../change/index.js";
  * Hooks allow you to register callbacks that fire at specific points
  * in Lix's execution, such as when state changes are committed.
  */
+type HookEvents = {
+	state_commit: { changes: StateCommitChange[] };
+};
+
+type HookEventType = keyof HookEvents;
+
 export type LixHooks = {
 	/**
 	 * Listen to state commit events.
@@ -13,6 +64,19 @@ export type LixHooks = {
 	 * Fires after any state mutation is committed to the database.
 	 * Useful for auto-saving, cache invalidation, sync operations, etc.
 	 *
+	 * Payload carries `changes: StateCommitChange[]`, including `writer_key` for each state row
+	 * (when applicable). For UIs, filter by writer to suppress echoes, e.g.:
+	 *
+	 * ```ts
+	 * const writer_key = 'app_component_<session_id>'
+	 * lix.hooks.onStateCommit(({ changes }) => {
+	 *   const external = changes.some(c =>
+	 *     c.file_id === activeFileId && (c.writer_key == null || c.writer_key !== writer_key)
+	 *   )
+	 *   if (external) refresh()
+	 * })
+	 * ```
+	 *
 	 * @param handler - Function to call when state is committed
 	 * @returns Unsubscribe function to remove the listener
 	 *
@@ -27,7 +91,9 @@ export type LixHooks = {
 	 * unsubscribe();
 	 * ```
 	 */
-	onStateCommit: (handler: (data: { changes: Change[] }) => void) => () => void;
+	onStateCommit: (
+		handler: (data: { changes: StateCommitChange[] }) => void
+	) => () => void;
 
 	/**
 	 * Internal method for emitting events.
@@ -36,7 +102,7 @@ export type LixHooks = {
 	 * This method is for internal use only and should not be called directly.
 	 * Use this to emit events from state mutation functions.
 	 */
-	_emit: (eventType: string, data?: any) => void;
+	_emit: <T extends HookEventType>(eventType: T, data: HookEvents[T]) => void;
 };
 
 /**
@@ -47,11 +113,32 @@ export type LixHooks = {
  *
  * @returns LixHooks instance with event subscription methods
  */
+function ensureCustomEventPolyfill(): void {
+	if (typeof globalThis.CustomEvent === "function") {
+		return;
+	}
+
+	class NodeCustomEvent<T = unknown> extends Event {
+		readonly detail: T;
+		constructor(type: string, params?: CustomEventInit<T>) {
+			super(type, params);
+			this.detail = (params?.detail ?? null) as T;
+		}
+	}
+
+	(globalThis as unknown as { CustomEvent: typeof CustomEvent }).CustomEvent =
+		NodeCustomEvent as unknown as typeof CustomEvent;
+}
+
 export function createHooks(): LixHooks {
+	ensureCustomEventPolyfill();
+
 	const eventTarget = new EventTarget();
 
 	return {
-		onStateCommit(handler: (data: { changes: Change[] }) => void): () => void {
+		onStateCommit(
+			handler: (data: { changes: StateCommitChange[] }) => void
+		): () => void {
 			const wrappedHandler = (event: Event) => {
 				const customEvent = event as CustomEvent;
 				handler(customEvent.detail);
@@ -61,7 +148,7 @@ export function createHooks(): LixHooks {
 				eventTarget.removeEventListener("state_commit", wrappedHandler);
 		},
 
-		_emit(eventType: string, data?: any): void {
+		_emit<T extends HookEventType>(eventType: T, data: HookEvents[T]): void {
 			eventTarget.dispatchEvent(new CustomEvent(eventType, { detail: data }));
 		},
 	};

package/src/index.ts

@@ -1,15 +1,16 @@
 export * from "./account/index.js";
 export * from "./change/index.js";
 export * from "./change-author/index.js";
+export * from "./environment/index.js";
 export * from "./change-set/index.js";
 export * from "./commit/index.js";
 export * from "./database/index.js";
-export * from "./deterministic/index.js";
+export * from "./engine/functions/index.js";
 export * from "./entity/index.js";
-export * from "./entity-views/index.js";
-export * from "./file/index.js";
+export * from "./engine/entity-views/index.js";
+export * from "./filesystem/index.js";
 export * from "./hooks/create-hooks.js";
-export * from "./key-value/schema.js";
+export * from "./key-value/index.js";
 export * from "./label/index.js";
 export * from "./lix/index.js";
 export * from "./log/index.js";
@@ -17,7 +18,10 @@ export * from "./observe/index.js";
 export * from "./plugin/index.js";
 export * from "./query-filter/index.js";
 export * from "./schema-definition/index.js";
+export * from "./state/index.js";
 export * from "./stored-schema/index.js";
 export * from "./server-protocol-handler/index.js";
-export * from "./thread/index.js";
+export * from "./conversation/index.js";
+export * from "./change-proposal/index.js";
 export * from "./version/index.js";
+export * from "./diff/index.js";

package/src/key-value/index.ts

@@ -1 +1 @@
-export { LixKeyValueSchema, type LixKeyValue as KeyValue } from "./schema.js";
+export { LixKeyValueSchema, type LixKeyValue } from "./schema-definition.js";

package/src/key-value/schema-definition.ts

@@ -0,0 +1,78 @@
+import type {
+	FromLixSchemaDefinition,
+	LixSchemaDefinition,
+} from "../schema-definition/definition.js";
+import { JSONTypeSchema } from "../schema-definition/json-type.js";
+
+/**
+ * Represents a key-value pair in Lix.
+ *
+ * The value can be any JSON-serializable type (string, number, boolean, object, array, null).
+ *
+ * **Important SQLite Limitation with Boolean Values:**
+ * SQLite does not have a native boolean type. When storing JSON values:
+ * - `true` is stored as `1`
+ * - `false` is stored as `0`
+ *
+ * This is a fundamental limitation of SQLite's JSON implementation. There is no way
+ * to distinguish between a boolean `true` and the number `1` after retrieval.
+ *
+ * When querying boolean values, use loose equality (`==`) or handle the numeric representation.
+ *
+ * @example
+ * ```typescript
+ * await lix.db.insertInto("key_value").values({
+ *   key: "lix_sync_enabled",
+ *   value: true // Will be stored as 1 in SQLite
+ * }).execute();
+ *
+ * await lix.db.insertInto("key_value").values({
+ *   key: "lix_server_url",
+ *   value: "https://api.example.com"
+ * }).execute();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const result = await lix.db
+ *   .selectFrom("key_value")
+ *   .where("key", "=", "lix_sync_enabled")
+ *   .select("value")
+ *   .executeTakeFirst();
+ *
+ * // result.value will be 1 (not true)
+ * const isEnabled = result?.value == true; // Use loose equality
+ * const isEnabled = result?.value === 1; // Or compare numeric value
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Common Lix system keys
+ * // "lix_id" - Unique identifier for the Lix instance
+ * // "lix_name" - Human-readable name for the Lix instance
+ * // "lix_server_url" - URL of the sync server
+ * // "lix_deterministic_mode" - Boolean flag for deterministic ID generation
+ * // "lix_telemetry" - Telemetry setting ("on" or "off")
+ * ```
+ */
+export type LixKeyValue = FromLixSchemaDefinition<typeof LixKeyValueSchema> & {
+	value: any;
+};
+
+export const LixKeyValueSchema = {
+	"x-lix-key": "lix_key_value",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["/key"],
+	"x-lix-override-lixcols": {
+		lixcol_file_id: '"lix"',
+		lixcol_plugin_key: '"lix_sdk"',
+	},
+	type: "object",
+	properties: {
+		key: { type: "string" },
+		value: JSONTypeSchema as any,
+	},
+	required: ["key", "value"],
+	additionalProperties: false,
+} as const;
+LixKeyValueSchema satisfies LixSchemaDefinition;

package/src/key-value/schema.test.ts

@@ -62,6 +62,18 @@ test("inserts, updates, deletes are handled", async () => {
 	]);
 });
 
+// NOTE ON SQLITE JSON1 AND BOOLEANS
+// ---------------------------------
+// SQLite JSON1 does not have a native boolean type at the SQL level.
+// When projecting a JSON boolean with json_extract(...), SQLite returns
+// SQL-native scalars: true -> 1 and false -> 0. Objects/arrays are
+// returned as JSON text unless wrapped, and strings are TEXT.
+//
+// Historically this test compared directly against JS booleans because
+// values were stored as strings (e.g. "true") and parsed elsewhere.
+// Now that we store proper JSON and project with json_extract, the view
+// returns 1/0 for booleans. This test therefore expects 1 for true and
+// 0 for false to reflect SQLite’s behavior.
 test("arbitrary json is allowed", async () => {
 	const lix = await openLix({});
 
@@ -86,7 +98,90 @@ test("arbitrary json is allowed", async () => {
 		)
 		.execute();
 
-	expect(viewAfterInsert).toEqual(kvs);
+	const expected = kvs.map((kv) => ({
+		key: kv.key,
+		value: typeof kv.value === "boolean" ? (kv.value ? 1 : 0) : kv.value,
+	}));
+
+	expect(viewAfterInsert).toEqual(expected);
+});
+
+test("key_value insert stores proper JSON in state_by_version (no double encoding)", async () => {
+	const lix = await openLix({});
+
+	const kvs = [
+		{ key: "key0", value: { foo: "bar" } },
+		{ key: "key1", value: ["foo", "bar"] },
+		{ key: "key2", value: "foo" },
+		{ key: "key3", value: 42 },
+		{ key: "key4", value: true },
+		{ key: "key5", value: null },
+	];
+
+	await lix.db.insertInto("key_value").values(kvs).execute();
+
+	const rows = await lix.db
+		.selectFrom("state_by_version")
+		.where("schema_key", "=", "lix_key_value")
+		.where(
+			"entity_id",
+			"in",
+			kvs.map((kv) => kv.key)
+		)
+		.select(["entity_id", sql`json(snapshot_content)`.as("snapshot_content")])
+		.execute();
+
+	// map by key
+	const byKey = new Map(rows.map((r) => [r.entity_id, r as any]));
+
+	expect(byKey.get("key0")?.snapshot_content.value).toEqual({ foo: "bar" });
+	expect(byKey.get("key1")?.snapshot_content.value).toEqual(["foo", "bar"]);
+	expect(byKey.get("key2")?.snapshot_content.value).toBe("foo");
+	expect(byKey.get("key3")?.snapshot_content.value).toBe(42);
+	// With json(snapshot_content), driver decodes JSON booleans to true/false
+	// SQLite JSON1 surfaces booleans as 1/0
+	expect(byKey.get("key4")?.snapshot_content.value).toBe(true);
+	expect(byKey.get("key5")?.snapshot_content.value).toBeNull();
+});
+
+test("boolean representation matches between key_value view and state view", async () => {
+	const lix = await openLix({});
+
+	// Insert booleans via entity view
+	await lix.db
+		.insertInto("key_value")
+		.values([
+			{ key: "bool_true", value: true },
+			{ key: "bool_false", value: false },
+		])
+		.execute();
+
+	// Read from key_value view
+	const viewRows = await lix.db
+		.selectFrom("key_value")
+		.where("key", "in", ["bool_true", "bool_false"])
+		.select(["key", "value"])
+		.orderBy("key")
+		.execute();
+
+	// Read from state view (active version) and extract JSON value
+	const stateRows = await lix.db
+		.selectFrom("state")
+		.where("schema_key", "=", "lix_key_value")
+		.where("entity_id", "in", ["bool_true", "bool_false"])
+		.select([
+			"entity_id",
+			// json_extract returns SQLite-native scalars (1/0), matching the key_value view's behavior
+			sql`json_extract(snapshot_content, '$.value')`.as("value"),
+		])
+		.orderBy("entity_id")
+		.execute();
+
+	const viewMap = new Map(viewRows.map((r) => [r.key, r.value]));
+	const stateMap = new Map(stateRows.map((r: any) => [r.entity_id, r.value]));
+
+	expect(viewMap.get("bool_true")).toBe(stateMap.get("bool_true"));
+	expect(viewMap.get("bool_false")).toBe(stateMap.get("bool_false"));
 });
 
 test("view should show changes across versions", async () => {
@@ -97,7 +192,7 @@ test("view should show changes across versions", async () => {
 
 	// inserting a key-value pair in version A
 	await lix.db
-		.insertInto("key_value_all")
+		.insertInto("key_value_by_version")
 		.values({
 			key: "foo",
 			value: "bar",
@@ -106,7 +201,7 @@ test("view should show changes across versions", async () => {
 		.execute();
 
 	const kvAfterInsert = await lix.db
-		.selectFrom("key_value_all")
+		.selectFrom("key_value_by_version")
 		.where("key", "=", "foo")
 		.selectAll()
 		.execute();
@@ -119,22 +214,16 @@ test("view should show changes across versions", async () => {
 		},
 	]);
 
-	const versionAAfterKvInsert = await lix.db
-		.selectFrom("version")
-		.where("id", "=", versionA.id)
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
 	// creating a new version from the active version
 	const versionB = await createVersion({
 		lix,
 		id: "versionB",
 		name: "versionB",
-		commit_id: versionAAfterKvInsert.commit_id,
+		from: versionA,
 	});
 
 	const kvAfterInsertInVersionB = await lix.db
-		.selectFrom("key_value_all")
+		.selectFrom("key_value_by_version")
 		.where("key", "=", "foo")
 		.selectAll()
 		.execute();
@@ -153,14 +242,14 @@ test("view should show changes across versions", async () => {
 	]);
 
 	await lix.db
-		.updateTable("key_value_all")
+		.updateTable("key_value_by_version")
 		.where("key", "=", "foo")
 		.where("lixcol_version_id", "=", versionB.id)
 		.set({ value: "bar_updated" })
 		.execute();
 
 	const kvAfterUpdate = await lix.db
-		.selectFrom("key_value_all")
+		.selectFrom("key_value_by_version")
 		.where("key", "=", "foo")
 		.selectAll()
 		.execute();
@@ -278,3 +367,39 @@ test("can update individual JSON properties using SQLite JSON functions", async
 		count: 100,
 	});
 });
+
+test("key_value preserves '1' as string when inserted as string", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("key_value")
+		.values({ key: "type_test_string", value: "1" })
+		.execute();
+
+	const row = await lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "type_test_string")
+		.executeTakeFirstOrThrow();
+
+	expect(typeof row.value).toBe("string");
+	expect(row.value).toBe("1");
+});
+
+test("key_value preserves 1 as number when inserted as number", async () => {
+	const lix = await openLix({});
+
+	await lix.db
+		.insertInto("key_value")
+		.values({ key: "type_test_number", value: 1 })
+		.execute();
+
+	const row = await lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "type_test_number")
+		.executeTakeFirstOrThrow();
+
+	expect(typeof row.value).toBe("number");
+	expect(row.value).toBe(1);
+});