@yorozu/db-sqlite 0.5.0

package/index.js

@@ -0,0 +1,2365 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+//#region src/handle.ts
+function bindArgs(params) {
+	return params === void 0 ? [] : [...params];
+}
+/** Wrap a better-sqlite3 Database. Array bind: `stmt.run(...params)`. */
+function wrapBetterSqlite3(db) {
+	return {
+		exec(sql) {
+			db.exec(sql);
+		},
+		prepare(sql) {
+			let stmt = db.prepare(sql);
+			return {
+				run(params) {
+					stmt.run(...bindArgs(params));
+				},
+				all(params) {
+					return stmt.all(...bindArgs(params));
+				},
+				get(params) {
+					return stmt.get(...bindArgs(params));
+				}
+			};
+		},
+		transaction(fn) {
+			return db.transaction(fn)();
+		},
+		close() {
+			db.close();
+		}
+	};
+}
+//#endregion
+//#region __vite-browser-external
+var require___vite_browser_external = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/util.js
+var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.getBooleanOption = (options, key) => {
+		let value = false;
+		if (key in options && typeof (value = options[key]) !== "boolean") throw new TypeError(`Expected the "${key}" option to be a boolean`);
+		return value;
+	};
+	exports.cppdb = Symbol();
+	exports.inspect = Symbol.for("nodejs.util.inspect.custom");
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var descriptor = {
+		value: "SqliteError",
+		writable: true,
+		enumerable: false,
+		configurable: true
+	};
+	function SqliteError(message, code) {
+		if (new.target !== SqliteError) return new SqliteError(message, code);
+		if (typeof code !== "string") throw new TypeError("Expected second argument to be a string");
+		Error.call(this, message);
+		descriptor.value = "" + message;
+		Object.defineProperty(this, "message", descriptor);
+		Error.captureStackTrace(this, SqliteError);
+		this.code = code;
+	}
+	Object.setPrototypeOf(SqliteError, Error);
+	Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+	Object.defineProperty(SqliteError.prototype, "name", descriptor);
+	module.exports = SqliteError;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	*/
+	var sep = require___vite_browser_external().sep || "/";
+	/**
+	* Module exports.
+	*/
+	module.exports = fileUriToPath;
+	/**
+	* File URI to Path function.
+	*
+	* @param {String} uri
+	* @return {String} path
+	* @api public
+	*/
+	function fileUriToPath(uri) {
+		if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) throw new TypeError("must pass in a file:// URI to convert to a file path");
+		var rest = decodeURI(uri.substring(7));
+		var firstSlash = rest.indexOf("/");
+		var host = rest.substring(0, firstSlash);
+		var path = rest.substring(firstSlash + 1);
+		if ("localhost" == host) host = "";
+		if (host) host = sep + sep + host;
+		path = path.replace(/^(.+)\|/, "$1:");
+		if (sep == "\\") path = path.replace(/\//g, "\\");
+		if (/^.+\:/.test(path)) {} else path = sep + path;
+		return host + path;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js
+var require_bindings = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	*/
+	var fs = require___vite_browser_external(), path = require___vite_browser_external(), fileURLToPath = require_file_uri_to_path(), join = path.join, dirname = path.dirname, exists = fs.accessSync && function(path) {
+		try {
+			fs.accessSync(path);
+		} catch (e) {
+			return false;
+		}
+		return true;
+	} || fs.existsSync || path.existsSync, defaults = {
+		arrow: process.env.NODE_BINDINGS_ARROW || " → ",
+		compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+		platform: process.platform,
+		arch: process.arch,
+		nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+		version: process.versions.node,
+		bindings: "bindings.node",
+		try: [
+			[
+				"module_root",
+				"build",
+				"bindings"
+			],
+			[
+				"module_root",
+				"build",
+				"Debug",
+				"bindings"
+			],
+			[
+				"module_root",
+				"build",
+				"Release",
+				"bindings"
+			],
+			[
+				"module_root",
+				"out",
+				"Debug",
+				"bindings"
+			],
+			[
+				"module_root",
+				"Debug",
+				"bindings"
+			],
+			[
+				"module_root",
+				"out",
+				"Release",
+				"bindings"
+			],
+			[
+				"module_root",
+				"Release",
+				"bindings"
+			],
+			[
+				"module_root",
+				"build",
+				"default",
+				"bindings"
+			],
+			[
+				"module_root",
+				"compiled",
+				"version",
+				"platform",
+				"arch",
+				"bindings"
+			],
+			[
+				"module_root",
+				"addon-build",
+				"release",
+				"install-root",
+				"bindings"
+			],
+			[
+				"module_root",
+				"addon-build",
+				"debug",
+				"install-root",
+				"bindings"
+			],
+			[
+				"module_root",
+				"addon-build",
+				"default",
+				"install-root",
+				"bindings"
+			],
+			[
+				"module_root",
+				"lib",
+				"binding",
+				"nodePreGyp",
+				"bindings"
+			]
+		]
+	};
+	/**
+	* The main `bindings()` function loads the compiled bindings for a given module.
+	* It uses V8's Error API to determine the parent filename that this function is
+	* being invoked from, which is then used to find the root directory.
+	*/
+	function bindings(opts) {
+		if (typeof opts == "string") opts = { bindings: opts };
+		else if (!opts) opts = {};
+		Object.keys(defaults).map(function(i) {
+			if (!(i in opts)) opts[i] = defaults[i];
+		});
+		if (!opts.module_root) opts.module_root = exports.getRoot(exports.getFileName());
+		if (path.extname(opts.bindings) != ".node") opts.bindings += ".node";
+		var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+		var tries = [], i = 0, l = opts.try.length, n, b, err;
+		for (; i < l; i++) {
+			n = join.apply(null, opts.try[i].map(function(p) {
+				return opts[p] || p;
+			}));
+			tries.push(n);
+			try {
+				b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+				if (!opts.path) b.path = n;
+				return b;
+			} catch (e) {
+				if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) throw e;
+			}
+		}
+		err = /* @__PURE__ */ new Error("Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+			return opts.arrow + a;
+		}).join("\n"));
+		err.tries = tries;
+		throw err;
+	}
+	module.exports = exports = bindings;
+	/**
+	* Gets the filename of the JavaScript file that invokes this function.
+	* Used to help find the root directory of a module.
+	* Optionally accepts an filename argument to skip when searching for the invoking filename
+	*/
+	exports.getFileName = function getFileName(calling_file) {
+		var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+		Error.stackTraceLimit = 10;
+		Error.prepareStackTrace = function(e, st) {
+			for (var i = 0, l = st.length; i < l; i++) {
+				fileName = st[i].getFileName();
+				if (fileName !== __filename) if (calling_file) {
+					if (fileName !== calling_file) return;
+				} else return;
+			}
+		};
+		Error.captureStackTrace(dummy);
+		dummy.stack;
+		Error.prepareStackTrace = origPST;
+		Error.stackTraceLimit = origSTL;
+		if (fileName.indexOf("file://") === 0) fileName = fileURLToPath(fileName);
+		return fileName;
+	};
+	/**
+	* Gets the root directory of a module, given an arbitrary filename
+	* somewhere in the module tree. The "root directory" is the directory
+	* containing the `package.json` file.
+	*
+	*   In:  /home/nate/node-native-module/lib/index.js
+	*   Out: /home/nate/node-native-module
+	*/
+	exports.getRoot = function getRoot(file) {
+		var dir = dirname(file), prev;
+		while (true) {
+			if (dir === ".") dir = process.cwd();
+			if (exists(join(dir, "package.json")) || exists(join(dir, "node_modules"))) return dir;
+			if (prev === dir) throw new Error("Could not find module root given file: \"" + file + "\". Do you have a `package.json` file? ");
+			prev = dir;
+			dir = join(dir, "..");
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var { cppdb } = require_util();
+	exports.prepare = function prepare(sql) {
+		return this[cppdb].prepare(sql, this, false);
+	};
+	exports.exec = function exec(sql) {
+		this[cppdb].exec(sql);
+		return this;
+	};
+	exports.close = function close() {
+		this[cppdb].close();
+		return this;
+	};
+	exports.loadExtension = function loadExtension(...args) {
+		this[cppdb].loadExtension(...args);
+		return this;
+	};
+	exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+		this[cppdb].defaultSafeIntegers(...args);
+		return this;
+	};
+	exports.unsafeMode = function unsafeMode(...args) {
+		this[cppdb].unsafeMode(...args);
+		return this;
+	};
+	exports.getters = {
+		name: {
+			get: function name() {
+				return this[cppdb].name;
+			},
+			enumerable: true
+		},
+		open: {
+			get: function open() {
+				return this[cppdb].open;
+			},
+			enumerable: true
+		},
+		inTransaction: {
+			get: function inTransaction() {
+				return this[cppdb].inTransaction;
+			},
+			enumerable: true
+		},
+		readonly: {
+			get: function readonly() {
+				return this[cppdb].readonly;
+			},
+			enumerable: true
+		},
+		memory: {
+			get: function memory() {
+				return this[cppdb].memory;
+			},
+			enumerable: true
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { cppdb } = require_util();
+	var controllers = /* @__PURE__ */ new WeakMap();
+	module.exports = function transaction(fn) {
+		if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+		const db = this[cppdb];
+		const controller = getController(db, this);
+		const { apply } = Function.prototype;
+		const properties = {
+			default: { value: wrapTransaction(apply, fn, db, controller.default) },
+			deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+			immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+			exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+			database: {
+				value: this,
+				enumerable: true
+			}
+		};
+		Object.defineProperties(properties.default.value, properties);
+		Object.defineProperties(properties.deferred.value, properties);
+		Object.defineProperties(properties.immediate.value, properties);
+		Object.defineProperties(properties.exclusive.value, properties);
+		return properties.default.value;
+	};
+	var getController = (db, self) => {
+		let controller = controllers.get(db);
+		if (!controller) {
+			const shared = {
+				commit: db.prepare("COMMIT", self, false),
+				rollback: db.prepare("ROLLBACK", self, false),
+				savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+				release: db.prepare("RELEASE `	_bs3.	`", self, false),
+				rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+			};
+			controllers.set(db, controller = {
+				default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+				deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+				immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+				exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+			});
+		}
+		return controller;
+	};
+	var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+		let before, after, undo;
+		if (db.inTransaction) {
+			before = savepoint;
+			after = release;
+			undo = rollbackTo;
+		} else {
+			before = begin;
+			after = commit;
+			undo = rollback;
+		}
+		before.run();
+		try {
+			const result = apply.call(fn, this, arguments);
+			if (result && typeof result.then === "function") throw new TypeError("Transaction function cannot return a promise");
+			after.run();
+			return result;
+		} catch (ex) {
+			if (db.inTransaction) {
+				undo.run();
+				if (undo !== rollback) after.run();
+			}
+			throw ex;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { getBooleanOption, cppdb } = require_util();
+	module.exports = function pragma(source, options) {
+		if (options == null) options = {};
+		if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
+		if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+		const simple = getBooleanOption(options, "simple");
+		const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+		return simple ? stmt.pluck().get() : stmt.all();
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var fs = require___vite_browser_external();
+	var path = require___vite_browser_external();
+	var { promisify } = require___vite_browser_external();
+	var { cppdb } = require_util();
+	var fsAccess = promisify(fs.access);
+	module.exports = async function backup(filename, options) {
+		if (options == null) options = {};
+		if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
+		if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+		filename = filename.trim();
+		const attachedName = "attached" in options ? options.attached : "main";
+		const handler = "progress" in options ? options.progress : null;
+		if (!filename) throw new TypeError("Backup filename cannot be an empty string");
+		if (filename === ":memory:") throw new TypeError("Invalid backup filename \":memory:\"");
+		if (typeof attachedName !== "string") throw new TypeError("Expected the \"attached\" option to be a string");
+		if (!attachedName) throw new TypeError("The \"attached\" option cannot be an empty string");
+		if (handler != null && typeof handler !== "function") throw new TypeError("Expected the \"progress\" option to be a function");
+		await fsAccess(path.dirname(filename)).catch(() => {
+			throw new TypeError("Cannot save backup because the directory does not exist");
+		});
+		const isNewFile = await fsAccess(filename).then(() => false, () => true);
+		return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
+	};
+	var runBackup = (backup, handler) => {
+		let rate = 0;
+		let useDefault = true;
+		return new Promise((resolve, reject) => {
+			setImmediate(function step() {
+				try {
+					const progress = backup.transfer(rate);
+					if (!progress.remainingPages) {
+						backup.close();
+						resolve(progress);
+						return;
+					}
+					if (useDefault) {
+						useDefault = false;
+						rate = 100;
+					}
+					if (handler) {
+						const ret = handler(progress);
+						if (ret !== void 0) if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+						else throw new TypeError("Expected progress callback to return a number or undefined");
+					}
+					setImmediate(step);
+				} catch (err) {
+					backup.close();
+					reject(err);
+				}
+			});
+		});
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { cppdb } = require_util();
+	module.exports = function serialize(options) {
+		if (options == null) options = {};
+		if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
+		const attachedName = "attached" in options ? options.attached : "main";
+		if (typeof attachedName !== "string") throw new TypeError("Expected the \"attached\" option to be a string");
+		if (!attachedName) throw new TypeError("The \"attached\" option cannot be an empty string");
+		return this[cppdb].serialize(attachedName);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/methods/function.js
+var require_function = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { getBooleanOption, cppdb } = require_util();
+	module.exports = function defineFunction(name, options, fn) {
+		if (options == null) options = {};
+		if (typeof options === "function") {
+			fn = options;
+			options = {};
+		}
+		if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+		if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
+		if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+		if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+		const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+		const deterministic = getBooleanOption(options, "deterministic");
+		const directOnly = getBooleanOption(options, "directOnly");
+		const varargs = getBooleanOption(options, "varargs");
+		let argCount = -1;
+		if (!varargs) {
+			argCount = fn.length;
+			if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
+			if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+		}
+		this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+		return this;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { getBooleanOption, cppdb } = require_util();
+	module.exports = function defineAggregate(name, options) {
+		if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+		if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
+		if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+		const start = "start" in options ? options.start : null;
+		const step = getFunctionOption(options, "step", true);
+		const inverse = getFunctionOption(options, "inverse", false);
+		const result = getFunctionOption(options, "result", false);
+		const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+		const deterministic = getBooleanOption(options, "deterministic");
+		const directOnly = getBooleanOption(options, "directOnly");
+		const varargs = getBooleanOption(options, "varargs");
+		let argCount = -1;
+		if (!varargs) {
+			argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+			if (argCount > 0) argCount -= 1;
+			if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+		}
+		this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+		return this;
+	};
+	var getFunctionOption = (options, key, required) => {
+		const value = key in options ? options[key] : null;
+		if (typeof value === "function") return value;
+		if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+		if (required) throw new TypeError(`Missing required option "${key}"`);
+		return null;
+	};
+	var getLength = ({ length }) => {
+		if (Number.isInteger(length) && length >= 0) return length;
+		throw new TypeError("Expected function.length to be a positive integer");
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/methods/table.js
+var require_table = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { cppdb } = require_util();
+	module.exports = function defineTable(name, factory) {
+		if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+		if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
+		let eponymous = false;
+		if (typeof factory === "object" && factory !== null) {
+			eponymous = true;
+			factory = defer(parseTableDefinition(factory, "used", name));
+		} else {
+			if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
+			factory = wrapFactory(factory);
+		}
+		this[cppdb].table(factory, name, eponymous);
+		return this;
+	};
+	function wrapFactory(factory) {
+		return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+			const thisObject = {
+				module: moduleName,
+				database: databaseName,
+				table: tableName
+			};
+			const def = apply.call(factory, thisObject, args);
+			if (typeof def !== "object" || def === null) throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+			return parseTableDefinition(def, "returned", moduleName);
+		};
+	}
+	function parseTableDefinition(def, verb, moduleName) {
+		if (!hasOwnProperty.call(def, "rows")) throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+		if (!hasOwnProperty.call(def, "columns")) throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+		const rows = def.rows;
+		if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+		let columns = def.columns;
+		if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+		if (columns.length !== new Set(columns).size) throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+		if (!columns.length) throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+		let parameters;
+		if (hasOwnProperty.call(def, "parameters")) {
+			parameters = def.parameters;
+			if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+		} else parameters = inferParameters(rows);
+		if (parameters.length !== new Set(parameters).size) throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+		if (parameters.length > 32) throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+		for (const parameter of parameters) if (columns.includes(parameter)) throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+		let safeIntegers = 2;
+		if (hasOwnProperty.call(def, "safeIntegers")) {
+			const bool = def.safeIntegers;
+			if (typeof bool !== "boolean") throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+			safeIntegers = +bool;
+		}
+		let directOnly = false;
+		if (hasOwnProperty.call(def, "directOnly")) {
+			directOnly = def.directOnly;
+			if (typeof directOnly !== "boolean") throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+		}
+		return [
+			`CREATE TABLE x(${[...parameters.map(identifier).map((str) => `${str} HIDDEN`), ...columns.map(identifier)].join(", ")});`,
+			wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+			parameters,
+			safeIntegers,
+			directOnly
+		];
+	}
+	function wrapGenerator(generator, columnMap, moduleName) {
+		return function* virtualTable(...args) {
+			const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+			for (let i = 0; i < columnMap.size; ++i) output.push(null);
+			for (const row of generator(...args)) if (Array.isArray(row)) {
+				extractRowArray(row, output, columnMap.size, moduleName);
+				yield output;
+			} else if (typeof row === "object" && row !== null) {
+				extractRowObject(row, output, columnMap, moduleName);
+				yield output;
+			} else throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+		};
+	}
+	function extractRowArray(row, output, columnCount, moduleName) {
+		if (row.length !== columnCount) throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+		const offset = output.length - columnCount;
+		for (let i = 0; i < columnCount; ++i) output[i + offset] = row[i];
+	}
+	function extractRowObject(row, output, columnMap, moduleName) {
+		let count = 0;
+		for (const key of Object.keys(row)) {
+			const index = columnMap.get(key);
+			if (index === void 0) throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+			output[index] = row[key];
+			count += 1;
+		}
+		if (count !== columnMap.size) throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+	}
+	function inferParameters({ length }) {
+		if (!Number.isInteger(length) || length < 0) throw new TypeError("Expected function.length to be a positive integer");
+		const params = [];
+		for (let i = 0; i < length; ++i) params.push(`$${i + 1}`);
+		return params;
+	}
+	var { hasOwnProperty } = Object.prototype;
+	var { apply } = Function.prototype;
+	var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {});
+	var identifier = (str) => `"${str.replace(/"/g, "\"\"")}"`;
+	var defer = (x) => () => x;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var DatabaseInspection = function Database() {};
+	module.exports = function inspect(depth, opts) {
+		return Object.assign(new DatabaseInspection(), this);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/database.js
+var require_database = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var fs = require___vite_browser_external();
+	var path = require___vite_browser_external();
+	var util = require_util();
+	var SqliteError = require_sqlite_error();
+	var DEFAULT_ADDON;
+	function Database(filenameGiven, options) {
+		if (new.target == null) return new Database(filenameGiven, options);
+		let buffer;
+		if (Buffer.isBuffer(filenameGiven)) {
+			buffer = filenameGiven;
+			filenameGiven = ":memory:";
+		}
+		if (filenameGiven == null) filenameGiven = "";
+		if (options == null) options = {};
+		if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
+		if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+		if ("readOnly" in options) throw new TypeError("Misspelled option \"readOnly\" should be \"readonly\"");
+		if ("memory" in options) throw new TypeError("Option \"memory\" was removed in v7.0.0 (use \":memory:\" filename instead)");
+		const filename = filenameGiven.trim();
+		const anonymous = filename === "" || filename === ":memory:";
+		const readonly = util.getBooleanOption(options, "readonly");
+		const fileMustExist = util.getBooleanOption(options, "fileMustExist");
+		const timeout = "timeout" in options ? options.timeout : 5e3;
+		const verbose = "verbose" in options ? options.verbose : null;
+		const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+		if (readonly && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
+		if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError("Expected the \"timeout\" option to be a positive integer");
+		if (timeout > 2147483647) throw new RangeError("Option \"timeout\" cannot be greater than 2147483647");
+		if (verbose != null && typeof verbose !== "function") throw new TypeError("Expected the \"verbose\" option to be a function");
+		if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError("Expected the \"nativeBinding\" option to be a string or addon object");
+		let addon;
+		if (nativeBinding == null) addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+		else if (typeof nativeBinding === "string") addon = (typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require)(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+		else addon = nativeBinding;
+		if (!addon.isInitialized) {
+			addon.setErrorConstructor(SqliteError);
+			addon.isInitialized = true;
+		}
+		if (!anonymous && !filename.startsWith("file:") && !fs.existsSync(path.dirname(filename))) throw new TypeError("Cannot open database because the directory does not exist");
+		Object.defineProperties(this, {
+			[util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
+			...wrappers.getters
+		});
+	}
+	var wrappers = require_wrappers();
+	Database.prototype.prepare = wrappers.prepare;
+	Database.prototype.transaction = require_transaction();
+	Database.prototype.pragma = require_pragma();
+	Database.prototype.backup = require_backup();
+	Database.prototype.serialize = require_serialize();
+	Database.prototype.function = require_function();
+	Database.prototype.aggregate = require_aggregate();
+	Database.prototype.table = require_table();
+	Database.prototype.loadExtension = wrappers.loadExtension;
+	Database.prototype.exec = wrappers.exec;
+	Database.prototype.close = wrappers.close;
+	Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+	Database.prototype.unsafeMode = wrappers.unsafeMode;
+	Database.prototype[util.inspect] = require_inspect();
+	module.exports = Database;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/better-sqlite3@12.11.1/node_modules/better-sqlite3/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_database();
+	module.exports.SqliteError = require_sqlite_error();
+}));
+//#endregion
+//#region ../db/src/bounds.ts
+function rankOf(value) {
+	if (typeof value === "number") {
+		if (Number.isNaN(value)) throw new TypeError("NaN is not a valid index key");
+		return 0;
+	}
+	if (typeof value === "string") return 1;
+	if (Array.isArray(value)) {
+		for (let item of value) rankOf(item);
+		return 2;
+	}
+	throw new TypeError(`unsupported index key type: ${value === null ? "null" : typeof value}`);
+}
+function cmp(a, b) {
+	let ra = rankOf(a);
+	let rb = rankOf(b);
+	if (ra < rb) return -1;
+	if (ra > rb) return 1;
+	if (ra === 0) {
+		let na = a;
+		let nb = b;
+		if (na < nb) return -1;
+		if (na > nb) return 1;
+		return 0;
+	}
+	if (ra === 1) {
+		let sa = a;
+		let sb = b;
+		if (sa < sb) return -1;
+		if (sa > sb) return 1;
+		return 0;
+	}
+	let aa = a;
+	let ba = b;
+	let n = Math.min(aa.length, ba.length);
+	for (let i = 0; i < n; i++) {
+		let c = cmp(aa[i], ba[i]);
+		if (c !== 0) return c;
+	}
+	if (aa.length < ba.length) return -1;
+	if (aa.length > ba.length) return 1;
+	return 0;
+}
+/** number < string < array; prefix-equal shorter array is less. */
+function compareIndexKey(a, b) {
+	return cmp(a, b);
+}
+/** Inclusive/exclusive bounds using compareIndexKey. limit / keysOnly are ignored. */
+function inRange(indexKey, bound = {}) {
+	if (bound.gt !== void 0 && compareIndexKey(indexKey, bound.gt) <= 0) return false;
+	if (bound.gte !== void 0 && compareIndexKey(indexKey, bound.gte) < 0) return false;
+	if (bound.lt !== void 0 && compareIndexKey(indexKey, bound.lt) >= 0) return false;
+	if (bound.lte !== void 0 && compareIndexKey(indexKey, bound.lte) > 0) return false;
+	return true;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/halua@5.0.0/node_modules/halua/lib/index.js
+function toarray(value) {
+	return Array.isArray(value) ? value : typeof value === "undefined" ? [] : [value];
+}
+function unknownToError(err) {
+	if (err instanceof Error) return err;
+	if (typeof err === "string") return new Error(err);
+	let error = "";
+	try {
+		error = JSON.stringify(err);
+	} catch (_) {}
+	return new Error(error, { cause: err });
+}
+var HaluaFailedToCallDispatcher = class extends Error {
+	constructor(message, options = {}) {
+		super(`HaluaFailedToCallDispatcherError: ${message}`, options);
+	}
+};
+var HaluaUnableToDetermineDispatcher = class extends Error {
+	constructor(message, options = {}) {
+		super(`HaluaUnableToDetermineDispatcherError: ${message}`, options);
+	}
+};
+function getType(arg) {
+	if (typeof arg === "undefined") return "undefined";
+	if (typeof arg === "object" && String(arg) === "null") return "null";
+	if (Array.isArray(arg)) return "array";
+	if (ArrayBuffer.isView(arg)) return "typedarray";
+	if (arg instanceof ArrayBuffer) return "arraybuffer";
+	if (arg instanceof Map) return "map";
+	if (arg instanceof Set) return "set";
+	if (arg instanceof WeakMap) return "weakmap";
+	if (arg instanceof WeakSet) return "weakset";
+	if (arg instanceof Date) return "date";
+	if (arg instanceof Error) return "error";
+	if (Number.isNaN(arg)) return "nan";
+	if (typeof arg === "number" && !Number.isFinite(arg)) return "infinity";
+	return typeof arg;
+}
+var Level = /* @__PURE__ */ ((Level2) => {
+	Level2["Trace"] = "TRACE";
+	Level2["Debug"] = "DEBUG";
+	Level2["Info"] = "INFO";
+	Level2["Notice"] = "NOTICE";
+	Level2["Warn"] = "WARN";
+	Level2["Error"] = "ERROR";
+	Level2["Fatal"] = "FATAL";
+	return Level2;
+})(Level || {});
+function extractLevels(level) {
+	if (typeof level !== "string") return [Level.Info, 0];
+	let s = level.toUpperCase().trim();
+	let data = s.split("+");
+	let major;
+	let minor;
+	if (data.length >= 2) {
+		major = data[0].trim() || Level.Info;
+		let n = Number(data[1].trim());
+		minor = Number.isFinite(n) ? Math.trunc(n) : 0;
+	} else {
+		major = s || Level.Info;
+		minor = 0;
+	}
+	if (minor < 0) minor = 0;
+	return [major, minor];
+}
+var REDACTION_TOKEN = "^_^";
+function redact(value, regexp) {
+	if (!regexp) return value;
+	return redactRec(value, regexp, /* @__PURE__ */ new WeakSet());
+}
+function redactRec(value, re, seen) {
+	if (value == null) return value;
+	let type = getType(value);
+	if (type === "string") return redactString(value, re);
+	if (type === "array") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		let result = [];
+		for (let entry of value) result.push(redactRec(entry, re, seen));
+		seen.delete(value);
+		return result;
+	}
+	if (type === "object") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		let result = {};
+		for (let key of Object.keys(value)) {
+			let k = key;
+			re.lastIndex = 0;
+			if (re.test(k)) result[k] = REDACTION_TOKEN;
+			else result[k] = redactRec(value[k], re, seen);
+		}
+		seen.delete(value);
+		return result;
+	}
+	if (type === "map") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		let result = /* @__PURE__ */ new Map();
+		for (let [k, v] of value) {
+			let keyStr = typeof k === "string" ? k : String(k ?? "");
+			re.lastIndex = 0;
+			if (re.test(keyStr)) result.set(k, REDACTION_TOKEN);
+			else result.set(k, redactRec(v, re, seen));
+		}
+		seen.delete(value);
+		return result;
+	}
+	if (type === "set") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		let result = /* @__PURE__ */ new Set();
+		for (let item of value) result.add(redactRec(item, re, seen));
+		seen.delete(value);
+		return result;
+	}
+	if (type === "error") {
+		let msg = value.message;
+		if (typeof msg === "string") msg = redactString(msg, re);
+		let Ctor = value.constructor || Error;
+		let redacted;
+		try {
+			redacted = new Ctor(msg);
+			if (value.name) redacted.name = value.name;
+			if (value.stack) redacted.stack = value.stack;
+		} catch (_) {
+			redacted = value;
+		}
+		return redacted;
+	}
+	return value;
+}
+function redactString(str, re) {
+	if (!re || typeof str !== "string") return str;
+	let flags = re.flags || "";
+	if (!flags.includes("g")) flags = flags + "g";
+	let searchRe;
+	try {
+		searchRe = new RegExp(re.source, flags);
+	} catch (_) {
+		return str;
+	}
+	searchRe.lastIndex = 0;
+	let result = "";
+	let last = 0;
+	let match;
+	while ((match = searchRe.exec(str)) !== null) {
+		let matchEnd = searchRe.lastIndex;
+		let replacement = REDACTION_TOKEN;
+		let newLast = matchEnd;
+		let assign = str.slice(matchEnd).match(/^(\s*[=:]\s*)(".*?"|'.*?'|\S+)?/);
+		if (assign) {
+			newLast = matchEnd + assign[0].length;
+			replacement = REDACTION_TOKEN;
+			searchRe.lastIndex = newLast;
+		}
+		result += str.slice(last, match.index) + replacement;
+		last = newLast;
+	}
+	result += str.slice(last);
+	return result;
+}
+var DispatcherBase = class {
+	sendMethod;
+	formatArg = void 0;
+	level;
+	exact = null;
+	printTimestamp = true;
+	printLevel = true;
+	redactDataRegExp;
+	_lastTimestampSec = -1;
+	_lastTimestampStr = "";
+	constructor(send = () => {}, options = {}) {
+		this.dispatch = this.dispatch.bind(this);
+		this.sendMethod = send;
+		this.printTimestamp = options.printTimestamp ?? true;
+		this.printLevel = options.printLevel ?? true;
+		this.level = options.level;
+		this.exact = options.exact ? toarray(options.exact) : null;
+		this.redactDataRegExp = options.redactDataRegExp;
+	}
+	dispatch(meta, args, errorMeta) {
+		let effectiveRe = this.redactDataRegExp || meta.redactDataRegExp;
+		let processedArgs = effectiveRe ? args.map((v) => redact(v, effectiveRe)) : args;
+		let processedErrorMeta = errorMeta;
+		if (effectiveRe && errorMeta != null) processedErrorMeta = redact(errorMeta, effectiveRe);
+		let parts = [];
+		if (this.printTimestamp) parts.push(this.formatTimestamp(meta.timestamp));
+		if (this.printLevel) parts.push(meta.level);
+		for (let value of processedArgs) {
+			let formatted;
+			if (typeof this.formatArg === "function") formatted = this.formatArg(value);
+			else formatted = value;
+			parts.push(formatted);
+		}
+		this.sendMethod(parts.join(" "), processedErrorMeta);
+	}
+	formatTimestamp(t) {
+		let sec = Math.floor(t / 1e3);
+		if (sec === this._lastTimestampSec) return this._lastTimestampStr;
+		let d = new Date(t);
+		let s = `${d.toLocaleDateString()} ${d.toLocaleTimeString()}`;
+		this._lastTimestampSec = sec;
+		this._lastTimestampStr = s;
+		return s;
+	}
+};
+function prepareDispatchArgs(redactDataRegExp, meta, rawArgs, errorMeta) {
+	let effectiveRe = redactDataRegExp || meta.redactDataRegExp;
+	let processedRawArgs = effectiveRe ? rawArgs.map((v) => redact(v, effectiveRe)) : rawArgs;
+	let processedErrorMeta = errorMeta;
+	if (effectiveRe && errorMeta != null) processedErrorMeta = redact(errorMeta, effectiveRe);
+	return {
+		processedRawArgs,
+		processedErrorMeta
+	};
+}
+function routeConsoleCall(target, level, args) {
+	let ul = level.toUpperCase();
+	if (ul.startsWith("DEBUG")) {
+		target.debug(...args);
+		return;
+	}
+	if (ul.startsWith("WARN")) {
+		target.warn(...args);
+		return;
+	}
+	if (ul.startsWith("ERROR") || ul.startsWith("FATAL")) {
+		target.error(...args);
+		return;
+	}
+	target.info(...args);
+}
+function NewConsoleDispatcher(console, options) {
+	return () => new class ConsoleDispatcher extends DispatcherBase {
+		constructor(console2, options2 = {}) {
+			super(() => {}, options2);
+			this.console = console2;
+		}
+		dispatch(meta, rawArgs, errorMeta) {
+			let { processedRawArgs, processedErrorMeta } = prepareDispatchArgs(this.redactDataRegExp, meta, rawArgs, errorMeta);
+			let args = [];
+			if (this.printTimestamp) args.push(`${this.formatTimestamp(meta.timestamp)}`);
+			if (this.printLevel) {
+				let margin = this.printTimestamp ? " " : "";
+				args.push(`${margin}${meta.level}`);
+			}
+			for (let value of processedRawArgs) {
+				let formatted;
+				if (typeof this.formatArg === "function") formatted = this.formatArg(value);
+				else formatted = value;
+				args.push(formatted);
+			}
+			if (processedErrorMeta !== void 0) {
+				let m = typeof this.formatArg === "function" ? this.formatArg(processedErrorMeta) : processedErrorMeta;
+				args.push(m);
+			}
+			routeConsoleCall(this.console, meta.level, args);
+		}
+	}(console, options);
+}
+typeof process !== "undefined" && process.versions != null && process.versions.node;
+function tryReportAnError(err) {
+	try {
+		(typeof self !== "undefined" ? self.console : console).error(err);
+	} catch (_) {}
+}
+var MajorLevelMap = /* @__PURE__ */ new Map([
+	[Level.Fatal, /* @__PURE__ */ new Set([Level.Fatal])],
+	[Level.Error, /* @__PURE__ */ new Set([Level.Fatal, Level.Error])],
+	[Level.Warn, /* @__PURE__ */ new Set([
+		Level.Fatal,
+		Level.Error,
+		Level.Warn
+	])],
+	[Level.Notice, /* @__PURE__ */ new Set([
+		Level.Fatal,
+		Level.Error,
+		Level.Warn,
+		Level.Notice
+	])],
+	[Level.Info, /* @__PURE__ */ new Set([
+		Level.Fatal,
+		Level.Error,
+		Level.Warn,
+		Level.Notice,
+		Level.Info
+	])],
+	[Level.Debug, /* @__PURE__ */ new Set([
+		Level.Fatal,
+		Level.Error,
+		Level.Warn,
+		Level.Notice,
+		Level.Info,
+		Level.Debug
+	])],
+	[Level.Trace, /* @__PURE__ */ new Set([
+		Level.Fatal,
+		Level.Error,
+		Level.Warn,
+		Level.Notice,
+		Level.Info,
+		Level.Debug,
+		Level.Trace
+	])]
+]);
+var DispatchersBalancer = class {
+	constructor(level, dispatchers) {
+		this.level = level;
+		this.dispatchers = dispatchers;
+		this.sendLog = this.sendLog.bind(this);
+		this.hasHandlers = this.hasHandlers.bind(this);
+	}
+	map = /* @__PURE__ */ new Map();
+	sendLog(meta, args, errorMeta) {
+		this.discover(meta.level);
+		if ((this.map.get(meta.level) ?? []).length === 0) return;
+		this.send(meta, args, errorMeta);
+	}
+	hasHandlers(level) {
+		this.discover(level);
+		let hs = this.map.get(level);
+		return !!(hs && hs.length > 0);
+	}
+	discover(level) {
+		if (this.map.get(level)) return;
+		let discovered = [];
+		this.map.set(level, discovered);
+		for (let h of this.dispatchers) {
+			if (h.exact) {
+				if (h.exact.some((l) => l === level)) discovered.push(h);
+				continue;
+			}
+			if (this.canSend(level, h.level ?? this.level)) discovered.push(h);
+		}
+	}
+	send(meta, args, errorMeta) {
+		try {
+			this.sendToDispatchers(meta, args, errorMeta);
+		} catch (e) {
+			tryReportAnError(new HaluaFailedToCallDispatcher(`Unable to call dispatch method of a dispatcher`, { cause: e }));
+		}
+	}
+	sendToDispatchers(meta, args, errorMeta) {
+		let hs = this.map.get(meta.level) ?? [];
+		for (let h of hs) try {
+			h.dispatch(meta, args, errorMeta);
+		} catch (e) {
+			tryReportAnError(new HaluaFailedToCallDispatcher(`Unable to call dispatch method of a dispatcher`, { cause: e }));
+		}
+	}
+	canSend(l, to = this.level || Level.Trace) {
+		let lvl = extractLevels(l);
+		let toLvl = extractLevels(to);
+		return this.majorLevelCheck(lvl[0], toLvl[0]) + this.minorLevelCheck(lvl[1], toLvl[1]) > 0;
+	}
+	majorLevelCheck(l, to) {
+		if (l === to) return 0;
+		let toSet = MajorLevelMap.get(to);
+		if (!toSet || !toSet.has(l)) return -1;
+		return 1;
+	}
+	minorLevelCheck(l, to) {
+		return l >= to ? 1 : 0;
+	}
+};
+var NOOP = () => {};
+function instantiate(passed, options = {}, features = []) {
+	return new Halua(passed, options, features);
+}
+var Halua = class {
+	constructor(passed, options = {}, features = []) {
+		this.options = options;
+		this.passedDispatchers = passed;
+		this.features = features;
+		this.dispatchers = this.buildDispatchers(this.mergeFeatureDispatchers(passed));
+		this.balancer = new DispatchersBalancer(this.options.level || Level.Trace, this.dispatchers);
+		this.bindCoreMethods();
+		this.refreshLevelMethods();
+		this.applyFeatures();
+	}
+	passedDispatchers = [];
+	features = [];
+	dispatchers = [];
+	balancer;
+	stamps = /* @__PURE__ */ new Map();
+	trace;
+	debug;
+	info;
+	warn;
+	notice;
+	error;
+	fatal;
+	assert;
+	logTo;
+	create(arg1 = this.passedDispatchers, arg2 = this.options) {
+		if (this.isDispatcherSpec(arg1)) return instantiate(arg1, { ...arg2 ?? this.options }, this.features);
+		return instantiate(this.passedDispatchers, { ...arg1 }, this.features);
+	}
+	child(...args) {
+		return instantiate(this.passedDispatchers, {
+			...this.options,
+			withArgs: (this.options.withArgs || []).concat(args)
+		}, this.features);
+	}
+	setDispatchers(dispatcher) {
+		this.dispatchers = this.buildDispatchers(this.mergeFeatureDispatchers(dispatcher));
+		this.updateBalancer();
+	}
+	appendDispatchers(dispatcher) {
+		let dispatchers = this.buildDispatchers(dispatcher);
+		this.dispatchers.push(...dispatchers);
+		this.updateBalancer();
+	}
+	_logTo(level, ...args) {
+		this.sendToBalancer(level, args);
+	}
+	_trace(...args) {
+		this.sendToBalancer(Level.Trace, args);
+	}
+	_debug(...args) {
+		this.sendToBalancer(Level.Debug, args);
+	}
+	_info(...args) {
+		this.sendToBalancer(Level.Info, args);
+	}
+	_warn(...args) {
+		this.sendToBalancer(Level.Warn, args);
+	}
+	_notice(...args) {
+		this.sendToBalancer(Level.Notice, args);
+	}
+	_error(error, meta) {
+		let e = unknownToError(error);
+		let payload = [e];
+		let finalMeta = meta != null ? {
+			...meta,
+			error: e
+		} : void 0;
+		this.sendToBalancer(Level.Error, payload, finalMeta);
+	}
+	_fatal(...args) {
+		this.sendToBalancer(Level.Fatal, args);
+	}
+	_assert(assertion, error, meta) {
+		if (assertion) return;
+		let e = unknownToError(error);
+		let payload = [e];
+		let finalMeta = meta != null ? {
+			...meta,
+			error: e
+		} : void 0;
+		this.sendToBalancer(Level.Error, payload, finalMeta);
+	}
+	stamp(label, id) {
+		let start = performance.now();
+		if (id != null) this.stamps.set(id, {
+			label,
+			start
+		});
+		let ended = false;
+		let duration = 0;
+		const ender = () => {
+			if (ended) return duration;
+			ended = true;
+			if (id != null) {
+				let current = this.stamps.get(id);
+				if (current && current.start === start) this.stamps.delete(id);
+			}
+			duration = this.endStamp(label, start);
+			return duration;
+		};
+		return ender;
+	}
+	stampEnd(id) {
+		let entry = this.stamps.get(id);
+		if (!entry) return;
+		this.stamps.delete(id);
+		return this.endStamp(entry.label, entry.start);
+	}
+	endStamp(label, start) {
+		let duration = performance.now() - start;
+		let ms = duration.toFixed(2);
+		this.info(label, `took ${ms}ms`);
+		return duration;
+	}
+	updateBalancer() {
+		this.balancer = new DispatchersBalancer(this.options.level || Level.Trace, this.dispatchers);
+		this.refreshLevelMethods();
+	}
+	sendToBalancer(level, args, errorMeta) {
+		let finalArgs = args.concat(this.options.withArgs ?? []);
+		let dispatchMeta = {
+			level,
+			timestamp: Date.now()
+		};
+		if (this.options.redactDataRegExp) dispatchMeta.redactDataRegExp = this.options.redactDataRegExp;
+		this.balancer.sendLog(dispatchMeta, finalArgs, errorMeta);
+	}
+	supposeIsDispatcher(v, reportError = true) {
+		let isDispatcher = typeof v?.dispatch === "function";
+		if (!isDispatcher && reportError) tryReportAnError(new HaluaUnableToDetermineDispatcher(`Unable to find dispatch method of a dispatcher`));
+		return isDispatcher;
+	}
+	isDispatcherSpec(v) {
+		if (Array.isArray(v)) return v.every((x) => typeof x === "function");
+		return typeof v === "function";
+	}
+	mergeFeatureDispatchers(passed) {
+		let extras = [];
+		for (let f of this.features) if (f.contributeDispatchers) extras.push(...f.contributeDispatchers());
+		return toarray(passed).concat(extras);
+	}
+	applyFeatures() {
+		for (let f of this.features) Object.assign(this, f.apply(this));
+	}
+	buildDispatchers(passed) {
+		return toarray(passed).map((b) => b()).filter((h) => this.supposeIsDispatcher(h));
+	}
+	bindCoreMethods() {
+		this.create = this.create.bind(this);
+		this.child = this.child.bind(this);
+		this.setDispatchers = this.setDispatchers.bind(this);
+		this.appendDispatchers = this.appendDispatchers.bind(this);
+		this.stamp = this.stamp.bind(this);
+		this.stampEnd = this.stampEnd.bind(this);
+		this.supposeIsDispatcher = this.supposeIsDispatcher.bind(this);
+	}
+	refreshLevelMethods() {
+		const isEnabled = (level) => this.balancer.hasHandlers(level);
+		this.trace = isEnabled(Level.Trace) ? this._trace.bind(this) : NOOP;
+		this.debug = isEnabled(Level.Debug) ? this._debug.bind(this) : NOOP;
+		this.info = isEnabled(Level.Info) ? this._info.bind(this) : NOOP;
+		this.warn = isEnabled(Level.Warn) ? this._warn.bind(this) : NOOP;
+		this.notice = isEnabled(Level.Notice) ? this._notice.bind(this) : NOOP;
+		this.error = isEnabled(Level.Error) ? this._error.bind(this) : NOOP;
+		this.fatal = isEnabled(Level.Fatal) ? this._fatal.bind(this) : NOOP;
+		this.assert = isEnabled(Level.Error) ? this._assert.bind(this) : NOOP;
+		this.logTo = this._logTo.bind(this);
+	}
+};
+var Builder = class {
+	userDispatchers = [];
+	opts = {};
+	features = [];
+	dispatchers(d) {
+		this.userDispatchers = d;
+		return this;
+	}
+	level(level) {
+		this.opts = {
+			...this.opts,
+			level
+		};
+		return this;
+	}
+	redact(redactDataRegExp) {
+		this.opts = {
+			...this.opts,
+			redactDataRegExp
+		};
+		return this;
+	}
+	withArgs(withArgs) {
+		this.opts = {
+			...this.opts,
+			withArgs
+		};
+		return this;
+	}
+	use(feature) {
+		this.features = this.features.concat(feature);
+		return this;
+	}
+	build() {
+		return instantiate(this.userDispatchers, this.opts, this.features);
+	}
+};
+function createHalua() {
+	return new Builder();
+}
+function flattenCtx(ctx) {
+	if (ctx == null || typeof ctx !== "object" || Array.isArray(ctx)) return [];
+	let pairs = [];
+	let keys = Object.keys(ctx);
+	for (let k of keys) pairs.push(k, ctx[k]);
+	return pairs;
+}
+function isThenable$1(v) {
+	return v != null && typeof v.then === "function";
+}
+function spanFlow() {
+	return { apply(host) {
+		let flow = (name, ctx) => {
+			return host.child("flow", name, ...flattenCtx(ctx));
+		};
+		let closeSuccess = (log, label, start) => {
+			let elapsedMs = performance.now() - start;
+			log.info("done", {
+				span: label,
+				elapsedMs
+			});
+			return elapsedMs;
+		};
+		let closeFailure = (log, label, start, err) => {
+			let elapsedMs = performance.now() - start;
+			if (err instanceof Error) log.error(err, {
+				span: label,
+				elapsedMs
+			});
+			else log.warn("never-happen", {
+				span: label,
+				elapsedMs,
+				err
+			});
+			return elapsedMs;
+		};
+		let startSpan = (label) => {
+			let log = host.child("span", label);
+			let start = performance.now();
+			log.info("start", { span: label });
+			return {
+				log,
+				start
+			};
+		};
+		let span = (label, fn) => {
+			if (typeof fn !== "function") {
+				let started2 = startSpan(label);
+				let ended = false;
+				let duration = 0;
+				return () => {
+					if (ended) return duration;
+					ended = true;
+					duration = closeSuccess(started2.log, label, started2.start);
+					return duration;
+				};
+			}
+			let started = startSpan(label);
+			try {
+				let result = fn(started.log);
+				if (isThenable$1(result)) return result.then((value) => {
+					closeSuccess(started.log, label, started.start);
+					return value;
+				}, (err) => {
+					closeFailure(started.log, label, started.start, err);
+					throw err;
+				});
+				closeSuccess(started.log, label, started.start);
+				return result;
+			} catch (err) {
+				closeFailure(started.log, label, started.start, err);
+				throw err;
+			}
+		};
+		return {
+			flow,
+			span
+		};
+	} };
+}
+var logConsole = (() => {
+	try {
+		return typeof self !== "undefined" ? self.console : console;
+	} catch (_) {
+		return null;
+	}
+})();
+createHalua().dispatchers(logConsole ? NewConsoleDispatcher(logConsole) : []).use(spanFlow()).build();
+//#endregion
+//#region ../log/src/silent.ts
+function makeSilentLog() {
+	return createHalua().use(spanFlow()).build();
+}
+//#endregion
+//#region ../log/src/make-log.ts
+function isThenable(v) {
+	return v != null && typeof v.then === "function";
+}
+/** LDD catch-boundary: Error → flow.error, else never-happen. */
+function reportFlowFailure(flow, err, ctx) {
+	if (err instanceof Error) flow.error(err, ctx);
+	else flow.warn("never-happen", {
+		err,
+		...ctx
+	});
+}
+/**
+* Bind issueKey on .error / .assert. Intercepts child / flow / create / span so
+* descendants keep the same key (including spanFlow closeFailure).
+* Input must already be a spanFlow logger (halua.create / createTestLog).
+* A missing .flow throws — it does not invent a child.
+*/
+function makeLog(src, issueKey) {
+	if (typeof src.flow !== "function") throw new Error("makeLog requires Logger.flow (halua.create / createTestLog with spanFlow)");
+	const mergeMeta = (meta) => {
+		if (!meta) return { issueKey };
+		let { issueKey: _ignored, ...rest } = meta;
+		return {
+			issueKey,
+			...rest
+		};
+	};
+	function wrap(inner) {
+		return new Proxy(inner, { get(target, prop, receiver) {
+			if (prop === "error") return (err, meta) => {
+				target.error(err, mergeMeta(meta));
+			};
+			if (prop === "assert") return (assertion, error, meta) => {
+				target.assert(assertion, error, meta ? mergeMeta(meta) : { issueKey });
+			};
+			if (prop === "child") return (...args) => wrap(target.child(...args));
+			if (prop === "flow") return (name, ctx) => wrap(target.flow(name, ctx));
+			if (prop === "create") return (arg1, arg2) => wrap(target.create(arg1, arg2));
+			if (prop === "span") return (label, fn) => {
+				let spanLog = wrap(target.child("span", label));
+				let start = performance.now();
+				spanLog.info("start", { span: label });
+				const closeOk = () => {
+					let elapsedMs = performance.now() - start;
+					spanLog.info("done", {
+						span: label,
+						elapsedMs
+					});
+					return elapsedMs;
+				};
+				const closeFail = (err) => {
+					reportFlowFailure(spanLog, err, {
+						span: label,
+						elapsedMs: performance.now() - start
+					});
+				};
+				if (typeof fn !== "function") {
+					let ended = false;
+					let duration = 0;
+					return () => {
+						if (ended) return duration;
+						ended = true;
+						duration = closeOk();
+						return duration;
+					};
+				}
+				try {
+					let result = fn(spanLog);
+					if (isThenable(result)) return result.then((value) => {
+						closeOk();
+						return value;
+					}, (err) => {
+						closeFail(err);
+						throw err;
+					});
+					closeOk();
+					return result;
+				} catch (err) {
+					closeFail(err);
+					throw err;
+				}
+			};
+			let value = Reflect.get(target, prop, receiver);
+			if (typeof value === "function") return value.bind(target);
+			return value;
+		} });
+	}
+	return wrap(src);
+}
+//#endregion
+//#region src/driver.ts
+var import___vite_browser_external = require___vite_browser_external();
+var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
+var IDENT_RE = /^[A-Za-z0-9_-]+$/;
+var ISSUE_KEY = "yorozu-db-sqlite";
+function reportError(log, err) {
+	if (err instanceof Error) log.error(err);
+	else log.warn("never-happen", { err });
+}
+function quoteIdent(name) {
+	if (!IDENT_RE.test(name)) throw new Error(`illegal identifier: ${name}`);
+	return `"${name}"`;
+}
+function validateSchema(schema) {
+	for (let col of schema.collections) {
+		quoteIdent(col.name);
+		for (let idx of col.indexes ?? []) quoteIdent(idx.name);
+	}
+}
+function indexFields(keyPath) {
+	return typeof keyPath === "string" ? [keyPath] : [...keyPath];
+}
+function indexColId(indexName, i) {
+	return `${indexName}__${i}`;
+}
+function allIndexColIds(def) {
+	let out = [];
+	for (let idx of def.indexes ?? []) {
+		let n = indexFields(idx.keyPath).length;
+		for (let i = 0; i < n; i++) out.push(indexColId(idx.name, i));
+	}
+	return out;
+}
+function isScalarKey(value) {
+	return typeof value === "string" || typeof value === "number" && !Number.isNaN(value);
+}
+function projectIndexKey(row, keyPath) {
+	if (typeof keyPath === "string") {
+		let value = row[keyPath];
+		if (!isScalarKey(value)) return void 0;
+		return value;
+	}
+	let parts = [];
+	for (let field of keyPath) {
+		let value = row[field];
+		if (!isScalarKey(value)) return void 0;
+		parts.push(value);
+	}
+	return parts;
+}
+function primaryKeyOf(row, keyPath) {
+	let raw = row[keyPath];
+	if (raw === void 0 || raw === null) throw new Error(`missing primary key field: ${keyPath}`);
+	return String(raw);
+}
+function withStringPk(row, keyPath, pk) {
+	if (row[keyPath] === pk) return row;
+	return {
+		...row,
+		[keyPath]: pk
+	};
+}
+function indexKeyPath(def, name) {
+	if (name === "__pk") return def.keyPath;
+	let idx = (def.indexes ?? []).find((item) => item.name === name);
+	if (!idx) throw new Error(`unknown index: ${name}`);
+	return idx.keyPath;
+}
+function isBlobish(value) {
+	if (typeof Blob !== "undefined" && value instanceof Blob) return true;
+	if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) return true;
+	if (value instanceof Uint8Array) return true;
+	return false;
+}
+async function toBytes(value) {
+	if (Buffer.isBuffer(value)) return value;
+	if (value instanceof ArrayBuffer) return Buffer.from(value);
+	if (value instanceof Uint8Array) return Buffer.from(value);
+	if (typeof Blob !== "undefined" && value instanceof Blob) return Buffer.from(await value.arrayBuffer());
+	throw new Error("expected blob field");
+}
+function rehydrate(data) {
+	let bytes = Uint8Array.from(data);
+	if (typeof Blob === "function") return new Blob([bytes]);
+	return bytes;
+}
+async function splitRow(row) {
+	let payload = {};
+	let blobs = /* @__PURE__ */ new Map();
+	for (let [key, value] of Object.entries(row)) if (isBlobish(value)) blobs.set(key, await toBytes(value));
+	else payload[key] = value;
+	return {
+		payload,
+		blobs
+	};
+}
+function indexBinds(row, def) {
+	let values = [];
+	for (let idx of def.indexes ?? []) for (let field of indexFields(idx.keyPath)) {
+		let value = row[field];
+		values.push(isScalarKey(value) ? value : null);
+	}
+	return values;
+}
+function lexSql(cols, parts, wantLess, inclusive) {
+	let n = cols.length;
+	let m = parts.length;
+	let clauses = [];
+	let params = [];
+	let shared = Math.min(n, m);
+	for (let i = 0; i < shared; i++) {
+		let terms = [];
+		for (let j = 0; j < i; j++) {
+			terms.push(`${cols[j]} = ?`);
+			params.push(parts[j]);
+		}
+		terms.push(`${cols[i]} ${wantLess ? "<" : ">"} ?`);
+		params.push(parts[i]);
+		clauses.push(`(${terms.join(" AND ")})`);
+	}
+	let eqTerms = [];
+	let eqParams = [];
+	for (let i = 0; i < shared; i++) {
+		eqTerms.push(`${cols[i]} = ?`);
+		eqParams.push(parts[i]);
+	}
+	if (n === m) {
+		if (inclusive && eqTerms.length > 0) {
+			clauses.push(`(${eqTerms.join(" AND ")})`);
+			params.push(...eqParams);
+		}
+	} else if (n > m) {
+		if (!wantLess) if (eqTerms.length > 0) {
+			clauses.push(`(${eqTerms.join(" AND ")})`);
+			params.push(...eqParams);
+		} else clauses.push("1");
+	} else if (wantLess) if (eqTerms.length > 0) {
+		clauses.push(`(${eqTerms.join(" AND ")})`);
+		params.push(...eqParams);
+	} else clauses.push("1");
+	if (clauses.length === 0) return {
+		sql: "0",
+		params: []
+	};
+	return {
+		sql: `(${clauses.join(" OR ")})`,
+		params
+	};
+}
+function edgeSql(cols, storedIsArray, key, wantLess, inclusive) {
+	if (storedIsArray !== Array.isArray(key)) {
+		if (storedIsArray) return wantLess ? {
+			sql: "0",
+			params: []
+		} : {
+			sql: "1",
+			params: []
+		};
+		return wantLess ? {
+			sql: "1",
+			params: []
+		} : {
+			sql: "0",
+			params: []
+		};
+	}
+	return lexSql(cols, Array.isArray(key) ? [...key] : [key], wantLess, inclusive);
+}
+function keyHasString(key) {
+	if (typeof key === "string") return true;
+	return Array.isArray(key) && key.some((part) => typeof part === "string");
+}
+/** SQLite TEXT is UTF-8; IndexKey strings compare as UTF-16. Do not use SQL WHERE as truth. */
+function trustSqlBounds(index, bound) {
+	if (index === "__pk") return false;
+	if (bound.lt !== void 0 && keyHasString(bound.lt)) return false;
+	if (bound.lte !== void 0 && keyHasString(bound.lte)) return false;
+	if (bound.gt !== void 0 && keyHasString(bound.gt)) return false;
+	if (bound.gte !== void 0 && keyHasString(bound.gte)) return false;
+	return true;
+}
+function boundSql(cols, storedIsArray, bound) {
+	let parts = [];
+	let params = [];
+	let add = (key, wantLess, inclusive) => {
+		if (key === void 0) return;
+		let frag = edgeSql(cols, storedIsArray, key, wantLess, inclusive);
+		parts.push(frag.sql);
+		params.push(...frag.params);
+	};
+	add(bound.gt, false, false);
+	add(bound.gte, false, true);
+	add(bound.lt, true, false);
+	add(bound.lte, true, true);
+	if (parts.includes("0")) return {
+		sql: "0",
+		params: []
+	};
+	let rest = parts.filter((p) => p !== "1");
+	if (rest.length === 0) return {
+		sql: "1",
+		params: []
+	};
+	return {
+		sql: rest.join(" AND "),
+		params
+	};
+}
+function applySchema(handle, schema) {
+	for (let col of schema.collections) {
+		let table = quoteIdent(col.name);
+		let extra = [];
+		for (let id of allIndexColIds(col)) extra.push(quoteIdent(id));
+		let extraSql = extra.length === 0 ? "" : extra.map((c) => `,\n  ${c}`).join("");
+		handle.exec(`CREATE TABLE IF NOT EXISTS ${table} (\n  pk TEXT PRIMARY KEY NOT NULL,\n  payload TEXT NOT NULL${extraSql}\n)`);
+		handle.exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(`${col.name}__blobs`)} (\n  pk TEXT NOT NULL,\n  field TEXT NOT NULL,\n  data BLOB NOT NULL,\n  PRIMARY KEY (pk, field)\n)`);
+		for (let idx of col.indexes ?? []) {
+			let cols = indexFields(idx.keyPath).map((_, i) => quoteIdent(indexColId(idx.name, i)));
+			let unique = idx.unique === true ? "UNIQUE " : "";
+			handle.exec(`CREATE ${unique}INDEX IF NOT EXISTS ${quoteIdent(`${col.name}_${idx.name}`)} ON ${table} (${cols.join(", ")})`);
+		}
+	}
+}
+async function unlinkIfExists(path) {
+	try {
+		await (0, import___vite_browser_external.unlink)(path);
+	} catch (err) {
+		if (err.code !== "ENOENT") throw err;
+	}
+}
+/** Reentrant in the owning async context so a pre-obtained collection used inside transact joins the SQL tx. */
+var SerialQueue = class {
+	_tail = Promise.resolve();
+	_held = new import___vite_browser_external.AsyncLocalStorage();
+	with(fn) {
+		if (this._held.getStore()) return fn();
+		let run = this._tail.then(() => this._held.run(true, fn));
+		this._tail = run.then(() => void 0, () => void 0);
+		return run;
+	}
+};
+var WriteGuardCollection = class {
+	name;
+	constructor(_inner, _mode) {
+		this._inner = _inner;
+		this._mode = _mode;
+		this.name = _inner.name;
+	}
+	_assertWritable() {
+		if (this._mode.value === "r") throw new Error("write is not allowed in a read-only transact");
+	}
+	get(key) {
+		return this._inner.get(key);
+	}
+	getMany(keys) {
+		return this._inner.getMany(keys);
+	}
+	async put(row, opts) {
+		this._assertWritable();
+		await this._inner.put(row, opts);
+	}
+	async putMany(rows, opts) {
+		this._assertWritable();
+		await this._inner.putMany(rows, opts);
+	}
+	async delete(keys) {
+		this._assertWritable();
+		await this._inner.delete(keys);
+	}
+	async clear() {
+		this._assertWritable();
+		await this._inner.clear();
+	}
+	count() {
+		return this._inner.count();
+	}
+	getAll() {
+		return this._inner.getAll();
+	}
+	scan(index, bound) {
+		return this._inner.scan(index, bound);
+	}
+};
+var NestedTxDb = class {
+	constructor(_inner, _unlocked, _flushUnlocked, _mode) {
+		this._inner = _inner;
+		this._unlocked = _unlocked;
+		this._flushUnlocked = _flushUnlocked;
+		this._mode = _mode;
+	}
+	get schema() {
+		return this._inner.schema;
+	}
+	collection(name) {
+		return new WriteGuardCollection(this._unlocked(name), this._mode);
+	}
+	transact(_names, _mode, _fn) {
+		return Promise.reject(/* @__PURE__ */ new Error("nested transact is not supported"));
+	}
+	flush() {
+		if (this._mode.value === "r") return Promise.resolve();
+		this._flushUnlocked();
+		return Promise.resolve();
+	}
+	close() {
+		return this._inner.close();
+	}
+};
+var GatedCollection = class {
+	name;
+	constructor(_inner, _lock) {
+		this._inner = _inner;
+		this._lock = _lock;
+		this.name = _inner.name;
+	}
+	get(key) {
+		return this._lock.with(() => this._inner.get(key));
+	}
+	getMany(keys) {
+		return this._lock.with(() => this._inner.getMany(keys));
+	}
+	put(row, opts) {
+		return this._lock.with(() => this._inner.put(row, opts));
+	}
+	putMany(rows, opts) {
+		return this._lock.with(() => this._inner.putMany(rows, opts));
+	}
+	delete(keys) {
+		return this._lock.with(() => this._inner.delete(keys));
+	}
+	clear() {
+		return this._lock.with(() => this._inner.clear());
+	}
+	count() {
+		return this._lock.with(() => this._inner.count());
+	}
+	getAll() {
+		return this._lock.with(() => this._inner.getAll());
+	}
+	scan(index, bound) {
+		return this._lock.with(() => this._inner.scan(index, bound));
+	}
+};
+var SqliteCollection = class {
+	name;
+	_def;
+	_keyPath;
+	_indexes;
+	_handle;
+	_pending;
+	_inSqlTx;
+	_table;
+	_blobTable;
+	_indexColIds;
+	constructor(def, handle, pending, inSqlTx) {
+		this.name = def.name;
+		this._def = def;
+		this._keyPath = def.keyPath;
+		this._indexes = /* @__PURE__ */ new Map();
+		for (let index of def.indexes ?? []) this._indexes.set(index.name, index);
+		this._handle = handle;
+		this._pending = pending;
+		this._inSqlTx = inSqlTx;
+		this._table = quoteIdent(def.name);
+		this._blobTable = quoteIdent(`${def.name}__blobs`);
+		this._indexColIds = allIndexColIds(def);
+	}
+	_colPending() {
+		return this._pending.get(this.name);
+	}
+	_ensurePending() {
+		let map = this._pending.get(this.name);
+		if (!map) {
+			map = /* @__PURE__ */ new Map();
+			this._pending.set(this.name, map);
+		}
+		return map;
+	}
+	_writeTx(fn) {
+		if (this._inSqlTx.value) {
+			fn();
+			return;
+		}
+		this._handle.transaction(fn);
+	}
+	async _prepareWrite(row) {
+		let pk = primaryKeyOf(row, this._keyPath);
+		let stored = withStringPk(row, this._keyPath, pk);
+		let split = await splitRow(stored);
+		return {
+			row: stored,
+			pk,
+			payloadJson: JSON.stringify(split.payload),
+			blobs: split.blobs,
+			indexBinds: indexBinds(stored, this._def)
+		};
+	}
+	insertWrite(write) {
+		let cols = [
+			"pk",
+			"payload",
+			...this._indexColIds.map(quoteIdent)
+		];
+		let ph = cols.map(() => "?").join(", ");
+		this._handle.prepare(`INSERT OR REPLACE INTO ${this._table} (${cols.join(", ")}) VALUES (${ph})`).run([
+			write.pk,
+			write.payloadJson,
+			...write.indexBinds
+		]);
+		this._handle.prepare(`DELETE FROM ${this._blobTable} WHERE pk = ?`).run([write.pk]);
+		if (write.blobs.size === 0) return;
+		let ins = this._handle.prepare(`INSERT INTO ${this._blobTable} (pk, field, data) VALUES (?, ?, ?)`);
+		for (let [field, data] of write.blobs) ins.run([
+			write.pk,
+			field,
+			data
+		]);
+	}
+	_attachBlobs(byPk, pks) {
+		if (pks.length === 0) return;
+		let ph = pks.map(() => "?").join(", ");
+		let blobRows = this._handle.prepare(`SELECT pk, field, data FROM ${this._blobTable} WHERE pk IN (${ph})`).all(pks);
+		for (let blobRow of blobRows) {
+			let pk = String(blobRow.pk);
+			let row = byPk.get(pk);
+			if (!row) continue;
+			row[String(blobRow.field)] = rehydrate(blobRow.data);
+		}
+	}
+	async get(key) {
+		let pending = this._colPending()?.get(key);
+		if (pending !== void 0) return pending.row;
+		let found = this._handle.prepare(`SELECT payload FROM ${this._table} WHERE pk = ?`).get([key]);
+		if (!found) return null;
+		let row = JSON.parse(found.payload);
+		this._attachBlobs(new Map([[key, row]]), [key]);
+		return row;
+	}
+	async getMany(keys) {
+		if (keys.length === 0) return [];
+		let pending = this._colPending();
+		let need = [];
+		let seen = /* @__PURE__ */ new Set();
+		for (let key of keys) {
+			if (pending?.has(key) || seen.has(key)) continue;
+			seen.add(key);
+			need.push(key);
+		}
+		let loaded = /* @__PURE__ */ new Map();
+		if (need.length > 0) {
+			let ph = need.map(() => "?").join(", ");
+			let rows = this._handle.prepare(`SELECT pk, payload FROM ${this._table} WHERE pk IN (${ph})`).all(need);
+			let byPk = /* @__PURE__ */ new Map();
+			for (let r of rows) byPk.set(String(r.pk), JSON.parse(String(r.payload)));
+			this._attachBlobs(byPk, need);
+			for (let [pk, row] of byPk) loaded.set(pk, row);
+		}
+		return keys.map((key) => {
+			let hit = pending?.get(key);
+			if (hit) return hit.row;
+			return loaded.get(key) ?? null;
+		});
+	}
+	async put(row, opts) {
+		let write = await this._prepareWrite(row);
+		if ((opts?.flush ?? "now") === "batch") {
+			this._ensurePending().set(write.pk, write);
+			return;
+		}
+		this._colPending()?.delete(write.pk);
+		this._writeTx(() => this.insertWrite(write));
+	}
+	async putMany(rows, opts) {
+		if (rows.length === 0) return;
+		let writes = [];
+		for (let row of rows) writes.push(await this._prepareWrite(row));
+		if ((opts?.flush ?? "now") === "batch") {
+			let pending = this._ensurePending();
+			for (let write of writes) pending.set(write.pk, write);
+			return;
+		}
+		let live = this._colPending();
+		this._writeTx(() => {
+			for (let write of writes) {
+				live?.delete(write.pk);
+				this.insertWrite(write);
+			}
+		});
+	}
+	async delete(keys) {
+		let pending = this._colPending();
+		if (pending) for (let key of keys) pending.delete(key);
+		if (keys.length === 0) return;
+		let ph = keys.map(() => "?").join(", ");
+		this._writeTx(() => {
+			this._handle.prepare(`DELETE FROM ${this._table} WHERE pk IN (${ph})`).run(keys);
+			this._handle.prepare(`DELETE FROM ${this._blobTable} WHERE pk IN (${ph})`).run(keys);
+		});
+	}
+	async clear() {
+		this._pending.delete(this.name);
+		this._writeTx(() => {
+			this._handle.exec(`DELETE FROM ${this._table}`);
+			this._handle.exec(`DELETE FROM ${this._blobTable}`);
+		});
+	}
+	async count() {
+		let pending = this._colPending();
+		if (!pending || pending.size === 0) return this._handle.prepare(`SELECT COUNT(*) AS c FROM ${this._table}`).get().c;
+		let rows = this._handle.prepare(`SELECT pk FROM ${this._table}`).all();
+		let keys = new Set(rows.map((r) => String(r.pk)));
+		for (let pk of pending.keys()) keys.add(pk);
+		return keys.size;
+	}
+	async getAll() {
+		let rows = this._handle.prepare(`SELECT pk, payload FROM ${this._table}`).all();
+		let byPk = /* @__PURE__ */ new Map();
+		for (let r of rows) byPk.set(String(r.pk), JSON.parse(r.payload));
+		this._attachBlobs(byPk, [...byPk.keys()]);
+		let pending = this._colPending();
+		if (pending) for (let [pk, write] of pending) byPk.set(pk, write.row);
+		let entries = [...byPk.entries()];
+		entries.sort((a, b) => compareIndexKey(a[0], b[0]));
+		return entries.map(([, row]) => row);
+	}
+	async scan(index, bound = {}) {
+		if (index !== "__pk" && !this._indexes.has(index)) throw new Error(`unknown index: ${index}`);
+		let keysOnly = bound.keysOnly === true;
+		let storedIsArray = false;
+		let rawCols = [];
+		let cols = [];
+		if (index === "__pk") {
+			rawCols = ["pk"];
+			cols = [quoteIdent("pk")];
+		} else {
+			let idx = this._indexes.get(index);
+			storedIsArray = Array.isArray(idx.keyPath);
+			rawCols = indexFields(idx.keyPath).map((_, i) => indexColId(index, i));
+			cols = rawCols.map(quoteIdent);
+		}
+		let pending = this._colPending();
+		let hits = [];
+		let frag = trustSqlBounds(index, bound) ? boundSql(cols, storedIsArray, bound) : {
+			sql: "1",
+			params: []
+		};
+		if (frag.sql !== "0") {
+			let selectList = index === "__pk" ? keysOnly ? ["pk"] : ["pk", "payload"] : keysOnly ? ["pk", ...cols] : [
+				"pk",
+				"payload",
+				...cols
+			];
+			let whereParts = [];
+			if (index !== "__pk") for (let col of cols) whereParts.push(`${col} IS NOT NULL`);
+			let params = [...frag.params];
+			if (frag.sql !== "1") whereParts.push(frag.sql);
+			let where = whereParts.length > 0 ? `WHERE ${whereParts.join(" AND ")}` : "";
+			let order = `ORDER BY ${cols.join(", ")}${index === "__pk" ? "" : ", pk"}`;
+			let sql = `SELECT ${selectList.join(", ")} FROM ${this._table} ${where} ${order}`;
+			let rows = this._handle.prepare(sql).all(params);
+			let valueByPk = /* @__PURE__ */ new Map();
+			for (let r of rows) {
+				let pk = String(r.pk);
+				let indexKey;
+				if (index === "__pk") indexKey = pk;
+				else if (storedIsArray) indexKey = rawCols.map((c) => r[c]);
+				else indexKey = r[rawCols[0]];
+				if (!inRange(indexKey, bound)) continue;
+				if (keysOnly) hits.push({
+					primaryKey: pk,
+					indexKey
+				});
+				else {
+					let value = JSON.parse(String(r.payload));
+					valueByPk.set(pk, value);
+					hits.push({
+						primaryKey: pk,
+						indexKey,
+						value
+					});
+				}
+			}
+			if (!keysOnly && valueByPk.size > 0) this._attachBlobs(valueByPk, [...valueByPk.keys()]);
+		}
+		if (pending && pending.size > 0) hits = this._mergePending(index, bound, hits, pending);
+		hits.sort((a, b) => {
+			let c = compareIndexKey(a.indexKey, b.indexKey);
+			if (c !== 0) return c;
+			return compareIndexKey(a.primaryKey, b.primaryKey);
+		});
+		if (bound.limit !== void 0) hits = hits.slice(0, Math.max(0, bound.limit));
+		return hits;
+	}
+	_mergePending(index, bound, hits, pending) {
+		let replaced = new Set(pending.keys());
+		let out = hits.filter((h) => !replaced.has(h.primaryKey));
+		let keyPath = indexKeyPath(this._def, index);
+		for (let [pk, write] of pending) {
+			let indexKey = index === "__pk" ? pk : projectIndexKey(write.row, keyPath);
+			if (indexKey === void 0) continue;
+			if (!inRange(indexKey, bound)) continue;
+			if (bound.keysOnly) out.push({
+				primaryKey: pk,
+				indexKey
+			});
+			else out.push({
+				primaryKey: pk,
+				indexKey,
+				value: write.row
+			});
+		}
+		out.sort((a, b) => {
+			let c = compareIndexKey(a.indexKey, b.indexKey);
+			if (c !== 0) return c;
+			return compareIndexKey(a.primaryKey, b.primaryKey);
+		});
+		return out;
+	}
+};
+var SqliteDb = class {
+	schema;
+	_handle;
+	_collections;
+	_gated;
+	_pending = /* @__PURE__ */ new Map();
+	_lock = new SerialQueue();
+	_inTransact = new import___vite_browser_external.AsyncLocalStorage();
+	_inSqlTx = { value: false };
+	_txMode = { value: null };
+	_txView;
+	_onClose;
+	_closed = false;
+	constructor(schema, handle, onClose) {
+		this.schema = schema;
+		this._handle = handle;
+		this._onClose = onClose;
+		this._collections = /* @__PURE__ */ new Map();
+		this._gated = /* @__PURE__ */ new Map();
+		this._txView = new NestedTxDb(this, (name) => {
+			let col = this._collections.get(name);
+			if (!col) throw new Error(`unknown collection: ${name}`);
+			return col;
+		}, () => this._flushPending(), this._txMode);
+		for (let def of schema.collections) {
+			let col = new SqliteCollection(def, handle, this._pending, this._inSqlTx);
+			this._collections.set(def.name, col);
+			this._gated.set(def.name, new GatedCollection(col, this._lock));
+		}
+	}
+	collection(name) {
+		let col = this._gated.get(name);
+		if (!col) throw new Error(`unknown collection: ${name}`);
+		return col;
+	}
+	transact(names, mode, fn) {
+		for (let name of names) if (!this._collections.has(name)) throw new Error(`unknown collection: ${name}`);
+		if (this._inTransact.getStore()) return Promise.reject(/* @__PURE__ */ new Error("nested transact is not supported"));
+		return this._lock.with(() => this._inTransact.run(true, async () => {
+			this._handle.exec("BEGIN IMMEDIATE");
+			this._inSqlTx.value = true;
+			this._txMode.value = mode;
+			try {
+				let result = await fn(this._txView);
+				if (mode !== "r") this._flushPending();
+				this._handle.exec("COMMIT");
+				return result;
+			} catch (err) {
+				try {
+					this._handle.exec("ROLLBACK");
+				} catch {}
+				throw err;
+			} finally {
+				this._inSqlTx.value = false;
+				this._txMode.value = null;
+			}
+		}));
+	}
+	flush() {
+		return this._lock.with(async () => {
+			this._flushPending();
+		});
+	}
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		try {
+			this._flushPending();
+		} finally {
+			this._handle.close();
+			this._onClose();
+		}
+	}
+	_flushPending() {
+		let snapshot = [];
+		for (let [name, rows] of this._pending) {
+			if (rows.size === 0) continue;
+			snapshot.push([name, [...rows.values()]]);
+		}
+		if (snapshot.length === 0) return;
+		let run = () => {
+			for (let [name, writes] of snapshot) {
+				let col = this._collections.get(name);
+				if (!col) continue;
+				for (let write of writes) col.insertWrite(write);
+			}
+		};
+		if (this._inSqlTx.value) run();
+		else this._handle.transaction(run);
+		for (let [name, writes] of snapshot) {
+			let live = this._pending.get(name);
+			if (!live) continue;
+			for (let write of writes) if (live.get(write.pk) === write) live.delete(write.pk);
+		}
+	}
+};
+var SqliteDriver = class {
+	log;
+	_filename;
+	_native;
+	_conns = /* @__PURE__ */ new Set();
+	constructor(opts) {
+		this.log = makeLog(opts.log ?? makeSilentLog(), ISSUE_KEY);
+		this._filename = opts.filename;
+		this._native = opts.native ?? import_lib.default;
+	}
+	async open(schema) {
+		let raw;
+		try {
+			validateSchema(schema);
+			let Native = this._native;
+			raw = new Native(this._filename);
+			try {
+				raw.pragma("journal_mode = WAL");
+			} catch {}
+			let handle = wrapBetterSqlite3(raw);
+			applySchema(handle, schema);
+			let db = new SqliteDb(schema, handle, () => {
+				this._conns.delete(db);
+			});
+			this._conns.add(db);
+			return db;
+		} catch (err) {
+			try {
+				raw?.close();
+			} catch {}
+			reportError(this.log, err);
+			throw err;
+		}
+	}
+	async drop(_schema) {
+		try {
+			for (let db of [...this._conns]) await db.close();
+			if (this._filename === ":memory:") return;
+			await unlinkIfExists(this._filename);
+			await unlinkIfExists(`${this._filename}-wal`);
+			await unlinkIfExists(`${this._filename}-shm`);
+		} catch (err) {
+			reportError(this.log, err);
+			throw err;
+		}
+	}
+};
+function createSqliteDriver(opts) {
+	return new SqliteDriver(opts);
+}
+//#endregion
+export { createSqliteDriver, wrapBetterSqlite3 };