@happyvertical/sql 0.80.0 → 0.80.1

package/dist/chunks/sqlite-native-BGtpx7Ro.js

@@ -0,0 +1,902 @@
+import { n as buildWhere, r as formatDbError, t as DatabaseSchemaManager } from "./schema-manager-a8RlxIE2.js";
+import { a as validateTableName, i as validateIndexName, n as generateCreateIndexStatement, r as validateColumnName, t as generateAddColumnStatement } from "./alter-utils-K7tiuj5L.js";
+import { resolveSchemas } from "../index.js";
+import { DatabaseError } from "@happyvertical/utils";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+//#region src/sqlite-native.ts
+var nativeMemoryConnectionCache = /* @__PURE__ */ new Map();
+var nativePendingConnections = /* @__PURE__ */ new Map();
+var nativeNullAwareUpsertLocks = /* @__PURE__ */ new Map();
+var nodeSqliteModulePromise = null;
+var requireOptionalPackage = createRequire(import.meta.url);
+function getCapabilityOptions(value) {
+	return typeof value === "object" && value ? value : {};
+}
+function resolveNativeLocation(url = ":memory:") {
+	if (url.startsWith("libsql://") || url.startsWith("http://") || url.startsWith("https://")) throw new DatabaseError("SQLite native capabilities are only supported for local SQLite databases", {
+		url,
+		hint: "Use a local file path, 'file:...' URL, or ':memory:' when enabling SQLite capabilities."
+	});
+	if (url === ":memory:" || url.startsWith("file::memory:")) return {
+		location: url,
+		filePath: null,
+		isMemory: true
+	};
+	if (url.startsWith("file://")) {
+		const filePath = fileURLToPath(new URL(url));
+		return {
+			location: filePath,
+			filePath,
+			isMemory: false
+		};
+	}
+	if (url.startsWith("file:")) {
+		const path = url.slice(5);
+		if (!path || path.includes("?")) throw new DatabaseError("SQLite native capabilities do not support file: URLs with query parameters", { url });
+		const filePath = resolve(path);
+		return {
+			location: filePath,
+			filePath,
+			isMemory: false
+		};
+	}
+	const filePath = resolve(url);
+	return {
+		location: filePath,
+		filePath,
+		isMemory: false
+	};
+}
+async function loadNodeSqlite() {
+	nodeSqliteModulePromise ??= importNodeSqlite().catch((error) => {
+		nodeSqliteModulePromise = null;
+		throw error;
+	});
+	return nodeSqliteModulePromise;
+}
+async function importNodeSqlite() {
+	const originalEmitWarning = process.emitWarning;
+	try {
+		process.emitWarning = function suppressNodeSqliteExperimentalWarning(warning, ...args) {
+			if (args[0] === "ExperimentalWarning" && String(warning).includes("SQLite is an experimental feature")) return;
+			return originalEmitWarning.call(process, warning, ...args);
+		};
+		return await import(
+			/* @vite-ignore */
+			"node:sqlite"
+);
+	} catch (error) {
+		throw new DatabaseError("Node native SQLite is not available", {
+			originalError: formatDbError(error),
+			hint: "SQLite native capabilities require a Node.js runtime with node:sqlite support."
+		});
+	} finally {
+		process.emitWarning = originalEmitWarning;
+	}
+}
+async function loadSqliteVectorExtension(database) {
+	try {
+		const module = requireOptionalPackage("@sqliteai/sqlite-vector");
+		const getExtensionPath = module.getExtensionPath ?? module.default?.getExtensionPath;
+		if (typeof getExtensionPath !== "function") throw new Error("getExtensionPath export was not found");
+		database.enableLoadExtension(true);
+		database.loadExtension(getExtensionPath());
+	} catch (error) {
+		throw new DatabaseError("Failed to load optional SQLite vector capability: install @sqliteai/sqlite-vector", {
+			packageName: "@sqliteai/sqlite-vector",
+			originalError: formatDbError(error),
+			hint: "Install @sqliteai/sqlite-vector to use SQLite vector capabilities."
+		});
+	} finally {
+		try {
+			database.enableLoadExtension(false);
+		} catch (_error) {}
+	}
+}
+async function openHonkerDatabase(filePath, options) {
+	try {
+		const module = requireOptionalPackage("@russellthehippo/honker-node");
+		const open = module.open ?? module.default?.open;
+		if (typeof open !== "function") throw new Error("open export was not found");
+		return open(filePath, options.maxReaders, options.watcherBackend);
+	} catch (error) {
+		throw new DatabaseError("Failed to load optional SQLite notification capability: install @russellthehippo/honker-node", {
+			packageName: "@russellthehippo/honker-node",
+			originalError: formatDbError(error),
+			hint: "Install @russellthehippo/honker-node to use SQLite notification capabilities."
+		});
+	}
+}
+function toPlainRow(row) {
+	return Object.fromEntries(Object.entries(row));
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : void 0;
+}
+function firstSqlToken(sql) {
+	return sql.trim().split(/\s+/)[0]?.toUpperCase() ?? "";
+}
+function normalizeNativeQuery(sql, values) {
+	const flatArgs = Array.isArray(values[0]) ? values[0] : values;
+	const parameterIndexes = Array.from(sql.matchAll(/\$(\d+)/g)).map((match) => Number(match[1]));
+	if (parameterIndexes.length === 0) return {
+		sql,
+		args: flatArgs
+	};
+	const args = parameterIndexes.map((index) => flatArgs[index - 1]);
+	return {
+		sql: sql.replace(/\$(\d+)/g, "?"),
+		args
+	};
+}
+function executeNativeQuery(database, sql, args = []) {
+	const statement = database.prepare(sql);
+	const columns = statement.columns();
+	if (columns.length > 0) {
+		const rows = statement.all(...args).map(toPlainRow);
+		return {
+			rows,
+			rowCount: rows.length,
+			command: firstSqlToken(sql),
+			fields: columns.map((column) => ({ name: column.name }))
+		};
+	}
+	const result = statement.run(...args);
+	return {
+		rows: [],
+		rowCount: Number(result?.changes ?? 0),
+		command: firstSqlToken(sql),
+		fields: []
+	};
+}
+function createNativeTablesFromSchemas(database, schemas) {
+	for (const [tableName, schema] of Object.entries(schemas)) try {
+		if (executeNativeQuery(database, "SELECT name FROM sqlite_master WHERE type='table' AND name=?", [tableName]).rows.length > 0) continue;
+		database.exec(schema.ddl);
+		for (const indexSql of schema.indexes ?? []) try {
+			database.exec(indexSql);
+		} catch (error) {
+			console.warn(`[sqlite] Failed to create index for ${tableName}: ${formatDbError(error)}`);
+		}
+		for (const triggerSql of schema.triggers ?? []) try {
+			database.exec(triggerSql);
+		} catch (error) {
+			console.warn(`[sqlite] Failed to create trigger for ${tableName}: ${formatDbError(error)}`);
+		}
+	} catch (error) {
+		throw new DatabaseError(`Failed to create table ${tableName} from schema`, {
+			tableName,
+			schema,
+			originalError: formatDbError(error)
+		});
+	}
+}
+function quoteIdentifier(identifier) {
+	return `"${identifier.replace(/"/g, "\"\"")}"`;
+}
+function buildQuestionWhere(where, startIndex = 1) {
+	const built = buildWhere(where, startIndex, "sqlite");
+	return {
+		sql: built.sql.replace(/\$(\d+)/g, "?"),
+		values: built.values
+	};
+}
+function serializeValue(value) {
+	if (value === null || value === void 0) return value;
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "object") return JSON.stringify(value);
+	return value;
+}
+function serializeRecord(record) {
+	const serialized = {};
+	for (const [key, value] of Object.entries(record)) {
+		if (value === void 0) continue;
+		serialized[key] = serializeValue(value);
+	}
+	return serialized;
+}
+async function withNativeNullAwareUpsertLock(lockKey, callback) {
+	const previous = nativeNullAwareUpsertLocks.get(lockKey) ?? Promise.resolve();
+	let release = () => {};
+	const current = new Promise((resolve) => {
+		release = resolve;
+	});
+	const next = previous.catch(() => {}).then(() => current);
+	nativeNullAwareUpsertLocks.set(lockKey, next);
+	await previous.catch(() => {});
+	try {
+		return await callback();
+	} finally {
+		release();
+		if (nativeNullAwareUpsertLocks.get(lockKey) === next) nativeNullAwareUpsertLocks.delete(lockKey);
+	}
+}
+function sqliteVectorDistance(metric) {
+	switch (metric) {
+		case "l2": return "L2";
+		case "ip": return "DOT";
+		default: return "COSINE";
+	}
+}
+function sqliteVectorQuantization(options) {
+	const parts = [];
+	switch (options.quantization ?? "turbo4") {
+		case "turbo2":
+			parts.push("qtype=TURBO,qbits=2");
+			break;
+		case "turbo3":
+			parts.push("qtype=TURBO,qbits=3");
+			break;
+		case "turbo4":
+			parts.push("qtype=TURBO,qbits=4");
+			break;
+		case "uint8":
+			parts.push("qtype=UINT8");
+			break;
+		case "int8":
+			parts.push("qtype=INT8");
+			break;
+		case "1bit":
+			parts.push("qtype=1BIT");
+			break;
+	}
+	if (options.maxMemory) parts.push(`max_memory=${options.maxMemory}`);
+	return parts.join(",");
+}
+function createNotificationCapabilities(honkerDb, closeables) {
+	return {
+		async notify(channel, payload) {
+			return Number(honkerDb.notify(channel, payload));
+		},
+		listen(channel, options) {
+			const listener = honkerDb.listen(channel, { fallbackPollS: options?.fallbackPollMs === null ? null : options?.fallbackPollMs !== void 0 ? options.fallbackPollMs / 1e3 : void 0 });
+			closeables.add(listener);
+			return listener;
+		},
+		async waitForUpdate(options) {
+			const updateEvents = honkerDb.updateEvents();
+			closeables.add(updateEvents);
+			let timeout;
+			let removeAbortListener;
+			try {
+				if (options?.signal?.aborted) return false;
+				const races = [updateEvents.next().then(() => true, () => false)];
+				if (options?.timeoutMs !== void 0) {
+					const timeoutMs = options.timeoutMs;
+					races.push(new Promise((resolve) => {
+						timeout = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
+					}));
+				}
+				if (options?.signal) races.push(new Promise((resolve) => {
+					const onAbort = () => resolve(false);
+					options.signal?.addEventListener("abort", onAbort, { once: true });
+					removeAbortListener = () => options.signal?.removeEventListener("abort", onAbort);
+				}));
+				return await Promise.race(races);
+			} finally {
+				if (timeout) clearTimeout(timeout);
+				removeAbortListener?.();
+				closeables.delete(updateEvents);
+				updateEvents.close?.();
+			}
+		},
+		async prune(options) {
+			return Number(honkerDb.pruneNotifications(options?.olderThanS, options?.maxKeep));
+		}
+	};
+}
+function createVectorCapabilities(database, options) {
+	const initialized = /* @__PURE__ */ new Map();
+	const indexed = /* @__PURE__ */ new Map();
+	const keyFor = (table, column) => `${table}.${column}`;
+	const columnExists = (table, column) => {
+		return database.prepare(`PRAGMA table_info(${quoteIdentifier(table)})`).all().map(toPlainRow).some((row) => row.name === column);
+	};
+	const ensureInitialized = (table, column, dimensions, metric = "cosine") => {
+		if (!Number.isInteger(dimensions) || dimensions <= 0) throw new DatabaseError("Vector dimensions must be a positive integer", { dimensions });
+		validateTableName(table);
+		validateColumnName(column);
+		executeNativeQuery(database, "SELECT vector_init(?, ?, ?)", [
+			table,
+			column,
+			`dimension=${dimensions},type=FLOAT32,distance=${sqliteVectorDistance(metric)}`
+		]);
+		initialized.set(keyFor(table, column), {
+			dimensions,
+			metric
+		});
+	};
+	const quantize = (table, column, vectorOptions) => {
+		const quantizationOptions = sqliteVectorQuantization(vectorOptions);
+		if (quantizationOptions) executeNativeQuery(database, "SELECT vector_quantize(?, ?, ?)", [
+			table,
+			column,
+			quantizationOptions
+		]);
+		else executeNativeQuery(database, "SELECT vector_quantize(?, ?)", [table, column]);
+		if (vectorOptions.preload) executeNativeQuery(database, "SELECT vector_quantize_preload(?, ?)", [table, column]);
+	};
+	return {
+		async ensureColumn(table, column, dimensions) {
+			validateTableName(table);
+			validateColumnName(column);
+			try {
+				if (!columnExists(table, column)) executeNativeQuery(database, `ALTER TABLE ${quoteIdentifier(table)} ADD COLUMN ${quoteIdentifier(column)} BLOB`);
+				ensureInitialized(table, column, dimensions, "cosine");
+			} catch (error) {
+				throw new DatabaseError("Failed to ensure SQLite vector column", {
+					table,
+					column,
+					dimensions,
+					originalError: formatDbError(error)
+				});
+			}
+		},
+		async ensureIndex(table, column, indexOptions) {
+			validateTableName(table);
+			validateColumnName(column);
+			const key = keyFor(table, column);
+			const dimensions = indexOptions?.dimensions ?? initialized.get(key)?.dimensions;
+			if (!dimensions) throw new DatabaseError("SQLite vector index creation requires dimensions", {
+				table,
+				column,
+				hint: "Call ensureColumn(table, column, dimensions) first or pass dimensions to ensureIndex()."
+			});
+			const metric = indexOptions?.metric ?? "cosine";
+			try {
+				ensureInitialized(table, column, dimensions, metric);
+				const vectorOptions = { ...options };
+				quantize(table, column, vectorOptions);
+				indexed.set(key, {
+					metric,
+					options: vectorOptions
+				});
+			} catch (error) {
+				throw new DatabaseError("Failed to ensure SQLite vector index", {
+					table,
+					column,
+					originalError: formatDbError(error)
+				});
+			}
+		},
+		async upsertVector(table, where, column, embedding) {
+			validateTableName(table);
+			validateColumnName(column);
+			const key = keyFor(table, column);
+			const dimensions = initialized.get(key)?.dimensions ?? embedding.length;
+			const { sql: whereClause, values } = buildQuestionWhere(where);
+			if (!whereClause) throw new DatabaseError("SQLite vector update requires at least one WHERE condition", {
+				table,
+				column
+			});
+			try {
+				ensureInitialized(table, column, dimensions, initialized.get(key)?.metric ?? "cosine");
+				executeNativeQuery(database, `UPDATE ${quoteIdentifier(table)} SET ${quoteIdentifier(column)} = vector_as_f32(?) ${whereClause}`, [JSON.stringify(embedding), ...values]);
+				const indexState = indexed.get(key);
+				if (indexState) quantize(table, column, indexState.options);
+			} catch (error) {
+				throw new DatabaseError("Failed to upsert SQLite vector", {
+					table,
+					column,
+					where,
+					originalError: formatDbError(error)
+				});
+			}
+		},
+		async search(table, column, embedding, searchOptions) {
+			validateTableName(table);
+			validateColumnName(column);
+			const key = keyFor(table, column);
+			const metric = searchOptions?.metric ?? "cosine";
+			const limit = searchOptions?.limit ?? 10;
+			const limitArg = BigInt(limit);
+			const dimensions = initialized.get(key)?.dimensions ?? embedding.length;
+			const scanFunction = indexed.get(key)?.metric === metric ? "vector_quantize_scan" : "vector_full_scan";
+			const convertedWhere = searchOptions?.where ? searchOptions.where.replace(/\$(\d+)/g, "?") : "";
+			const whereParams = searchOptions?.params ?? [];
+			try {
+				ensureInitialized(table, column, dimensions, metric);
+				return (convertedWhere ? executeNativeQuery(database, `SELECT base.*, base.rowid AS __sqlite_rowid, vec.distance
+               FROM ${scanFunction}(?, ?, vector_as_f32(?)) AS vec
+               JOIN ${quoteIdentifier(table)} AS base ON base.rowid = vec.rowid
+               WHERE (${convertedWhere})
+               ORDER BY vec.distance
+               LIMIT ?`, [
+					table,
+					column,
+					JSON.stringify(embedding),
+					...whereParams,
+					limitArg
+				]).rows : executeNativeQuery(database, `SELECT base.*, base.rowid AS __sqlite_rowid, vec.distance
+               FROM ${scanFunction}(?, ?, vector_as_f32(?), ?) AS vec
+               JOIN ${quoteIdentifier(table)} AS base ON base.rowid = vec.rowid
+               ORDER BY vec.distance`, [
+					table,
+					column,
+					JSON.stringify(embedding),
+					limitArg
+				]).rows).map((row) => {
+					const { __sqlite_rowid: rowid, ...result } = row;
+					return {
+						...result,
+						id: String(result.id ?? rowid),
+						distance: Number(row.distance)
+					};
+				});
+			} catch (error) {
+				throw new DatabaseError("Failed to execute SQLite vector search", {
+					table,
+					column,
+					metric,
+					limit,
+					originalError: formatDbError(error)
+				});
+			}
+		}
+	};
+}
+async function getNativeSqliteDatabase(options = {}) {
+	const url = options.url || ":memory:";
+	if (options.dbid) {
+		const cached = nativeMemoryConnectionCache.get(options.dbid);
+		if (cached) return cached;
+		const pending = nativePendingConnections.get(options.dbid);
+		if (pending) return pending;
+	}
+	const connectionPromise = createNativeSqliteDatabase(options, url);
+	if (options.dbid) nativePendingConnections.set(options.dbid, connectionPromise);
+	try {
+		const db = await connectionPromise;
+		if (options.dbid) nativeMemoryConnectionCache.set(options.dbid, db);
+		return db;
+	} finally {
+		if (options.dbid) nativePendingConnections.delete(options.dbid);
+	}
+}
+async function createNativeSqliteDatabase(options, url) {
+	const location = resolveNativeLocation(url);
+	const notificationsOptions = getCapabilityOptions(options.capabilities?.notifications);
+	const vectorOptions = getCapabilityOptions(options.capabilities?.vector);
+	const wantsNotifications = Boolean(options.capabilities?.notifications);
+	const wantsVector = Boolean(options.capabilities?.vector);
+	if (wantsNotifications && location.isMemory) throw new DatabaseError("SQLite notification capabilities require a file-backed database", {
+		url,
+		hint: "Use a temporary file-backed .db for development and tests that need notifications."
+	});
+	const { DatabaseSync } = await loadNodeSqlite();
+	const database = new DatabaseSync(location.location, { allowExtension: wantsVector });
+	try {
+		if (wantsVector) await loadSqliteVectorExtension(database);
+		const honkerDb = wantsNotifications && location.filePath ? await openHonkerDatabase(location.filePath, notificationsOptions) : null;
+		const notificationCloseables = /* @__PURE__ */ new Set();
+		let closed = false;
+		const vectorCapabilities = wantsVector ? createVectorCapabilities(database, vectorOptions) : void 0;
+		const notificationCapabilities = honkerDb ? createNotificationCapabilities(honkerDb, notificationCloseables) : void 0;
+		const query = async (sql, ...values) => {
+			const normalized = normalizeNativeQuery(sql, values);
+			try {
+				const result = executeNativeQuery(database, normalized.sql, normalized.args);
+				return {
+					rows: result.rows,
+					rowCount: result.rowCount
+				};
+			} catch (error) {
+				throw new DatabaseError("Failed to execute raw query", {
+					sql: normalized.sql,
+					values: normalized.args,
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const parseTemplate = (strings, ...vars) => {
+			let sql = strings[0];
+			const values = [];
+			for (let i = 0; i < vars.length; i++) {
+				values.push(vars[i]);
+				sql += `?${strings[i + 1]}`;
+			}
+			return {
+				sql,
+				values
+			};
+		};
+		const insert = async (table, data) => {
+			const records = (Array.isArray(data) ? data : [data]).map(serializeRecord);
+			const keys = Object.keys(records[0]);
+			const placeholders = records.map(() => `(${keys.map(() => "?").join(", ")})`).join(", ");
+			const values = records.flatMap((record) => keys.map((key) => record[key]));
+			const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES ${placeholders}`;
+			try {
+				return {
+					operation: "insert",
+					affected: executeNativeQuery(database, sql, values).rowCount
+				};
+			} catch (error) {
+				throw new DatabaseError("Failed to insert records into table", {
+					table,
+					sql,
+					values,
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const get = async (table, where) => {
+			const { sql: whereClause, values } = buildQuestionWhere(where);
+			if (!whereClause) throw new DatabaseError("GET requires at least one WHERE condition to prevent returning an arbitrary record", { table });
+			const sql = `SELECT * FROM ${table} ${whereClause}`;
+			try {
+				return executeNativeQuery(database, sql, values).rows[0] || null;
+			} catch (error) {
+				throw new DatabaseError("Failed to retrieve record from table", {
+					table,
+					sql,
+					values,
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const list = async (table, where) => {
+			const { sql: whereClause, values } = buildQuestionWhere(where);
+			const sql = `SELECT * FROM ${table} ${whereClause}`;
+			try {
+				return executeNativeQuery(database, sql, values).rows;
+			} catch (error) {
+				throw new DatabaseError("Failed to list records from table", {
+					table,
+					sql,
+					values,
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const update = async (table, where, data) => {
+			const serializedData = serializeRecord(data);
+			const keys = Object.keys(serializedData);
+			const values = Object.values(serializedData);
+			const setClause = keys.map((key) => `${key} = ?`).join(", ");
+			const { sql: whereClause, values: whereValues } = buildQuestionWhere(where);
+			if (!whereClause) throw new DatabaseError("UPDATE requires at least one WHERE condition to prevent accidental update of all records", { table });
+			const sql = `UPDATE ${table} SET ${setClause} ${whereClause}`;
+			try {
+				return {
+					operation: "update",
+					affected: executeNativeQuery(database, sql, [...values, ...whereValues]).rowCount
+				};
+			} catch (error) {
+				throw new DatabaseError("Failed to update records in table", {
+					table,
+					sql,
+					values: [...values, ...whereValues],
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const hasNullConflictValue = (conflictColumns, data) => conflictColumns.some((column) => data[column] === null);
+		const validateUpsertConflictColumns = (table, conflictColumns, serializedData) => {
+			const missingColumns = conflictColumns.filter((column) => !(column in serializedData));
+			if (missingColumns.length > 0) throw new DatabaseError("Conflict columns missing from data", {
+				table,
+				conflictColumns,
+				missingColumns,
+				availableColumns: Object.keys(serializedData),
+				hint: "All columns specified in ON CONFLICT must be present in the data being inserted. Undefined values are filtered out during serialization - consider using null or an empty string instead."
+			});
+		};
+		const executeStandardUpsert = (table, conflictColumns, serializedData) => {
+			const keys = Object.keys(serializedData);
+			const values = Object.values(serializedData);
+			const placeholders = keys.map(() => "?").join(", ");
+			const updateSet = keys.map((key) => `${key} = excluded.${key}`).join(", ");
+			const conflict = conflictColumns.join(", ");
+			const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${conflict}) DO UPDATE SET ${updateSet}`;
+			return {
+				operation: "upsert",
+				affected: executeNativeQuery(database, sql, values).rowCount
+			};
+		};
+		const executeNullAwareUpsertAttempt = (table, conflictColumns, serializedData) => {
+			const keys = Object.keys(serializedData);
+			const values = Object.values(serializedData);
+			const updateSet = keys.map((key) => `${key} = ?`).join(", ");
+			const whereClause = conflictColumns.map((column) => `${column} IS ?`).join(" AND ");
+			const whereValues = conflictColumns.map((column) => serializedData[column]);
+			const updateResult = executeNativeQuery(database, `UPDATE ${table} SET ${updateSet} WHERE ${whereClause}`, [...values, ...whereValues]);
+			if (updateResult.rowCount > 0) return {
+				operation: "upsert",
+				affected: updateResult.rowCount
+			};
+			const placeholders = keys.map(() => "?").join(", ");
+			return {
+				operation: "upsert",
+				affected: executeNativeQuery(database, `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`, values).rowCount
+			};
+		};
+		const executeUpsert = async (table, conflictColumns, data, upsertOptions, acquireTransaction) => {
+			const serializedData = serializeRecord(data);
+			validateUpsertConflictColumns(table, conflictColumns, serializedData);
+			if (upsertOptions?.nullsDistinct || !hasNullConflictValue(conflictColumns, serializedData)) return executeStandardUpsert(table, conflictColumns, serializedData);
+			if (!acquireTransaction) return executeNullAwareUpsertAttempt(table, conflictColumns, serializedData);
+			return withNativeNullAwareUpsertLock(`${location.location}:${table}:${conflictColumns.map((column) => `${column}:${JSON.stringify(serializedData[column])}`).join("|")}`, async () => {
+				try {
+					database.exec("BEGIN IMMEDIATE");
+					const result = executeNullAwareUpsertAttempt(table, conflictColumns, serializedData);
+					database.exec("COMMIT");
+					return result;
+				} catch (error) {
+					try {
+						database.exec("ROLLBACK");
+					} catch (_rollbackError) {}
+					throw error;
+				}
+			});
+		};
+		const upsert = async (table, conflictColumns, data, upsertOptions) => {
+			try {
+				return await executeUpsert(table, conflictColumns, data, upsertOptions, true);
+			} catch (error) {
+				if (getErrorMessage(error) === "Conflict columns missing from data") throw error;
+				throw new DatabaseError("Failed to upsert record into table", {
+					table,
+					values: data,
+					conflictColumns,
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const upsertInCurrentTransaction = (table, conflictColumns, data, upsertOptions) => executeUpsert(table, conflictColumns, data, upsertOptions, false);
+		const getOrInsert = async (table, where, data) => {
+			const existing = await get(table, where);
+			if (existing) return existing;
+			await insert(table, data);
+			const inserted = await get(table, where);
+			if (!inserted) throw new DatabaseError("Failed to insert and retrieve record", {
+				table,
+				where,
+				data
+			});
+			return inserted;
+		};
+		const deleteRecords = async (table, where) => {
+			validateTableName(table);
+			const { sql: whereClause, values } = buildQuestionWhere(where);
+			if (!whereClause) throw new DatabaseError("DELETE requires at least one WHERE condition to prevent accidental deletion of all records", { table });
+			try {
+				return {
+					operation: "delete",
+					affected: executeNativeQuery(database, `DELETE FROM ${table} ${whereClause}`, values).rowCount
+				};
+			} catch (error) {
+				throw new DatabaseError("Failed to delete records from table", {
+					table,
+					where,
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const count = async (table, where) => {
+			validateTableName(table);
+			if (!where || typeof where === "object" && Object.keys(where).length === 0) {
+				const result = executeNativeQuery(database, `SELECT COUNT(*) as count FROM ${table}`);
+				return Number(result.rows[0]?.count) || 0;
+			}
+			const { sql: whereClause, values } = buildQuestionWhere(where);
+			const result = executeNativeQuery(database, `SELECT COUNT(*) as count FROM ${table} ${whereClause}`, values);
+			return Number(result.rows[0]?.count) || 0;
+		};
+		const tableExists = async (tableName) => {
+			return executeNativeQuery(database, "SELECT name FROM sqlite_master WHERE type='table' AND name=?", [tableName]).rows.length > 0;
+		};
+		const syncSchema = async (schema) => {
+			const commands = schema.replace(/\s+/g, " ").replace(/DEFAULT CAST\(([^)]+)\s+AS\s+\w+\)/gi, "DEFAULT $1").trim().split(";").map((command) => command.trim()).filter((command) => command.length > 0);
+			for (const command of commands) database.exec(command);
+		};
+		const many = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				return executeNativeQuery(database, sql, values).rows;
+			} catch (error) {
+				throw new DatabaseError("Failed to execute many query", {
+					sql,
+					values,
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const single = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				return executeNativeQuery(database, sql, values).rows[0] || null;
+			} catch (error) {
+				throw new DatabaseError("Failed to execute single query", {
+					sql,
+					values,
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const pluck = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				const row = executeNativeQuery(database, sql, values).rows[0];
+				return row ? Object.values(row)[0] : null;
+			} catch (error) {
+				throw new DatabaseError("Failed to execute pluck query", {
+					sql,
+					values,
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const execute = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				if (values.length === 0) {
+					database.exec(sql);
+					return;
+				}
+				executeNativeQuery(database, sql, values);
+			} catch (error) {
+				throw new DatabaseError("Failed to execute query", {
+					sql,
+					values,
+					originalError: formatDbError(error)
+				});
+			}
+		};
+		const oo = many;
+		const oO = single;
+		const ox = pluck;
+		const xx = execute;
+		const table = (tableName) => ({
+			insert: (data) => insert(tableName, data),
+			get: (where) => get(tableName, where),
+			list: (where) => list(tableName, where)
+		});
+		const transaction = async (callback) => {
+			try {
+				database.exec("BEGIN TRANSACTION");
+				const result = await callback(buildDatabaseInterface(upsertInCurrentTransaction));
+				database.exec("COMMIT");
+				return result;
+			} catch (error) {
+				database.exec("ROLLBACK");
+				throw error;
+			}
+		};
+		const beginTransaction = async () => {
+			database.exec("BEGIN TRANSACTION");
+			let active = true;
+			const commit = async () => {
+				if (!active) throw new DatabaseError("Transaction already ended", {});
+				database.exec("COMMIT");
+				active = false;
+			};
+			const rollback = async () => {
+				if (!active) throw new DatabaseError("Transaction already ended", {});
+				database.exec("ROLLBACK");
+				active = false;
+			};
+			return {
+				...buildDatabaseInterface(upsertInCurrentTransaction),
+				commit,
+				rollback,
+				isActive: () => active
+			};
+		};
+		const initializeSchemas = async (schemaOptions) => {
+			await new DatabaseSchemaManager().initializeSchemas(buildDatabaseInterface(upsert), schemaOptions);
+		};
+		const getTableSchema = async (tableName) => {
+			validateTableName(tableName);
+			if (!await tableExists(tableName)) return null;
+			const columnRows = database.prepare(`PRAGMA table_info(${quoteIdentifier(tableName)})`).all().map(toPlainRow);
+			const columns = {};
+			for (const row of columnRows) columns[row.name] = {
+				type: row.type,
+				primaryKey: row.pk === 1,
+				notNull: row.notnull === 1,
+				defaultValue: row.dflt_value
+			};
+			const indexRows = executeNativeQuery(database, `SELECT name FROM sqlite_master
+         WHERE type = 'index'
+           AND tbl_name = ?
+           AND name NOT LIKE 'sqlite_%'`, [tableName]).rows;
+			const indexes = [];
+			for (const row of indexRows) {
+				const indexName = row.name;
+				const indexInfoRows = database.prepare(`PRAGMA index_info(${quoteIdentifier(indexName)})`).all().map(toPlainRow);
+				const indexListRows = database.prepare(`PRAGMA index_list(${quoteIdentifier(tableName)})`).all().map(toPlainRow);
+				indexes.push({
+					name: indexName,
+					columns: indexInfoRows.map((info) => info.name),
+					unique: indexListRows.some((info) => info.name === indexName && info.unique === 1)
+				});
+			}
+			return {
+				tableName,
+				columns,
+				indexes,
+				foreignKeys: database.prepare(`PRAGMA foreign_key_list(${quoteIdentifier(tableName)})`).all().map(toPlainRow).map((row) => ({
+					column: row.from,
+					referencesTable: row.table,
+					referencesColumn: row.to,
+					onDelete: row.on_delete,
+					onUpdate: row.on_update
+				}))
+			};
+		};
+		const alterTable = {
+			addColumn: async (tableName, column) => {
+				validateTableName(tableName);
+				validateColumnName(column.name);
+				const sql = generateAddColumnStatement(tableName, column, "sqlite");
+				executeNativeQuery(database, sql);
+			},
+			addIndex: async (tableName, index) => {
+				validateTableName(tableName);
+				validateIndexName(index.name);
+				for (const column of index.columns) validateColumnName(column);
+				const sql = generateCreateIndexStatement(tableName, index);
+				executeNativeQuery(database, sql);
+			}
+		};
+		const close = async () => {
+			if (closed) return;
+			closed = true;
+			for (const closeable of notificationCloseables) closeable.close?.();
+			notificationCloseables.clear();
+			honkerDb?.close?.();
+			database.close();
+			if (options.dbid) nativeMemoryConnectionCache.delete(options.dbid);
+		};
+		function buildDatabaseInterface(upsertImpl) {
+			return {
+				url,
+				client: database,
+				query,
+				insert,
+				update,
+				upsert: upsertImpl,
+				get,
+				list,
+				getOrInsert,
+				delete: deleteRecords,
+				count,
+				table,
+				tableExists,
+				many,
+				single,
+				pluck,
+				execute,
+				oo,
+				oO,
+				ox,
+				xx,
+				syncSchema,
+				initializeSchemas,
+				transaction,
+				beginTransaction,
+				getTableSchema,
+				alterTable,
+				close,
+				...vectorCapabilities ? { vector: vectorCapabilities } : {},
+				...notificationCapabilities ? { notifications: notificationCapabilities } : {}
+			};
+		}
+		const db = buildDatabaseInterface(upsert);
+		const resolvedSchemas = resolveSchemas(options.schemas);
+		if (resolvedSchemas && Object.keys(resolvedSchemas).length > 0) createNativeTablesFromSchemas(database, resolvedSchemas);
+		return db;
+	} catch (error) {
+		try {
+			database.close();
+		} catch (_closeError) {}
+		throw error;
+	}
+}
+//#endregion
+export { getNativeSqliteDatabase };
+
+//# sourceMappingURL=sqlite-native-BGtpx7Ro.js.map