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

package/src/state-history/schema.ts

@@ -1,5 +1,5 @@
 import type { Selectable } from "kysely";
-import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
+import type { Lix } from "../lix/open-lix.js";
 
 /**
  * State history table interface for querying historical entity states.
@@ -34,29 +34,40 @@ export interface StateHistoryTable {
 	change_id: string;
 
 	/**
-	 * Change set ID that serves as the root/starting point for depth calculation.
-	 * This is the change_set_id that was queried, NOT the change set where this
-	 * specific entity state was originally created.
+	 * The actual commit ID where this entity state was originally created.
 	 *
-	 * For example, if you query `WHERE change_set_id = 'checkpoint-123'`, then
-	 * all returned rows will have `change_set_id = 'checkpoint-123'`, even if
-	 * some entity states came from earlier change sets (at depth > 0).
+	 * This represents the true origin commit for each historical state, making it easy
+	 * to understand the provenance of each entity state without additional joins.
 	 *
-	 * To get the actual change set where this entity state was created,
-	 * join with the change table: `JOIN change ON state_history.change_id = change.id`
-	 * and then `JOIN change_set_element ON change.id = change_set_element.change_id`.
+	 * For example, when viewing history you might see:
+	 * - depth 0: commit_id = 'commit-123' (current state created in commit-123)
+	 * - depth 2: commit_id = 'commit-100' (historical state created in commit-100)
+	 *
+	 * This tells you exactly where each state was created in the commit graph.
 	 */
-	change_set_id: string;
+	commit_id: string;
 
 	/**
-	 * Depth of this entity state relative to the queried change_set_id.
-	 * - depth = 0: Current state at the queried change_set_id
-	 * - depth = 1: One change set back in history (parent)
-	 * - depth = 2: Two change sets back in history (grandparent)
+	 * The root commit ID used as the starting point for traversing history.
+	 *
+	 * When querying history from a specific commit, this field contains that
+	 * commit ID for all returned rows. Used with `depth` to understand how
+	 * far back in history each entity state is from this root.
+	 *
+	 * For example, if you query `WHERE root_commit_id = 'commit-123'`,
+	 * all returned rows will have `root_commit_id = 'commit-123'`.
+	 */
+	root_commit_id: string;
+
+	/**
+	 * Depth of this entity state relative to the root_commit_id.
+	 * - depth = 0: Current state at the queried commit_id
+	 * - depth = 1: One commit back in history (parent)
+	 * - depth = 2: Two commits back in history (grandparent)
 	 * - etc.
 	 *
-	 * Depth is calculated by traversing the change set ancestry graph backwards
-	 * from the queried change_set_id through parent change set edges.
+	 * Depth is calculated by traversing the commit ancestry graph backwards
+	 * from the queried commit_id through parent commit edges.
 	 * Used for blame functionality to show how entities evolved over time.
 	 */
 	depth: number;
