@happyvertical/sql 0.89.3 → 0.89.4

package/dist/chunks/sqlite-Cz2NMiDs.js

@@ -0,0 +1,2619 @@
+import { b as wrapDatabaseError, d as validateIndexName, f as validateTableName, h as formatDbError, l as validateColumnName, m as buildWhere, o as generateAddColumnStatement, p as DatabaseSchemaManager, r as validateDatabaseCacheOptions, s as generateCreateIndexStatement, u as validateColumnNames, v as resolveInsertColumns } from "./connection-cache-Da5UcY5u.js";
+import { t as redactDatabaseUrl } from "./redact-database-url-CfMDvSdy.js";
+import { i as createTransactionLock, n as resolveSchemas } from "./types-CwWJ-yju.js";
+import { t as getCachedSqliteDatabase } from "./sqlite-connection-cache-BAakj2HO.js";
+import { DatabaseError } from "@happyvertical/utils";
+import { execFile } from "node:child_process";
+import { lstat, open, unlink } from "node:fs/promises";
+import { dirname, parse, relative, resolve, sep } from "node:path";
+import { AsyncLocalStorage, createHook, executionAsyncId } from "node:async_hooks";
+import { createHash } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { types } from "node:util";
+//#region src/secure-sqlite-client.ts
+/**
+* @internal Parses the stable ACL section emitted by macOS `/bin/ls`.
+* Returns true only when the ACL grants authority; deny-only ACLs are
+* restrictive and do not weaken trusted-parent custody.
+*/
+function parseDarwinAclListing(listing) {
+	const permissionMarker = /^[bcdlps-][rwxStTs-]{9}([+@ ])/.exec(listing)?.[1];
+	if (!permissionMarker) throw new Error("macOS ACL inspection returned an unrecognized listing");
+	const aclEntries = listing.split("\n").slice(1).filter(Boolean);
+	if (aclEntries.length === 0) {
+		if (permissionMarker === "+") throw new Error("macOS ACL inspection returned no ACL entries");
+		return false;
+	}
+	if (permissionMarker !== "+" && permissionMarker !== "@") throw new Error("macOS ACL inspection returned entries without a marker");
+	let grantsAuthority = false;
+	for (const entry of aclEntries) {
+		const parsed = /^\s+\d+:\s+.+\s+(allow|deny)\s+[A-Za-z_,]+\s*$/.exec(entry);
+		if (!parsed) throw new Error("macOS ACL inspection returned an unrecognized entry");
+		if (parsed[1] === "allow") grantsAuthority = true;
+	}
+	return grantsAuthority;
+}
+function inspectDarwinAcl(filePath) {
+	return new Promise((resolveInspection, reject) => {
+		execFile("/bin/ls", [
+			"-lde",
+			"--",
+			filePath
+		], {
+			encoding: "utf8",
+			env: { LC_ALL: "C" },
+			timeout: 5e3
+		}, (error, stdout) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			try {
+				resolveInspection(parseDarwinAclListing(stdout));
+			} catch (parseError) {
+				reject(parseError);
+			}
+		});
+	});
+}
+var defaultRuntime = {
+	platform: process.platform,
+	nodeVersion: process.versions.node,
+	currentUid: () => {
+		if (!process.getuid) throw new Error("process.getuid() is unavailable");
+		return process.getuid();
+	},
+	inspectDarwinAcl,
+	loadDriver: async () => {
+		return await import(
+			/* @vite-ignore */
+			"node:sqlite"
+);
+	}
+};
+var GROUP_OR_WORLD_WRITE = 18;
+var STICKY_BIT = 512;
+var MINIMUM_NODE_VERSION = [
+	24,
+	18,
+	0
+];
+function validateNodeVersion(runtime) {
+	const version = runtime.nodeVersion ?? defaultRuntime.nodeVersion ?? "";
+	const match = /^v?(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+	const parsed = match?.slice(1, 4).map(Number);
+	const isPrerelease = Boolean(match?.[4]);
+	if (!parsed || parsed.some((part) => !Number.isSafeInteger(part)) || isPrerelease || parsed[0] < MINIMUM_NODE_VERSION[0] || parsed[0] === MINIMUM_NODE_VERSION[0] && parsed[1] < MINIMUM_NODE_VERSION[1] || parsed[0] === MINIMUM_NODE_VERSION[0] && parsed[1] === MINIMUM_NODE_VERSION[1] && parsed[2] < MINIMUM_NODE_VERSION[2]) throw new DatabaseError("Secure SQLite requires Node.js 24.18.0 or newer", {
+		actualVersion: version || "unknown",
+		minimumVersion: MINIMUM_NODE_VERSION.join("."),
+		hint: "Upgrade the runtime before requesting trusted-parent secure SQLite. Default LibSQL mode remains available on older supported runtimes."
+	});
+}
+function pathComponents(path) {
+	const root = parse(path).root;
+	const components = path.slice(root.length).split(sep).filter(Boolean);
+	const paths = [root];
+	for (const component of components) paths.push(resolve(paths.at(-1) ?? root, component));
+	return paths;
+}
+async function validateDarwinAcl(filePath, runtime) {
+	if (runtime.platform !== "darwin") return;
+	let hasAcl;
+	try {
+		const inspect = runtime.inspectDarwinAcl ?? defaultRuntime.inspectDarwinAcl;
+		if (!inspect) throw new Error("macOS ACL inspector is unavailable");
+		hasAcl = await inspect(filePath);
+	} catch (error) {
+		throw new DatabaseError("Secure SQLite acquisition cannot inspect macOS access control lists", {
+			path: filePath,
+			originalError: error instanceof Error ? error.message : String(error)
+		});
+	}
+	if (hasAcl) throw new DatabaseError("Secure SQLite custody path contains a permissive macOS access control list", {
+		path: filePath,
+		hint: "Remove ACL entries that grant authority from the application-custodied path before requesting secure acquisition."
+	});
+}
+async function validateTrustedParentCustody(filePath, options, runtime) {
+	if (options.custody !== "trusted-parent") throw new DatabaseError("Secure SQLite acquisition requires trusted-parent custody", {});
+	let currentUid;
+	try {
+		currentUid = (runtime.currentUid ?? defaultRuntime.currentUid)?.() ?? -1;
+	} catch (error) {
+		throw new DatabaseError("Secure SQLite acquisition cannot verify the current user", { originalError: error instanceof Error ? error.message : String(error) });
+	}
+	const databaseParent = dirname(filePath);
+	const custodyRoot = resolve(options.root ?? databaseParent);
+	const relativeDatabasePath = relative(custodyRoot, filePath);
+	if (!relativeDatabasePath || relativeDatabasePath === ".." || relativeDatabasePath.startsWith(`..${sep}`) || parse(relativeDatabasePath).root) throw new DatabaseError("Secure SQLite database must be beneath its trusted custody root", {
+		path: filePath,
+		custodyRoot
+	});
+	const custodyRelative = relative(custodyRoot, databaseParent);
+	const custodiedParents = /* @__PURE__ */ new Set([custodyRoot, ...pathComponents(databaseParent).filter((path) => {
+		const child = relative(custodyRoot, path);
+		return child === "" || !child.startsWith(`..${sep}`) && child !== "..";
+	})]);
+	if (custodyRelative === ".." || custodyRelative.startsWith(`..${sep}`) || parse(custodyRelative).root) throw new DatabaseError("Secure SQLite parent must be beneath its trusted custody root", {
+		path: databaseParent,
+		custodyRoot
+	});
+	for (const componentPath of pathComponents(databaseParent)) {
+		let stats;
+		try {
+			stats = await lstat(componentPath);
+		} catch (error) {
+			throw new DatabaseError("Secure SQLite custody chain contains an inaccessible component", {
+				path: componentPath,
+				originalError: error instanceof Error ? error.message : String(error)
+			});
+		}
+		if (stats.isSymbolicLink() || !stats.isDirectory()) throw new DatabaseError("Secure SQLite custody chain must contain only real directories", { path: componentPath });
+		await validateDarwinAcl(componentPath, runtime);
+		const componentUid = runtime.pathOwnerUid?.(componentPath, stats.uid) ?? stats.uid;
+		if (custodiedParents.has(componentPath)) {
+			if (componentUid !== currentUid) throw new DatabaseError("Secure SQLite custody directory is not owned by the current user", {
+				path: componentPath,
+				expectedUid: currentUid,
+				actualUid: componentUid
+			});
+			if ((stats.mode & GROUP_OR_WORLD_WRITE) !== 0) throw new DatabaseError("Secure SQLite custody directory is group/world writable", { path: componentPath });
+		} else {
+			if (componentUid !== currentUid && componentUid !== 0) throw new DatabaseError("Secure SQLite ancestor is owned by an untrusted user", {
+				path: componentPath,
+				expectedUid: currentUid,
+				actualUid: componentUid
+			});
+			if ((stats.mode & GROUP_OR_WORLD_WRITE) !== 0 && (stats.mode & STICKY_BIT) === 0) throw new DatabaseError("Secure SQLite ancestor permits replacement by another principal", { path: componentPath });
+		}
+	}
+	try {
+		const leaf = await lstat(filePath);
+		if (leaf.isSymbolicLink() || !leaf.isFile()) throw new DatabaseError("Secure SQLite database leaf must be a regular file", { path: filePath });
+		const leafUid = runtime.pathOwnerUid?.(filePath, leaf.uid) ?? leaf.uid;
+		if (leafUid !== currentUid) throw new DatabaseError("Secure SQLite database leaf is not owned by the current user", {
+			path: filePath,
+			expectedUid: currentUid,
+			actualUid: leafUid
+		});
+		if ((leaf.mode & GROUP_OR_WORLD_WRITE) !== 0) throw new DatabaseError("Secure SQLite database leaf is group/world writable", { path: filePath });
+		await validateDarwinAcl(filePath, runtime);
+		return true;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		return false;
+	}
+}
+function leafIdentity(stats) {
+	return {
+		birthtimeNs: stats.birthtimeNs,
+		ctimeNs: stats.ctimeNs,
+		dev: stats.dev,
+		ino: stats.ino
+	};
+}
+function sameLeafIdentity(left, right) {
+	return left.dev === right.dev && left.ino === right.ino && left.birthtimeNs === right.birthtimeNs && left.ctimeNs === right.ctimeNs;
+}
+async function createSecureLeaf(filePath, runtime) {
+	let handle;
+	try {
+		handle = await (runtime.openLeaf ?? open)(filePath, "wx", 384);
+	} catch (error) {
+		if (error.code === "EEXIST") return void 0;
+		throw new DatabaseError("Secure SQLite could not create the database leaf", {
+			path: filePath,
+			originalError: error instanceof Error ? error.message : String(error)
+		});
+	}
+	let identity;
+	let acquisitionError;
+	try {
+		identity = leafIdentity(await handle.stat({ bigint: true }));
+	} catch (error) {
+		acquisitionError = error;
+	}
+	try {
+		await handle.close();
+	} catch (error) {
+		acquisitionError = acquisitionError ? new AggregateError([acquisitionError, error], "Secure SQLite leaf inspection and close failed") : error;
+	}
+	if (acquisitionError) {
+		const cleanupError = identity ? await removeCreatedLeafIfUnchanged(filePath, identity, runtime) : void 0;
+		throw new DatabaseError("Secure SQLite could not close the created leaf", {
+			path: filePath,
+			originalError: acquisitionError instanceof Error ? acquisitionError.message : String(acquisitionError),
+			...!identity ? { cleanupSkipped: "leaf identity unavailable" } : {},
+			...cleanupError ? { cleanupError } : {}
+		});
+	}
+	return identity;
+}
+async function removeCreatedLeafIfUnchanged(filePath, identity, runtime) {
+	try {
+		if (!sameLeafIdentity(leafIdentity(await (runtime.lstatLeaf ?? lstat)(filePath, { bigint: true })), identity)) return;
+		await unlink(filePath);
+		return;
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		return error instanceof Error ? error.message : String(error);
+	}
+}
+function resolveSecureFilePath(url) {
+	if (url === ":memory:" || url.startsWith("file::memory:") || /^(?:https?|libsql):/i.test(url)) throw new DatabaseError("Secure SQLite acquisition requires a local file-backed database", { hint: "Use a local path or 'file:...' URL, or disable secureFile for memory and remote databases." });
+	if (url.startsWith("file://")) {
+		const parsed = new URL(url);
+		if (parsed.search || parsed.hash) throw new DatabaseError("Secure SQLite acquisition does not support file URLs with query parameters or fragments", {});
+		return resolve(fileURLToPath(parsed));
+	}
+	if (url.startsWith("file:")) {
+		const path = url.slice(5);
+		if (!path || path.includes("?") || path.includes("#")) throw new DatabaseError("Secure SQLite acquisition requires a plain file path without query parameters or fragments", {});
+		return resolve(path);
+	}
+	return resolve(url);
+}
+function normalizeExactInteger(value) {
+	if (typeof value !== "bigint") return value;
+	if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) return Number(value);
+	return value;
+}
+function normalizeExactRow(row) {
+	return Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeExactInteger(value)]));
+}
+function toExactBigInt(value, metric) {
+	if (typeof value === "bigint") return value;
+	if (!Number.isSafeInteger(value)) throw new DatabaseError(`Secure SQLite returned an inexact ${metric} metric`, {
+		metric,
+		value
+	});
+	return BigInt(value);
+}
+/** @internal Exact public-contract range guard used by deterministic tests. */
+function toPublicRowCount(value) {
+	const exact = toExactBigInt(value, "changes");
+	if (exact < 0n || exact > BigInt(Number.MAX_SAFE_INTEGER)) throw new DatabaseError("Secure SQLite changes exceed the public safe-integer row-count range", {
+		changes: exact.toString(),
+		maxSafeInteger: Number.MAX_SAFE_INTEGER
+	});
+	return Number(exact);
+}
+/**
+* node:sqlite does not bind named parameters from the positional array used by
+* the existing LibSQL adapter. Translate executable parameters to SQLite
+* numeric slots while preserving SQLite's first-occurrence allocation and
+* reuse rules, including Tcl-style `$name::suffix(...)` parameters. Quoted
+* text, identifiers, and comments remain untouched.
+*/
+function normalizeNodeSqlitePlaceholders(sql) {
+	let normalized = "";
+	let index = 0;
+	let quote;
+	let largestParameterIndex = 0;
+	const namedParameterIndexes = /* @__PURE__ */ new Map();
+	while (index < sql.length) {
+		const char = sql[index];
+		const next = sql[index + 1];
+		if (quote) {
+			normalized += char;
+			if (char === quote) {
+				if (next === quote && quote !== "]") {
+					normalized += next;
+					index += 2;
+					continue;
+				}
+				quote = void 0;
+			}
+			index += 1;
+			continue;
+		}
+		if (char === "'" || char === "\"" || char === "`" || char === "[") {
+			quote = char === "[" ? "]" : char;
+			normalized += char;
+			index += 1;
+			continue;
+		}
+		if (char === "-" && next === "-") {
+			const end = sql.indexOf("\n", index + 2);
+			if (end === -1) return normalized + sql.slice(index);
+			normalized += sql.slice(index, end + 1);
+			index = end + 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			const end = sql.indexOf("*/", index + 2);
+			if (end === -1) return normalized + sql.slice(index);
+			normalized += sql.slice(index, end + 2);
+			index = end + 2;
+			continue;
+		}
+		if (char === "?") {
+			let end = index + 1;
+			while (/[0-9]/.test(sql[end] ?? "")) end += 1;
+			if (end > index + 1) {
+				largestParameterIndex = Math.max(largestParameterIndex, Number(sql.slice(index + 1, end)));
+				normalized += sql.slice(index, end);
+			} else {
+				largestParameterIndex += 1;
+				normalized += `?${largestParameterIndex}`;
+			}
+			index = end;
+			continue;
+		}
+		if ((char === "$" || char === ":" || char === "@") && /[A-Za-z0-9_]/.test(next ?? "") && !/[A-Za-z0-9_$:@]/.test(sql[index - 1] ?? "")) {
+			let end = index + 2;
+			while (/[A-Za-z0-9_]/.test(sql[end] ?? "")) end += 1;
+			if (char === "$") {
+				while (sql.slice(end, end + 2) === "::" && /[A-Za-z0-9_]/.test(sql[end + 2] ?? "")) {
+					end += 3;
+					while (/[A-Za-z0-9_]/.test(sql[end] ?? "")) end += 1;
+				}
+				if (sql[end] === "(") {
+					const closingParenthesis = sql.indexOf(")", end + 1);
+					if (closingParenthesis !== -1) end = closingParenthesis + 1;
+				}
+			}
+			const token = sql.slice(index, end);
+			let parameterIndex = namedParameterIndexes.get(token);
+			if (parameterIndex === void 0) {
+				largestParameterIndex += 1;
+				parameterIndex = largestParameterIndex;
+				namedParameterIndexes.set(token, parameterIndex);
+			}
+			normalized += `?${parameterIndex}`;
+			index = end;
+			continue;
+		}
+		normalized += char;
+		index += 1;
+	}
+	return normalized;
+}
+function executeNodeSqlite(database, statement) {
+	const sql = normalizeNodeSqlitePlaceholders(typeof statement === "string" ? statement : statement.sql);
+	const args = (typeof statement === "string" ? [] : statement.args ?? []).map((value) => typeof value === "boolean" ? Number(value) : value);
+	const prepared = database.prepare(sql);
+	prepared.setReadBigInts(true);
+	if (prepared.columns().length > 0) {
+		const beforeStatement = database.prepare("SELECT total_changes() AS totalChanges");
+		beforeStatement.setReadBigInts(true);
+		const before = toExactBigInt(beforeStatement.all()[0]?.totalChanges, "totalChanges");
+		const rows = prepared.all(...args).map(normalizeExactRow);
+		const afterStatement = database.prepare("SELECT total_changes() AS totalChanges, changes() AS changes, last_insert_rowid() AS lastInsertRowid");
+		afterStatement.setReadBigInts(true);
+		const metrics = afterStatement.all()[0];
+		const changed = toExactBigInt(metrics?.totalChanges, "totalChanges") > before;
+		return {
+			rows,
+			rowsAffected: changed ? toPublicRowCount(metrics?.changes) : 0,
+			...changed ? { lastInsertRowid: toExactBigInt(metrics?.lastInsertRowid, "lastInsertRowid") } : {}
+		};
+	}
+	const result = prepared.run(...args);
+	const rowsAffected = toPublicRowCount(result.changes);
+	return {
+		rows: [],
+		rowsAffected,
+		...rowsAffected > 0 ? { lastInsertRowid: toExactBigInt(result.lastInsertRowid, "lastInsertRowid") } : {}
+	};
+}
+function createClient(database) {
+	let closePromise;
+	let executionTail = Promise.resolve();
+	let state = "open";
+	const executeStatement = async (statement) => {
+		return executeNodeSqlite(database, statement);
+	};
+	const enqueue = (statement, owner) => {
+		if (owner) {
+			if (!owner.active || state === "closed") return Promise.reject(new DatabaseError("Secure SQLite transaction reservation is closed", {}));
+			const pending = owner.tail.then(() => {
+				if (!owner.active || state === "closed") throw new DatabaseError("Secure SQLite transaction reservation is closed", {});
+				owner.beforeExecute?.();
+				return executeStatement(statement);
+			});
+			owner.tail = pending.then(() => void 0, () => void 0);
+			return pending;
+		}
+		if (state !== "open") return Promise.reject(new DatabaseError("Secure SQLite client is closing or closed", {}));
+		const pending = executionTail.then(() => executeStatement(statement));
+		executionTail = pending.then(() => void 0, () => void 0);
+		return pending;
+	};
+	const acquireReservation = async () => {
+		if (state !== "open") throw new DatabaseError("Secure SQLite client is closing or closed", {});
+		const owner = {
+			active: false,
+			tail: Promise.resolve()
+		};
+		let markAcquired = () => {};
+		let markReleased = () => {};
+		const acquired = new Promise((resolveAcquired) => {
+			markAcquired = resolveAcquired;
+		});
+		const released = new Promise((resolveReleased) => {
+			markReleased = resolveReleased;
+		});
+		const reservation = executionTail.then(async () => {
+			owner.active = true;
+			markAcquired();
+			await released;
+			await owner.tail;
+			owner.active = false;
+		});
+		executionTail = reservation.then(() => void 0, () => void 0);
+		await acquired;
+		let releaseStarted = false;
+		return {
+			owner,
+			release: async () => {
+				if (!releaseStarted) {
+					releaseStarted = true;
+					markReleased();
+				}
+				await reservation;
+			}
+		};
+	};
+	const execute = (statement) => enqueue(statement);
+	return {
+		transactionReservation: "exclusive",
+		execute,
+		transaction: async () => {
+			const { owner, release } = await acquireReservation();
+			try {
+				await enqueue("BEGIN IMMEDIATE", owner);
+			} catch (error) {
+				await release();
+				throw error;
+			}
+			let transactionClosed = false;
+			let transactionEnding = false;
+			let reservationReleased = false;
+			let automaticRollbackError;
+			const releaseReservation = async () => {
+				if (reservationReleased) return;
+				reservationReleased = true;
+				await release();
+			};
+			const detectAutomaticRollback = () => {
+				if (transactionClosed || database.isTransaction) return;
+				transactionClosed = true;
+				automaticRollbackError = new DatabaseError("Secure SQLite transaction ended automatically", { hint: "A statement conflict policy such as ON CONFLICT ROLLBACK ended the transaction. No later accepted work was executed." });
+				releaseReservation().catch(() => {});
+			};
+			const executeInTransaction = async (statement) => {
+				detectAutomaticRollback();
+				if (transactionClosed) throw automaticRollbackError ?? new DatabaseError("Secure SQLite transaction reservation is closed", {});
+				try {
+					return await enqueue(statement, owner);
+				} finally {
+					detectAutomaticRollback();
+				}
+			};
+			owner.beforeExecute = () => {
+				detectAutomaticRollback();
+				if (transactionClosed) throw automaticRollbackError ?? new DatabaseError("Secure SQLite transaction reservation is closed", {});
+			};
+			const end = async (sql) => {
+				if (transactionEnding) throw new DatabaseError("Secure SQLite transaction is already ending", {});
+				if (transactionClosed) {
+					await releaseReservation();
+					if (sql === "COMMIT" && automaticRollbackError) throw automaticRollbackError;
+					return;
+				}
+				transactionEnding = true;
+				if (sql === "COMMIT") try {
+					await enqueue(sql, owner);
+					transactionClosed = true;
+					await releaseReservation();
+					return;
+				} finally {
+					transactionEnding = false;
+				}
+				try {
+					await enqueue(sql, owner);
+					transactionClosed = true;
+					await releaseReservation();
+				} catch (rollbackError) {
+					transactionClosed = true;
+					state = "closing";
+					let closeError;
+					try {
+						await releaseReservation();
+						database.close();
+					} catch (error) {
+						closeError = error;
+					} finally {
+						state = "closed";
+					}
+					if (closeError) throw new AggregateError([rollbackError, closeError], "Secure SQLite rollback and connection invalidation both failed", { cause: rollbackError });
+					throw rollbackError;
+				} finally {
+					transactionEnding = false;
+				}
+			};
+			return {
+				get closed() {
+					return transactionClosed;
+				},
+				execute: executeInTransaction,
+				commit: () => end("COMMIT"),
+				rollback: () => end("ROLLBACK"),
+				close: () => {
+					if (!transactionClosed) end("ROLLBACK").catch(() => {});
+				}
+			};
+		},
+		close: async () => {
+			if (state === "closed") return;
+			if (!closePromise) {
+				state = "closing";
+				closePromise = executionTail.then(() => database.close());
+			}
+			try {
+				await closePromise;
+				state = "closed";
+			} catch (error) {
+				state = "open";
+				closePromise = void 0;
+				throw error;
+			}
+		}
+	};
+}
+/**
+* Opens a local SQLite file under an explicit trusted-parent custody contract.
+*
+* Static path components and their ownership/mode are checked before the
+* built-in `node:sqlite` driver opens the file. Other principals cannot replace
+* a path beneath the caller-custodied parent. Hostile processes running as the
+* same account are explicitly outside this boundary.
+*
+* @internal Call through `getDatabase()` with typed `secureFile` custody.
+*/
+async function createSecureSqliteClient(url, options, runtime = defaultRuntime) {
+	validateNodeVersion(runtime);
+	if (runtime.platform !== "darwin" && runtime.platform !== "linux") throw new DatabaseError(`Secure SQLite acquisition is unsupported on ${runtime.platform}`, { hint: "secureFile requires built-in node:sqlite on macOS or Linux. Disable secureFile only if trusted-parent custody is not required." });
+	const filePath = resolveSecureFilePath(url);
+	const leafExisted = await validateTrustedParentCustody(filePath, options, runtime);
+	let nodeSqlite;
+	try {
+		nodeSqlite = await runtime.loadDriver();
+	} catch (error) {
+		throw new DatabaseError("Secure SQLite acquisition could not load the node:sqlite driver", {
+			hint: "Run @happyvertical/sql on its supported Node.js version with built-in node:sqlite available.",
+			originalError: error instanceof Error ? error.message : String(error)
+		});
+	}
+	let createdLeaf;
+	if (!leafExisted) {
+		createdLeaf = await createSecureLeaf(filePath, runtime);
+		try {
+			if (!await validateTrustedParentCustody(filePath, options, runtime)) throw new DatabaseError("Secure SQLite database leaf disappeared during acquisition", { path: filePath });
+			if (createdLeaf) {
+				let current;
+				try {
+					current = await (runtime.lstatLeaf ?? lstat)(filePath, { bigint: true });
+				} catch (error) {
+					throw new DatabaseError("Secure SQLite database leaf changed during acquisition", {
+						path: filePath,
+						originalError: error instanceof Error ? error.message : String(error)
+					});
+				}
+				if (!sameLeafIdentity(leafIdentity(current), createdLeaf)) throw new DatabaseError("Secure SQLite database leaf changed during acquisition", { path: filePath });
+			}
+		} catch (error) {
+			if (createdLeaf) await removeCreatedLeafIfUnchanged(filePath, createdLeaf, runtime);
+			throw error;
+		}
+	}
+	let database;
+	try {
+		database = new nodeSqlite.DatabaseSync(filePath, {
+			enableForeignKeyConstraints: false,
+			enableDoubleQuotedStringLiterals: true
+		});
+	} catch (error) {
+		let cleanupError;
+		if (createdLeaf) cleanupError = await removeCreatedLeafIfUnchanged(filePath, createdLeaf, runtime);
+		throw new DatabaseError("Secure SQLite acquisition rejected the database path", {
+			path: filePath,
+			hint: "Ensure the database path and every ancestor are real directories/files, not symbolic links, and that the file is writable.",
+			originalError: error instanceof Error ? error.message : String(error),
+			...cleanupError ? { cleanupError } : {}
+		});
+	}
+	return createClient(database);
+}
+//#endregion
+//#region src/sqlite.ts
+/**
+* Connection cache for in-memory databases with memoryId
+* Enables sharing of :memory: databases across multiple getDatabase() calls
+*/
+var NULL_AWARE_UPSERT_MAX_ATTEMPTS = 8;
+var NULL_AWARE_UPSERT_BASE_DELAY_MS = 25;
+var nullAwareUpsertLocks = /* @__PURE__ */ new Map();
+var MANAGED_TRANSACTION_CONTROL_KEYWORDS = /* @__PURE__ */ new Set([
+	"begin",
+	"commit",
+	"end",
+	"release",
+	"rollback",
+	"savepoint"
+]);
+function firstSqlKeyword(sql) {
+	let offset = 0;
+	while (offset < sql.length) {
+		const remaining = sql.slice(offset);
+		const whitespace = remaining.match(/^\s+/)?.[0];
+		if (whitespace) {
+			offset += whitespace.length;
+			continue;
+		}
+		if (remaining.startsWith("--")) {
+			const newline = remaining.indexOf("\n", 2);
+			if (newline === -1) return void 0;
+			offset += newline + 1;
+			continue;
+		}
+		if (remaining.startsWith("/*")) {
+			const end = remaining.indexOf("*/", 2);
+			if (end === -1) return void 0;
+			offset += end + 2;
+			continue;
+		}
+		if (remaining.startsWith(";")) {
+			offset += 1;
+			continue;
+		}
+		return remaining.match(/^[A-Za-z]+/)?.[0]?.toLowerCase();
+	}
+}
+function prepareManagedStatement(statement) {
+	const sql = typeof statement === "string" ? statement : statement?.sql;
+	if (typeof sql === "string" && MANAGED_TRANSACTION_CONTROL_KEYWORDS.has(firstSqlKeyword(sql) ?? "")) throw new DatabaseError("Transaction-control SQL is managed by the SQLite transaction scope", { hint: "Use transaction(), beginTransaction(), commit(), or rollback() instead of issuing BEGIN, COMMIT, ROLLBACK, SAVEPOINT, or RELEASE as raw SQL." });
+	if (typeof statement === "object" && statement !== null) {
+		const args = statement.args;
+		return {
+			sql,
+			args: Array.isArray(args) ? [...args] : args
+		};
+	}
+	return statement;
+}
+/**
+* Orders secure adapter calls at public invocation time.
+*
+* The reservation is appended before this function returns a promise. A later
+* `close()` therefore cannot overtake an operation while it awaits an internal
+* transaction/upsert lock before publishing work to the driver queue.
+*/
+function createInvocationBarrier() {
+	let tail = Promise.resolve();
+	let closePromise;
+	let state = "open";
+	const run = (work) => {
+		if (state !== "open") return Promise.reject(new DatabaseError("Secure SQLite adapter is closing or closed", {}));
+		const previous = tail;
+		let release = () => {};
+		const current = new Promise((resolveCurrent) => {
+			release = resolveCurrent;
+		});
+		tail = previous.then(() => current, () => current);
+		return previous.then(work, work).finally(release);
+	};
+	const close = (work) => {
+		if (state === "closed") return Promise.resolve();
+		if (closePromise) return closePromise;
+		state = "closing";
+		closePromise = tail.then(work, work).then(() => {
+			state = "closed";
+		}, (error) => {
+			state = "open";
+			closePromise = void 0;
+			throw error;
+		});
+		tail = closePromise.then(() => void 0, () => void 0);
+		return closePromise;
+	};
+	return {
+		run,
+		close
+	};
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toSafeSqliteCount(value) {
+	const count = typeof value === "bigint" ? value : BigInt(String(value ?? 0));
+	if (count < 0n || count > BigInt(Number.MAX_SAFE_INTEGER)) throw new DatabaseError("SQLite count exceeds the safe integer range", {
+		value: String(value),
+		maximum: Number.MAX_SAFE_INTEGER
+	});
+	return Number(count);
+}
+function combineTransactionFailures(primary, secondary) {
+	return new AggregateError([primary, secondary], "Transaction callback and accepted transaction work both failed", { cause: primary });
+}
+var activeNativeTransferObservations = /* @__PURE__ */ new Set();
+var trackedPromiseObservations = /* @__PURE__ */ new Set();
+var nativePromiseResources = /* @__PURE__ */ new Map();
+var nativePromiseTriggers = /* @__PURE__ */ new Map();
+var nativePromiseIds = /* @__PURE__ */ new WeakMap();
+var nativePromiseWatermarks = /* @__PURE__ */ new WeakMap();
+var latestNativePromiseId = 0;
+var nativePromiseTrackingUsers = 0;
+var MAX_TRACKED_PROMISE_RESOURCES = 8192;
+var nativePromiseHook = createHook({
+	init(asyncId, type, triggerAsyncId, resource) {
+		if (type === "PROMISE") {
+			latestNativePromiseId = Math.max(latestNativePromiseId, asyncId);
+			nativePromiseResources.set(asyncId, new WeakRef(resource));
+			nativePromiseTriggers.set(asyncId, triggerAsyncId);
+			nativePromiseIds.set(resource, asyncId);
+			while (nativePromiseResources.size > MAX_TRACKED_PROMISE_RESOURCES) {
+				const oldest = nativePromiseResources.keys().next().value;
+				if (oldest === void 0) break;
+				nativePromiseResources.delete(oldest);
+				nativePromiseTriggers.delete(oldest);
+				for (const observation of trackedPromiseObservations) if (!observation.observed && observation.nativeCorrelationIds.has(oldest)) observation.nativeCorrelationIncomplete = true;
+			}
+		}
+	},
+	destroy(asyncId) {
+		nativePromiseResources.delete(asyncId);
+		nativePromiseTriggers.delete(asyncId);
+	}
+});
+var nativeTransferListenerInstalled = false;
+function configuredUnhandledRejectionMode() {
+	return [...`${process.env.NODE_OPTIONS ?? ""} ${process.execArgv.join(" ")}`.matchAll(/--unhandled-rejections(?:=|\s+)(warn-with-error-code|none|strict|throw|warn)\b/g)].at(-1)?.[1] ?? "throw";
+}
+function promisesAreRelated(rejectedPromise, transferPromise) {
+	const rejectedId = nativePromiseIds.get(rejectedPromise);
+	const transferId = nativePromiseIds.get(transferPromise);
+	if (rejectedId === void 0 || transferId === void 0) return false;
+	if (rejectedId > (nativePromiseWatermarks.get(transferPromise) ?? -1)) return false;
+	if (rejectedId === transferId) return true;
+	const isAncestor = (ancestor, descendant) => {
+		let current = descendant;
+		while (nativePromiseTriggers.has(current)) {
+			current = nativePromiseTriggers.get(current) ?? 0;
+			if (current === ancestor) return true;
+			if (current === 0) break;
+		}
+		return false;
+	};
+	if (isAncestor(rejectedId, transferId) || isAncestor(transferId, rejectedId)) return true;
+	return rejectedId === transferId - 1 && nativePromiseTriggers.get(rejectedId) === nativePromiseTriggers.get(transferId);
+}
+var recordUnhandledNativeTransfer = (reason, rejectedPromise) => {
+	let matched = false;
+	for (const observation of activeNativeTransferObservations) for (const transferPromise of observation.nativeTransfers) if (promisesAreRelated(rejectedPromise, transferPromise)) {
+		observation.unhandledNativeTransfers.add(transferPromise);
+		observation.observed = false;
+		matched = true;
+	}
+	if (!matched && process.listenerCount("unhandledRejection") === 1) {
+		const mode = configuredUnhandledRejectionMode();
+		if (mode === "none" || mode === "strict") return;
+		if (mode === "warn") return;
+		if (mode === "warn-with-error-code") {
+			process.emitWarning(reason instanceof Error ? reason.stack ?? reason.message : String(reason), { type: "UnhandledPromiseRejectionWarning" });
+			process.exitCode = 1;
+			return;
+		}
+		const error = reason instanceof Error ? reason : new Error(`Unhandled promise rejection: ${String(reason)}`, { cause: reason });
+		queueMicrotask(() => {
+			if (process.hasUncaughtExceptionCaptureCallback()) throw error;
+			if (process.listenerCount("uncaughtException") > 0) {
+				const emitProcessEvent = process.emit;
+				emitProcessEvent.call(process, "uncaughtExceptionMonitor", error, "unhandledRejection");
+				emitProcessEvent.call(process, "uncaughtException", error, "unhandledRejection");
+				return;
+			}
+			throw error;
+		});
+	}
+};
+function retainNativePromiseTracking(observation) {
+	if (observation.nativeTrackingActive) return;
+	observation.nativeTrackingActive = true;
+	trackedPromiseObservations.add(observation);
+	nativePromiseTrackingUsers += 1;
+	if (nativePromiseTrackingUsers === 1) nativePromiseHook.enable();
+}
+function releaseNativePromiseTracking(observation) {
+	if (!observation.nativeTrackingActive) return;
+	observation.nativeTrackingActive = false;
+	trackedPromiseObservations.delete(observation);
+	nativePromiseTrackingUsers -= 1;
+	if (nativePromiseTrackingUsers === 0) {
+		nativePromiseHook.disable();
+		nativePromiseResources.clear();
+		nativePromiseTriggers.clear();
+	}
+}
+function recordNativePromiseTransfer(observation) {
+	const executionId = executionAsyncId();
+	const adoptionId = nativePromiseTriggers.get(executionId) ?? executionId;
+	const adoptingPromise = nativePromiseResources.get(adoptionId)?.deref();
+	if (!adoptingPromise) return;
+	observation.nativeTransfers.add(adoptingPromise);
+	observation.observed = true;
+	nativePromiseWatermarks.set(adoptingPromise, latestNativePromiseId);
+	let correlationId = adoptionId;
+	observation.nativeCorrelationIds.add(correlationId);
+	while (nativePromiseTriggers.has(correlationId)) {
+		correlationId = nativePromiseTriggers.get(correlationId) ?? 0;
+		if (correlationId === 0) break;
+		observation.nativeCorrelationIds.add(correlationId);
+	}
+	activeNativeTransferObservations.add(observation);
+	if (!nativeTransferListenerInstalled) {
+		process.prependListener("unhandledRejection", recordUnhandledNativeTransfer);
+		nativeTransferListenerInstalled = true;
+	}
+}
+async function settleNativePromiseTransfers(observations) {
+	const observed = expandPromiseObservations(observations);
+	const transferred = observed.filter((observation) => observation.nativeTransfers.size > 0);
+	if (transferred.length === 0) {
+		for (const observation of observed) releaseNativePromiseTracking(observation);
+		return;
+	}
+	await new Promise((resolvePromise) => setImmediate(resolvePromise));
+	for (const observation of transferred) {
+		if (!observation.nativeCorrelationIncomplete && [...observation.nativeTransfers].every((promise) => !observation.unhandledNativeTransfers.has(promise))) observation.observed = true;
+		activeNativeTransferObservations.delete(observation);
+	}
+	for (const observation of observed) releaseNativePromiseTracking(observation);
+	if (nativeTransferListenerInstalled && activeNativeTransferObservations.size === 0) {
+		process.off("unhandledRejection", recordUnhandledNativeTransfer);
+		nativeTransferListenerInstalled = false;
+	}
+}
+function expandPromiseObservations(observations) {
+	const expanded = /* @__PURE__ */ new Set();
+	for (const observation of observations) {
+		expanded.add(observation);
+		for (const branch of observation.branches ?? []) expanded.add(branch);
+	}
+	return [...expanded];
+}
+function isNativePromiseAssimilation(onFulfilled, onRejected) {
+	const anonymousPromiseResolver = (handler) => handler.name === "" && handler.length === 1 && /\{\s*\[native code\]\s*\}/.test(Function.prototype.toString.call(handler));
+	return typeof onFulfilled === "function" && typeof onRejected === "function" && anonymousPromiseResolver(onFulfilled) && anonymousPromiseResolver(onRejected);
+}
+function looksLikeNativePromiseCapabilityExecutor(executor) {
+	return typeof executor === "function" && !types.isProxy(executor) && executor.name === "" && executor.length === 2 && /\{\s*\[native code\]\s*\}/.test(Function.prototype.toString.call(executor));
+}
+function isConsumedPromiseCapabilityExecutor(executor) {
+	try {
+		executor(() => void 0, () => void 0);
+		return false;
+	} catch (error) {
+		return error instanceof TypeError && error.message === "Promise executor has already been invoked with non-undefined arguments";
+	}
+}
+/**
+* Returns a native Promise chain that records rejection handling per derived
+* branch. A handler transfers responsibility from its parent to a branch-local
+* observation, so catching one sibling cannot hide another detached failure.
+*/
+function withRejectionObservation(source, rootObservation) {
+	retainNativePromiseTracking(rootObservation);
+	const wrap = (promise, observation = rootObservation) => {
+		const createStandaloneObservation = () => ({
+			observed: false,
+			handlers: /* @__PURE__ */ new Set(),
+			nativeTransfers: /* @__PURE__ */ new Set(),
+			unhandledNativeTransfers: /* @__PURE__ */ new Set(),
+			nativeCorrelationIds: /* @__PURE__ */ new Set()
+		});
+		const suppressIntrinsicRecovery = (callback, targetObservation = observation) => {
+			targetObservation.suppressIntrinsicRecovery = (targetObservation.suppressIntrinsicRecovery ?? 0) + 1;
+			try {
+				return callback();
+			} finally {
+				targetObservation.suppressIntrinsicRecovery -= 1;
+			}
+		};
+		suppressIntrinsicRecovery(() => {
+			Promise.prototype.then.call(promise, void 0, () => void 0);
+		});
+		const intrinsicPromiseObservations = /* @__PURE__ */ new WeakMap();
+		const createPromiseSpeciesOwner = (parentObservation) => {
+			const speciesOwner = function transactionObservedPromiseBranch(executor) {
+				return new Promise(executor);
+			};
+			Object.setPrototypeOf(speciesOwner, Promise);
+			Object.defineProperty(speciesOwner, Symbol.species, {
+				configurable: true,
+				get: () => createIntrinsicDerivedPromise(parentObservation)
+			});
+			return speciesOwner;
+		};
+		const createIntrinsicDerivedPromise = (parentObservation) => {
+			class IntrinsicDerivedPromise extends Promise {
+				#observation;
+				static get [Symbol.species]() {
+					return Promise;
+				}
+				constructor(executor) {
+					const suppressed = (parentObservation.suppressIntrinsicRecovery ?? 0) > 0;
+					const candidateRecovery = !suppressed && looksLikeNativePromiseCapabilityExecutor(executor);
+					const branch = suppressed ? parentObservation : createStandaloneObservation();
+					let finishHandling = () => {};
+					const handling = new Promise((resolveHandling) => {
+						finishHandling = resolveHandling;
+					});
+					super((resolve, reject) => {
+						try {
+							executor((value) => {
+								if (candidateRecovery) new Promise((resolveValue) => resolveValue(value)).then(() => {
+									branch.observed = true;
+									finishHandling();
+								}, (error) => {
+									branch.error = error;
+									if (branch.propagateFailureToParent) branch.propagateFailureToParent.observed = true;
+									finishHandling();
+								});
+								else finishHandling();
+								resolve(value);
+							}, (reason) => {
+								if (candidateRecovery) {
+									branch.error = reason;
+									if (branch.propagateFailureToParent) branch.propagateFailureToParent.observed = true;
+								}
+								finishHandling();
+								reject(reason);
+							});
+						} catch (error) {
+							if (candidateRecovery) {
+								branch.error = error;
+								if (branch.propagateFailureToParent) branch.propagateFailureToParent.observed = true;
+							}
+							finishHandling();
+							throw error;
+						}
+					});
+					const tracksRecovery = candidateRecovery && isConsumedPromiseCapabilityExecutor(executor);
+					if (tracksRecovery) {
+						const branches = parentObservation.branches ?? /* @__PURE__ */ new Set();
+						parentObservation.branches = branches;
+						branch.branches = branches;
+						branches.add(branch);
+						parentObservation.observed = true;
+					}
+					this.#observation = branch;
+					intrinsicPromiseObservations.set(this, branch);
+					Promise.prototype.then.call(this, void 0, () => void 0);
+					if (tracksRecovery) {
+						branch.handlers.add(handling);
+						handling.finally(() => branch.handlers.delete(handling));
+					}
+					Object.defineProperty(this, "constructor", {
+						configurable: true,
+						value: createPromiseSpeciesOwner(branch)
+					});
+				}
+				then(onFulfilled, onRejected) {
+					const branch = this.#observation;
+					const transfersToNativePromise = isNativePromiseAssimilation(onFulfilled, onRejected);
+					const handleRejected = transfersToNativePromise && typeof onRejected === "function" ? (reason) => {
+						recordNativePromiseTransfer(branch);
+						return onRejected(reason);
+					} : onRejected;
+					const wasObserved = branch.observed;
+					const derived = Promise.prototype.then.call(this, onFulfilled, handleRejected);
+					if (transfersToNativePromise) {
+						branch.observed = wasObserved;
+						const child = intrinsicPromiseObservations.get(derived);
+						if (child) child.propagateFailureToParent = branch;
+					} else branch.observed = true;
+					return derived;
+				}
+				catch(onRejected) {
+					return this.then(void 0, onRejected);
+				}
+				finally(onFinally) {
+					if (typeof onFinally !== "function") return this.then((value) => value, (reason) => {
+						throw reason;
+					});
+					return this.then((value) => Promise.resolve(onFinally()).then(() => value), (reason) => Promise.resolve(onFinally()).then(() => {
+						throw reason;
+					}));
+				}
+			}
+			return IntrinsicDerivedPromise;
+		};
+		class ObservedPromise extends Promise {
+			#observation;
+			static get [Symbol.species]() {
+				return createIntrinsicDerivedPromise(observation);
+			}
+			constructor(executor) {
+				super((resolve, reject) => {
+					if (executor) executor(resolve, reject);
+					else Promise.prototype.then.call(promise, resolve, reject);
+				});
+				this.#observation = executor ? createStandaloneObservation() : observation;
+				Object.defineProperty(this, "constructor", {
+					configurable: true,
+					value: createPromiseSpeciesOwner(this.#observation)
+				});
+			}
+			then(onFulfilled, onRejected) {
+				const currentObservation = this.#observation;
+				const transfersToNativePromise = isNativePromiseAssimilation(onFulfilled, onRejected);
+				const handleRejected = transfersToNativePromise && typeof onRejected === "function" ? (reason) => {
+					recordNativePromiseTransfer(currentObservation);
+					return onRejected(reason);
+				} : onRejected;
+				const wasObserved = currentObservation.observed;
+				const derived = Promise.prototype.then.call(this, onFulfilled, handleRejected);
+				if (transfersToNativePromise) {
+					currentObservation.observed = wasObserved;
+					const child = intrinsicPromiseObservations.get(derived);
+					if (child) child.propagateFailureToParent = currentObservation;
+				} else currentObservation.observed = true;
+				return derived;
+			}
+			catch(onRejected) {
+				return this.then(void 0, onRejected);
+			}
+			finally(onFinally) {
+				if (typeof onFinally !== "function") return this.then((value) => value, (reason) => {
+					throw reason;
+				});
+				return this.then((value) => Promise.resolve(onFinally()).then(() => value), (reason) => Promise.resolve(onFinally()).then(() => {
+					throw reason;
+				}));
+			}
+		}
+		const observed = new ObservedPromise();
+		suppressIntrinsicRecovery(() => Promise.prototype.then.call(observed, void 0, () => void 0));
+		return observed;
+	};
+	return wrap(source);
+}
+function isRetriableSqliteTransactionError(error) {
+	const formatted = formatDbError(error).toLowerCase();
+	return formatted.includes("busy") || formatted.includes("locked") || formatted.includes("database is locked");
+}
+async function withNullAwareUpsertLock(lockKey, callback) {
+	const previous = nullAwareUpsertLocks.get(lockKey) ?? Promise.resolve();
+	let release = () => {};
+	const current = new Promise((resolve) => {
+		release = resolve;
+	});
+	const next = previous.catch(() => {}).then(() => current);
+	nullAwareUpsertLocks.set(lockKey, next);
+	await previous.catch(() => {});
+	try {
+		return await callback();
+	} finally {
+		release();
+		if (nullAwareUpsertLocks.get(lockKey) === next) nullAwareUpsertLocks.delete(lockKey);
+	}
+}
+/**
+* Generates a unique identifier for in-memory databases
+* @returns A unique database identifier string
+*/
+function generateDbId() {
+	return `memory-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+/**
+* Creates a LibSQL client using the default client implementation
+* Supports in-memory databases and remote LibSQL URLs
+*
+* @param options - SQLite connection options
+* @returns Promise resolving to a LibSQL client instance
+*/
+async function createLibSQLClient(options) {
+	const { url = ":memory:", authToken, encryptionKey } = options;
+	let libsqlUrl = url;
+	const remoteUrl = url.replace(/[\t\n\r]/g, "").trim();
+	const hasRemoteScheme = /^(?:https?|libsql):/i.test(remoteUrl);
+	if (hasRemoteScheme) {
+		libsqlUrl = remoteUrl;
+		let parsedRemoteUrl;
+		try {
+			parsedRemoteUrl = new URL(remoteUrl);
+		} catch {
+			const safeUrl = redactDatabaseUrl(remoteUrl);
+			throw new DatabaseError(`Invalid remote database URL: ${safeUrl}`, { url: safeUrl });
+		}
+		if (!/^(?:https?|libsql):\/\//i.test(remoteUrl) || !parsedRemoteUrl.host) {
+			const safeUrl = redactDatabaseUrl(remoteUrl);
+			throw new DatabaseError(`Invalid remote database URL: ${safeUrl}`, { url: safeUrl });
+		}
+	}
+	if (url !== ":memory:" && !hasRemoteScheme && !url.startsWith("file:")) {
+		const { resolve } = await import("node:path");
+		libsqlUrl = `file://${resolve(url)}`;
+	}
+	try {
+		const { createClient } = await import(
+			/* @vite-ignore */
+			"@libsql/client"
+);
+		return createClient({
+			url: libsqlUrl,
+			authToken,
+			encryptionKey
+		});
+	} catch (error) {
+		const errorMessage = redactDatabaseUrl(error instanceof Error ? error.message : String(error));
+		const safeUrl = redactDatabaseUrl(libsqlUrl);
+		if (errorMessage?.includes("URL_SCHEME_NOT_SUPPORTED")) throw new DatabaseError(`Unsupported URL scheme. Use ':memory:' for in-memory databases or 'libsql://' for remote LibSQL databases. URL: ${safeUrl}`, {
+			url: safeUrl,
+			originalError: errorMessage
+		});
+		throw new DatabaseError(`Failed to create LibSQL client: ${errorMessage}`, {
+			url: safeUrl,
+			originalError: errorMessage
+		});
+	}
+}
+function hasNativeSqliteCapabilities(options) {
+	return Boolean(options.capabilities?.notifications || options.capabilities?.vector);
+}
+/**
+* Creates tables from provided schema definitions
+*
+* @param client - LibSQL client
+* @param schemas - Schema definitions to create
+*/
+async function createTablesFromSchemas(client, schemas) {
+	for (const [tableName, schema] of Object.entries(schemas)) try {
+		if ((await client.execute({
+			sql: `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
+			args: [tableName]
+		})).rows.length > 0) {
+			console.log(`[sqlite] Table ${tableName} already exists, skipping`);
+			continue;
+		}
+		console.log(`[sqlite] Creating table ${tableName} from provided schema`);
+		await client.execute(schema.ddl);
+		if (schema.indexes && schema.indexes.length > 0) for (const indexSQL of schema.indexes) try {
+			await client.execute(indexSQL);
+		} catch (error) {
+			console.warn(`[sqlite] Failed to create index for ${tableName}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (schema.triggers && schema.triggers.length > 0) for (const triggerSQL of schema.triggers) try {
+			await client.execute(triggerSQL);
+		} catch (error) {
+			console.warn(`[sqlite] Failed to create trigger for ${tableName}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	} catch (error) {
+		console.error(`[sqlite] Error creating table ${tableName}:`, error instanceof Error ? error.message : String(error));
+		console.error(`[sqlite] DDL was:`, schema.ddl?.substring(0, 200) + "...");
+		throw new DatabaseError(`Failed to create table ${tableName} from schema: ${error instanceof Error ? error.message : String(error)}`, {
+			tableName,
+			schema,
+			originalError: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+/**
+* Creates a SQLite database adapter
+*
+* @param options - SQLite connection options
+* @returns Database interface for SQLite
+*/
+async function getDatabase(options = {}) {
+	validateDatabaseCacheOptions(options);
+	const url = options.url || ":memory:";
+	if (url === ":memory:" && !options.dbid && options.cache !== false) options.dbid = generateDbId();
+	if (options.secureFile) {
+		if (options.secureFile === true) throw new DatabaseError("Secure SQLite acquisition requires an explicit trusted-parent custody contract", { hint: "Use secureFile: { driver: 'node:sqlite', custody: 'trusted-parent' } after placing the database beneath a current-user-owned parent with no group/world write permission." });
+		const secureOptions = options.secureFile;
+		if (secureOptions.driver !== "node:sqlite") throw new DatabaseError(`Unsupported secure SQLite driver: ${String(secureOptions.driver)}`, { hint: "Use secureFile: { driver: 'node:sqlite', custody: 'trusted-parent' }." });
+		if (secureOptions.custody !== "trusted-parent") throw new DatabaseError("Secure SQLite acquisition requires trusted-parent custody", { hint: "Set custody: 'trusted-parent' only when the application controls the database parent directory." });
+		if (options.authToken || options.encryptionKey) throw new DatabaseError("Secure SQLite acquisition does not support LibSQL authentication or encryption options", { hint: "Remove authToken/encryptionKey for a local secure file, or disable secureFile to use LibSQL features." });
+		if (hasNativeSqliteCapabilities(options)) throw new DatabaseError("Secure SQLite acquisition cannot be combined with native SQLite capabilities", { hint: "Use either secureFile custody or optional native capabilities for a connection, not both." });
+		return getCachedSqliteDatabase("secure", options, () => createDatabase(options, url, () => createSecureSqliteClient(url, {
+			custody: secureOptions.custody,
+			root: secureOptions.root
+		})));
+	}
+	if (hasNativeSqliteCapabilities(options)) return (await import("./sqlite-native-ByGwGEbS.js")).getNativeSqliteDatabase(options);
+	return getCachedSqliteDatabase("libsql", options, () => createDatabase(options, url));
+}
+async function createDatabase(options, url, clientFactory = () => createLibSQLClient(options)) {
+	return (async () => {
+		const connectionLock = createTransactionLock("sqlite", options.transactionQueueTimeout);
+		const client = await clientFactory();
+		const executorContext = new AsyncLocalStorage();
+		const transactionCallbackContext = new AsyncLocalStorage();
+		const currentExecutor = () => executorContext.getStore() ?? client;
+		const resolvedSchemas = resolveSchemas(options.schemas);
+		if (resolvedSchemas && Object.keys(resolvedSchemas).length > 0) try {
+			await createTablesFromSchemas(client, resolvedSchemas);
+		} catch (error) {
+			try {
+				await client.close();
+			} catch (cleanupError) {
+				throw new AggregateError([error, cleanupError], "LibSQL schema initialization and cleanup failed");
+			}
+			throw error;
+		}
+		/**
+		* Serializes a value for SQLite storage
+		* Converts objects and arrays to JSON strings
+		* Converts Dates to ISO strings
+		* Passes through primitives unchanged
+		*/
+		const 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;
+		};
+		/**
+		* Serializes all values in an object
+		*/
+		const serializeRecord = (record) => {
+			const serialized = {};
+			for (const [key, value] of Object.entries(record)) {
+				if (value === void 0) continue;
+				serialized[key] = serializeValue(value);
+			}
+			return serialized;
+		};
+		const hasNullConflictValue = (conflictColumns, data) => conflictColumns.some((col) => data[col] === null);
+		const buildNullAwareUpsertLockKey = (table, conflictColumns) => {
+			const material = JSON.stringify({
+				url,
+				table: table.toLowerCase(),
+				conflicts: [...new Set(conflictColumns.map((column) => column.toLowerCase()))].sort()
+			});
+			return `sqlite-null-aware:${createHash("sha256").update(material).digest("hex")}`;
+		};
+		const validateUpsertConflictColumns = (table, conflictColumns, serializedData) => {
+			const missingColumns = conflictColumns.filter((col) => !(col 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 = async (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: (await currentExecutor().execute({
+					sql,
+					args: values
+				})).rowsAffected
+			};
+		};
+		const executeNullAwareUpsertAttempt = async (executor, table, conflictColumns, serializedData) => {
+			const keys = Object.keys(serializedData);
+			const values = Object.values(serializedData);
+			const updateSet = keys.map((key) => `${key} = ?`).join(", ");
+			const whereClause = conflictColumns.map((col) => `${col} IS ?`).join(" AND ");
+			const whereValues = conflictColumns.map((col) => serializedData[col]);
+			const updateSql = `UPDATE ${table} SET ${updateSet} WHERE ${whereClause}`;
+			const updateResult = await executor.execute({
+				sql: updateSql,
+				args: [...values, ...whereValues]
+			});
+			if ((updateResult.rowsAffected ?? 0) > 0) return {
+				operation: "upsert",
+				affected: updateResult.rowsAffected
+			};
+			const placeholders = keys.map(() => "?").join(", ");
+			const insertSql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
+			return {
+				operation: "upsert",
+				affected: (await executor.execute({
+					sql: insertSql,
+					args: values
+				})).rowsAffected
+			};
+		};
+		const executeNullAwareUpsertWithRetry = async (table, conflictColumns, serializedData, lockKey) => {
+			if (url === ":memory:") return withNullAwareUpsertLock(lockKey, () => executeNullAwareUpsertAttempt(client, table, conflictColumns, serializedData));
+			let lastError;
+			for (let attempt = 0; attempt < NULL_AWARE_UPSERT_MAX_ATTEMPTS; attempt++) {
+				let transaction;
+				const releaseConnection = await connectionLock.acquire();
+				try {
+					return await withNullAwareUpsertLock(lockKey, async () => {
+						transaction = await client.transaction("write");
+						const result = await executeNullAwareUpsertAttempt(transaction, table, conflictColumns, serializedData);
+						await transaction.commit();
+						return result;
+					});
+				} catch (error) {
+					lastError = error;
+					if (transaction && !transaction.closed) try {
+						await transaction.rollback();
+					} catch (rollbackError) {
+						lastError = combineTransactionFailures(lastError, rollbackError);
+					}
+				} finally {
+					transaction?.close();
+					releaseConnection();
+				}
+				if (lastError && attempt < NULL_AWARE_UPSERT_MAX_ATTEMPTS - 1 && isRetriableSqliteTransactionError(lastError)) {
+					await delay(NULL_AWARE_UPSERT_BASE_DELAY_MS * 2 ** attempt);
+					continue;
+				}
+				break;
+			}
+			throw lastError;
+		};
+		/**
+		* Rejects hostile table/column identifiers before an upsert builds SQL.
+		*
+		* Called from the public entry points rather than from `executeUpsert`, so
+		* the failure reaches the caller naming the bad identifier instead of being
+		* flattened into the wrapper's generic "Failed to upsert record into table".
+		*
+		* Validates the keys of the already-serialized snapshot — the exact array
+		* the executors interpolate — not a fresh enumeration of the caller's
+		* `data`. Enumerating `data` again could disagree with the snapshot if it is
+		* a Proxy whose `ownKeys` trap returns different keys on successive reads.
+		*/
+		const validateUpsertIdentifiers = (table, conflictColumns, serializedData) => {
+			validateTableName(table);
+			validateColumnNames([...conflictColumns, ...Object.keys(serializedData)]);
+		};
+		const executeUpsert = async (table, conflictColumns, serializedData, options, acquireTransaction) => {
+			validateUpsertConflictColumns(table, conflictColumns, serializedData);
+			if (options?.nullsDistinct || !hasNullConflictValue(conflictColumns, serializedData)) return executeStandardUpsert(table, conflictColumns, serializedData);
+			if (!acquireTransaction) {
+				const executor = currentExecutor();
+				return withNullAwareUpsertLock(buildNullAwareUpsertLockKey(table, conflictColumns), () => executeNullAwareUpsertAttempt(executor, table, conflictColumns, serializedData));
+			}
+			return executeNullAwareUpsertWithRetry(table, conflictColumns, serializedData, buildNullAwareUpsertLockKey(table, conflictColumns));
+		};
+		/**
+		* Inserts one or more records into a table
+		*
+		* @param table - Table name
+		* @param data - Single record or array of records to insert
+		* @returns Promise resolving to operation result
+		* @throws Error if the insert operation fails
+		*/
+		const insert = async (table, data) => {
+			validateTableName(table);
+			let sql;
+			let values;
+			if (Array.isArray(data)) {
+				if (data.length === 0) return {
+					operation: "insert",
+					affected: 0
+				};
+				const serializedRecords = data.map((record) => serializeRecord(record));
+				const keys = resolveInsertColumns(table, serializedRecords);
+				validateColumnNames(keys);
+				const placeholders = serializedRecords.map(() => `(${keys.map(() => "?").join(", ")})`).join(", ");
+				sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES ${placeholders}`;
+				values = serializedRecords.flatMap((record) => keys.map((key) => record[key]));
+			} else {
+				const serializedData = serializeRecord(data);
+				const keys = Object.keys(serializedData);
+				validateColumnNames(keys);
+				const placeholders = keys.map(() => "?").join(", ");
+				sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
+				values = Object.values(serializedData);
+			}
+			try {
+				return {
+					operation: "insert",
+					affected: (await currentExecutor().execute({
+						sql,
+						args: values
+					})).rowsAffected
+				};
+			} catch (e) {
+				throw new DatabaseError("Failed to insert records into table", {
+					table,
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Retrieves a single record matching the where criteria
+		*
+		* @param table - Table name
+		* @param where - Criteria to match records
+		* @returns Promise resolving to matching record or null if not found
+		* @throws Error if the query fails
+		*/
+		const get = async (table, where) => {
+			validateTableName(table);
+			const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
+			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 (await currentExecutor().execute({
+					sql,
+					args: values
+				})).rows[0] || null;
+			} catch (e) {
+				throw new DatabaseError("Failed to retrieve record from table", {
+					table,
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Retrieves multiple records matching the where criteria
+		*
+		* @param table - Table name
+		* @param where - Criteria to match records
+		* @returns Promise resolving to array of matching records
+		* @throws Error if the query fails
+		*/
+		const list = async (table, where) => {
+			validateTableName(table);
+			const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
+			const sql = `SELECT * FROM ${table} ${whereClause}`;
+			try {
+				return (await currentExecutor().execute({
+					sql,
+					args: values
+				})).rows;
+			} catch (e) {
+				throw new DatabaseError("Failed to list records from table", {
+					table,
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Updates records matching the where criteria
+		*
+		* @param table - Table name
+		* @param where - Criteria to match records to update
+		* @param data - New data to set
+		* @returns Promise resolving to operation result
+		* @throws Error if the update operation fails
+		*/
+		const update = async (table, where, data) => {
+			validateTableName(table);
+			const serializedData = serializeRecord(data);
+			const keys = Object.keys(serializedData);
+			validateColumnNames(keys);
+			const values = Object.values(serializedData);
+			const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
+			const { sql: whereClause, values: whereValues } = buildWhere(where, values.length + 1, "sqlite");
+			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: (await currentExecutor().execute({
+						sql,
+						args: [...values, ...whereValues]
+					})).rowsAffected
+				};
+			} catch (e) {
+				throw new DatabaseError("Failed to update records in table", {
+					table,
+					sql,
+					values: [...values, ...whereValues],
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Inserts a record or updates it if it already exists (UPSERT)
+		*
+		* @param table - Table name
+		* @param conflictColumns - Columns that define the uniqueness constraint
+		* @param data - Data to insert or update
+		* @returns Promise resolving to operation result
+		* @throws Error if the upsert operation fails
+		*/
+		const upsert = async (table, conflictColumns, data, options) => {
+			const serializedData = serializeRecord(data);
+			const conflictCols = [...conflictColumns];
+			validateUpsertIdentifiers(table, conflictCols, serializedData);
+			try {
+				return await executeUpsert(table, conflictCols, serializedData, options, true);
+			} catch (e) {
+				if (e instanceof DatabaseError && e.message === "Conflict columns missing from data") throw e;
+				throw new DatabaseError("Failed to upsert record into table", {
+					table,
+					values: data,
+					conflictColumns,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		let savepointSequence = 0;
+		const upsertInCurrentTransaction = async (table, conflictColumns, data, options) => {
+			const serializedData = serializeRecord(data);
+			const conflictCols = [...conflictColumns];
+			validateUpsertIdentifiers(table, conflictCols, serializedData);
+			try {
+				return await executeUpsert(table, conflictCols, serializedData, options, false);
+			} catch (e) {
+				if (e instanceof DatabaseError && e.message === "Conflict columns missing from data") throw e;
+				throw new DatabaseError("Failed to upsert record into table", {
+					table,
+					values: data,
+					conflictColumns,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Gets a record matching the where criteria or inserts it if not found
+		*
+		* @param table - Table name
+		* @param where - Criteria to match existing record
+		* @param data - Data to insert if no record found
+		* @returns Promise resolving to the record (either retrieved or newly inserted)
+		* @throws Error if the operation fails or if the record cannot be retrieved after insert
+		*/
+		const getOrInsert = async (table, where, data) => {
+			const result = await get(table, where);
+			if (result) return result;
+			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;
+		};
+		/**
+		* Deletes records from a table matching the where criteria
+		*
+		* @param table - Table name
+		* @param where - Criteria to match records for deletion
+		* @returns Promise resolving to operation result with count of deleted rows
+		* @throws Error if the delete operation fails
+		*/
+		const deleteRecords = async (table, where) => {
+			validateTableName(table);
+			if (Object.keys(where).length === 0) throw new DatabaseError("DELETE requires at least one WHERE condition to prevent accidental deletion of all records", { table });
+			const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
+			try {
+				await currentExecutor().execute({
+					sql: `DELETE FROM ${table} ${whereClause}`,
+					args: values
+				});
+				return {
+					operation: "delete",
+					affected: 1
+				};
+			} catch (e) {
+				throw new DatabaseError("Failed to delete records from table", {
+					table,
+					where,
+					originalError: e
+				});
+			}
+		};
+		/**
+		* Counts records in a table matching the where criteria
+		*
+		* @param table - Table name
+		* @param where - Criteria to match records (optional, counts all if omitted)
+		* @returns Promise resolving to count of matching records
+		* @throws Error if the count operation fails
+		*/
+		const count = async (table, where) => {
+			validateTableName(table);
+			try {
+				if (!where || Object.keys(where).length === 0) return toSafeSqliteCount((await currentExecutor().execute({
+					sql: `SELECT COUNT(*) as count FROM ${table}`,
+					args: []
+				})).rows[0]?.count);
+				const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
+				return toSafeSqliteCount((await currentExecutor().execute({
+					sql: `SELECT COUNT(*) as count FROM ${table} ${whereClause}`,
+					args: values
+				})).rows[0]?.count);
+			} catch (e) {
+				if (e instanceof DatabaseError) throw e;
+				throw new DatabaseError("Failed to count records in table", {
+					table,
+					where,
+					originalError: e
+				});
+			}
+		};
+		/**
+		* Checks if a table exists in the database
+		*
+		* @param tableName - Name of the table to check
+		* @returns Promise resolving to boolean indicating if the table exists
+		*/
+		const tableExists = async (tableName) => {
+			return !!await pluck`SELECT name FROM sqlite_master WHERE type='table' AND name=${tableName}`;
+		};
+		/**
+		* Synchronizes database schema with provided SQL DDL
+		* Creates tables if they don't exist and adds missing columns
+		*
+		* @param schema - SQL schema definition with CREATE TABLE statements
+		* @returns Promise that resolves when schema is synchronized
+		*/
+		const syncSchema = async (schema) => {
+			console.log("[sqlite.syncSchema] Starting schema sync for dbid:", options.dbid);
+			console.log("[sqlite.syncSchema] Schema length:", schema.length, "chars");
+			const reservedKeywords = /* @__PURE__ */ new Set([
+				"references",
+				"order",
+				"group",
+				"table",
+				"index",
+				"select",
+				"from",
+				"where",
+				"join",
+				"left",
+				"right",
+				"inner",
+				"outer",
+				"on",
+				"as",
+				"and",
+				"or",
+				"not",
+				"like",
+				"in",
+				"between",
+				"case",
+				"when",
+				"then",
+				"else",
+				"end",
+				"union",
+				"distinct",
+				"having",
+				"limit",
+				"offset",
+				"default",
+				"check",
+				"unique",
+				"primary",
+				"foreign",
+				"key",
+				"constraint",
+				"cascade"
+			]);
+			let normalizedSchema = schema.replace(/\s+/g, " ").replace(/DEFAULT CAST\(([^)]+)\s+AS\s+\w+\)/gi, "DEFAULT $1").trim();
+			normalizedSchema = normalizedSchema.replace(/"(\w+)"/g, (match, identifier) => {
+				return reservedKeywords.has(identifier.toLowerCase()) ? match : identifier;
+			});
+			console.log("[sqlite.syncSchema] Normalized schema:", normalizedSchema);
+			const commands = normalizedSchema.split(";").map((cmd) => cmd.trim()).filter((cmd) => cmd.length > 0);
+			console.log("[sqlite.syncSchema] Found", commands.length, "commands to process");
+			for (const command of commands) try {
+				console.log("[sqlite.syncSchema] Executing:", `${command.substring(0, 50)}...`);
+				await currentExecutor().execute(command);
+				console.log("[sqlite.syncSchema] Successfully executed command");
+			} catch (error) {
+				console.error("[sqlite.syncSchema] Failed to execute command:", command);
+				console.error("[sqlite.syncSchema] Error:", error);
+				throw error;
+			}
+		};
+		const createNestedTransaction = (transactionClient) => {
+			const scopeContext = new AsyncLocalStorage();
+			const rootScope = {
+				accepting: true,
+				tail: Promise.resolve(),
+				children: /* @__PURE__ */ new Set()
+			};
+			const enqueueInScope = (scope, operation) => {
+				if (!scope.accepting) return Promise.reject(new DatabaseError("Nested transaction scope is ending", {}));
+				const current = scope.tail.then(operation);
+				scope.tail = current.then(() => void 0, () => void 0);
+				return current;
+			};
+			const assertBoundScope = (scope) => {
+				const ambientScope = scopeContext.getStore();
+				if (ambientScope && ambientScope !== scope) throw new DatabaseError("A parent transaction handle cannot run inside a nested transaction callback", { hint: "Use the nested callback transaction handle, or wait for the nested transaction to settle before using its parent handle." });
+			};
+			const runBoundOperation = (scope, operation) => {
+				try {
+					assertBoundScope(scope);
+					return enqueueInScope(scope, operation);
+				} catch (error) {
+					return Promise.reject(error);
+				}
+			};
+			const drainNestedScope = async (scope) => {
+				await scope.tail;
+				while (expandPromiseObservations(scope.children).some((child) => child.handlers.size > 0)) await Promise.all(expandPromiseObservations(scope.children).flatMap((child) => [...child.handlers]));
+				await settleNativePromiseTransfers(scope.children);
+				const failures = expandPromiseObservations(scope.children).filter((child) => !child.observed && "error" in child).map((child) => child.error);
+				if (failures.length === 1) throw failures[0];
+				if (failures.length > 1) throw new AggregateError(failures, "Accepted nested transactions failed");
+			};
+			const runScope = async (scope, callback) => {
+				savepointSequence += 1;
+				const name = `hv_sp_${savepointSequence}`;
+				await transactionClient.execute({
+					sql: `SAVEPOINT ${name}`,
+					args: []
+				});
+				const callbackScope = createTransactionScope(transactionClient, nestedTransaction, (operation) => runBoundOperation(scope, operation), (nestedCallback) => {
+					try {
+						assertBoundScope(scope);
+						return startNested(scope, nestedCallback);
+					} catch (error) {
+						return Promise.reject(error);
+					}
+				});
+				const drainScope = async () => {
+					await callbackScope.sealAndDrain();
+					await drainNestedScope(scope);
+				};
+				try {
+					const result = await callback(callbackScope.database);
+					scope.accepting = false;
+					await drainScope();
+					await transactionClient.execute({
+						sql: `RELEASE SAVEPOINT ${name}`,
+						args: []
+					});
+					return result;
+				} catch (error) {
+					scope.accepting = false;
+					let failure = error;
+					try {
+						await drainScope();
+					} catch (drainError) {
+						if (drainError !== error) failure = combineTransactionFailures(error, drainError);
+					}
+					try {
+						await transactionClient.execute({
+							sql: `ROLLBACK TO SAVEPOINT ${name}`,
+							args: []
+						});
+						await transactionClient.execute({
+							sql: `RELEASE SAVEPOINT ${name}`,
+							args: []
+						});
+					} catch (teardownError) {
+						if (teardownError !== failure) failure = combineTransactionFailures(failure, teardownError);
+					}
+					throw failure;
+				}
+			};
+			const startNested = (parentScope, callback) => {
+				if (!parentScope.accepting) return Promise.reject(new DatabaseError("Nested transaction scope is ending", {}));
+				const scope = {
+					accepting: true,
+					tail: Promise.resolve(),
+					children: /* @__PURE__ */ new Set()
+				};
+				const child = {
+					observed: false,
+					handlers: /* @__PURE__ */ new Set(),
+					nativeTransfers: /* @__PURE__ */ new Set(),
+					unhandledNativeTransfers: /* @__PURE__ */ new Set(),
+					nativeCorrelationIds: /* @__PURE__ */ new Set()
+				};
+				parentScope.children.add(child);
+				const current = enqueueInScope(parentScope, () => scopeContext.run(scope, () => runScope(scope, callback)));
+				current.catch((error) => {
+					child.error = error;
+				});
+				return withRejectionObservation(current, child);
+			};
+			const nestedTransaction = ((callback) => startNested(scopeContext.getStore() ?? rootScope, callback));
+			nestedTransaction.drain = () => {
+				rootScope.accepting = false;
+				return drainNestedScope(rootScope);
+			};
+			nestedTransaction.runOperation = (operation) => runBoundOperation(rootScope, operation);
+			nestedTransaction.runNested = (callback) => {
+				try {
+					assertBoundScope(rootScope);
+					return startNested(rootScope, callback);
+				} catch (error) {
+					return Promise.reject(error);
+				}
+			};
+			return nestedTransaction;
+		};
+		/**
+		* Executes a callback within a database transaction
+		* Automatically commits on success or rolls back on error
+		*
+		* @param callback - Function to execute within transaction
+		* @returns Promise resolving to callback result
+		*/
+		const transaction = async (callback, preAcquiredLock) => {
+			const releaseConnection = await (preAcquiredLock ?? connectionLock.acquire());
+			try {
+				if (client.transactionReservation !== "exclusive") {
+					let nestedTransaction;
+					let transactionScope;
+					try {
+						await client.execute({
+							sql: "BEGIN TRANSACTION",
+							args: []
+						});
+						nestedTransaction = createNestedTransaction(client);
+						transactionScope = createTransactionScope(client, nestedTransaction);
+						const activeScope = transactionScope;
+						const result = await transactionCallbackContext.run(true, () => callback(activeScope.database));
+						await transactionScope.sealAndDrain();
+						await nestedTransaction.drain();
+						await client.execute({
+							sql: "COMMIT",
+							args: []
+						});
+						return result;
+					} catch (error) {
+						let failure = error;
+						try {
+							await transactionScope?.sealAndDrain();
+						} catch (drainError) {
+							if (drainError !== error) failure = combineTransactionFailures(failure, drainError);
+						}
+						try {
+							await nestedTransaction?.drain();
+						} catch (drainError) {
+							if (drainError !== failure) failure = combineTransactionFailures(failure, drainError);
+						}
+						try {
+							await client.execute({
+								sql: "ROLLBACK",
+								args: []
+							});
+						} catch {}
+						throw failure;
+					}
+				}
+				const transactionClient = await client.transaction("write");
+				let nestedTransaction;
+				let transactionScope;
+				try {
+					nestedTransaction = createNestedTransaction(transactionClient);
+					transactionScope = createTransactionScope(transactionClient, nestedTransaction);
+					const activeScope = transactionScope;
+					const result = await transactionCallbackContext.run(true, () => callback(activeScope.database));
+					await transactionScope.sealAndDrain();
+					await nestedTransaction.drain();
+					await transactionClient.commit();
+					return result;
+				} catch (error) {
+					let failure = error;
+					try {
+						await transactionScope?.sealAndDrain();
+					} catch (drainError) {
+						if (drainError !== error) failure = combineTransactionFailures(failure, drainError);
+					}
+					try {
+						await nestedTransaction?.drain();
+					} catch (drainError) {
+						if (drainError !== failure) failure = combineTransactionFailures(failure, drainError);
+					}
+					if (!transactionClient.closed) try {
+						await transactionClient.rollback();
+					} catch (rollbackError) {
+						failure = combineTransactionFailures(failure, rollbackError);
+					}
+					throw failure;
+				} finally {
+					transactionClient.close();
+				}
+			} finally {
+				releaseConnection();
+			}
+		};
+		/**
+		* Builds the transaction-scoped interface handed to a transaction callback.
+		*
+		* The only difference from the top-level interface is `transaction`: this
+		* one re-enters the transaction already in progress under a savepoint
+		* instead of issuing a second BEGIN. SQLite shares one connection, so the
+		* old behaviour of re-exposing the top-level `transaction` sent a nested
+		* call into `BEGIN` on a connection that was already in a transaction; that
+		* throws, and the nested call's own ROLLBACK then discarded the *enclosing*
+		* transaction's work while later writes silently committed in autocommit.
+		*/
+		const createTransactionScope = (transactionClient, nestedTransaction, runOperation = nestedTransaction.runOperation, runNested = nestedTransaction.runNested) => {
+			const isSecureTransaction = client.transactionReservation === "exclusive";
+			const scopedExecutor = isSecureTransaction ? { execute: (statement) => {
+				return transactionClient.execute(prepareManagedStatement(statement));
+			} } : transactionClient;
+			let accepting = true;
+			const pending = /* @__PURE__ */ new Set();
+			const operations = /* @__PURE__ */ new Set();
+			let drainPromise;
+			const bind = (fn, trackFailure = true) => ((...args) => {
+				if (!accepting) return Promise.reject(new DatabaseError("Transaction scope is ending or ended", {}));
+				const run = () => Promise.resolve(executorContext.run(scopedExecutor, () => fn(...args)));
+				const operation = isSecureTransaction ? runOperation(run) : run();
+				const tracked = {
+					observed: false,
+					handlers: /* @__PURE__ */ new Set(),
+					nativeTransfers: /* @__PURE__ */ new Set(),
+					unhandledNativeTransfers: /* @__PURE__ */ new Set(),
+					nativeCorrelationIds: /* @__PURE__ */ new Set()
+				};
+				operations.add(tracked);
+				pending.add(operation);
+				operation.then(() => pending.delete(operation), (error) => {
+					pending.delete(operation);
+					if (trackFailure) tracked.error = error;
+				});
+				return withRejectionObservation(operation, tracked);
+			});
+			const scopedInsert = bind(insert);
+			const scopedGet = bind(get);
+			const scopedList = bind(list);
+			const scopedUpdate = bind(update);
+			const scopedUpsert = bind(upsertInCurrentTransaction);
+			const scopedGetOrInsert = bind(getOrInsert);
+			const scopedDelete = bind(deleteRecords);
+			const scopedCount = bind(count);
+			const scopedMany = bind(many);
+			const scopedSingle = bind(single);
+			const scopedPluck = bind(pluck);
+			const scopedExecute = bind(execute);
+			const scopedQuery = bind(query);
+			const scopedTableExists = bind(tableExists);
+			const scopedSyncSchema = bind(syncSchema);
+			const scopedTable = (tableName) => {
+				if (!accepting) {
+					const reject = () => Promise.reject(new DatabaseError("Transaction scope is ending or ended", {}));
+					return {
+						insert: reject,
+						get: reject,
+						list: reject
+					};
+				}
+				return {
+					insert: (data) => scopedInsert(tableName, data),
+					get: (where) => scopedGet(tableName, where),
+					list: (where) => scopedList(tableName, where)
+				};
+			};
+			const scopedTransaction = ((callback) => {
+				if (!accepting) return Promise.reject(new DatabaseError("Transaction scope is ending or ended", {}));
+				return executorContext.run(scopedExecutor, () => runNested(callback));
+			});
+			const scopedClient = {
+				transactionReservation: "exclusive",
+				execute: bind((statement) => scopedExecutor.execute(statement)),
+				transaction: () => Promise.reject(new DatabaseError("Use the transaction scope transaction() method instead of client.transaction()", {})),
+				close: () => Promise.reject(new DatabaseError("Transaction-scoped SQLite clients cannot be closed directly", {}))
+			};
+			return {
+				database: {
+					url,
+					client: client.transactionReservation === "exclusive" ? scopedClient : transactionClient,
+					insert: scopedInsert,
+					get: scopedGet,
+					list: scopedList,
+					update: scopedUpdate,
+					upsert: scopedUpsert,
+					getOrInsert: scopedGetOrInsert,
+					delete: scopedDelete,
+					count: scopedCount,
+					table: scopedTable,
+					many: scopedMany,
+					single: scopedSingle,
+					pluck: scopedPluck,
+					execute: scopedExecute,
+					query: scopedQuery,
+					oo: scopedMany,
+					oO: scopedSingle,
+					ox: scopedPluck,
+					xx: scopedExecute,
+					tableExists: scopedTableExists,
+					syncSchema: scopedSyncSchema,
+					transaction: scopedTransaction
+				},
+				sealAndDrain: async () => {
+					accepting = false;
+					drainPromise ??= (async () => {
+						while (pending.size > 0) await Promise.allSettled([...pending]);
+						while (expandPromiseObservations(operations).some((entry) => entry.handlers.size > 0)) await Promise.all(expandPromiseObservations(operations).flatMap((entry) => [...entry.handlers]));
+						await settleNativePromiseTransfers(operations);
+						const failures = expandPromiseObservations(operations).filter((operation) => !operation.observed && "error" in operation).map((operation) => operation.error);
+						if (failures.length === 1) throw failures[0];
+						if (failures.length > 1) throw new AggregateError(failures, "Accepted transaction operations failed");
+					})();
+					return drainPromise;
+				}
+			};
+		};
+		/**
+		* Begins a new transaction and returns a handle for manual control
+		*
+		* Unlike transaction(), this gives you explicit control over commit/rollback.
+		* Ideal for test isolation where you want to rollback after each test.
+		*
+		* @returns Promise resolving to a TransactionHandle
+		*/
+		const beginTransaction = async (preAcquiredLock) => {
+			const releaseConnection = await (preAcquiredLock ?? connectionLock.acquire());
+			let transactionClient;
+			try {
+				if (client.transactionReservation === "exclusive") transactionClient = await client.transaction("write");
+				else await client.execute({
+					sql: "BEGIN TRANSACTION",
+					args: []
+				});
+			} catch (error) {
+				releaseConnection();
+				throw error;
+			}
+			let active = true;
+			let nestedTransaction;
+			let transactionScope;
+			const end = async (command) => {
+				if (!active) throw new DatabaseError("Transaction already ended", {});
+				active = false;
+				try {
+					let drainFailure;
+					try {
+						await transactionScope?.sealAndDrain();
+					} catch (error) {
+						drainFailure = error;
+					}
+					try {
+						await nestedTransaction?.drain();
+					} catch (error) {
+						drainFailure = drainFailure ? combineTransactionFailures(drainFailure, error) : error;
+					}
+					if (drainFailure) throw drainFailure;
+					if (transactionClient) if (command === "COMMIT") await transactionClient.commit();
+					else await transactionClient.rollback();
+					else await client.execute({
+						sql: command,
+						args: []
+					});
+				} catch (error) {
+					let failure = error;
+					if (transactionClient && !transactionClient.closed) try {
+						await transactionClient.rollback();
+					} catch (rollbackError) {
+						failure = combineTransactionFailures(failure, rollbackError);
+					}
+					else if (!transactionClient) try {
+						await client.execute({
+							sql: "ROLLBACK",
+							args: []
+						});
+					} catch (rollbackError) {
+						failure = combineTransactionFailures(failure, rollbackError);
+					}
+					throw failure;
+				} finally {
+					transactionClient?.close();
+					releaseConnection();
+				}
+			};
+			const commit = () => end("COMMIT");
+			const rollback = () => end("ROLLBACK");
+			const isActive = () => active;
+			const executor = transactionClient ?? client;
+			nestedTransaction = createNestedTransaction(executor);
+			transactionScope = createTransactionScope(executor, nestedTransaction);
+			return {
+				...transactionScope.database,
+				commit,
+				rollback,
+				isActive
+			};
+		};
+		/**
+		* Creates a table-specific interface for simplified table operations
+		*
+		* @param tableName - Table name
+		* @returns TableInterface for the specified table
+		*/
+		const table = (tableName) => ({
+			insert: (data) => insert(tableName, data),
+			get: (where) => get(tableName, where),
+			list: (where) => list(tableName, where)
+		});
+		/**
+		* Parses a tagged template literal into a SQL query and values
+		*
+		* @param strings - Template strings
+		* @param vars - Variables to interpolate into the query
+		* @returns Object with SQL query and values array
+		*/
+		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
+			};
+		};
+		/**
+		* Executes a SQL query using template literals and returns a single value
+		*
+		* @param strings - Template strings
+		* @param vars - Variables to interpolate into the query
+		* @returns Promise resolving to a single value (first column of first row)
+		* @throws Error if the query fails
+		*/
+		const pluck = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				const result = await currentExecutor().execute({
+					sql,
+					args: values
+				});
+				return result.rows[0]?.[Object.keys(result.rows[0])[0]] ?? null;
+			} catch (e) {
+				throw new DatabaseError("Failed to execute pluck query", {
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Executes a SQL query using template literals and returns a single row
+		*
+		* @param strings - Template strings
+		* @param vars - Variables to interpolate into the query
+		* @returns Promise resolving to a single result record or null
+		* @throws Error if the query fails
+		*/
+		const single = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				return (await currentExecutor().execute({
+					sql,
+					args: values
+				})).rows[0] || null;
+			} catch (e) {
+				throw new DatabaseError("Failed to execute single query", {
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Executes a SQL query using template literals and returns multiple rows
+		*
+		* @param strings - Template strings
+		* @param vars - Variables to interpolate into the query
+		* @returns Promise resolving to array of result records
+		* @throws Error if the query fails
+		*/
+		const many = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				return (await currentExecutor().execute({
+					sql,
+					args: values
+				})).rows;
+			} catch (e) {
+				throw new DatabaseError("Failed to execute many query", {
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Executes a SQL query using template literals without returning results
+		*
+		* @param strings - Template strings
+		* @param vars - Variables to interpolate into the query
+		* @returns Promise that resolves when the query completes
+		* @throws Error if the query fails
+		*/
+		const execute = async (strings, ...vars) => {
+			const { sql, values } = parseTemplate(strings, ...vars);
+			try {
+				await currentExecutor().execute({
+					sql,
+					args: values
+				});
+			} catch (e) {
+				throw new DatabaseError("Failed to execute query", {
+					sql,
+					values,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* Executes a raw SQL query with parameterized values
+		*
+		* @param str - SQL query string
+		* @param values - Variables to use as parameters
+		* @returns Promise resolving to query result with rows and metadata
+		* @throws Error if the query fails
+		*/
+		const query = async (str, ...values) => {
+			const sql = str;
+			const args = Array.isArray(values[0]) ? values[0] : values;
+			try {
+				const result = await currentExecutor().execute({
+					sql,
+					args
+				});
+				return {
+					command: sql.split(" ")[0].toUpperCase(),
+					rowCount: result.rowsAffected ?? result.rows.length,
+					oid: null,
+					fields: Object.keys(result.rows[0] || {}).map((name) => ({
+						name,
+						tableID: 0,
+						columnID: 0,
+						dataTypeID: 0,
+						dataTypeSize: -1,
+						dataTypeModifier: -1,
+						format: "text"
+					})),
+					rows: result.rows
+				};
+			} catch (e) {
+				throw wrapDatabaseError("Failed to execute raw query", e, {
+					sql,
+					args
+				});
+			}
+		};
+		const oo = many;
+		const oO = single;
+		const ox = pluck;
+		const xx = execute;
+		/**
+		* Initialize database schemas from JSON manifest
+		* Supports dependency resolution and schema overrides
+		*
+		* @param options - Schema initialization options
+		* @returns Promise that resolves when schemas are initialized
+		*/
+		const initializeSchemas = async (options) => {
+			const schemaManager = new DatabaseSchemaManager();
+			const currentDb = {
+				url,
+				client,
+				query,
+				insert,
+				update,
+				upsert,
+				get,
+				list,
+				getOrInsert,
+				delete: deleteRecords,
+				count,
+				table,
+				tableExists,
+				many,
+				single,
+				pluck,
+				execute,
+				oo,
+				oO,
+				ox,
+				xx,
+				syncSchema,
+				transaction
+			};
+			await schemaManager.initializeSchemas(currentDb, options);
+		};
+		/**
+		* Retrieves the schema information for a table
+		*
+		* @param table - Table name
+		* @returns Promise resolving to table schema info or null if table doesn't exist
+		* @throws Error if the query fails
+		*/
+		const getTableSchema = async (table) => {
+			validateTableName(table);
+			try {
+				if (!await tableExists(table)) return null;
+				const columnRows = await many`SELECT * FROM pragma_table_info(${table})`;
+				const columns = {};
+				for (const row of columnRows) {
+					const colName = row.name;
+					columns[colName] = {
+						type: row.type,
+						primaryKey: row.pk === 1,
+						notNull: row.notnull === 1,
+						defaultValue: row.dflt_value
+					};
+				}
+				const indexRows = await many`
+        SELECT name, sql FROM sqlite_master
+        WHERE type = 'index'
+          AND tbl_name = ${table}
+          AND name NOT LIKE 'sqlite_%'
+      `;
+				const indexes = [];
+				for (const row of indexRows) {
+					const indexName = row.name;
+					const indexInfoRows = await many`SELECT * FROM pragma_index_info(${indexName})`;
+					const indexColumns = [];
+					for (const infoRow of indexInfoRows) indexColumns.push(infoRow.name);
+					const indexListRow = await single`SELECT * FROM pragma_index_list(${table}) WHERE name = ${indexName}`;
+					indexes.push({
+						name: indexName,
+						columns: indexColumns,
+						unique: indexListRow?.unique === 1
+					});
+				}
+				const fkRows = await many`SELECT * FROM pragma_foreign_key_list(${table})`;
+				const foreignKeys = [];
+				for (const fkRow of fkRows) foreignKeys.push({
+					column: fkRow.from,
+					referencesTable: fkRow.table,
+					referencesColumn: fkRow.to,
+					onDelete: fkRow.on_delete,
+					onUpdate: fkRow.on_update
+				});
+				return {
+					tableName: table,
+					columns,
+					indexes,
+					foreignKeys
+				};
+			} catch (e) {
+				throw new DatabaseError("Failed to retrieve table schema", {
+					table,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		/**
+		* ALTER TABLE operations for schema evolution
+		*/
+		const alterTable = {
+			/**
+			* Adds a new column to an existing table
+			*
+			* @param table - Table name
+			* @param column - Column definition with name
+			* @returns Promise that resolves when column is added
+			* @throws Error if the alter operation fails
+			*/
+			addColumn: async (table, column) => {
+				validateTableName(table);
+				validateColumnName(column.name);
+				let sql;
+				try {
+					sql = generateAddColumnStatement(table, column, "sqlite");
+					await currentExecutor().execute({
+						sql,
+						args: []
+					});
+				} catch (e) {
+					throw wrapDatabaseError("Failed to add column to table", e, {
+						table,
+						column: column.name,
+						...sql ? { sql } : {}
+					});
+				}
+			},
+			/**
+			* Adds a new index to an existing table
+			*
+			* @param table - Table name
+			* @param index - Index definition
+			* @returns Promise that resolves when index is created
+			* @throws Error if the create index operation fails
+			*/
+			addIndex: async (table, index) => {
+				validateTableName(table);
+				validateIndexName(index.name);
+				for (const col of index.columns) validateColumnName(col);
+				let sql;
+				try {
+					sql = generateCreateIndexStatement(table, index);
+					await currentExecutor().execute({
+						sql,
+						args: []
+					});
+				} catch (e) {
+					throw wrapDatabaseError("Failed to create index on table", e, {
+						table,
+						index: index.name,
+						...sql ? { sql } : {}
+					});
+				}
+			}
+		};
+		let closed = false;
+		const rawClose = async () => {
+			if (closed) return;
+			await client.close();
+			closed = true;
+		};
+		const db = {
+			url,
+			client,
+			query,
+			insert,
+			update,
+			upsert,
+			get,
+			list,
+			getOrInsert,
+			delete: deleteRecords,
+			count,
+			table,
+			tableExists,
+			many,
+			single,
+			pluck,
+			execute,
+			oo,
+			oO,
+			ox,
+			xx,
+			syncSchema,
+			initializeSchemas,
+			transaction,
+			beginTransaction,
+			getTableSchema,
+			alterTable,
+			close: rawClose
+		};
+		if (client.transactionReservation !== "exclusive") return db;
+		const barrier = createInvocationBarrier();
+		const managedRootExecutor = { execute: (statement) => {
+			return client.execute(prepareManagedStatement(statement));
+		} };
+		const rootCallbackError = (operation) => operation === "close" ? new DatabaseError("Cannot close the SQLite database from inside its active transaction callback", { hint: "Finish the transaction callback before closing the database." }) : new DatabaseError("Cannot use the root SQLite database from inside its active transaction callback", { hint: "Use the transaction-scoped database passed to the callback." });
+		const reservedClose = () => {
+			if (transactionCallbackContext.getStore() === true) return Promise.reject(rootCallbackError("close"));
+			return barrier.close(async () => {
+				if (connectionLock.held) (await connectionLock.acquire())();
+				await rawClose();
+			});
+		};
+		const reserveManaged = (fn) => ((...args) => {
+			if (transactionCallbackContext.getStore() === true) return Promise.reject(rootCallbackError("use"));
+			const timeoutMs = options.transactionQueueTimeout ?? 3e4;
+			let expired = false;
+			let timer;
+			const deadline = new Promise((_, reject) => {
+				timer = setTimeout(() => {
+					expired = true;
+					reject(new DatabaseError(`Timed out after ${timeoutMs}ms waiting for the sqlite connection's current operation to finish`, {
+						adapter: "sqlite",
+						timeoutMs
+					}));
+				}, timeoutMs);
+			});
+			const queued = barrier.run(async () => {
+				if (expired) return deadline;
+				if (timer) {
+					clearTimeout(timer);
+					timer = void 0;
+				}
+				if (connectionLock.held) (await connectionLock.acquire())();
+				return executorContext.run(managedRootExecutor, () => fn(...args));
+			});
+			return Promise.race([queued, deadline]).finally(() => {
+				if (timer) clearTimeout(timer);
+			});
+		});
+		const reservedTable = (tableName) => {
+			const scoped = table(tableName);
+			return {
+				insert: reserveManaged(scoped.insert),
+				get: reserveManaged(scoped.get),
+				list: reserveManaged(scoped.list)
+			};
+		};
+		const reservedAlterTable = {
+			addColumn: reserveManaged(alterTable.addColumn),
+			addIndex: reserveManaged(alterTable.addIndex)
+		};
+		const reserveTransactionEntry = (work) => {
+			if (transactionCallbackContext.getStore() === true) return Promise.reject(rootCallbackError("use"));
+			const timeoutMs = options.transactionQueueTimeout ?? 3e4;
+			let expired = false;
+			let timer;
+			const deadline = new Promise((_, reject) => {
+				timer = setTimeout(() => {
+					expired = true;
+					reject(new DatabaseError(`Timed out after ${timeoutMs}ms waiting for the sqlite connection's current transaction to finish`, {
+						adapter: "sqlite",
+						timeoutMs
+					}));
+				}, timeoutMs);
+			});
+			const queued = barrier.run(async () => {
+				if (expired) return deadline;
+				const acquisition = connectionLock.acquire();
+				try {
+					const release = await Promise.race([acquisition, deadline]);
+					if (expired) {
+						release();
+						return deadline;
+					}
+					if (timer) {
+						clearTimeout(timer);
+						timer = void 0;
+					}
+					return work(Promise.resolve(release));
+				} catch (error) {
+					if (expired) acquisition.then((release) => release(), () => {});
+					throw error;
+				}
+			});
+			return Promise.race([queued, deadline]).finally(() => {
+				if (timer) clearTimeout(timer);
+			});
+		};
+		const reservedTransaction = (callback) => reserveTransactionEntry((preAcquiredLock) => transaction(callback, preAcquiredLock));
+		const reservedBeginTransaction = () => reserveTransactionEntry((preAcquiredLock) => beginTransaction(preAcquiredLock));
+		const reservedClient = {
+			transactionReservation: "exclusive",
+			execute: reserveManaged(async (statement) => {
+				return client.execute(prepareManagedStatement(statement));
+			}),
+			transaction: () => Promise.reject(new DatabaseError("Use database.transaction() or database.beginTransaction() instead of client.transaction()", {})),
+			close: reservedClose
+		};
+		return {
+			...db,
+			client: reservedClient,
+			query: reserveManaged(query),
+			insert: reserveManaged(insert),
+			update: reserveManaged(update),
+			upsert: reserveManaged(upsert),
+			get: reserveManaged(get),
+			list: reserveManaged(list),
+			getOrInsert: reserveManaged(getOrInsert),
+			delete: reserveManaged(deleteRecords),
+			count: reserveManaged(count),
+			table: reservedTable,
+			tableExists: reserveManaged(tableExists),
+			many: reserveManaged(many),
+			single: reserveManaged(single),
+			pluck: reserveManaged(pluck),
+			execute: reserveManaged(execute),
+			oo: reserveManaged(oo),
+			oO: reserveManaged(oO),
+			ox: reserveManaged(ox),
+			xx: reserveManaged(xx),
+			syncSchema: reserveManaged(syncSchema),
+			initializeSchemas: reserveManaged(initializeSchemas),
+			transaction: reservedTransaction,
+			beginTransaction: reservedBeginTransaction,
+			getTableSchema: reserveManaged(getTableSchema),
+			alterTable: reservedAlterTable,
+			close: reservedClose
+		};
+	})();
+}
+//#endregion
+export { getDatabase };
+
+//# sourceMappingURL=sqlite-Cz2NMiDs.js.map