bleam 0.0.11 → 0.0.13

package/dist/state-DkaRFkZJ.js

@@ -0,0 +1,843 @@
+import { t as crypto } from "./crypto-BB92-Upx.js";
+import { t as currentAppStorageKey } from "./app-storage-Isi5Bo0R.js";
+import { l as schema } from "./schema-B7ELMpuI.js";
+import { useAtom, useAtomValue, useSetAtom } from "jotai/react";
+import { atom, getDefaultStore } from "jotai/vanilla";
+import { atomFamily } from "jotai-family";
+
+//#region src/state/atom.ts
+const storedAtomsKey = Symbol.for("bleam.state.storedAtoms.v1");
+function storedAtoms() {
+	const scope = globalThis;
+	scope[storedAtomsKey] ??= /* @__PURE__ */ new Map();
+	return scope[storedAtomsKey];
+}
+function asJotaiAtom(value) {
+	return value;
+}
+function asJotaiWritableAtom(value) {
+	return value;
+}
+function asAtom(value) {
+	return value;
+}
+function asWritableAtom(value) {
+	return value;
+}
+function storageKey(key) {
+	const trimmed = key.trim();
+	if (!trimmed) throw new Error("Atom storage key must not be empty");
+	return `bleam.apps.${currentAppStorageKey()}.atoms.${trimmed}`;
+}
+function assertStoredValue(value, seen = /* @__PURE__ */ new Set()) {
+	if (value === null) return;
+	if (value === void 0) throw new Error("Persisted atom objects cannot contain undefined");
+	if (typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error("Persisted atom numbers must be finite");
+		return;
+	}
+	if (typeof value !== "object") throw new Error("Persisted atom values must be JSON-safe");
+	if (seen.has(value)) throw new Error("Persisted atom values cannot be cyclic");
+	seen.add(value);
+	if (Array.isArray(value)) for (const item of value) {
+		if (item === void 0) throw new Error("Persisted atom arrays cannot contain undefined");
+		assertStoredValue(item, seen);
+	}
+	else {
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) throw new Error("Persisted atom objects must be plain objects");
+		for (const item of Object.values(value)) assertStoredValue(item, seen);
+	}
+	seen.delete(value);
+}
+function encoded(value) {
+	if (value === void 0) return void 0;
+	assertStoredValue(value);
+	return JSON.stringify(value);
+}
+function persistedAtom(initialValue, key) {
+	const resolvedKey = storageKey(key);
+	const initial = encoded(initialValue);
+	const existing = storedAtoms().get(resolvedKey);
+	if (existing) {
+		if (process.env.NODE_ENV !== "production" && existing.initial !== initial) console.warn(`Atom storage key "${key}" was declared with different initial values`);
+		return existing.atom;
+	}
+	const defaults = NSUserDefaults.standardUserDefaults;
+	const stored = defaults.objectForKey(resolvedKey);
+	let value = initialValue;
+	if (typeof stored === "string") try {
+		value = JSON.parse(stored);
+		assertStoredValue(value);
+	} catch {
+		defaults.removeObjectForKey(resolvedKey);
+		value = initialValue;
+	}
+	const base = atom(value);
+	const result = asWritableAtom(atom((get) => get(base), (get, set, update) => {
+		const next = typeof update === "function" ? update(get(base)) : update;
+		const nextEncoded = encoded(next);
+		if (nextEncoded === void 0) defaults.removeObjectForKey(resolvedKey);
+		else defaults.setObjectForKey(nextEncoded, resolvedKey);
+		set(base, next);
+	}));
+	storedAtoms().set(resolvedKey, {
+		atom: result,
+		initial
+	});
+	return result;
+}
+function atom$1(initialOrRead, optionsOrWrite) {
+	if (typeof initialOrRead === "function") {
+		const read = initialOrRead;
+		const wrappedRead = (get) => read((value) => get(asJotaiAtom(value)));
+		if (typeof optionsOrWrite === "function") {
+			const write = optionsOrWrite;
+			return asWritableAtom(atom(wrappedRead, (get, set, ...args) => write((value) => get(asJotaiAtom(value)), (value, ...nextArgs) => set(asJotaiWritableAtom(value), ...nextArgs), ...args)));
+		}
+		return asAtom(atom(wrappedRead));
+	}
+	const options = optionsOrWrite;
+	return options?.storage ? persistedAtom(initialOrRead, options.storage) : asWritableAtom(atom(initialOrRead));
+}
+function useAtomValue$1(value) {
+	return useAtomValue(asJotaiAtom(value));
+}
+function useSetAtom$1(value) {
+	return useSetAtom(asJotaiWritableAtom(value));
+}
+function useAtom$1(value) {
+	return useAtom(asJotaiWritableAtom(value));
+}
+function internalAtom(value) {
+	return asAtom(value);
+}
+function internalWritableAtom(value) {
+	return asWritableAtom(value);
+}
+function internalJotaiAtom(value) {
+	return asJotaiAtom(value);
+}
+function internalJotaiWritableAtom(value) {
+	return asJotaiWritableAtom(value);
+}
+const internalStore = getDefaultStore();
+
+//#endregion
+//#region src/state/collection.ts
+var CollectionVersionConflictError = class extends Error {
+	name = "CollectionVersionConflictError";
+	constructor(collection, id, expectedVersion, actualVersion) {
+		super(`Version conflict for "${collection}:${id}": expected ${expectedVersion}, received ${actualVersion}`);
+		this.collection = collection;
+		this.id = id;
+		this.expectedVersion = expectedVersion;
+		this.actualVersion = actualVersion;
+	}
+};
+const schemaVersion = 2;
+const registryKey = Symbol.for("bleam.state.collections.v3");
+function registry() {
+	const scope = globalThis;
+	scope[registryKey] ??= /* @__PURE__ */ new Map();
+	return scope[registryKey];
+}
+const queryPlans = /* @__PURE__ */ new Map();
+const mutationTerminals = /* @__PURE__ */ new Map();
+let databasePromise;
+let initializedPromise;
+let jsonSqlSupportPromise;
+let mutationPipeline = Promise.resolve();
+let transactionCallbackStarting = false;
+function getDatabase() {
+	databasePromise ??= import("./native-sqlite-WzRNzCSh.js").then((module) => module.openNativeSQLiteDatabase(`${currentAppStorageKey()}.sqlite3`));
+	return databasePromise;
+}
+async function initializedDatabase() {
+	initializedPromise ??= (async () => {
+		const database = await getDatabase();
+		await database.execute("PRAGMA journal_mode = WAL");
+		if (numberValue(await database.get("PRAGMA user_version"), "user_version", 0) !== schemaVersion) await database.transaction(async () => {
+			await database.execute("DROP TABLE IF EXISTS links");
+			await database.execute("DROP TABLE IF EXISTS collections");
+			await createTables(database);
+			await database.execute(`PRAGMA user_version = ${schemaVersion}`);
+		});
+		else await createTables(database);
+		return database;
+	})();
+	return initializedPromise;
+}
+async function createTables(database) {
+	await database.execute(`CREATE TABLE IF NOT EXISTS collections (
+    collection TEXT NOT NULL,
+    id TEXT NOT NULL,
+    version INTEGER NOT NULL,
+    createdAt TEXT NOT NULL,
+    updatedAt TEXT NOT NULL,
+    data TEXT NOT NULL,
+    PRIMARY KEY (collection, id)
+  )`);
+	await database.execute(`CREATE TABLE IF NOT EXISTS links (
+    leftCollection TEXT NOT NULL,
+    leftId TEXT NOT NULL,
+    rightCollection TEXT NOT NULL,
+    rightId TEXT NOT NULL,
+    createdAt TEXT NOT NULL,
+    PRIMARY KEY (leftCollection, leftId, rightCollection, rightId)
+  )`);
+	await database.execute("CREATE INDEX IF NOT EXISTS collections_created_idx ON collections(collection, createdAt, id)");
+	await database.execute("CREATE INDEX IF NOT EXISTS links_left_idx ON links(leftCollection, leftId, rightCollection)");
+	await database.execute("CREATE INDEX IF NOT EXISTS links_right_idx ON links(rightCollection, rightId, leftCollection)");
+}
+function stableStringify(value) {
+	if (value === void 0) return "undefined";
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+}
+function collectionDefinition(collection) {
+	const definition = registry().get(collectionName(collection));
+	if (!definition || definition.atom !== collection) throw new Error("Invalid collection atom");
+	return definition;
+}
+function collectionName(collection) {
+	for (const definition of registry().values()) if (definition.atom === collection) return definition.name;
+	throw new Error("Invalid collection atom");
+}
+function stringValue(row, key) {
+	const value = row?.[key];
+	if (typeof value !== "string") throw new Error(`Expected SQLite ${key} string`);
+	return value;
+}
+function numberValue(row, key, fallback) {
+	const value = row?.[key];
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (fallback !== void 0 && value === void 0) return fallback;
+	throw new Error(`Expected SQLite ${key} number`);
+}
+function parseRow(definition, row) {
+	const parsed = JSON.parse(stringValue(row, "data"));
+	return {
+		id: stringValue(row, "id"),
+		collection: definition.name,
+		version: numberValue(row, "version"),
+		createdAt: stringValue(row, "createdAt"),
+		updatedAt: stringValue(row, "updatedAt"),
+		data: definition.validator.parse(parsed)
+	};
+}
+function assertId(id) {
+	if (!id.trim()) throw new TypeError("Record ID must not be empty");
+}
+function assertCollectionName(name) {
+	if (!name.trim()) throw new TypeError("Collection name must not be empty");
+}
+function assertFieldPaths(shape, prefix = "") {
+	for (const [key, field] of Object.entries(shape)) {
+		if (!key || key.includes(".")) throw new TypeError(`Collection field name "${prefix}${key}" must not be empty or contain a dot`);
+		if (field.kind === "object") assertFieldPaths(field.shape, `${prefix}${key}.`);
+	}
+}
+function endpointOrder(first, second) {
+	if (first.collection === second.collection && first.id === second.id) throw new Error(`Cannot link record "${first.collection}:${first.id}" to itself`);
+	return first.collection < second.collection || first.collection === second.collection && first.id < second.id ? [first, second] : [second, first];
+}
+async function linkedIds(database, collection, id, target) {
+	return (await database.select(`SELECT leftCollection, leftId, rightCollection, rightId FROM links
+     WHERE (leftCollection = ? AND leftId = ? AND rightCollection = ?)
+        OR (rightCollection = ? AND rightId = ? AND leftCollection = ?)`, [
+		collection,
+		id,
+		target,
+		collection,
+		id,
+		target
+	])).map((row) => stringValue(row, "leftCollection") === collection && stringValue(row, "leftId") === id ? stringValue(row, "rightId") : stringValue(row, "leftId")).sort((left, right) => left.localeCompare(right));
+}
+async function incidentLinks(database, collection, id) {
+	return database.select(`SELECT leftCollection, leftId, rightCollection, rightId FROM links
+     WHERE (leftCollection = ? AND leftId = ?)
+        OR (rightCollection = ? AND rightId = ?)`, [
+		collection,
+		id,
+		collection,
+		id
+	]);
+}
+async function fullRow(database, definition, persisted, linkNames = []) {
+	const links = {};
+	for (const target of [...new Set(linkNames)].sort()) links[target] = await linkedIds(database, definition.name, persisted.id, target);
+	return {
+		...persisted,
+		data: persisted.data,
+		links
+	};
+}
+async function getPersisted(database, definition, id) {
+	const row = await database.get(`SELECT id, version, createdAt, updatedAt, data FROM collections
+     WHERE collection = ? AND id = ?`, [definition.name, id]);
+	return row ? parseRow(definition, row) : null;
+}
+function dataValueAt(data, path) {
+	let current = data;
+	for (const segment of path.split(".")) {
+		if (!current || typeof current !== "object" || Array.isArray(current)) return;
+		current = current[segment];
+	}
+	return current;
+}
+function valueAt(row, path) {
+	if (path === "createdAt" || path === "updatedAt") return row[path];
+	return dataValueAt(row.data, path);
+}
+function sqliteOperand(value) {
+	return typeof value === "boolean" ? value ? 1 : 0 : value;
+}
+function topLevelClauseSql(clause, parameters) {
+	if (clause.path.includes(".")) return void 0;
+	parameters.push(`$.${clause.path}`, sqliteOperand(clause.operand));
+	switch (clause.comparison) {
+		case "equals": return "json_extract(data, ?) = ?";
+		case "greater-than": return "json_extract(data, ?) > ?";
+		case "less-than": return "json_extract(data, ?) < ?";
+		case "contains": return "instr(json_extract(data, ?), ?) > 0";
+	}
+}
+function supportsJsonSql(database) {
+	jsonSqlSupportPromise ??= database.get(`SELECT json_extract('{"value":1}', '$.value') AS value`).then((row) => row?.value === 1).catch(() => false);
+	return jsonSqlSupportPromise;
+}
+function matches(value, clause) {
+	const operand = clause.operand;
+	switch (clause.comparison) {
+		case "equals": return typeof value === typeof operand && Object.is(value, operand);
+		case "greater-than": return typeof value === "number" && typeof operand === "number" && value > operand;
+		case "less-than": return typeof value === "number" && typeof operand === "number" && value < operand;
+		case "contains": return typeof value === "string" && typeof operand === "string" && value.includes(operand);
+	}
+}
+function relatedPath(left, right) {
+	return left === right || left.startsWith(`${right}.`) || right.startsWith(`${left}.`);
+}
+function sameIds(left, right) {
+	return Array.isArray(left) && left.length === right.length && left.every((id, index) => id === right[index]);
+}
+function compareValues(left, right, order) {
+	const leftMissing = left === void 0;
+	const rightMissing = right === void 0;
+	if (leftMissing || rightMissing) {
+		if (leftMissing && rightMissing) return 0;
+		return leftMissing ? 1 : -1;
+	}
+	if (Object.is(left, right)) return 0;
+	if (typeof left !== "string" && typeof left !== "number" && typeof left !== "boolean" || typeof left !== typeof right) return 0;
+	const comparison = left < right ? -1 : 1;
+	return order === "desc" ? -comparison : comparison;
+}
+async function selectRows(database, definition, plan) {
+	const parameters = [definition.name];
+	const predicates = [];
+	if (await supportsJsonSql(database)) for (const clause of plan.where) {
+		const predicate = topLevelClauseSql(clause, parameters);
+		if (predicate) predicates.push(predicate);
+	}
+	let rows = (await database.select(`SELECT id, version, createdAt, updatedAt, data FROM collections
+     WHERE collection = ?${predicates.length > 0 ? ` AND ${predicates.join(" AND ")}` : ""}`, parameters)).map((row) => parseRow(definition, row));
+	if (plan.from) {
+		const ids = new Set(await linkedIds(database, plan.from.collection, plan.from.id, definition.name));
+		rows = rows.filter((row) => ids.has(row.id));
+	}
+	rows = rows.filter((row) => plan.where.every((clause) => matches(valueAt(row, clause.path), clause)));
+	rows.sort((left, right) => {
+		return (plan.sort ? compareValues(valueAt(left, plan.sort.path), valueAt(right, plan.sort.path), plan.sort.order) : left.createdAt.localeCompare(right.createdAt)) || left.id.localeCompare(right.id);
+	});
+	return plan.take === void 0 ? rows : rows.slice(0, plan.take);
+}
+async function executeQuery(database, definition, terminal) {
+	const plan = terminal.plan;
+	if (plan.terminal === "ids") return (await selectRows(database, definition, plan)).map((row) => row.id);
+	const persisted = await getPersisted(database, definition, plan.id);
+	if (plan.terminal === "row") return persisted ? await fullRow(database, definition, persisted, plan.links) : null;
+	return persisted ? dataValueAt(persisted.data, plan.path) : void 0;
+}
+function fieldAtPath(shape, path) {
+	const segments = path.split(".");
+	let currentShape = shape;
+	let field = currentShape[segments[0]];
+	for (let index = 1; index < segments.length; index += 1) {
+		if (field?.kind !== "object") throw new Error(`Unknown schema field path "${path}"`);
+		currentShape = field.shape;
+		field = currentShape[segments[index]];
+	}
+	if (!field) throw new Error(`Unknown schema field path "${path}"`);
+	return field;
+}
+function validateScalarPath(definition, path) {
+	const field = fieldAtPath(definition.shape, path);
+	if (field.kind === "object" || field.kind === "array") throw new TypeError(`Collection query path "${path}" must be scalar`);
+	return field;
+}
+function queryBuilder(definition) {
+	const plan = {
+		terminal: "ids",
+		where: []
+	};
+	const builder = {
+		where(filters) {
+			for (const [path, value] of Object.entries(filters)) {
+				const field = validateScalarPath(definition, path);
+				const clauses = Array.isArray(value) ? typeof value[0] === "string" ? [value] : value : [["equals", value]];
+				for (const [comparison, operand] of clauses) {
+					if (typeof operand === "number" && !Number.isFinite(operand)) throw new TypeError("Collection query numbers must be finite");
+					const fieldType = field.kind === "literal" ? typeof field.value : field.kind;
+					if (typeof operand !== fieldType) throw new TypeError(`Invalid comparison value for "${path}"`);
+					if (comparison !== "equals" && comparison !== "greater-than" && comparison !== "less-than" && comparison !== "contains") throw new TypeError(`Invalid comparison operator "${comparison}"`);
+					if (comparison === "contains" && fieldType !== "string" || (comparison === "greater-than" || comparison === "less-than") && fieldType !== "number") throw new TypeError(`Invalid ${comparison} comparison for "${path}"`);
+					plan.where.push({
+						path,
+						comparison,
+						operand
+					});
+				}
+			}
+			return builder;
+		},
+		from(other, id) {
+			assertId(id);
+			plan.from = {
+				collection: collectionName(other),
+				id
+			};
+			return builder;
+		},
+		sortBy(path, order = "asc") {
+			if (path !== "createdAt" && path !== "updatedAt") validateScalarPath(definition, path);
+			if (order !== "asc" && order !== "desc") throw new TypeError("Invalid sort order");
+			plan.sort = {
+				path,
+				order
+			};
+			return builder;
+		},
+		take(count) {
+			if (!Number.isInteger(count) || count <= 0) throw new TypeError("Collection query take must be a positive integer");
+			plan.take = count;
+			return builder;
+		},
+		ids() {
+			return { plan: {
+				...plan,
+				terminal: "ids"
+			} };
+		},
+		row(id, options) {
+			assertId(id);
+			return { plan: {
+				...plan,
+				terminal: "row",
+				id,
+				links: options?.links?.map(collectionName).sort()
+			} };
+		},
+		field(id, path) {
+			assertId(id);
+			fieldAtPath(definition.shape, path);
+			return { plan: {
+				...plan,
+				terminal: "field",
+				id,
+				path
+			} };
+		}
+	};
+	return builder;
+}
+function canonicalPlan(plan) {
+	return {
+		...plan,
+		where: [...plan.where].sort((left, right) => stableStringify(left).localeCompare(stableStringify(right))),
+		links: plan.links ? [...new Set(plan.links)].sort() : void 0
+	};
+}
+const queryFamily = atomFamily((key) => {
+	const registration = queryPlans.get(key);
+	if (!registration) throw new Error(`Missing collection query plan "${key}"`);
+	return atom(async (get) => {
+		get(internalJotaiAtom(registration.revision));
+		const result = await executeQuery(await initializedDatabase(), registration.definition, { plan: registration.plan });
+		if (registration.hasCache && registration.plan.terminal === "ids" && sameIds(registration.cache, result)) return registration.cache;
+		if (registration.hasCache && Object.is(registration.cache, result)) return registration.cache;
+		registration.cache = result;
+		registration.hasCache = true;
+		return result;
+	});
+});
+const mutationFamily = atomFamily((key) => {
+	const registration = mutationTerminals.get(key);
+	if (!registration) throw new Error(`Missing collection mutation terminal "${key}"`);
+	return atom(() => null, (_get, _set, ...args) => enqueueMutation((database, changes) => executeMutation(database, changes, registration.collection, registration.terminal, args)));
+});
+function atomCollection(name, shape) {
+	assertCollectionName(name);
+	assertFieldPaths(shape);
+	const validator = schema(shape);
+	const signature = stableStringify(validator.toJSONSchema());
+	const existing = registry().get(name);
+	if (existing) {
+		if (existing.signature !== signature) throw new Error(`Collection "${name}" was registered with a different schema`);
+		return existing.atom;
+	}
+	const definition = {
+		name,
+		shape,
+		signature,
+		validator,
+		revision: atom$1(0)
+	};
+	const value = atom$1(async (get) => {
+		get(definition.revision);
+		const ids = (await selectRows(await initializedDatabase(), definition, {
+			terminal: "ids",
+			where: []
+		})).map((row) => row.id);
+		if (sameIds(definition.idsCache, ids)) return definition.idsCache;
+		definition.idsCache = ids;
+		return ids;
+	});
+	definition.atom = value;
+	registry().set(name, definition);
+	return value;
+}
+function queryAtom(collection, build) {
+	const definition = collectionDefinition(collection);
+	const plan = canonicalPlan(build(queryBuilder(definition)).plan);
+	const key = stableStringify({
+		collection: definition.name,
+		plan
+	});
+	if (!queryPlans.has(key)) queryPlans.set(key, {
+		definition,
+		plan,
+		revision: atom$1(0),
+		hasCache: false
+	});
+	return internalAtom(queryFamily(key));
+}
+function mutationBuilder() {
+	return {
+		insert: () => ({ kind: "insert" }),
+		update: (id) => ({
+			kind: "update",
+			id,
+			args: [],
+			result: void 0
+		}),
+		remove: (id) => ({
+			kind: "remove",
+			id
+		}),
+		link: (id, other) => ({
+			kind: "link",
+			id,
+			other
+		}),
+		unlink: (id, other) => ({
+			kind: "unlink",
+			id,
+			other
+		})
+	};
+}
+function terminalKey(terminal) {
+	return stableStringify({
+		kind: terminal.kind,
+		id: "id" in terminal ? terminal.id : void 0,
+		other: "other" in terminal ? collectionName(terminal.other) : void 0
+	});
+}
+function collectionChange(changes, name) {
+	let change = changes.get(name);
+	if (!change) {
+		change = {
+			structural: false,
+			links: false,
+			records: /* @__PURE__ */ new Map()
+		};
+		changes.set(name, change);
+	}
+	return change;
+}
+function markRecord(changes, collection, id, kind, paths = []) {
+	const change = collectionChange(changes, collection);
+	if (kind === "insert" || kind === "remove") change.structural = true;
+	const record = change.records.get(id) ?? {
+		kind,
+		paths: /* @__PURE__ */ new Set(),
+		data: true,
+		links: false
+	};
+	record.kind = kind;
+	record.data = true;
+	for (const path of paths) record.paths.add(path);
+	change.records.set(id, record);
+}
+function markLink(changes, collection, id) {
+	const change = collectionChange(changes, collection);
+	change.links = true;
+	const record = change.records.get(id) ?? {
+		kind: "update",
+		paths: /* @__PURE__ */ new Set(),
+		data: false,
+		links: false
+	};
+	record.links = true;
+	change.records.set(id, record);
+}
+function changedDataPaths(previous, next, prefix = "", output = /* @__PURE__ */ new Set()) {
+	if (stableStringify(previous) === stableStringify(next)) return output;
+	if (previous && next && typeof previous === "object" && typeof next === "object" && !Array.isArray(previous) && !Array.isArray(next)) {
+		const keys = new Set([...Object.keys(previous), ...Object.keys(next)]);
+		for (const key of keys) changedDataPaths(previous[key], next[key], prefix ? `${prefix}.${key}` : key, output);
+	} else if (prefix) output.add(prefix);
+	return output;
+}
+function queryAffected(registration, changes) {
+	const { definition, plan } = registration;
+	const change = changes.get(definition.name);
+	if (plan.terminal === "row") {
+		const record = change?.records.get(plan.id);
+		return Boolean(record && (record.data || record.links && (plan.links?.length ?? 0) > 0));
+	}
+	if (plan.terminal === "field") {
+		const record = change?.records.get(plan.id);
+		if (!record?.data) return false;
+		if (record.kind !== "update") return true;
+		return [...record.paths].some((path) => relatedPath(path, plan.path));
+	}
+	if (change?.structural) return true;
+	if (plan.from && (change?.links || changes.get(plan.from.collection)?.links)) return true;
+	const dependencies = [...plan.where.map((clause) => clause.path), ...plan.sort ? [plan.sort.path] : []];
+	if (!change || dependencies.length === 0) return false;
+	return [...change.records.values()].some((record) => [...record.paths].some((path) => dependencies.some((dependency) => relatedPath(path, dependency))));
+}
+function publishChanges(changes) {
+	for (const [name, change] of changes) {
+		if (!change.structural) continue;
+		const definition = registry().get(name);
+		if (definition) internalStore.set(internalJotaiWritableAtom(definition.revision), (value) => value + 1);
+	}
+	for (const registration of queryPlans.values()) {
+		if (!queryAffected(registration, changes)) continue;
+		internalStore.set(internalJotaiWritableAtom(registration.revision), (value) => value + 1);
+	}
+}
+function enqueueMutation(action) {
+	let resolve;
+	let reject;
+	const result = new Promise((onResolve, onReject) => {
+		resolve = onResolve;
+		reject = onReject;
+	});
+	mutationPipeline = mutationPipeline.then(async () => {
+		const database = await initializedDatabase();
+		const changes = /* @__PURE__ */ new Map();
+		try {
+			const value = await database.transaction(() => action(database, changes));
+			publishChanges(changes);
+			resolve(value);
+		} catch (error) {
+			reject(error);
+		}
+	}).catch(() => void 0);
+	return result;
+}
+async function insertRecord(database, changes, definition, input) {
+	const data = definition.validator.parse(input);
+	const id = crypto.randomUUID();
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	await database.execute(`INSERT INTO collections (collection, id, version, createdAt, updatedAt, data)
+     VALUES (?, ?, 1, ?, ?, ?)`, [
+		definition.name,
+		id,
+		timestamp,
+		timestamp,
+		JSON.stringify(data)
+	]);
+	markRecord(changes, definition.name, id, "insert");
+	return id;
+}
+function validatePatch(shape, patch, path = "patch") {
+	if (!patch || typeof patch !== "object" || Array.isArray(patch)) throw new TypeError(`${path} must be an object`);
+	for (const [key, value] of Object.entries(patch)) {
+		const field = shape[key];
+		if (!field) throw new TypeError(`Unknown field ${path}.${key}`);
+		if (value !== void 0 && field.kind === "object") validatePatch(field.shape, value, `${path}.${key}`);
+	}
+}
+function applyPatch(current, patch) {
+	const next = { ...current };
+	for (const [key, value] of Object.entries(patch)) if (value === void 0) delete next[key];
+	else if (value && typeof value === "object" && !Array.isArray(value) && current[key] && typeof current[key] === "object" && !Array.isArray(current[key])) next[key] = applyPatch(current[key], value);
+	else next[key] = value;
+	return next;
+}
+async function updateRecord(database, changes, definition, id, patch, options) {
+	assertId(id);
+	validatePatch(definition.shape, patch);
+	const previous = await getPersisted(database, definition, id);
+	if (!previous) throw new Error(`Cannot update missing record "${definition.name}:${id}"`);
+	if (options?.ifVersion !== void 0 && options.ifVersion !== previous.version) throw new CollectionVersionConflictError(definition.name, id, options.ifVersion, previous.version);
+	const data = definition.validator.parse(applyPatch(previous.data, patch));
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const timestamp = now > previous.updatedAt ? now : new Date(Date.parse(previous.updatedAt) + 1).toISOString();
+	await database.execute(`UPDATE collections SET data = ?, updatedAt = ?, version = ?
+     WHERE collection = ? AND id = ? AND version = ?`, [
+		JSON.stringify(data),
+		timestamp,
+		previous.version + 1,
+		definition.name,
+		id,
+		previous.version
+	]);
+	const persisted = await getPersisted(database, definition, id);
+	if (!persisted) throw new Error(`Cannot update missing record "${definition.name}:${id}"`);
+	if (persisted.version !== previous.version + 1 || stableStringify(persisted.data) !== stableStringify(data)) throw new CollectionVersionConflictError(definition.name, id, options?.ifVersion ?? previous.version, persisted.version);
+	const paths = changedDataPaths(previous.data, data);
+	paths.add("updatedAt");
+	markRecord(changes, definition.name, id, "update", paths);
+	return fullRow(database, definition, persisted);
+}
+async function removeRecord(database, changes, definition, id) {
+	assertId(id);
+	if (!await getPersisted(database, definition, id)) return false;
+	const links = await incidentLinks(database, definition.name, id);
+	for (const link of links) {
+		markLink(changes, stringValue(link, "leftCollection"), stringValue(link, "leftId"));
+		markLink(changes, stringValue(link, "rightCollection"), stringValue(link, "rightId"));
+	}
+	await database.execute("DELETE FROM links WHERE (leftCollection = ? AND leftId = ?) OR (rightCollection = ? AND rightId = ?)", [
+		definition.name,
+		id,
+		definition.name,
+		id
+	]);
+	await database.execute("DELETE FROM collections WHERE collection = ? AND id = ?", [definition.name, id]);
+	markRecord(changes, definition.name, id, "remove");
+	return true;
+}
+async function mutateLink(database, changes, kind, leftCollection, leftId, rightCollection, rightId) {
+	assertId(leftId);
+	assertId(rightId);
+	const leftDefinition = collectionDefinition(leftCollection);
+	const rightDefinition = collectionDefinition(rightCollection);
+	const [left, right] = endpointOrder({
+		collection: leftDefinition.name,
+		id: leftId
+	}, {
+		collection: rightDefinition.name,
+		id: rightId
+	});
+	if (!await getPersisted(database, leftDefinition, leftId)) throw new Error(`Cannot link missing record "${leftDefinition.name}:${leftId}"`);
+	if (!await getPersisted(database, rightDefinition, rightId)) throw new Error(`Cannot link missing record "${rightDefinition.name}:${rightId}"`);
+	const parameters = [
+		left.collection,
+		left.id,
+		right.collection,
+		right.id
+	];
+	const existing = await database.get(`SELECT createdAt FROM links WHERE leftCollection = ? AND leftId = ?
+     AND rightCollection = ? AND rightId = ?`, parameters);
+	if (kind === "unlink") {
+		if (!existing) return false;
+		await database.execute(`DELETE FROM links WHERE leftCollection = ? AND leftId = ?
+       AND rightCollection = ? AND rightId = ?`, parameters);
+		markLink(changes, left.collection, left.id);
+		markLink(changes, right.collection, right.id);
+		return true;
+	}
+	if (existing) return false;
+	await database.execute(`INSERT INTO links (leftCollection, leftId, rightCollection, rightId, createdAt)
+     VALUES (?, ?, ?, ?, ?)`, [...parameters, (/* @__PURE__ */ new Date()).toISOString()]);
+	markLink(changes, left.collection, left.id);
+	markLink(changes, right.collection, right.id);
+	return true;
+}
+async function executeMutation(database, changes, collection, terminal, args) {
+	const definition = collectionDefinition(collection);
+	switch (terminal.kind) {
+		case "insert": return insertRecord(database, changes, definition, args[0]);
+		case "update": return updateRecord(database, changes, definition, terminal.id, args[0], args[1]);
+		case "remove": return removeRecord(database, changes, definition, terminal.id);
+		case "link":
+		case "unlink": return mutateLink(database, changes, terminal.kind, collection, terminal.id, terminal.other, args[0]);
+	}
+}
+function mutateAtom(collection, build) {
+	const definition = collectionDefinition(collection);
+	const terminal = build(mutationBuilder());
+	if ("id" in terminal) assertId(terminal.id);
+	const key = stableStringify({
+		collection: definition.name,
+		terminal: terminalKey(terminal)
+	});
+	if (!mutationTerminals.has(key)) mutationTerminals.set(key, {
+		collection,
+		terminal
+	});
+	return internalWritableAtom(mutationFamily(key));
+}
+function transactionContext(database, changes) {
+	return {
+		async get(collection, id, options) {
+			const definition = collectionDefinition(collection);
+			const persisted = await getPersisted(database, definition, id);
+			return persisted ? fullRow(database, definition, persisted, options?.links?.map(collectionName)) : null;
+		},
+		query(collection, build) {
+			const definition = collectionDefinition(collection);
+			return executeQuery(database, definition, { plan: canonicalPlan(build(queryBuilder(definition)).plan) });
+		},
+		insert(collection, value) {
+			return insertRecord(database, changes, collectionDefinition(collection), value);
+		},
+		update(collection, id, patch, options) {
+			return updateRecord(database, changes, collectionDefinition(collection), id, patch, options);
+		},
+		remove(collection, id) {
+			return removeRecord(database, changes, collectionDefinition(collection), id);
+		},
+		link(collection, id, other, otherId) {
+			return mutateLink(database, changes, "link", collection, id, other, otherId);
+		},
+		unlink(collection, id, other, otherId) {
+			return mutateLink(database, changes, "unlink", collection, id, other, otherId);
+		}
+	};
+}
+function transactionAtom(action) {
+	return atom$1(() => null, (_get, _set, ...args) => {
+		if (transactionCallbackStarting) return Promise.reject(/* @__PURE__ */ new Error("Nested collection transactions are not supported"));
+		return enqueueMutation((database, changes) => {
+			transactionCallbackStarting = true;
+			try {
+				return Promise.resolve(action(transactionContext(database, changes), ...args));
+			} finally {
+				transactionCallbackStarting = false;
+			}
+		});
+	});
+}
+function useList(collection, build = (builder) => builder.ids()) {
+	return useAtomValue$1(queryAtom(collection, build));
+}
+function useRow(collection, id, options) {
+	return useAtomValue$1(queryAtom(collection, (builder) => builder.row(id, options)));
+}
+function useField(collection, id, path) {
+	return useAtomValue$1(queryAtom(collection, (builder) => builder.field(id, path)));
+}
+
+//#endregion
+export { transactionAtom as a, useRow as c, internalJotaiWritableAtom as d, internalStore as f, useSetAtom$1 as h, queryAtom as i, atom$1 as l, useAtomValue$1 as m, atomCollection as n, useField as o, useAtom$1 as p, mutateAtom as r, useList as s, CollectionVersionConflictError as t, internalJotaiAtom as u };