@@ -91,13 +102,12 @@ export interface StateHistoryTable {
 export type StateHistoryView = Selectable<StateHistoryTable>;
 
 export function applyStateHistoryDatabaseSchema(
-	sqlite: SqliteWasmDatabase
-): SqliteWasmDatabase {
-	sqlite.exec(STATE_HISTORY_VIEW_SQL);
-	return sqlite;
+	lix: Pick<Lix, "sqlite" | "db">
+): void {
+	lix.sqlite.exec(STATE_HISTORY_VIEW_SQL);
 }
 
-// Optimized to use materialized change_set_edge_all and change_set_element_all from global version
+// Optimized to use materialized commit_edge_all and change_set_element_all from global version
 export const STATE_HISTORY_VIEW_SQL = `
 CREATE VIEW IF NOT EXISTS state_history AS
 WITH
@@ -112,49 +122,61 @@ WITH
 		FROM internal_change ic
 		LEFT JOIN internal_snapshot s ON ic.snapshot_id = s.id
 	),
-	-- For state_history, we work with any change_set_id, not just version heads
-	requested_change_sets AS (
-		SELECT DISTINCT cs.id as change_set_id
-		FROM change_set_all cs
+	-- For state_history, we work with any commit_id, not just version heads
+	requested_commits AS (
+		SELECT DISTINCT c.id as commit_id
+		FROM commit_all c
 		-- This will be filtered by the WHERE clause in queries
 	),
-	-- Find all change sets reachable from requested ones (including ancestors)
-	reachable_cs_from_requested(id, root_change_set_id, depth) AS (
-		SELECT change_set_id, change_set_id as root_change_set_id, 0 as depth 
-		FROM requested_change_sets
+	-- Find all commits reachable from requested ones (including ancestors)
+	reachable_commits_from_requested(id, root_commit_id, depth) AS (
+		SELECT commit_id, commit_id as root_commit_id, 0 as depth 
+		FROM requested_commits
 		UNION
-		SELECT cse.parent_id, r.root_change_set_id, r.depth + 1
-		FROM change_set_edge_all cse 
-		JOIN reachable_cs_from_requested r ON cse.child_id = r.id
-		WHERE cse.lixcol_version_id = 'global'
+		SELECT ce.parent_id, r.root_commit_id, r.depth + 1
+		FROM commit_edge_all ce 
+		JOIN reachable_commits_from_requested r ON ce.child_id = r.id
+		WHERE ce.lixcol_version_id = 'global'
+	),
+	-- Get change set IDs for each commit
+	commit_changesets AS (
+		SELECT 
+			c.id as commit_id,
+			c.change_set_id as change_set_id,
+			rc.root_commit_id,
+			rc.depth as commit_depth
+		FROM commit_all c
+		JOIN reachable_commits_from_requested rc ON c.id = rc.id
+		WHERE c.lixcol_version_id = 'global'
 	),
-	-- Find all change set elements in reachable change sets
-	cse_in_reachable_cs AS (
+	-- Find all change set elements in reachable commits
+	cse_in_reachable_commits AS (
 		SELECT cse.entity_id AS target_entity_id,
 			   cse.file_id AS target_file_id,
 			   cse.schema_key AS target_schema_key, 
 			   cse.change_id AS target_change_id,
 			   cse.change_set_id AS cse_origin_change_set_id,
-			   rcs.root_change_set_id,
-			   rcs.depth as changeset_depth,
-			   rcs.id as depth_change_set_id
+			   cc.commit_id AS origin_commit_id,
+			   cc.root_commit_id,
+			   cc.commit_depth,
+			   cc.commit_id as depth_commit_id
 		FROM change_set_element_all cse
-		JOIN reachable_cs_from_requested rcs ON cse.change_set_id = rcs.id
+		JOIN commit_changesets cc ON cse.change_set_id = cc.change_set_id
 		WHERE cse.lixcol_version_id = 'global'
 	),
-	-- For each entity at each depth, find the latest change within that depth's change set
+	-- For each entity at each depth, find the latest change within that depth's commit
 	latest_change_per_entity_per_depth AS (
 		SELECT 
 			r.target_entity_id,
 			r.target_file_id,
 			r.target_schema_key,
-			r.root_change_set_id,
-			r.changeset_depth,
-			r.depth_change_set_id,
+			r.root_commit_id,
+			r.commit_depth,
+			r.depth_commit_id,
 			MAX(target_change.created_at) as latest_created_at
-		FROM cse_in_reachable_cs r 
+		FROM cse_in_reachable_commits r 
 		INNER JOIN all_changes_with_snapshots target_change ON r.target_change_id = target_change.id
-		GROUP BY r.target_entity_id, r.target_file_id, r.target_schema_key, r.root_change_set_id, r.changeset_depth
+		GROUP BY r.target_entity_id, r.target_file_id, r.target_schema_key, r.root_commit_id, r.commit_depth
 	),
 	-- Get the actual changes for each entity at each depth
 	entity_states_at_depths AS (
@@ -166,16 +188,16 @@ WITH
 			target_change.snapshot_content,
 			target_change.schema_version,
 			r.target_change_id,
-			r.cse_origin_change_set_id,
-			r.root_change_set_id,
-			latest.changeset_depth
+			r.origin_commit_id,
+			r.root_commit_id,
+			latest.commit_depth
 		FROM latest_change_per_entity_per_depth latest
-		INNER JOIN cse_in_reachable_cs r ON (
+		INNER JOIN cse_in_reachable_commits r ON (
 			latest.target_entity_id = r.target_entity_id 
 			AND latest.target_file_id = r.target_file_id
 			AND latest.target_schema_key = r.target_schema_key
-			AND latest.root_change_set_id = r.root_change_set_id
-			AND latest.changeset_depth = r.changeset_depth
+			AND latest.root_commit_id = r.root_commit_id
+			AND latest.commit_depth = r.commit_depth
 		)
 		INNER JOIN all_changes_with_snapshots target_change ON (
 			r.target_change_id = target_change.id
@@ -190,9 +212,10 @@ SELECT
 	esad.snapshot_content,
 	esad.schema_version,
 	esad.target_change_id as change_id,
-	esad.root_change_set_id as change_set_id,
-	esad.changeset_depth as depth
+	esad.origin_commit_id as commit_id,
+	esad.root_commit_id as root_commit_id,
+	esad.commit_depth as depth
 FROM entity_states_at_depths esad
 WHERE esad.snapshot_content IS NOT NULL  -- Exclude deletions for now
-ORDER BY esad.entity_id, esad.changeset_depth;
+ORDER BY esad.entity_id, esad.commit_depth;
 `;

package/src/stored-schema/index.ts

@@ -1 +1,4 @@
-export { LixStoredSchemaSchema, type StoredSchema } from "./schema.js";
+export {
+	LixStoredSchemaSchema,
+	type LixStoredSchema as StoredSchema,
+} from "./schema.js";

package/src/stored-schema/schema.test.ts

@@ -2,12 +2,12 @@ import { test, expect } from "vitest";
 import { openLix } from "../lix/open-lix.js";
 import type { LixSchemaDefinition } from "../schema-definition/definition.js";
 import type { NewState } from "../entity-views/types.js";
-import type { StoredSchema } from "./schema.js";
+import type { LixStoredSchema } from "./schema.js";
 
 test("insert and delete a stored schema", async () => {
 	const lix = await openLix({});
 
-	const schema: NewState<StoredSchema> = {
+	const schema: NewState<LixStoredSchema> = {
 		value: {
 			type: "object",
 			"x-lix-key": "mock",
@@ -50,7 +50,7 @@ test("insert and delete a stored schema", async () => {
 test("throws if the stored schema version does not match the x-lix-version prop", async () => {
 	const lix = await openLix({});
 
-	const schema: NewState<StoredSchema> = {
+	const schema: NewState<LixStoredSchema> = {
 		version: "2.0",
 		key: "mock",
 		value: {
@@ -73,7 +73,7 @@ test("throws if the stored schema version does not match the x-lix-version prop"
 test("throws if the stored schema key does not match the x-lix-key prop", async () => {
 	const lix = await openLix({});
 
-	const schema: NewState<StoredSchema> = {
+	const schema: NewState<LixStoredSchema> = {
 		key: "mock",
 		version: "1.0",
 		value: {
@@ -96,7 +96,7 @@ test("throws if the stored schema key does not match the x-lix-key prop", async
 test("updating is not possible (schema is immutable, needs new version bumb)", async () => {
 	const lix = await openLix({});
 
-	const schema: NewState<StoredSchema> = {
+	const schema: NewState<LixStoredSchema> = {
 		value: {
 			type: "object",
 			"x-lix-key": "mock",
@@ -121,7 +121,7 @@ test("updating is not possible (schema is immutable, needs new version bumb)", a
 test("default fills in key and version from the schema value", async () => {
 	const lix = await openLix({});
 
-	const schema: NewState<StoredSchema> = {
+	const schema: NewState<LixStoredSchema> = {
 		value: {
 			"x-lix-key": "mock",
 			"x-lix-version": "1.0",
@@ -149,7 +149,7 @@ test("default fills in key and version from the schema value", async () => {
 test("validates inserted schemas", async () => {
 	const lix = await openLix({});
 
-	const schema: NewState<StoredSchema> = {
+	const schema: NewState<LixStoredSchema> = {
 		value: {
 			type: "object",
 			"x-lix-key": "mock",

package/src/stored-schema/schema.ts

@@ -59,7 +59,7 @@ export const LixStoredSchemaSchema = {
 
 LixStoredSchemaSchema satisfies LixSchemaDefinition;
 
-export type StoredSchema = FromLixSchemaDefinition<
+export type LixStoredSchema = FromLixSchemaDefinition<
 	typeof LixStoredSchemaSchema
 > & {
 	// override the value to any to allow any JSON type (instead of unknown which is annoying)

package/src/sync/push-to-server.test.ts

@@ -5,8 +5,8 @@ import { pushToServer } from "./push-to-server.js";
 import { newLixFile } from "../lix/new-lix.js";
 import { pullFromServer } from "./pull-from-server.js";
 import { createLspInMemoryEnvironment } from "../server-protocol-handler/environment/create-in-memory-environment.js";
-import type { KeyValue } from "../key-value/schema.js";
-import type { Account } from "../account/schema.js";
+import type { LixKeyValue } from "../key-value/schema.js";
+import type { LixAccount } from "../account/schema.js";
 
 test.skip("push rows of multiple tables to server successfully", async () => {
 	const lixBlob = await newLixFile();
@@ -76,14 +76,14 @@ test.skip("push rows of multiple tables to server successfully", async () => {
 		.execute();
 
 	expect(accountsChangesOnServer.map((c) => c.snapshot_content)).toEqual([
-		{ id: "account0", name: "some account" } satisfies Account,
+		{ id: "account0", name: "some account" } satisfies LixAccount,
 	]);
 	expect(keyValueChangesOnServer.map((c) => c.snapshot_content)).toEqual([
 		expect.objectContaining({
 			key: "mock-key",
 			value: "mock-value",
 		}),
-	] satisfies Account[]);
+	] satisfies LixAccount[]);
 });
 
 // commented out for lix v0.5
@@ -157,7 +157,7 @@ test.skip("push-pull-push with two clients", async () => {
 
 	expect(client2AccountAfterPull).toEqual(
 		expect.arrayContaining([
-			{ id: "account0", name: "account from client 1" } satisfies Account,
+			{ id: "account0", name: "account from client 1" } satisfies LixAccount,
 		])
 	);
 
@@ -166,7 +166,7 @@ test.skip("push-pull-push with two clients", async () => {
 			expect.objectContaining({
 				key: "mock-key",
 				value: "mock-value from client 1",
-			} satisfies KeyValue),
+			} satisfies LixKeyValue),
 		])
 	);
 

package/src/test-utilities/simulation-test/cache-miss-simulation.test.ts

@@ -0,0 +1,162 @@
+import { expect, test } from "vitest";
+import {
+	simulationTest,
+	normalSimulation,
+	cacheMissSimulation,
+} from "./simulation-test.js";
+import { timestamp } from "../../deterministic/timestamp.js";
+import { nextDeterministicSequenceNumber } from "../../deterministic/sequence.js";
+test("cache miss simulation test discovery", () => {});
+
+simulationTest(
+	"cache miss simulation clears cache before every select",
+	async ({ openSimulatedLix }) => {
+		const lix = await openSimulatedLix({
+			keyValues: [
+				{
+					key: "lix_deterministic_mode",
+					value: { enabled: true },
+					lixcol_version_id: "global",
+					lixcol_untracked: true,
+				},
+				{
+					key: "lix_log_levels",
+					value: ["debug"],
+					lixcol_version_id: "global",
+					lixcol_untracked: true,
+				},
+			],
+		});
+
+		// Insert test data
+		await lix.db
+			.insertInto("key_value")
+			.values([{ key: "test_1", value: "value_1" }])
+			.execute();
+
+		const timeBefore = timestamp({ lix });
+
+		await lix.db
+			.selectFrom("key_value")
+			.where("key", "=", "test_1")
+			.selectAll()
+			.execute();
+
+		const cacheMissAfter = await lix.db
+			.selectFrom("log")
+			.where("key", "=", "lix_state_cache_miss")
+			.where("lixcol_created_at", ">", timeBefore)
+			.selectAll()
+			.execute();
+
+		// greater than one because the entity view key value
+		// might fire off subqueries that also trigger cache misses
+		expect(cacheMissAfter.length).toBeGreaterThan(1);
+	},
+	{
+		simulations: [cacheMissSimulation],
+	}
+);
+simulationTest(
+	"cache miss simulation produces correct query results",
+	async ({ openSimulatedLix, expectDeterministic }) => {
+		const lix = await openSimulatedLix({
+			keyValues: [
+				{
+					key: "lix_deterministic_mode",
+					value: { enabled: true, bootstrap: true },
+					lixcol_version_id: "global",
+					lixcol_untracked: true,
+				},
+			],
+		});
+
+		// Insert data - this creates changes and change sets
+		await lix.db
+			.insertInto("key_value")
+			.values([
+				{ key: "config_a", value: "a" },
+				{ key: "config_b", value: "b" },
+				{ key: "config_c", value: "c" },
+			])
+			.execute();
+
+		// Query state_all
+		const stateAll = await lix.db
+			.selectFrom("state_all")
+			.where("schema_key", "=", "lix_key_value")
+			.where("entity_id", "!=", "lix_state_cache_stale")
+			.orderBy("entity_id")
+			.selectAll()
+			.execute();
+
+		const allChanges = await lix.db.selectFrom("change").selectAll().execute();
+
+		// expect that the state and all changes are identical
+		expectDeterministic(stateAll).toBeDefined();
+		expectDeterministic(allChanges).toBeDefined();
+	},
+	{
+		simulations: [normalSimulation, cacheMissSimulation],
+	}
+);
+
+simulationTest(
+	"cache miss simulation maintains deterministic sequence equal to normal simulation",
+	async ({ openSimulatedLix, expectDeterministic }) => {
+		const lix = await openSimulatedLix({
+			keyValues: [
+				{
+					key: "lix_deterministic_mode",
+					value: { enabled: true, bootstrap: true },
+					lixcol_version_id: "global",
+					lixcol_untracked: true,
+				},
+			],
+		});
+
+		// Get initial sequence numbers
+		const seq1 = nextDeterministicSequenceNumber({ lix });
+		const seq2 = nextDeterministicSequenceNumber({ lix });
+		const seq3 = nextDeterministicSequenceNumber({ lix });
+
+		// These should be deterministic across simulations
+		expectDeterministic(seq1).toBeDefined();
+		expectDeterministic(seq2).toBe(seq1 + 1);
+		expectDeterministic(seq3).toBe(seq2 + 1);
+
+		// Get timestamps (which use sequence numbers internally)
+		const ts1 = timestamp({ lix });
+		const ts2 = timestamp({ lix });
+
+		// Timestamps should also be deterministic
+		expectDeterministic(ts1).toBeDefined();
+		expectDeterministic(ts2).toBeDefined();
+
+		// Perform a query that would trigger cache operations
+		await lix.db
+			.insertInto("key_value")
+			.values({ key: "test_key", value: "test_value" })
+			.execute();
+
+		const result = await lix.db
+			.selectFrom("key_value")
+			.where("key", "=", "test_key")
+			.selectAll()
+			.execute();
+
+		// The query result should be deterministic
+		expectDeterministic(result).toHaveLength(1);
+		expectDeterministic(result[0]?.value).toBe("test_value");
+
+		// Get sequence number after operations
+		const seqAfter = nextDeterministicSequenceNumber({ lix });
+
+		// This sequence number should be deterministic across simulations
+		expectDeterministic(seqAfter).toBeDefined();
+		expectDeterministic(seqAfter).toBeGreaterThan(seq3);
+	},
+	{
+		simulations: [normalSimulation, cacheMissSimulation],
+	}
+);

package/src/test-utilities/simulation-test/cache-miss-simulation.ts

@@ -0,0 +1,99 @@
+import { vi } from "vitest";
+import * as cacheModule from "../../state/cache/mark-state-cache-as-stale.js";
+import type { SimulationTestDef } from "./simulation-test.js";
+
+const CACHE_TIMESTAMP = "2099-12-31T23:59:59.999Z";
+
+// Store original functions
+const originalMarkStale = cacheModule.markStateCacheAsStale;
+const originalMarkFresh = cacheModule.markStateCacheAsFresh;
+
+// Create wrapped versions that inject the fixed timestamp
+const wrappedMarkStale = (args: any) => {
+	return originalMarkStale({ ...args, timestamp: CACHE_TIMESTAMP });
+};
+
+const wrappedMarkFresh = (args: any) => {
+	return originalMarkFresh({ ...args, timestamp: CACHE_TIMESTAMP });
+};
+
+/**
+ * Cache miss simulation - Clears cache before every select operation to force re-materialization from changes.
+ * This tests that state can be correctly reconstructed from the change log
+ * without relying on cached state.
+ */
+export const cacheMissSimulation: SimulationTestDef = {
+	name: "cache miss",
+	setup: async (lix) => {
+		// Mock the cache marking functions to use our wrapped versions
+		vi.spyOn(cacheModule, "markStateCacheAsStale").mockImplementation(
+			wrappedMarkStale
+		);
+		vi.spyOn(cacheModule, "markStateCacheAsFresh").mockImplementation(
+			wrappedMarkFresh
+		);
+
+		// Don't clear cache on bootup - it consumes sequence numbers
+		// The cache will be cleared before each query anyway
+
+		// Helper to wrap a query builder to clear cache before execute
+		const wrapQueryBuilder = (query: any): any => {
+			const originalExecute = query.execute;
+
+			// Override execute
+			query.execute = async function (...args: any[]) {
+				// Clear cache before executing select
+				lix.sqlite.exec({
+					sql: "DELETE FROM internal_state_cache",
+					returnValue: "resultRows",
+				});
+
+				cacheModule.markStateCacheAsStale({ lix, timestamp: CACHE_TIMESTAMP });
+
+				// Call the original execute
+				return originalExecute.apply(this, args);
+			};
+
+			// Wrap methods that return query builders
+			const methodsToWrap = [
+				"where",
+				"orderBy",
+				"limit",
+				"offset",
+				"innerJoin",
+				"leftJoin",
+				"rightJoin",
+				"fullJoin",
+				"select",
+				"selectAll",
+			];
+
+			for (const method of methodsToWrap) {
+				if (query[method]) {
+					const originalMethod = query[method];
+					query[method] = function (...args: any[]) {
+						const result = originalMethod.apply(this, args);
+						// If it returns a query builder, wrap it too
+						if (result && typeof result === "object" && "execute" in result) {
+							return wrapQueryBuilder(result);
+						}
+						return result;
+					};
+				}
+			}
+
+			return query;
+		};
+
+		// Wrap the db.selectFrom method
+		const originalSelectFrom = lix.db.selectFrom.bind(lix.db);
+
+		lix.db.selectFrom = (table: any) => {
+			const query = originalSelectFrom(table);
+			return wrapQueryBuilder(query);
+		};
+
+		// Return the modified lix object
+		return lix;
+	},
+};

package/src/test-utilities/simulation-test/out-of-order-sequence-simulation.test.ts

@@ -0,0 +1,88 @@
+import { expect, test } from "vitest";
+import { simulationTest } from "./simulation-test.js";
+import { nextDeterministicSequenceNumber } from "../../deterministic/sequence.js";
+import { outOfOrderSequenceSimulation } from "./out-of-order-sequence-simulation.js";
+
+test("out-of-order sequence simulation test discovery", () => {});
+
+simulationTest(
+	"out-of-order sequence simulation returns non-monotonic sequence numbers",
+	async ({ openSimulatedLix }) => {
+		const lix = await openSimulatedLix({
+			keyValues: [
+				{
+					key: "lix_deterministic_mode",
+					value: { enabled: true },
+					lixcol_version_id: "global",
+					lixcol_untracked: true,
+				},
+			],
+		});
+
+		// Get several sequence numbers
+		const sequences: number[] = [];
+		for (let i = 0; i < 10; i++) {
+			sequences.push(nextDeterministicSequenceNumber({ lix }));
+		}
+
+		// In out-of-order simulation, sequences should not be monotonic
+		// We'll check if any sequence is smaller than a previous one
+		let foundOutOfOrder = false;
+		for (let i = 1; i < sequences.length; i++) {
+			if (sequences[i]! < sequences[i - 1]!) {
+				foundOutOfOrder = true;
+				break;
+			}
+		}
+
+		expect(foundOutOfOrder).toBe(true);
+		expect(sequences).toHaveLength(10);
+	},
+	{
+		simulations: [outOfOrderSequenceSimulation],
+	}
+);
+
+simulationTest(
+	"out-of-order sequence simulation produces correct query results despite shuffled sequences",
+	async ({ openSimulatedLix, expectDeterministic }) => {
+		const lix = await openSimulatedLix({
+			keyValues: [
+				{
+					key: "lix_deterministic_mode",
+					value: { enabled: true, bootstrap: true },
+					lixcol_version_id: "global",
+					lixcol_untracked: true,
+				},
+			],
+		});
+
+		// Insert data - this creates changes and change sets
+		await lix.db
+			.insertInto("key_value")
+			.values([
+				{ key: "config_a", value: "a" },
+				{ key: "config_b", value: "b" },
+				{ key: "config_c", value: "c" },
+			])
+			.execute();
+
+		// Query state_all - results should be consistent within the out-of-order group
+		const stateAll = await lix.db
+			.selectFrom("state_all")
+			.where("schema_key", "=", "lix_key_value")
+			.where("entity_id", "!=", "lix_state_cache_stale")
+			.orderBy("entity_id")
+			.selectAll()
+			.execute();
+
+		const allChanges = await lix.db.selectFrom("change").selectAll().execute();
+
+		// Results should be deterministic within the out-of-order group
+		expectDeterministic(stateAll).toBeDefined();
+		expectDeterministic(allChanges).toBeDefined();
+	},
+	{
+		simulations: [outOfOrderSequenceSimulation],
+	}
+);