@moyodb/sdk 1.0.1 → 1.1.0

package/dist/node.js

@@ -0,0 +1,3194 @@
+import { $ as StoreExistsError, A as prefixRange, B as DatabaseClosedError, C as compoundKey, Ct as isWorkerProtocolReadyEnvelope, D as indexKey, Dt as isWorkerProtocolResponseBatchMessage, E as encodeIndexScalar, F as utf8Encode, G as InvalidRangeError, H as InjectedFailureError, Ht as compareStringsByCodeUnit, I as ChangeFeedCompactedError, J as ReadonlyTransactionError, K as KeyTooLargeError, L as ConstraintError, M as splitCompoundKey, Mt as prepareWorkerCommandPayload, N as u64Key, O as jsonDecode, Ot as isWorkerProtocolResponseMessage, P as utf8Decode, Q as StorageError, R as CorruptionError, S as toPublicIndexDefinitions, T as encodeCompoundKeyParts, U as InternalError, Ut as isRecord$1, V as IndexNotFoundError, Vt as workerProtocolError, W as InvalidOpenOptionsError, X as ReservedStoreNameError, Y as RecoveryRequiredError, Z as SerializationError, _ as indexRangeToPhysicalRange, a as createIndexKeyExtractor, at as UnsupportedPlatformError, b as normalizeIndexDefinitions, c as decodeIndexedDocument, ct as WriteTransactionAlreadyOpenError, d as encodeIndexMetadataValue, et as StoreNameTooLongError, f as extractLogicalIndexKey, ft as WORKER_PROTOCOL_REQUEST, g as indexKeyExactRange, gt as captureWorkerPayload, h as indexDefinitionIdentity, i as compareNormalizedIndexDefinitions, it as UniqueIndexConstraintError, j as prefixSuccessor, k as jsonEncode, l as encodeIndexEntryKey, lt as normalizeError, m as findIndexDefinition, n as assertPublicStoreName, nt as TransactionClosedError, o as decodeIndexEntryKey, ot as ValueTooLargeError, p as extractLogicalIndexKeyFromDocument, pt as WORKER_PROTOCOL_REQUEST_BATCH, q as MoyoDbError, r as cloneNormalizedIndexDefinitions, rt as TransactionConflictError, s as decodeIndexMetadataValue, st as VersionError, t as INDEX_METADATA_STORE, tt as StoreNotFoundError, u as encodeIndexMetadataKey, v as indexesForStore, vt as decodeWorkerResponsePayload, w as compoundKeyRange, wt as isWorkerProtocolReadyMessage, x as serializeNormalizedIndexDefinitions, y as isInternalStoreName, yt as deserializeWorkerError, z as DatabaseBusyError } from "./chunks/indexing-BzmFhWXs.js";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, realpath } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { Worker as Worker$1 } from "node:worker_threads";
+import fs from "node:fs";
+//#region src/worker-client.ts
+function clearPendingTimeout(pending) {
+	if (pending.timeout) clearTimeout(pending.timeout);
+}
+var WorkerProtocolClient = class {
+	worker;
+	nextRequestId = 1;
+	pending = /* @__PURE__ */ new Map();
+	closed = false;
+	readyResolved = false;
+	readyResolve = null;
+	readyReject = null;
+	ready;
+	requestTimeoutMs;
+	fatalHandler = null;
+	closeReason = null;
+	batching = false;
+	queuedRequests = [];
+	queuedBytes = 0;
+	flushScheduled = false;
+	awaitingReady = 0;
+	readyTimeout = null;
+	constructor(worker, options = {}) {
+		this.worker = worker;
+		this.requestTimeoutMs = options.requestTimeoutMs ?? 0;
+		this.ready = new Promise((resolve, reject) => {
+			this.readyResolve = resolve;
+			this.readyReject = reject;
+		});
+		if ((options.readyTimeoutMs ?? 0) > 0) this.readyTimeout = setTimeout(() => {
+			this.fail(workerProtocolError("WorkerReadyTimeoutError", "worker did not become ready"));
+		}, options.readyTimeoutMs);
+		this.ready.catch(() => void 0);
+		this.worker.addEventListener("message", this.handleMessage);
+		this.worker.addEventListener("messageerror", this.handleMessageError);
+		this.worker.addEventListener("error", this.handleError);
+	}
+	setFatalHandler(handler) {
+		this.fatalHandler = handler;
+	}
+	whenReady() {
+		return this.ready;
+	}
+	dispose(reason = workerProtocolError("WorkerTerminatedError", "worker transport was closed")) {
+		this.disposeInternal(reason, false);
+	}
+	fail(reason) {
+		this.disposeInternal(reason, true);
+	}
+	open(request) {
+		return this.request("open", [request]);
+	}
+	close() {
+		return this.request("close", []);
+	}
+	destroy() {
+		return this.request("destroy", []);
+	}
+	deleteDB(dbName) {
+		return this.request("deleteDB", [dbName]);
+	}
+	begin(mode) {
+		return this.request("begin", [mode]);
+	}
+	commit(txId) {
+		return this.request("commit", [txId]);
+	}
+	rollback(txId) {
+		return this.request("rollback", [txId]);
+	}
+	autocommit(mode, command, args) {
+		return this.send("autocommit", [
+			mode,
+			command,
+			args
+		], command);
+	}
+	createStore(txId, name, options) {
+		return this.request("createStore", [
+			txId,
+			name,
+			options
+		]);
+	}
+	dropStore(txId, name) {
+		return this.request("dropStore", [txId, name]);
+	}
+	clearStore(txId, name) {
+		return this.request("clearStore", [txId, name]);
+	}
+	get(txId, store, key) {
+		return this.request("get", [
+			txId,
+			store,
+			key
+		]);
+	}
+	getMany(txId, store, keys) {
+		return this.request("getMany", [
+			txId,
+			store,
+			keys
+		]);
+	}
+	has(txId, store, key) {
+		return this.request("has", [
+			txId,
+			store,
+			key
+		]);
+	}
+	put(txId, store, key, value, options) {
+		return this.request("put", [
+			txId,
+			store,
+			key,
+			value,
+			options
+		]);
+	}
+	putMany(txId, store, entries, options) {
+		return this.request("putMany", [
+			txId,
+			store,
+			entries,
+			options
+		]);
+	}
+	delete(txId, store, key) {
+		return this.request("delete", [
+			txId,
+			store,
+			key
+		]);
+	}
+	deleteMany(txId, store, keys) {
+		return this.request("deleteMany", [
+			txId,
+			store,
+			keys
+		]);
+	}
+	applyBatch(txId, store, ops) {
+		return this.request("applyBatch", [
+			txId,
+			store,
+			ops
+		]);
+	}
+	scan(txId, store, range) {
+		return this.request("scan", [
+			txId,
+			store,
+			range
+		]);
+	}
+	getByIndex(txId, store, indexName, key) {
+		return this.request("getByIndex", [
+			txId,
+			store,
+			indexName,
+			key
+		]);
+	}
+	scanByIndex(txId, store, indexName, range) {
+		return this.request("scanByIndex", [
+			txId,
+			store,
+			indexName,
+			range
+		]);
+	}
+	scanByIndexPage(txId, store, indexName, range, cursor, limit) {
+		return this.request("scanByIndexPage", [
+			txId,
+			store,
+			indexName,
+			range,
+			cursor,
+			limit
+		]);
+	}
+	getIndexes(txId) {
+		return this.request("getIndexes", txId === void 0 ? [] : [txId]);
+	}
+	reconcileIndexes(txId, indexes) {
+		return this.request("reconcileIndexes", [txId, indexes]);
+	}
+	listStores() {
+		return this.request("listStores", []);
+	}
+	getVersion() {
+		return this.request("getVersion", []);
+	}
+	changesSince(txId, options) {
+		return this.request("changesSince", [txId, options]);
+	}
+	setSchemaVersion(txId, version) {
+		return this.request("setSchemaVersion", [txId, version]);
+	}
+	exportSnapshot(options) {
+		return this.request("exportSnapshot", [options]);
+	}
+	importSnapshot(data) {
+		return this.request("importSnapshot", [data]);
+	}
+	reset() {
+		return this.request("reset", []);
+	}
+	compact() {
+		return this.request("compact", []);
+	}
+	rebuild() {
+		return this.request("rebuild", []);
+	}
+	stats() {
+		return this.request("stats", []);
+	}
+	storageInfo() {
+		return this.request("storageInfo", []);
+	}
+	requestPersistence() {
+		return this.request("requestPersistence", []);
+	}
+	setFailpoint(failpoint) {
+		return this.request("setFailpoint", [failpoint]);
+	}
+	async request(command, args) {
+		return await this.send(command, args, command);
+	}
+	async send(command, args, responseCommand) {
+		this.ensureOpen();
+		this.awaitingReady += 1;
+		try {
+			await this.ready;
+		} finally {
+			this.awaitingReady -= 1;
+		}
+		this.ensureOpen();
+		const shouldQueue = this.batching && (this.awaitingReady > 0 || this.queuedRequests.length > 0);
+		const id = this.nextRequestId;
+		this.nextRequestId += 1;
+		const prepared = prepareWorkerCommandPayload(command, args);
+		const message = {
+			type: WORKER_PROTOCOL_REQUEST,
+			version: 1,
+			id,
+			command,
+			args: prepared.args
+		};
+		return await new Promise((resolve, reject) => {
+			const timeout = this.requestTimeoutMs > 0 ? setTimeout(() => {
+				this.pending.delete(id);
+				reject(workerProtocolError("WorkerRequestTimeoutError", `worker command ${command} timed out after ${this.requestTimeoutMs}ms`));
+			}, this.requestTimeoutMs) : null;
+			this.pending.set(id, {
+				command: responseCommand,
+				resolve: (value) => resolve(value),
+				reject,
+				timeout
+			});
+			try {
+				if (shouldQueue) this.queueRequest(message, prepared.transfer);
+				else if (prepared.transfer.length > 0) this.worker.postMessage(message, prepared.transfer);
+				else this.worker.postMessage(message);
+			} catch (error) {
+				this.rejectPending(id, error instanceof Error ? error : new Error(String(error)));
+			}
+		});
+	}
+	queueRequest(message, transfer) {
+		const captured = captureWorkerPayload(message, transfer);
+		if (!this.pending.has(message.id)) return;
+		if (this.queuedRequests.length > 0 && this.queuedBytes + captured.byteLength > 1048576) this.flushRequests();
+		this.queuedRequests.push({
+			message: captured.value,
+			transfer: captured.transfer,
+			byteLength: captured.byteLength
+		});
+		this.queuedBytes += captured.byteLength;
+		if (!this.flushScheduled) {
+			this.flushScheduled = true;
+			queueMicrotask(() => {
+				this.flushScheduled = false;
+				this.flushRequests();
+			});
+		}
+		if (this.queuedRequests.length >= 128 || this.queuedBytes >= 1048576) this.flushRequests();
+	}
+	flushRequests() {
+		const queued = this.queuedRequests;
+		this.queuedRequests = [];
+		this.queuedBytes = 0;
+		if (this.closed) return;
+		const active = queued.filter((entry) => this.pending.has(entry.message.id));
+		if (active.length === 0) return;
+		const message = active.length === 1 ? active[0].message : {
+			type: WORKER_PROTOCOL_REQUEST_BATCH,
+			version: 1,
+			requests: active.map((entry) => entry.message)
+		};
+		const transfer = [];
+		for (const entry of active) for (const buffer of entry.transfer) transfer.push(buffer);
+		try {
+			if (transfer.length > 0) this.worker.postMessage(message, transfer);
+			else this.worker.postMessage(message);
+		} catch (error) {
+			const reason = error instanceof Error ? error : new Error(String(error));
+			for (const entry of active) this.rejectPending(entry.message.id, reason);
+		}
+	}
+	ensureOpen() {
+		if (this.closed) throw this.closeReason ?? workerProtocolError("WorkerTerminatedError", "worker transport is closed");
+	}
+	handleMessage = (event) => {
+		const data = event.data;
+		if (isWorkerProtocolReadyMessage(data)) {
+			if (this.readyResolved) return;
+			this.batching = data.batching === 1;
+			this.readyResolved = true;
+			if (this.readyTimeout) clearTimeout(this.readyTimeout);
+			this.readyTimeout = null;
+			this.readyResolve?.();
+			this.readyResolve = null;
+			this.readyReject = null;
+			return;
+		}
+		if (isWorkerProtocolReadyEnvelope(data)) {
+			this.fail(workerProtocolError("WorkerProtocolError", "incompatible worker protocol ready message"));
+			return;
+		}
+		if (isWorkerProtocolResponseBatchMessage(data)) {
+			for (const response of data.responses) this.handleResponse(response);
+			return;
+		}
+		if (isRecord$1(data) && data.type === "moyodb:worker-protocol:response-batch" && data.version === 1) {
+			this.fail(workerProtocolError("WorkerProtocolError", "invalid worker response batch"));
+			return;
+		}
+		this.handleResponse(data);
+	};
+	handleResponse(data) {
+		if (!isWorkerProtocolResponseMessage(data)) {
+			if (isRecord$1(data) && data.type === "moyodb:worker-protocol:response" && data.version === 1 && typeof data.id === "number" && Number.isSafeInteger(data.id)) this.rejectPending(data.id, workerProtocolError("WorkerProtocolError", "invalid worker response"));
+			return;
+		}
+		const pending = this.pending.get(data.id);
+		if (!pending) return;
+		this.pending.delete(data.id);
+		clearPendingTimeout(pending);
+		try {
+			if (data.ok) pending.resolve(decodeWorkerResponsePayload(pending.command, data.result));
+			else pending.reject(deserializeWorkerError(data.error));
+		} catch (error) {
+			pending.reject(error instanceof Error && error.name === "WorkerProtocolError" ? error : workerProtocolError("WorkerProtocolError", "worker response could not be decoded"));
+		}
+	}
+	handleMessageError = () => {
+		this.fail(workerProtocolError("WorkerMessageError", "worker message could not be deserialized"));
+	};
+	handleError = (event) => {
+		const error = event.error instanceof Error ? event.error : workerProtocolError("WorkerError", event.message || "worker runtime failed");
+		this.fail(error);
+	};
+	rejectPending(id, error) {
+		const pending = this.pending.get(id);
+		if (!pending) return;
+		this.pending.delete(id);
+		clearPendingTimeout(pending);
+		pending.reject(error);
+	}
+	disposeInternal(reason, notifyFatal) {
+		if (this.closed) return;
+		this.closed = true;
+		this.closeReason = reason;
+		this.worker.removeEventListener("message", this.handleMessage);
+		this.worker.removeEventListener("messageerror", this.handleMessageError);
+		this.worker.removeEventListener("error", this.handleError);
+		if (this.readyTimeout) clearTimeout(this.readyTimeout);
+		this.readyTimeout = null;
+		if (!this.readyResolved) this.readyReject?.(reason);
+		this.readyResolve = null;
+		this.readyReject = null;
+		this.queuedRequests = [];
+		this.queuedBytes = 0;
+		for (const pending of this.pending.values()) {
+			clearPendingTimeout(pending);
+			pending.reject(reason);
+		}
+		this.pending.clear();
+		if (notifyFatal) this.fatalHandler?.(reason);
+	}
+};
+//#endregion
+//#region src/registry.ts
+var VALID_FAILPOINTS = /* @__PURE__ */ new Set([
+	"after_wal_flush",
+	"after_main_flush",
+	"before_superblock_flush"
+]);
+var DEFAULT_CHANGE_FEED_RETAIN_TXIDS = 1e5;
+var registry$1 = /* @__PURE__ */ new Map();
+var lifecycleOperations$1 = /* @__PURE__ */ new Map();
+function queueLifecycleOperation$1(dbName, operation) {
+	const result = (lifecycleOperations$1.get(dbName) ?? Promise.resolve()).then(operation);
+	const settled = result.then(() => void 0, () => void 0);
+	lifecycleOperations$1.set(dbName, settled);
+	settled.then(() => {
+		if (lifecycleOperations$1.get(dbName) === settled) lifecycleOperations$1.delete(dbName);
+	});
+	return result;
+}
+function requirePlainOptionsObject(options) {
+	if (options === null || typeof options !== "object" || Array.isArray(options)) throw new InvalidOpenOptionsError("open options must be an object");
+}
+function normalizeBoolean(value, field, defaultValue) {
+	if (value === void 0) return defaultValue;
+	if (typeof value !== "boolean") throw new InvalidOpenOptionsError(`${field} must be a boolean`);
+	return value;
+}
+function normalizeNonNegativeInteger(value, field, defaultValue) {
+	if (value === void 0) return defaultValue;
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new InvalidOpenOptionsError(`${field} must be a non-negative safe integer`);
+	return value;
+}
+function normalizeCachePages(value) {
+	return Math.max(1, normalizeNonNegativeInteger(value, "cachePages", 256));
+}
+function normalizeFailpoint(value) {
+	if (value === void 0 || value === null) return null;
+	if (typeof value !== "string" || !VALID_FAILPOINTS.has(value)) throw new InvalidOpenOptionsError(`debugFailpoint must be one of: ${Array.from(VALID_FAILPOINTS).join(", ")}`);
+	return value;
+}
+function normalizeChangeFeed(value) {
+	if (value === void 0) return null;
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new InvalidOpenOptionsError("changeFeed must be an object");
+	const settings = value;
+	const enabled = normalizeBoolean(settings.enabled, "changeFeed.enabled", true);
+	let retainTxids = DEFAULT_CHANGE_FEED_RETAIN_TXIDS;
+	if (settings.retainTxids === null) retainTxids = null;
+	else if (settings.retainTxids !== void 0) {
+		retainTxids = normalizeNonNegativeInteger(settings.retainTxids, "changeFeed.retainTxids", 0);
+		if (retainTxids === 0) throw new InvalidOpenOptionsError("changeFeed.retainTxids must be positive; disable the feed instead");
+	}
+	return {
+		enabled,
+		retainTxids
+	};
+}
+function normalizeWorkerMode(value) {
+	if (value === void 0) return "dedicated";
+	if (value !== "dedicated" && value !== "shared") throw new InvalidOpenOptionsError("workerMode must be dedicated or shared");
+	return value;
+}
+function normalizeOptions(options = {}) {
+	requirePlainOptionsObject(options);
+	return {
+		workerMode: normalizeWorkerMode(options.workerMode),
+		createIfMissing: normalizeBoolean(options.createIfMissing, "createIfMissing", true),
+		ownerWaitMs: normalizeNonNegativeInteger(options.ownerWaitMs, "ownerWaitMs", 0),
+		requestPersistence: normalizeBoolean(options.requestPersistence, "requestPersistence", true),
+		cachePages: normalizeCachePages(options.cachePages),
+		debugFailpoint: normalizeFailpoint(options.debugFailpoint),
+		changeFeed: normalizeChangeFeed(options.changeFeed)
+	};
+}
+function sameChangeFeed(left, right) {
+	return left?.enabled === right?.enabled && left?.retainTxids === right?.retainTxids;
+}
+function assertCompatibleOptions(dbName, current, next) {
+	if (current.workerMode !== next.workerMode) throw new InvalidOpenOptionsError(`database ${dbName} is already open with workerMode=${current.workerMode}`);
+	if (current.cachePages !== next.cachePages) throw new InvalidOpenOptionsError(`database ${dbName} is already open in this tab with cachePages=${current.cachePages}; requested cachePages=${next.cachePages}`);
+	if (next.changeFeed !== null && !sameChangeFeed(current.changeFeed, next.changeFeed)) throw new InvalidOpenOptionsError(`database ${dbName} is already open in this tab with a different changeFeed policy`);
+}
+function emitListeners(listeners) {
+	for (const listener of Array.from(listeners)) listener();
+}
+function subscribeTransactionsInvalidated(entry, listener) {
+	entry.txInvalidationListeners.add(listener);
+	return () => {
+		entry.txInvalidationListeners.delete(listener);
+	};
+}
+function subscribeHandleInvalidated(entry, listener) {
+	entry.handleInvalidationListeners.add(listener);
+	return () => {
+		entry.handleInvalidationListeners.delete(listener);
+	};
+}
+function invalidateTransactions(entry) {
+	emitListeners(entry.txInvalidationListeners);
+}
+function invalidateEntry$1(entry) {
+	if (entry.invalidated) return;
+	entry.invalidated = true;
+	invalidateTransactions(entry);
+	emitListeners(entry.handleInvalidationListeners);
+}
+async function releaseDbWorker(entry) {
+	if (entry.release) return entry.release();
+	return queueLifecycleOperation$1(entry.dbName, async () => {
+		if (entry.invalidated || registry$1.get(entry.dbName) !== entry) return;
+		entry.refs -= 1;
+		if (entry.refs > 0) return;
+		registry$1.delete(entry.dbName);
+		try {
+			await entry.proxy.close();
+		} finally {
+			entry.persistenceBridge.close();
+			entry.proxy.dispose(/* @__PURE__ */ new Error("worker was released"));
+			await entry.worker.terminate();
+		}
+	});
+}
+async function destroyDbWorker(entry) {
+	if (entry.destroy) return entry.destroy();
+	return queueLifecycleOperation$1(entry.dbName, () => destroyEntry$1(entry));
+}
+async function destroyEntry$1(entry) {
+	if (entry.invalidated || registry$1.get(entry.dbName) !== entry) throw new DatabaseClosedError();
+	if (entry.options.workerMode === "shared") {
+		try {
+			await entry.proxy.destroy();
+		} catch (error) {
+			throw normalizeError(error);
+		}
+		registry$1.delete(entry.dbName);
+		invalidateEntry$1(entry);
+		entry.refs = 0;
+		entry.persistenceBridge.close();
+		entry.proxy.dispose(/* @__PURE__ */ new Error("worker was released"));
+		await entry.worker.terminate();
+		return;
+	}
+	registry$1.delete(entry.dbName);
+	invalidateEntry$1(entry);
+	entry.refs = 0;
+	try {
+		await entry.proxy.destroy();
+	} catch (error) {
+		throw normalizeError(error);
+	} finally {
+		entry.persistenceBridge.close();
+		entry.proxy.dispose(/* @__PURE__ */ new Error("worker was released"));
+		await entry.worker.terminate();
+	}
+}
+//#endregion
+//#region src/change-events.ts
+function isDbChange(value) {
+	if (!isRecord$1(value) || !(value.key instanceof Uint8Array)) return false;
+	if (value.kind === "put" || value.kind === "delete") return true;
+	return (value.kind === "clear" || value.kind === "drop") && value.key.byteLength === 0;
+}
+function isStoreChangeSet(value) {
+	return isRecord$1(value) && typeof value.store === "string" && Array.isArray(value.changes) && value.changes.every(isDbChange);
+}
+function isCommitAppliedEvent(value) {
+	return isRecord$1(value) && value.type === "commit_applied" && typeof value.dbName === "string" && typeof value.txid === "number" && Array.isArray(value.stores) && value.stores.every(isStoreChangeSet);
+}
+//#endregion
+//#region src/subscriptions.ts
+function cloneChanges(changes) {
+	return changes.map((change) => ({
+		key: change.key.slice(),
+		kind: change.kind
+	}));
+}
+function hasKeyPrefix(key, prefix) {
+	if (prefix.byteLength > key.byteLength) return false;
+	for (let index = 0; index < prefix.byteLength; index += 1) if (key[index] !== prefix[index]) return false;
+	return true;
+}
+function normalizeSubscriptionSpec(arg1, arg2, arg3) {
+	if (typeof arg1 === "function") {
+		if (arg2 !== void 0 || arg3 !== void 0) throw new TypeError("subscribe(callback) accepts exactly one callback argument");
+		return {
+			store: null,
+			keyPrefix: null,
+			callback: arg1
+		};
+	}
+	if (typeof arg1 !== "string") throw new TypeError("subscribe() storeName must be a string");
+	assertPublicStoreName(arg1);
+	if (typeof arg2 === "function") {
+		if (arg3 !== void 0) throw new TypeError("subscribe(storeName, callback) accepts exactly two arguments");
+		return {
+			store: arg1,
+			keyPrefix: null,
+			callback: arg2
+		};
+	}
+	if (arg2 instanceof Uint8Array && typeof arg3 === "function") return {
+		store: arg1,
+		keyPrefix: arg2.slice(),
+		callback: arg3
+	};
+	throw new TypeError("subscribe() expects one of: (callback), (storeName, callback), (storeName, keyPrefix, callback)");
+}
+var SubscriptionHub = class {
+	#dbName;
+	#channelName;
+	#channel = null;
+	#entries = /* @__PURE__ */ new Set();
+	#closed = false;
+	constructor(dbName, channelName = dbName) {
+		this.#dbName = dbName;
+		this.#channelName = channelName;
+	}
+	subscribe(arg1, arg2, arg3) {
+		if (this.#closed) throw new DatabaseClosedError();
+		const spec = normalizeSubscriptionSpec(arg1, arg2, arg3);
+		const entry = {
+			active: true,
+			store: spec.store,
+			keyPrefix: spec.keyPrefix,
+			callback: spec.callback
+		};
+		this.#ensureChannel();
+		this.#entries.add(entry);
+		return () => {
+			if (!entry.active) return;
+			entry.active = false;
+			this.#entries.delete(entry);
+			if (this.#entries.size === 0) this.#disposeChannel();
+		};
+	}
+	close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		for (const entry of this.#entries) entry.active = false;
+		this.#entries.clear();
+		this.#disposeChannel();
+	}
+	#ensureChannel() {
+		if (this.#channel !== null || this.#closed) return;
+		const channel = new BroadcastChannel(`db:${this.#channelName}:events`);
+		channel.onmessage = (event) => {
+			this.#handleMessage(event.data);
+		};
+		this.#channel = channel;
+	}
+	#disposeChannel() {
+		this.#channel?.close();
+		this.#channel = null;
+	}
+	#handleMessage(payload) {
+		if (!isCommitAppliedEvent(payload) || payload.dbName !== this.#dbName || this.#entries.size === 0) return;
+		const entries = Array.from(this.#entries);
+		for (const storeEvent of payload.stores) for (const entry of entries) {
+			if (!entry.active) continue;
+			if (entry.store !== null && entry.store !== storeEvent.store) continue;
+			let changes;
+			const keyPrefix = entry.keyPrefix;
+			if (keyPrefix === null) changes = cloneChanges(storeEvent.changes);
+			else {
+				changes = cloneChanges(storeEvent.changes.filter((change) => change.kind === "clear" || change.kind === "drop" || hasKeyPrefix(change.key, keyPrefix)));
+				if (changes.length === 0) continue;
+			}
+			try {
+				entry.callback(storeEvent.store, changes, payload.txid);
+			} catch (error) {
+				queueMicrotask(() => {
+					throw error;
+				});
+			}
+		}
+	}
+};
+//#endregion
+//#region src/records.ts
+var fatalDecoder = new TextDecoder("utf-8", { fatal: true });
+var NUMBER_MASK = (1n << 64n) - 1n;
+var NUMBER_SIGN = 1n << 63n;
+function sameBytes(left, right) {
+	return left.length === right.length && left.every((byte, index) => byte === right[index]);
+}
+function decodeScalarKey(bytes) {
+	if (!(bytes instanceof Uint8Array) || bytes.length === 0) throw new TypeError("invalid scalar key encoding");
+	let value;
+	switch (bytes[0]) {
+		case 16:
+			value = null;
+			break;
+		case 32:
+			value = false;
+			break;
+		case 33:
+			value = true;
+			break;
+		case 48: {
+			if (bytes.length !== 9) throw new TypeError("invalid number key encoding");
+			const ordered = new DataView(bytes.buffer, bytes.byteOffset + 1, 8).getBigUint64(0, false);
+			const bits = (ordered & NUMBER_SIGN) !== 0n ? ordered ^ NUMBER_SIGN : ordered ^ NUMBER_MASK;
+			const decoded = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+			decoded.setBigUint64(0, bits, false);
+			value = decoded.getFloat64(0, false);
+			break;
+		}
+		case 64:
+			value = fatalDecoder.decode(bytes.subarray(1));
+			break;
+		case 80:
+			value = bytes.slice(1);
+			break;
+		default: throw new TypeError("invalid scalar key type");
+	}
+	if (!sameBytes(encodeIndexScalar(value), bytes)) throw new TypeError("noncanonical scalar key encoding");
+	return value;
+}
+var scalarKeyCodec = Object.freeze({
+	encode: encodeIndexScalar,
+	decode: decodeScalarKey
+});
+function typedKeyCodec(type, accepts) {
+	function check(value) {
+		if (!accepts(value)) throw new TypeError(`key must be ${type}`);
+		return value;
+	}
+	return Object.freeze({
+		encode(value) {
+			return encodeIndexScalar(check(value));
+		},
+		decode(bytes) {
+			return check(decodeScalarKey(bytes));
+		}
+	});
+}
+var keyCodecs = Object.freeze({
+	string: typedKeyCodec("a string", (value) => typeof value === "string"),
+	number: typedKeyCodec("a finite number", (value) => typeof value === "number"),
+	boolean: typedKeyCodec("a boolean", (value) => typeof value === "boolean"),
+	null: typedKeyCodec("null", (value) => value === null),
+	bytes: typedKeyCodec("Uint8Array", (value) => value instanceof Uint8Array)
+});
+function compoundKeyCodec(...parts) {
+	return Object.freeze({
+		encode(value) {
+			if (!Array.isArray(value) || value.length !== parts.length) throw new TypeError(`compound key must contain ${parts.length} parts`);
+			return encodeCompoundKeyParts(parts.map((codec, index) => codec.encode(value[index])));
+		},
+		decode(bytes) {
+			const encoded = splitCompoundKey(bytes);
+			if (encoded.length !== parts.length) throw new TypeError(`compound key must contain ${parts.length} parts`);
+			return parts.map((codec, index) => codec.decode(encoded[index]));
+		}
+	});
+}
+function assertJsonValue(value) {
+	const pending = [{ value }];
+	const active = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const entry = pending.pop();
+		const current = entry.value;
+		if (entry.leave) {
+			active.delete(current);
+			continue;
+		}
+		if (current === null || typeof current === "string" || typeof current === "boolean") continue;
+		if (typeof current === "number" && Number.isFinite(current) && !Object.is(current, -0)) continue;
+		if (typeof current !== "object" || active.has(current)) throw new TypeError("record must contain JSON values without cycles, nonfinite numbers or negative zero");
+		const array = Array.isArray(current);
+		if (Object.getPrototypeOf(current) !== (array ? Array.prototype : Object.prototype)) throw new TypeError("record objects must be plain objects or arrays");
+		active.add(current);
+		pending.push({
+			value: current,
+			leave: true
+		});
+		const keys = Reflect.ownKeys(current);
+		if (array && keys.length !== current.length + 1) throw new TypeError("record arrays must be dense and have no extra properties");
+		for (const key of keys) {
+			if (array && key === "length") continue;
+			if (typeof key !== "string") throw new TypeError("record properties must have string keys");
+			if (array && (!/^(?:0|[1-9]\d*)$/.test(key) || Number(key) >= current.length)) throw new TypeError("record arrays must have no extra properties");
+			const descriptor = Object.getOwnPropertyDescriptor(current, key);
+			if (!descriptor || !descriptor.enumerable || !Object.hasOwn(descriptor, "value")) throw new TypeError("record properties must be enumerable data properties");
+			pending.push({ value: descriptor.value });
+		}
+	}
+}
+/** A type guard checks the application schema. Without one, only the JSON domain is checked. */
+function jsonRecordCodec(validate) {
+	function check(value) {
+		assertJsonValue(value);
+		if (validate) {
+			if (!validate(value)) throw new TypeError("record does not match its schema");
+			assertJsonValue(value);
+		}
+		return value;
+	}
+	return Object.freeze({
+		encode(value) {
+			return jsonEncode(check(value));
+		},
+		decode(bytes) {
+			return check(jsonDecode(bytes));
+		}
+	});
+}
+function encodeRange(codec, range) {
+	const encoded = {};
+	for (const bound of [
+		"gt",
+		"gte",
+		"lt",
+		"lte"
+	]) if (Object.hasOwn(range, bound)) encoded[bound] = codec.encode(range[bound]);
+	if (range.reverse !== void 0) encoded.reverse = range.reverse;
+	if (range.limit !== void 0) encoded.limit = range.limit;
+	return encoded;
+}
+async function withRecordTransaction(db, mode, action) {
+	const transaction = await db.begin(mode);
+	let result;
+	try {
+		result = await action(transaction);
+	} catch (error) {
+		try {
+			await transaction.rollback();
+		} catch (rollbackError) {
+			if (!(rollbackError instanceof TransactionClosedError)) throw new AggregateError([error, rollbackError], "record transaction and rollback failed", { cause: rollbackError });
+		}
+		throw error;
+	}
+	if (mode === "readwrite") await transaction.commit();
+	else await transaction.rollback();
+	return result;
+}
+function useTransaction(source, mode, action) {
+	return "begin" in source ? withRecordTransaction(source, mode, action) : action(source);
+}
+var RecordIndex = class {
+	name;
+	#source;
+	#store;
+	#indexKey;
+	#codecs;
+	constructor(source, store, name, indexKey, codecs) {
+		this.#source = source;
+		this.#store = store;
+		this.name = name;
+		this.#indexKey = indexKey;
+		this.#codecs = codecs;
+	}
+	async get(key) {
+		const encoded = this.#indexKey.encode(key);
+		return useTransaction(this.#source, "readonly", async (transaction) => {
+			const value = await transaction.getByIndex(this.#store, this.name, encoded);
+			return value === null ? null : this.#codecs.value.decode(value);
+		});
+	}
+	async scan(range = {}) {
+		const encoded = encodeRange(this.#indexKey, range);
+		return useTransaction(this.#source, "readonly", async (transaction) => {
+			const rows = [];
+			for await (const [key, value] of transaction.scanByIndex(this.#store, this.name, encoded)) rows.push({
+				key: this.#codecs.key.decode(key),
+				value: this.#codecs.value.decode(value)
+			});
+			return rows;
+		});
+	}
+};
+var RecordStore = class RecordStore {
+	name;
+	#source;
+	#codecs;
+	constructor(source, name, codecs) {
+		this.#source = source;
+		this.name = name;
+		this.#codecs = codecs;
+	}
+	async get(key) {
+		const value = await this.#source.get(this.name, this.#codecs.key.encode(key));
+		return value === null ? null : this.#codecs.value.decode(value);
+	}
+	async getMany(keys) {
+		return (await this.#source.getMany(this.name, keys.map((key) => this.#codecs.key.encode(key)))).map((value) => value === null ? null : this.#codecs.value.decode(value));
+	}
+	async has(key) {
+		return this.#source.has(this.name, this.#codecs.key.encode(key));
+	}
+	async put(key, value, options) {
+		await this.#source.put(this.name, this.#codecs.key.encode(key), this.#codecs.value.encode(value), options);
+	}
+	async putMany(entries, options) {
+		const encoded = entries.map(([key, value]) => [this.#codecs.key.encode(key), this.#codecs.value.encode(value)]);
+		await useTransaction(this.#source, "readwrite", (transaction) => transaction.putMany(this.name, encoded, options));
+	}
+	async delete(key) {
+		return this.#source.delete(this.name, this.#codecs.key.encode(key));
+	}
+	async deleteMany(keys) {
+		const encoded = keys.map((key) => this.#codecs.key.encode(key));
+		await useTransaction(this.#source, "readwrite", (transaction) => transaction.deleteMany(this.name, encoded));
+	}
+	async applyBatch(operations) {
+		const encoded = operations.map((operation) => {
+			const kind = operation.kind;
+			if (kind !== "put" && kind !== "delete") throw new TypeError("record batch operation must be put or delete");
+			const key = this.#codecs.key.encode(operation.key);
+			if (operation.kind === "delete") return {
+				kind: "delete",
+				key
+			};
+			return {
+				kind: "put",
+				key,
+				value: this.#codecs.value.encode(operation.value)
+			};
+		});
+		await useTransaction(this.#source, "readwrite", (transaction) => transaction.applyBatch(this.name, encoded));
+	}
+	async scan(range = {}) {
+		return (await this.#source.scan(this.name, encodeRange(this.#codecs.key, range))).map(({ key, value }) => ({
+			key: this.#codecs.key.decode(key),
+			value: this.#codecs.value.decode(value)
+		}));
+	}
+	async clear() {
+		await this.#source.clearStore(this.name);
+	}
+	index(name, key) {
+		return new RecordIndex(this.#source, this.name, name, key, this.#codecs);
+	}
+	transaction(mode, action) {
+		if (!("begin" in this.#source)) return Promise.reject(/* @__PURE__ */ new TypeError("record store already belongs to a transaction"));
+		return withRecordTransaction(this.#source, mode, (transaction) => action(new RecordStore(transaction, this.name, this.#codecs), transaction));
+	}
+};
+/** Bind codecs to an existing store. The database still enforces store existence. */
+function openRecordStore(source, name, codecs) {
+	return new RecordStore(source, name, codecs);
+}
+async function createRecordStore(source, name, codecs, options) {
+	await source.createStore(name, options);
+	return openRecordStore(source, name, codecs);
+}
+//#endregion
+//#region src/sql-types.ts
+var SQL_INTEGER_MIN = -(1n << 63n);
+var SQL_INTEGER_MAX = (1n << 63n) - 1n;
+//#endregion
+//#region src/sql-parser.ts
+var MAX_SQL_LENGTH = 1048576;
+var MAX_TOKENS = 16384;
+var MAX_NESTING = 64;
+var MAX_PREDICATES = 128;
+var MAX_IDENTIFIER_LENGTH = 128;
+var MAX_NUMBER_LENGTH = 1024;
+var FORBIDDEN_IDENTIFIERS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+var COLUMN_TYPES$1 = /* @__PURE__ */ new Set([
+	"INTEGER",
+	"REAL",
+	"TEXT",
+	"BOOLEAN",
+	"BLOB"
+]);
+var KEYWORDS = /* @__PURE__ */ new Set([
+	"CREATE",
+	"TABLE",
+	"IF",
+	"NOT",
+	"EXISTS",
+	"DROP",
+	"INSERT",
+	"INTO",
+	"VALUES",
+	"SELECT",
+	"FROM",
+	"WHERE",
+	"ORDER",
+	"BY",
+	"ASC",
+	"DESC",
+	"LIMIT",
+	"OFFSET",
+	"UPDATE",
+	"SET",
+	"DELETE",
+	"PRIMARY",
+	"KEY",
+	"NULL",
+	"TRUE",
+	"FALSE",
+	"IS",
+	"AND",
+	"OR",
+	"JOIN",
+	"LEFT",
+	"RIGHT",
+	"INNER",
+	"OUTER",
+	"CROSS",
+	"ON",
+	"AS",
+	"DISTINCT",
+	"GROUP",
+	"HAVING",
+	"UNION",
+	"ALL",
+	"IN",
+	"LIKE",
+	"BETWEEN",
+	"DEFAULT",
+	"UNIQUE",
+	"CHECK",
+	"REFERENCES",
+	"CONSTRAINT",
+	"FOREIGN",
+	"AUTOINCREMENT",
+	"RETURNING",
+	"CONFLICT",
+	...COLUMN_TYPES$1
+]);
+var SqlSyntaxError = class extends SyntaxError {
+	position;
+	constructor(message, position) {
+		super(`${message} at position ${position}`);
+		this.name = "SqlSyntaxError";
+		this.position = position;
+	}
+};
+function parseSql(sql) {
+	if (typeof sql !== "string") throw new TypeError("SQL must be a string");
+	if (sql.length > MAX_SQL_LENGTH) throw new SqlSyntaxError(`SQL exceeds ${MAX_SQL_LENGTH} characters`, MAX_SQL_LENGTH);
+	return new Parser(tokenize(sql)).parse();
+}
+function bindSqlParameters(parsed, parameters = []) {
+	if (!Array.isArray(parameters)) throw new TypeError("SQL parameters must be an array");
+	if (parameters.length !== parsed.parameterCount) throw new RangeError(`SQL expects ${parsed.parameterCount} parameters; received ${parameters.length}`);
+	return Array.from(parameters, (value, index) => {
+		if (value === null || typeof value === "boolean") return value;
+		if (typeof value === "number") {
+			if (!Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value)) throw new RangeError(`SQL parameter ${index + 1} must be finite; use bigint for integers outside the safe range`);
+			return value;
+		}
+		if (typeof value === "bigint") {
+			if (value < SQL_INTEGER_MIN || value > SQL_INTEGER_MAX) throw new RangeError(`SQL parameter ${index + 1} exceeds the signed 64-bit integer range`);
+			return value;
+		}
+		if (typeof value === "string") {
+			if (!hasValidUnicode(value)) throw new TypeError(`SQL parameter ${index + 1} must contain valid Unicode scalar values`);
+			return value;
+		}
+		if (value instanceof Uint8Array) return Uint8Array.from(value);
+		throw new TypeError(`SQL parameter ${index + 1} must be null, boolean, number, bigint, string, or Uint8Array`);
+	});
+}
+function resolveSqlValue(expression, parameters) {
+	if (expression.kind === "literal") return expression.value;
+	if (!Number.isSafeInteger(expression.index) || expression.index < 0 || expression.index >= parameters.length) throw new RangeError(`SQL parameter ${expression.index + 1} is missing`);
+	const value = parameters.at(expression.index);
+	if (value === void 0) throw new RangeError(`SQL parameter ${expression.index + 1} is missing`);
+	return value;
+}
+var Parser = class {
+	#tokens;
+	#index = 0;
+	#parameterCount = 0;
+	#nesting = 0;
+	#predicates = 0;
+	constructor(tokens) {
+		this.#tokens = tokens;
+	}
+	parse() {
+		const statement = this.#parseStatement();
+		this.#acceptSymbol(";");
+		if (this.#current().kind !== "end") throw this.#error("Unexpected or unsupported SQL syntax");
+		return {
+			statement,
+			parameterCount: this.#parameterCount
+		};
+	}
+	#parseStatement() {
+		if (this.#acceptKeyword("CREATE")) return this.#createTable();
+		if (this.#acceptKeyword("DROP")) return this.#dropTable();
+		if (this.#acceptKeyword("INSERT")) return this.#insert();
+		if (this.#acceptKeyword("SELECT")) return this.#select();
+		if (this.#acceptKeyword("UPDATE")) return this.#update();
+		if (this.#acceptKeyword("DELETE")) return this.#delete();
+		throw this.#error("Expected CREATE TABLE, DROP TABLE, INSERT, SELECT, UPDATE, or DELETE");
+	}
+	#createTable() {
+		this.#expectKeyword("TABLE");
+		const ifNotExists = this.#acceptKeyword("IF");
+		if (ifNotExists) {
+			this.#expectKeyword("NOT");
+			this.#expectKeyword("EXISTS");
+		}
+		const table = this.#identifier();
+		this.#expectSymbol("(");
+		const columns = [];
+		const names = /* @__PURE__ */ new Set();
+		let primaryKeyCount = 0;
+		do {
+			const name = this.#identifier();
+			this.#assertUnique(names, name, "column");
+			const typeToken = this.#current();
+			const type = typeToken.text.toUpperCase();
+			if (typeToken.kind !== "word" || !COLUMN_TYPES$1.has(type)) throw this.#error("Expected INTEGER, REAL, TEXT, BOOLEAN, or BLOB column type");
+			this.#index += 1;
+			let primaryKey = false;
+			let nullable = true;
+			let nullabilitySpecified = false;
+			for (;;) if (this.#acceptKeyword("PRIMARY")) {
+				if (primaryKey) throw this.#error("Duplicate PRIMARY KEY constraint");
+				this.#expectKeyword("KEY");
+				primaryKey = true;
+				primaryKeyCount += 1;
+				if (primaryKeyCount > 1) throw this.#error("Only one inline PRIMARY KEY is supported");
+			} else if (this.#acceptKeyword("NOT")) {
+				this.#expectKeyword("NULL");
+				if (nullabilitySpecified) throw this.#error("Duplicate nullability constraint");
+				nullable = false;
+				nullabilitySpecified = true;
+			} else if (this.#acceptKeyword("NULL")) {
+				if (nullabilitySpecified) throw this.#error("Duplicate nullability constraint");
+				nullable = true;
+				nullabilitySpecified = true;
+			} else break;
+			if (primaryKey && nullable && nullabilitySpecified) throw this.#error("PRIMARY KEY cannot be declared NULL");
+			columns.push({
+				name,
+				type,
+				primaryKey,
+				nullable: primaryKey ? false : nullable
+			});
+		} while (this.#acceptSymbol(","));
+		this.#expectSymbol(")");
+		return {
+			kind: "createTable",
+			table,
+			columns,
+			ifNotExists
+		};
+	}
+	#dropTable() {
+		this.#expectKeyword("TABLE");
+		const ifExists = this.#acceptKeyword("IF");
+		if (ifExists) this.#expectKeyword("EXISTS");
+		return {
+			kind: "dropTable",
+			table: this.#identifier(),
+			ifExists
+		};
+	}
+	#insert() {
+		this.#expectKeyword("INTO");
+		const table = this.#identifier();
+		let columns = null;
+		if (this.#acceptSymbol("(")) {
+			columns = this.#identifierList();
+			this.#expectSymbol(")");
+		}
+		this.#expectKeyword("VALUES");
+		const rows = [];
+		let width = columns?.length;
+		do {
+			this.#expectSymbol("(");
+			const row = [this.#value()];
+			while (this.#acceptSymbol(",")) row.push(this.#value());
+			this.#expectSymbol(")");
+			width ??= row.length;
+			if (row.length !== width) throw this.#error("INSERT rows must match the column count");
+			rows.push(row);
+		} while (this.#acceptSymbol(","));
+		return {
+			kind: "insert",
+			table,
+			columns,
+			rows
+		};
+	}
+	#select() {
+		const columns = this.#acceptSymbol("*") ? null : this.#identifierList();
+		this.#expectKeyword("FROM");
+		const table = this.#identifier();
+		const where = this.#where();
+		const orderBy = [];
+		if (this.#acceptKeyword("ORDER")) {
+			this.#expectKeyword("BY");
+			const names = /* @__PURE__ */ new Set();
+			do {
+				const column = this.#identifier();
+				this.#assertUnique(names, column, "ORDER BY column");
+				const direction = this.#acceptKeyword("DESC") ? "desc" : "asc";
+				if (direction === "asc") this.#acceptKeyword("ASC");
+				orderBy.push({
+					column,
+					direction
+				});
+			} while (this.#acceptSymbol(","));
+		}
+		let limit = null;
+		let offset = null;
+		if (this.#acceptKeyword("LIMIT")) {
+			limit = this.#rowCount("LIMIT");
+			if (this.#acceptKeyword("OFFSET")) offset = this.#rowCount("OFFSET");
+		}
+		return {
+			kind: "select",
+			table,
+			columns,
+			where,
+			orderBy,
+			limit,
+			offset
+		};
+	}
+	#update() {
+		const table = this.#identifier();
+		this.#expectKeyword("SET");
+		const assignments = [];
+		const names = /* @__PURE__ */ new Set();
+		do {
+			const column = this.#identifier();
+			this.#assertUnique(names, column, "assignment");
+			this.#expectSymbol("=");
+			assignments.push({
+				column,
+				value: this.#value()
+			});
+		} while (this.#acceptSymbol(","));
+		return {
+			kind: "update",
+			table,
+			assignments,
+			where: this.#where()
+		};
+	}
+	#delete() {
+		this.#expectKeyword("FROM");
+		return {
+			kind: "delete",
+			table: this.#identifier(),
+			where: this.#where()
+		};
+	}
+	#where() {
+		return this.#acceptKeyword("WHERE") ? this.#or() : null;
+	}
+	#or() {
+		let expression = this.#and();
+		while (this.#acceptKeyword("OR")) expression = {
+			kind: "or",
+			left: expression,
+			right: this.#and()
+		};
+		return expression;
+	}
+	#and() {
+		let expression = this.#predicate();
+		while (this.#acceptKeyword("AND")) expression = {
+			kind: "and",
+			left: expression,
+			right: this.#predicate()
+		};
+		return expression;
+	}
+	#predicate() {
+		if (this.#acceptSymbol("(")) {
+			this.#nesting += 1;
+			if (this.#nesting > MAX_NESTING) throw this.#error(`WHERE nesting exceeds ${MAX_NESTING}`);
+			const expression = this.#or();
+			this.#expectSymbol(")");
+			this.#nesting -= 1;
+			return expression;
+		}
+		this.#predicates += 1;
+		if (this.#predicates > MAX_PREDICATES) throw this.#error(`WHERE predicates exceed ${MAX_PREDICATES}`);
+		const column = this.#identifier();
+		if (this.#acceptKeyword("IS")) {
+			const negated = this.#acceptKeyword("NOT");
+			this.#expectKeyword("NULL");
+			return {
+				kind: "isNull",
+				column,
+				negated
+			};
+		}
+		const token = this.#current();
+		if (token.kind !== "symbol" || ![
+			"=",
+			"!=",
+			"<>",
+			"<",
+			"<=",
+			">",
+			">="
+		].includes(token.text)) throw this.#error("Expected a comparison operator or IS [NOT] NULL");
+		this.#index += 1;
+		return {
+			kind: "comparison",
+			column,
+			operator: token.text === "<>" ? "!=" : token.text,
+			value: this.#value()
+		};
+	}
+	#rowCount(clause) {
+		const value = this.#value();
+		if (value.kind === "literal" && (typeof value.value !== "number" || !Number.isSafeInteger(value.value) || value.value < 0)) throw this.#error(`${clause} must be a non-negative safe integer or parameter`);
+		return value;
+	}
+	#value() {
+		const token = this.#current();
+		if (token.kind === "parameter") {
+			this.#index += 1;
+			return {
+				kind: "parameter",
+				index: this.#parameterCount++
+			};
+		}
+		if (token.kind === "string") {
+			this.#index += 1;
+			return {
+				kind: "literal",
+				value: token.text
+			};
+		}
+		if (this.#acceptKeyword("NULL")) return {
+			kind: "literal",
+			value: null
+		};
+		if (this.#acceptKeyword("TRUE")) return {
+			kind: "literal",
+			value: true
+		};
+		if (this.#acceptKeyword("FALSE")) return {
+			kind: "literal",
+			value: false
+		};
+		const sign = this.#acceptSymbol("-") ? "-" : this.#acceptSymbol("+") ? "+" : "";
+		const number = this.#current();
+		if (number.kind === "number") {
+			this.#index += 1;
+			return {
+				kind: "literal",
+				value: parseNumber(sign + number.text, token.position)
+			};
+		}
+		throw this.#error("Expected a scalar literal or positional ? parameter");
+	}
+	#identifierList() {
+		const names = /* @__PURE__ */ new Set();
+		const columns = [];
+		do {
+			const name = this.#identifier();
+			this.#assertUnique(names, name, "column");
+			columns.push(name);
+		} while (this.#acceptSymbol(","));
+		return columns;
+	}
+	#identifier() {
+		const token = this.#current();
+		if (token.kind !== "identifier" && (token.kind !== "word" || KEYWORDS.has(token.text.toUpperCase()))) throw this.#error("Expected an identifier; use double quotes for keywords");
+		if (token.text.length === 0 || token.text.length > MAX_IDENTIFIER_LENGTH || hasControlCharacters(token.text) || FORBIDDEN_IDENTIFIERS.has(token.text.toLowerCase()) || !hasValidUnicode(token.text)) throw this.#error("Invalid or reserved identifier");
+		this.#index += 1;
+		return token.text;
+	}
+	#assertUnique(names, name, label) {
+		if (names.has(name)) throw this.#error(`Duplicate ${label}: ${name}`);
+		names.add(name);
+	}
+	#current() {
+		return this.#tokens[this.#index];
+	}
+	#acceptKeyword(keyword) {
+		const token = this.#current();
+		if (token.kind !== "word" || token.text.toUpperCase() !== keyword) return false;
+		this.#index += 1;
+		return true;
+	}
+	#expectKeyword(keyword) {
+		if (!this.#acceptKeyword(keyword)) throw this.#error(`Expected ${keyword}`);
+	}
+	#acceptSymbol(symbol) {
+		const token = this.#current();
+		if (token.kind !== "symbol" || token.text !== symbol) return false;
+		this.#index += 1;
+		return true;
+	}
+	#expectSymbol(symbol) {
+		if (!this.#acceptSymbol(symbol)) throw this.#error(`Expected ${symbol}`);
+	}
+	#error(message) {
+		return new SqlSyntaxError(message, this.#current().position);
+	}
+};
+function tokenize(sql) {
+	const tokens = [];
+	let index = 0;
+	while (index < sql.length) {
+		const character = sql[index];
+		if (/\s/u.test(character)) {
+			index += 1;
+			continue;
+		}
+		if (sql.startsWith("--", index)) {
+			index += 2;
+			while (index < sql.length && sql[index] !== "\n" && sql[index] !== "\r") index += 1;
+			continue;
+		}
+		if (sql.startsWith("/*", index)) {
+			const end = sql.indexOf("*/", index + 2);
+			if (end < 0) throw new SqlSyntaxError("Unterminated block comment", index);
+			index = end + 2;
+			continue;
+		}
+		if (tokens.length >= MAX_TOKENS) throw new SqlSyntaxError(`SQL token count exceeds ${MAX_TOKENS}`, index);
+		const position = index;
+		if (character === "'" || character === "\"") {
+			const quote = character;
+			let text = "";
+			let closed = false;
+			index += 1;
+			while (index < sql.length) if (sql[index] === quote) {
+				if (sql[index + 1] === quote) {
+					text += quote;
+					index += 2;
+				} else {
+					index += 1;
+					closed = true;
+					break;
+				}
+			} else text += sql[index++];
+			if (!closed) throw new SqlSyntaxError("Unterminated quoted token", position);
+			if (!hasValidUnicode(text)) throw new SqlSyntaxError("Quoted token must contain valid Unicode scalar values", position);
+			tokens.push({
+				kind: quote === "'" ? "string" : "identifier",
+				text,
+				position
+			});
+		} else if (/[A-Za-z_]/u.test(character)) {
+			index += 1;
+			while (index < sql.length && /\w/u.test(sql[index])) index += 1;
+			tokens.push({
+				kind: "word",
+				text: sql.slice(position, index),
+				position
+			});
+		} else if (/\d/u.test(character) || character === "." && /\d/u.test(sql[index + 1] ?? "")) {
+			index += 1;
+			while (index < sql.length && /\d/u.test(sql[index])) index += 1;
+			if (character !== "." && sql[index] === ".") {
+				index += 1;
+				while (index < sql.length && /\d/u.test(sql[index])) index += 1;
+			}
+			if (sql[index] === "e" || sql[index] === "E") {
+				index += 1;
+				if (sql[index] === "+" || sql[index] === "-") index += 1;
+				const exponentStart = index;
+				while (index < sql.length && /\d/u.test(sql[index])) index += 1;
+				if (index === exponentStart) throw new SqlSyntaxError("Invalid numeric exponent", position);
+			}
+			const text = sql.slice(position, index);
+			if (text.length > MAX_NUMBER_LENGTH) throw new SqlSyntaxError(`Numeric literal exceeds ${MAX_NUMBER_LENGTH} characters`, position);
+			tokens.push({
+				kind: "number",
+				text,
+				position
+			});
+		} else if (character === "?") {
+			index += 1;
+			tokens.push({
+				kind: "parameter",
+				text: character,
+				position
+			});
+		} else {
+			const pair = sql.slice(index, index + 2);
+			if ([
+				"<=",
+				">=",
+				"<>",
+				"!="
+			].includes(pair)) {
+				index += 2;
+				tokens.push({
+					kind: "symbol",
+					text: pair,
+					position
+				});
+			} else if ("(),;*=<>+-".includes(character)) {
+				index += 1;
+				tokens.push({
+					kind: "symbol",
+					text: character,
+					position
+				});
+			} else throw new SqlSyntaxError(`Unsupported SQL character: ${character}`, position);
+		}
+	}
+	tokens.push({
+		kind: "end",
+		text: "",
+		position: sql.length
+	});
+	return tokens;
+}
+function parseNumber(text, position) {
+	if (/^[+-]?\d+$/u.test(text)) {
+		const integer = BigInt(text);
+		if (integer < SQL_INTEGER_MIN || integer > SQL_INTEGER_MAX) throw new SqlSyntaxError("Integer literal exceeds the signed 64-bit range", position);
+		return integer >= BigInt(Number.MIN_SAFE_INTEGER) && integer <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(integer) : integer;
+	}
+	const value = Number(text);
+	if (!Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value)) throw new SqlSyntaxError("REAL literal must be finite; use integer notation for large integers", position);
+	const [mantissa, exponentText = "0"] = text.toLowerCase().split("e");
+	const digits = mantissa.replace(/[+.-]/gu, "");
+	const nonzero = /[1-9]/u.test(digits);
+	if (value === 0 && nonzero) throw new SqlSyntaxError("REAL literal underflows to zero", position);
+	if (Number.isInteger(value) && nonzero) {
+		const fractionLength = mantissa.includes(".") ? mantissa.length - mantissa.indexOf(".") - 1 : 0;
+		const trailingZeros = digits.length - digits.replace(/0+$/u, "").length;
+		if (Number(exponentText) - fractionLength + trailingZeros < 0) throw new SqlSyntaxError("REAL literal loses its fractional part", position);
+	}
+	return value;
+}
+function hasValidUnicode(value) {
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint >= 55296 && codePoint <= 57343) return false;
+	}
+	return true;
+}
+function hasControlCharacters(value) {
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint < 32 || codePoint === 127) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/sql.ts
+var CATALOG = "_moyodb_sql_catalog";
+var OWNER_KEY = Uint8Array.of(0);
+var OWNER = {
+	format: "moyodb.sql",
+	version: 1
+};
+var TABLE_OWNER_KEY = Uint8Array.of(255);
+var TABLE_OWNER_FIELD = "\0moyodb.sql.table";
+var INTEGER_MIN = -(1n << 63n);
+var INTEGER_MAX = (1n << 63n) - 1n;
+var ROW_ID_MAX = (1n << 64n) - 1n;
+var COLUMN_TYPES = /* @__PURE__ */ new Set([
+	"INTEGER",
+	"REAL",
+	"TEXT",
+	"BOOLEAN",
+	"BLOB"
+]);
+var SqlSchemaError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "SqlSchemaError";
+	}
+};
+var SqlTypeError = class extends TypeError {
+	constructor(message) {
+		super(message);
+		this.name = "SqlTypeError";
+	}
+};
+function createSqlClient(db, options = {}) {
+	const expectedIndexes = options.indexes === void 0 ? null : normalizeIndexDefinitions(options.indexes);
+	const run = async (sql, parameters, explain) => {
+		const parsed = parseSql(sql);
+		const bound = bindSqlParameters(parsed, parameters);
+		const statement = parsed.statement;
+		if (explain && !isRowStatement(statement)) throw new SqlSchemaError("EXPLAIN requires SELECT, UPDATE, or DELETE");
+		const tx = await db.begin(statement.kind === "select" || explain ? "readonly" : "readwrite");
+		let finished = false;
+		try {
+			const indexes = normalizeIndexDefinitions(await tx.listIndexes?.() ?? []);
+			if (expectedIndexes && serializeNormalizedIndexDefinitions(expectedIndexes) !== serializeNormalizedIndexDefinitions(indexes)) throw new SqlSchemaError("SQL index definitions do not match the transaction catalog");
+			const result = await executeStatement(tx, statement, bound, indexes, explain);
+			finished = true;
+			if (tx.mode === "readwrite") await tx.commit();
+			else await tx.rollback();
+			return result;
+		} catch (error) {
+			if (!finished) try {
+				await tx.rollback();
+			} catch (rollbackError) {
+				throw new AggregateError([error, rollbackError], "SQL statement and rollback failed", { cause: rollbackError });
+			}
+			throw error;
+		}
+	};
+	return {
+		execute: (sql, parameters = []) => run(sql, parameters, false),
+		async query(sql, parameters = []) {
+			if (parseSql(sql).statement.kind !== "select") throw new SqlSchemaError("query() requires SELECT");
+			return (await run(sql, parameters, false)).rows;
+		},
+		async explain(sql, parameters = []) {
+			const result = await run(sql, parameters, true);
+			if (!result.plan) throw new SqlSchemaError("statement has no query plan");
+			return result.plan;
+		}
+	};
+}
+async function executeStatement(tx, statement, parameters, indexes, explain) {
+	assertTableName(statement.table);
+	const catalogExists = await readCatalog(tx);
+	const schema = catalogExists ? await readSchema(tx, statement.table) : null;
+	if (schema) await assertTableOwnership(tx, schema);
+	if (statement.kind === "createTable") {
+		if (schema) {
+			if (statement.ifNotExists) return {
+				rows: [],
+				rowsAffected: 0
+			};
+			throw new SqlSchemaError(`table already exists: ${statement.table}`);
+		}
+		const created = {
+			version: 1,
+			table: statement.table,
+			columns: statement.columns,
+			nextRowId: "1"
+		};
+		validateSchema(created, statement.table);
+		if (!catalogExists) {
+			await tx.createStore(CATALOG);
+			await tx.put(CATALOG, OWNER_KEY, jsonEncode(OWNER));
+		}
+		await tx.createStore(statement.table);
+		await tx.put(statement.table, TABLE_OWNER_KEY, tableOwnerValue(created));
+		await tx.put(CATALOG, schemaKey(statement.table), jsonEncode(created));
+		return {
+			rows: [],
+			rowsAffected: 0
+		};
+	}
+	if (!schema) {
+		if (statement.kind === "dropTable" && statement.ifExists) return {
+			rows: [],
+			rowsAffected: 0
+		};
+		throw new SqlSchemaError(`table does not exist: ${statement.table}`);
+	}
+	if (statement.kind === "dropTable") {
+		await tx.dropStore(statement.table);
+		await tx.delete(CATALOG, schemaKey(statement.table));
+		return {
+			rows: [],
+			rowsAffected: 0
+		};
+	}
+	if (statement.kind === "insert") return insertRows(tx, schema, statement, parameters);
+	validateWhere(schema, statement.where, parameters);
+	if (statement.kind === "select") {
+		validateColumnList(schema, statement.columns);
+		for (const order of statement.orderBy) getColumn(schema, order.column);
+	}
+	if (statement.kind === "update") {
+		validateColumnList(schema, statement.assignments.map((assignment) => assignment.column));
+		for (const assignment of statement.assignments) normalizeValue(getColumn(schema, assignment.column), resolveSqlValue(assignment.value, parameters));
+	}
+	const orderBy = statement.kind === "select" ? statement.orderBy : [];
+	const plan = planAccess(schema, statement.where, orderBy, parameters, indexes);
+	const limit = statement.kind === "select" ? resolveCount(statement.limit, parameters, "LIMIT") : null;
+	const offset = statement.kind === "select" ? resolveCount(statement.offset, parameters, "OFFSET") ?? 0 : 0;
+	if (explain) return {
+		rows: [],
+		rowsAffected: 0,
+		plan: plan.public
+	};
+	const rows = (limit === 0 ? [] : await readRows(tx, schema, plan)).filter(({ row }) => !statement.where || evaluateWhere(row, statement.where, parameters) === true);
+	if (statement.kind === "select") {
+		if (orderBy.length) rows.sort((left, right) => compareRows(left, right, orderBy));
+		return {
+			rows: rows.slice(offset, limit === null ? void 0 : offset + limit).map(({ row }) => projectRow(row, statement.columns ?? schema.columns.map((column) => column.name))),
+			rowsAffected: 0,
+			plan: plan.public
+		};
+	}
+	if (statement.kind === "delete") {
+		await tx.deleteMany(schema.table, rows.map(({ key }) => key));
+		return {
+			rows: [],
+			rowsAffected: rows.length,
+			plan: plan.public
+		};
+	}
+	const updates = rows.map(({ key, row }) => {
+		const updated = { ...row };
+		for (const assignment of statement.assignments) updated[assignment.column] = normalizeValue(getColumn(schema, assignment.column), resolveSqlValue(assignment.value, parameters));
+		const primary = primaryColumn(schema);
+		return {
+			oldKey: key,
+			key: primary ? primaryKey(primary, updated[primary.name]) : key,
+			row: updated
+		};
+	});
+	const destinations = /* @__PURE__ */ new Set();
+	const oldKeys = new Set(rows.map(({ key }) => bytesIdentity(key)));
+	for (const update of updates) {
+		const identity = bytesIdentity(update.key);
+		if (destinations.has(identity)) throw new ConstraintError(`duplicate primary key in ${schema.table}`);
+		destinations.add(identity);
+		if (!oldKeys.has(identity) && await tx.has(schema.table, update.key)) throw new ConstraintError(`duplicate primary key in ${schema.table}`);
+	}
+	await tx.deleteMany(schema.table, updates.map(({ oldKey }) => oldKey));
+	for (const update of updates) await tx.put(schema.table, update.key, encodeRow(schema, update.row));
+	return {
+		rows: [],
+		rowsAffected: updates.length,
+		plan: plan.public
+	};
+}
+async function readCatalog(tx) {
+	let value;
+	try {
+		value = await tx.get(CATALOG, OWNER_KEY);
+	} catch (error) {
+		if (error instanceof StoreNotFoundError || error instanceof Error && error.name === "StoreNotFoundError") return false;
+		throw error;
+	}
+	if (!value) throw new SqlSchemaError(`SQL catalog store is not owned by SQL: ${CATALOG}`);
+	const owner = decodeJson(value);
+	if (!isRecord(owner) || owner.format !== OWNER.format || owner.version !== OWNER.version) throw new SqlSchemaError("invalid SQL catalog metadata");
+	return true;
+}
+async function readSchema(tx, table) {
+	const value = await tx.get(CATALOG, schemaKey(table));
+	if (!value) return null;
+	const schema = decodeJson(value);
+	validateSchema(schema, table);
+	return schema;
+}
+async function assertTableOwnership(tx, schema) {
+	let owner;
+	try {
+		owner = await tx.get(schema.table, TABLE_OWNER_KEY);
+	} catch (error) {
+		if (error instanceof StoreNotFoundError || error instanceof Error && error.name === "StoreNotFoundError") throw new SqlSchemaError(`SQL table store is missing: ${schema.table}`, { cause: error });
+		throw error;
+	}
+	if (!owner || compareBytes(owner, tableOwnerValue(schema)) !== 0) throw new SqlSchemaError(`SQL table ownership does not match its catalog: ${schema.table}`);
+}
+function tableOwnerValue(schema) {
+	return jsonEncode({ [TABLE_OWNER_FIELD]: JSON.stringify({
+		format: "moyodb.sql.table",
+		version: schema.version,
+		table: schema.table,
+		columns: schema.columns
+	}) });
+}
+function validateSchema(value, table) {
+	if (!isRecord(value) || value.version !== 1 || value.table !== table || !Array.isArray(value.columns) || !value.columns.length || typeof value.nextRowId !== "string" || value.nextRowId.length > 20 || !/^[1-9]\d*$/u.test(value.nextRowId) || BigInt(value.nextRowId) > ROW_ID_MAX + 1n) throw new SqlSchemaError(`invalid schema metadata for ${table}`);
+	const names = /* @__PURE__ */ new Set();
+	let primaries = 0;
+	for (const candidate of value.columns) {
+		if (!isRecord(candidate) || typeof candidate.name !== "string" || !candidate.name.length || typeof candidate.type !== "string" || !COLUMN_TYPES.has(candidate.type) || typeof candidate.primaryKey !== "boolean" || typeof candidate.nullable !== "boolean" || names.has(candidate.name) || candidate.primaryKey && candidate.nullable) throw new SqlSchemaError(`invalid column metadata for ${table}`);
+		names.add(candidate.name);
+		if (candidate.primaryKey) primaries += 1;
+	}
+	if (primaries > 1) throw new SqlSchemaError(`multiple primary keys in ${table}`);
+}
+async function insertRows(tx, schema, statement, parameters) {
+	const columns = statement.columns ?? schema.columns.map((column) => column.name);
+	validateColumnList(schema, columns);
+	const primary = primaryColumn(schema);
+	let nextRowId = BigInt(schema.nextRowId);
+	const entries = [];
+	const keys = /* @__PURE__ */ new Set();
+	for (const values of statement.rows) {
+		if (values.length !== columns.length) throw new SqlSchemaError("INSERT column count does not match VALUES");
+		const row = Object.create(null);
+		for (const column of schema.columns) row[column.name] = null;
+		values.forEach((expression, index) => {
+			row[columns[index]] = resolveSqlValue(expression, parameters);
+		});
+		for (const column of schema.columns) row[column.name] = normalizeValue(column, row[column.name]);
+		if (!primary && nextRowId > ROW_ID_MAX) throw new ConstraintError(`row identifier space exhausted in ${schema.table}`);
+		const key = primary ? primaryKey(primary, row[primary.name]) : u64Key(nextRowId++);
+		const identity = bytesIdentity(key);
+		if (keys.has(identity) || await tx.has(schema.table, key)) throw new ConstraintError(`duplicate primary key in ${schema.table}`);
+		keys.add(identity);
+		entries.push([key, encodeRow(schema, row)]);
+	}
+	await tx.putMany(schema.table, entries);
+	if (!primary) {
+		schema.nextRowId = nextRowId.toString();
+		await tx.put(CATALOG, schemaKey(schema.table), jsonEncode(schema));
+	}
+	return {
+		rows: [],
+		rowsAffected: entries.length
+	};
+}
+function normalizeValue(column, value) {
+	if (value === null) {
+		if (!column.nullable) throw new ConstraintError(`column ${column.name} cannot be NULL`);
+		return null;
+	}
+	switch (column.type) {
+		case "INTEGER": {
+			if (typeof value !== "bigint" && (typeof value !== "number" || !Number.isSafeInteger(value))) break;
+			const integer = typeof value === "bigint" ? value : BigInt(value);
+			if (integer < INTEGER_MIN || integer > INTEGER_MAX) break;
+			return integer >= BigInt(Number.MIN_SAFE_INTEGER) && integer <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(integer) : integer;
+		}
+		case "REAL":
+			if (typeof value === "number" && Number.isFinite(value)) return Object.is(value, -0) ? 0 : value;
+			if (typeof value === "bigint" && value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) return Number(value);
+			break;
+		case "TEXT":
+			if (typeof value === "string") {
+				indexKey(value);
+				return value;
+			}
+			break;
+		case "BOOLEAN":
+			if (typeof value === "boolean") return value;
+			break;
+		case "BLOB": if (value instanceof Uint8Array) return value.slice();
+	}
+	throw new SqlTypeError(`column ${column.name} requires ${column.type}`);
+}
+function primaryKey(column, value) {
+	if (value === null) throw new ConstraintError(`primary key ${column.name} cannot be NULL`);
+	if (column.type === "INTEGER") return u64Key(BigInt(value) - INTEGER_MIN);
+	if (typeof value === "bigint") throw new SqlTypeError(`invalid primary key ${column.name}`);
+	return indexKey(value);
+}
+function encodeRow(schema, row) {
+	const stored = Object.create(null);
+	for (const column of schema.columns) stored[column.name] = storedValue(row[column.name]);
+	return jsonEncode(stored);
+}
+function storedValue(value) {
+	if (typeof value === "bigint") return value.toString();
+	if (value instanceof Uint8Array) return bytesIdentity(value);
+	return value;
+}
+function decodeRow(schema, item) {
+	const stored = decodeJson(item.value);
+	if (!isRecord(stored) || Object.keys(stored).length !== schema.columns.length) throw new SerializationError(`invalid SQL row in ${schema.table}`);
+	const row = Object.create(null);
+	try {
+		for (const column of schema.columns) {
+			if (!Object.hasOwn(stored, column.name)) throw new Error("missing SQL column");
+			let value = stored[column.name];
+			if (column.type === "INTEGER" && typeof value === "string") {
+				if (value.length > 20 || !/^-?(?:0|[1-9]\d*)$/u.test(value)) throw new Error("invalid stored integer");
+				value = BigInt(value);
+			} else if (column.type === "BLOB" && typeof value === "string") {
+				if (value.length % 2 || !/^[0-9a-f]*$/u.test(value)) throw new Error("invalid stored blob");
+				value = Uint8Array.from(value.match(/.{2}/gu) ?? [], (byte) => Number.parseInt(byte, 16));
+			}
+			if (value !== null && typeof value !== "boolean" && typeof value !== "number" && typeof value !== "string" && typeof value !== "bigint" && !(value instanceof Uint8Array)) throw new Error("invalid stored value");
+			row[column.name] = normalizeValue(column, value);
+		}
+		const primary = primaryColumn(schema);
+		if (primary && compareBytes(primaryKey(primary, row[primary.name]), item.key) !== 0) throw new Error("SQL row primary key differs from storage key");
+	} catch (error) {
+		throw new SerializationError(`invalid SQL row in ${schema.table}: ${error instanceof Error ? error.message : "invalid value"}`);
+	}
+	return {
+		key: item.key,
+		row
+	};
+}
+function validateWhere(schema, expression, parameters) {
+	if (!expression) return;
+	if ("left" in expression) {
+		validateWhere(schema, expression.left, parameters);
+		validateWhere(schema, expression.right, parameters);
+		return;
+	}
+	const column = getColumn(schema, expression.column);
+	if (expression.kind === "comparison") {
+		const value = resolveSqlValue(expression.value, parameters);
+		if (value === null) return;
+		if (column.type === "INTEGER" || column.type === "REAL") {
+			if (typeof value === "bigint" || typeof value === "number" && Number.isFinite(value)) return;
+			throw new SqlTypeError(`comparison for ${column.name} requires a numeric value`);
+		}
+		normalizeValue({
+			...column,
+			nullable: true
+		}, value);
+	}
+}
+function evaluateWhere(row, expression, parameters) {
+	if ("left" in expression) {
+		const left = evaluateWhere(row, expression.left, parameters);
+		const right = evaluateWhere(row, expression.right, parameters);
+		if (expression.kind === "and") return left === false || right === false ? false : left === null || right === null ? null : true;
+		return left === true || right === true ? true : left === null || right === null ? null : false;
+	}
+	const left = row[expression.column];
+	if (expression.kind === "isNull") return expression.negated ? left !== null : left === null;
+	const right = resolveSqlValue(expression.value, parameters);
+	if (left === null || right === null) return null;
+	const compared = compareValues(left, right);
+	switch (expression.operator) {
+		case "=": return compared === 0;
+		case "!=": return compared !== 0;
+		case "<": return compared < 0;
+		case "<=": return compared <= 0;
+		case ">": return compared > 0;
+		case ">=": return compared >= 0;
+	}
+}
+function planAccess(schema, where, orderBy, parameters, indexes) {
+	const comparisons = conjunctiveComparisons(where);
+	const primary = primaryColumn(schema);
+	const candidates = [];
+	if (primary) candidates.push({ column: primary });
+	for (const index of indexes) if (index.store === schema.table && !index.compound && index.keyPath.length === 1 && !index.keyPath[0].includes(".")) {
+		const column = schema.columns.find((entry) => entry.name === index.keyPath[0]);
+		if (column) candidates.push({
+			column,
+			index
+		});
+	}
+	for (const equalityOnly of [true, false]) for (const candidate of candidates) {
+		const selected = comparisons.filter((entry) => entry.column === candidate.column.name && (equalityOnly ? entry.operator === "=" : [
+			"<",
+			"<=",
+			">",
+			">="
+		].includes(entry.operator)));
+		let key;
+		const range = {};
+		for (const comparison of selected) {
+			const value = resolveSqlValue(comparison.value, parameters);
+			const encoded = planKey(candidate.column, value, Boolean(candidate.index), equalityOnly);
+			if (!encoded) continue;
+			if (equalityOnly) {
+				key = encoded;
+				break;
+			}
+			setRangeBound(range, comparison.operator, encoded);
+		}
+		if (!key && !Object.keys(range).length) continue;
+		const access = candidate.index ? equalityOnly ? "index-lookup" : "index-range" : equalityOnly ? "primary-key-lookup" : "primary-key-range";
+		return {
+			public: {
+				table: schema.table,
+				access,
+				column: candidate.column.name,
+				...candidate.index ? { index: candidate.index.name } : {},
+				sort: orderBy.length ? "memory" : "none",
+				reason: `use ${candidate.index ? `index ${candidate.index.name}` : "primary key"} for ${equalityOnly ? "equality" : "range"}; apply remaining predicates after lookup`
+			},
+			key,
+			range,
+			empty: !key && emptyRange(range)
+		};
+	}
+	return { public: {
+		table: schema.table,
+		access: "table-scan",
+		sort: orderBy.length ? "memory" : "none",
+		reason: "no supported primary key or index bound; filter table rows"
+	} };
+}
+function planKey(column, value, secondary, equality) {
+	if (value === null) return null;
+	if (column.type === "INTEGER") {
+		if (typeof value !== "bigint" && (typeof value !== "number" || !Number.isSafeInteger(value))) return null;
+		if (secondary && !equality) return null;
+		const normalized = normalizeValue({
+			...column,
+			nullable: true
+		}, value);
+		return secondary ? indexKey(storedValue(normalized)) : primaryKey(column, normalized);
+	}
+	if (column.type === "REAL" && typeof value === "bigint" && (value < BigInt(Number.MIN_SAFE_INTEGER) || value > BigInt(Number.MAX_SAFE_INTEGER))) return null;
+	const normalized = normalizeValue({
+		...column,
+		nullable: true
+	}, value);
+	return secondary ? indexKey(storedValue(normalized)) : primaryKey(column, normalized);
+}
+function conjunctiveComparisons(where) {
+	if (!where) return [];
+	if (where.kind === "comparison") return [where];
+	if (where.kind === "and") return [...conjunctiveComparisons(where.left), ...conjunctiveComparisons(where.right)];
+	return [];
+}
+function setRangeBound(range, operator, key) {
+	if (operator === ">" || operator === ">=") {
+		const current = range.gt ?? range.gte;
+		const compared = current ? compareBytes(key, current) : 1;
+		if (compared > 0 || compared === 0 && operator === ">") {
+			delete range.gt;
+			delete range.gte;
+			if (operator === ">") range.gt = key;
+			else range.gte = key;
+		}
+	} else if (operator === "<" || operator === "<=") {
+		const current = range.lt ?? range.lte;
+		const compared = current ? compareBytes(key, current) : -1;
+		if (compared < 0 || compared === 0 && operator === "<") {
+			delete range.lt;
+			delete range.lte;
+			if (operator === "<") range.lt = key;
+			else range.lte = key;
+		}
+	}
+}
+function emptyRange(range) {
+	const lower = range.gt ?? range.gte;
+	const upper = range.lt ?? range.lte;
+	if (!lower || !upper) return false;
+	const compared = compareBytes(lower, upper);
+	return compared > 0 || compared === 0 && (Boolean(range.gt) || Boolean(range.lt));
+}
+async function readRows(tx, schema, plan) {
+	if (plan.empty) return [];
+	let items;
+	if (plan.public.index) {
+		items = [];
+		const range = plan.key ? {
+			gte: plan.key,
+			lte: plan.key
+		} : plan.range;
+		for await (const [key, value] of tx.scanByIndex(schema.table, plan.public.index, range)) items.push({
+			key,
+			value
+		});
+	} else if (plan.key) {
+		const value = await tx.get(schema.table, plan.key);
+		items = value ? [{
+			key: plan.key,
+			value
+		}] : [];
+	} else items = await tx.scan(schema.table, plan.range);
+	return items.filter(({ key }) => key.length !== 1 || key[0] !== TABLE_OWNER_KEY[0]).map((item) => decodeRow(schema, item));
+}
+function compareRows(left, right, orders) {
+	for (const order of orders) {
+		const compared = compareValues(left.row[order.column], right.row[order.column]);
+		if (compared) return order.direction === "desc" ? -compared : compared;
+	}
+	return compareBytes(left.key, right.key);
+}
+function compareValues(left, right) {
+	if (left === null) return right === null ? 0 : -1;
+	if (right === null) return 1;
+	if ((typeof left === "number" || typeof left === "bigint") && (typeof right === "number" || typeof right === "bigint")) return left < right ? -1 : left > right ? 1 : 0;
+	if (typeof left === "string" && typeof right === "string") return compareBytes(indexKey(left), indexKey(right));
+	if (typeof left === "boolean" && typeof right === "boolean") return Number(left) - Number(right);
+	if (left instanceof Uint8Array && right instanceof Uint8Array) return compareBytes(left, right);
+	throw new SqlTypeError("comparison values have different SQL types");
+}
+function resolveCount(expression, parameters, clause) {
+	if (!expression) return null;
+	const value = resolveSqlValue(expression, parameters);
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new SqlTypeError(`${clause} requires a non-negative safe integer`);
+	return value;
+}
+function projectRow(row, columns) {
+	const result = {};
+	for (const column of columns) Object.defineProperty(result, column, {
+		value: row[column] instanceof Uint8Array ? row[column].slice() : row[column],
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	return result;
+}
+function validateColumnList(schema, columns) {
+	if (!columns) return;
+	const seen = /* @__PURE__ */ new Set();
+	for (const name of columns) {
+		getColumn(schema, name);
+		if (seen.has(name)) throw new SqlSchemaError(`duplicate column: ${name}`);
+		seen.add(name);
+	}
+}
+function getColumn(schema, name) {
+	const column = schema.columns.find((entry) => entry.name === name);
+	if (!column) throw new SqlSchemaError(`unknown column: ${name}`);
+	return column;
+}
+function primaryColumn(schema) {
+	return schema.columns.find((column) => column.primaryKey);
+}
+function schemaKey(table) {
+	return utf8Encode(`table:${table}`);
+}
+function assertTableName(table) {
+	if (table === CATALOG || table.startsWith("__browserdb:")) throw new SqlSchemaError(`reserved SQL table name: ${table}`);
+}
+function isRowStatement(statement) {
+	return statement.kind === "select" || statement.kind === "update" || statement.kind === "delete";
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function decodeJson(value) {
+	try {
+		return jsonDecode(value);
+	} catch {
+		throw new SerializationError("invalid SQL JSON data");
+	}
+}
+function bytesIdentity(bytes) {
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function compareBytes(left, right) {
+	for (let index = 0; index < Math.min(left.length, right.length); index += 1) if (left[index] !== right[index]) return left[index] - right[index];
+	return left.length - right.length;
+}
+//#endregion
+//#region src/index.ts
+var INDEX_SCAN_PAGE_ROWS = 256;
+async function callProxy(fn) {
+	try {
+		return await fn();
+	} catch (error) {
+		throw normalizeError(error);
+	}
+}
+var TransactionImpl = class {
+	mode;
+	#entry;
+	#txId;
+	#closed = false;
+	#onClose;
+	constructor(entry, txId, mode, onClose) {
+		this.#entry = entry;
+		this.#txId = txId;
+		this.mode = mode;
+		this.#onClose = onClose;
+	}
+	async listIndexes() {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.proxy.getIndexes(this.#txId));
+	}
+	async get(store, key) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		return callProxy(() => this.#entry.proxy.get(this.#txId, store, key));
+	}
+	async getMany(store, keys) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		return callProxy(() => this.#entry.proxy.getMany(this.#txId, store, keys));
+	}
+	async has(store, key) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		return callProxy(() => this.#entry.proxy.has(this.#txId, store, key));
+	}
+	async put(store, key, value, options = {}) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		return callProxy(() => this.#entry.proxy.put(this.#txId, store, key, value, normalizePutOptions(options)));
+	}
+	async putMany(store, entries, options = {}) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		return callProxy(() => this.#entry.proxy.putMany(this.#txId, store, entries, normalizePutOptions(options)));
+	}
+	async delete(store, key) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		return callProxy(() => this.#entry.proxy.delete(this.#txId, store, key));
+	}
+	async deleteMany(store, keys) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		return callProxy(() => this.#entry.proxy.deleteMany(this.#txId, store, keys));
+	}
+	async applyBatch(store, ops) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		return callProxy(() => this.#entry.proxy.applyBatch(this.#txId, store, ops));
+	}
+	async scan(store, range = {}) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		return callProxy(() => this.#entry.proxy.scan(this.#txId, store, range));
+	}
+	async getByIndex(store, indexName, key) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		return callProxy(() => this.#entry.proxy.getByIndex(this.#txId, store, indexName, key));
+	}
+	async *scanByIndex(store, indexName, range = {}) {
+		this.#ensureOpen();
+		assertPublicStoreName(store);
+		let remaining = range.limit ?? Number.POSITIVE_INFINITY;
+		let cursor = null;
+		while (remaining > 0) {
+			this.#ensureOpen();
+			const pageLimit = Math.min(remaining, INDEX_SCAN_PAGE_ROWS);
+			const resumeAfter = cursor;
+			const page = await callProxy(() => this.#entry.proxy.scanByIndexPage(this.#txId, store, indexName, range, resumeAfter, pageLimit));
+			for (const row of page.rows) yield [row.key, row.value];
+			remaining -= page.rows.length;
+			if (page.cursor === null) return;
+			cursor = page.cursor;
+		}
+	}
+	async createStore(name, options = {}) {
+		this.#ensureOpen();
+		assertPublicStoreName(name);
+		return callProxy(() => this.#entry.proxy.createStore(this.#txId, name, normalizeCreateStoreOptions(options)));
+	}
+	async dropStore(name) {
+		this.#ensureOpen();
+		assertPublicStoreName(name);
+		return callProxy(() => this.#entry.proxy.dropStore(this.#txId, name));
+	}
+	async clearStore(name) {
+		this.#ensureOpen();
+		assertPublicStoreName(name);
+		return callProxy(() => this.#entry.proxy.clearStore(this.#txId, name));
+	}
+	async commit() {
+		this.#ensureOpen();
+		try {
+			await callProxy(() => this.#entry.proxy.commit(this.#txId));
+		} finally {
+			this.#markClosed();
+		}
+	}
+	async rollback() {
+		this.#ensureOpen();
+		try {
+			await callProxy(() => this.#entry.proxy.rollback(this.#txId));
+		} finally {
+			this.#markClosed();
+		}
+	}
+	async rollbackIfOpen() {
+		if (this.#closed) return;
+		if (this.#entry.invalidated) {
+			this.#markClosed();
+			return;
+		}
+		try {
+			await this.#entry.proxy.rollback(this.#txId);
+		} catch (error) {
+			const normalized = normalizeError(error);
+			if (!(normalized instanceof TransactionClosedError)) throw normalized;
+		} finally {
+			this.#markClosed();
+		}
+	}
+	forceClose() {
+		this.#markClosed();
+	}
+	internalId() {
+		return this.#txId;
+	}
+	#ensureOpen() {
+		if (this.#closed || this.#entry.invalidated) throw new TransactionClosedError();
+	}
+	#markClosed() {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#onClose();
+	}
+};
+var DBImpl = class {
+	#entry;
+	#closed = false;
+	#closePromise = null;
+	#transactions = /* @__PURE__ */ new Set();
+	#pendingBegins = /* @__PURE__ */ new Set();
+	#transactionGeneration = 0;
+	#subscriptions;
+	#unsubscribeTxInvalidated = null;
+	#unsubscribeHandleInvalidated = null;
+	constructor(entry) {
+		this.#entry = entry;
+		this.#subscriptions = new SubscriptionHub(entry.dbName, entry.channelName);
+		this.#unsubscribeTxInvalidated = subscribeTransactionsInvalidated(entry, () => {
+			this.#forceCloseTransactions();
+		});
+		this.#unsubscribeHandleInvalidated = subscribeHandleInvalidated(entry, () => {
+			this.#markInvalidated();
+		});
+	}
+	async begin(mode = "readonly") {
+		return this.#beginImpl(mode);
+	}
+	async runSchemaMigration(oldVersion, newVersion, migrate, targetIndexes) {
+		this.#ensureOpen();
+		const tx = await this.#beginImpl("readwrite");
+		const tracker = new MigrationCatalogTracker();
+		const migrationTransaction = new MigrationTransactionImpl(tx, tracker);
+		const migrationDb = new MigrationDbImpl(this, migrationTransaction, tracker);
+		try {
+			await this.#entry.proxy.reconcileIndexes(tx.internalId(), targetIndexes);
+			await migrate({
+				db: migrationDb,
+				oldVersion,
+				newVersion,
+				transaction: migrationTransaction
+			});
+			await this.#entry.proxy.setSchemaVersion(tx.internalId(), newVersion);
+			await tx.commit();
+		} catch (error) {
+			try {
+				await tx.rollbackIfOpen();
+			} catch {}
+			throw error;
+		}
+	}
+	async listStores() {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.proxy.listStores());
+	}
+	async listIndexes() {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.proxy.getIndexes());
+	}
+	async getVersion() {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.proxy.getVersion());
+	}
+	async changesSince(txid, options = {}) {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.proxy.changesSince(normalizeTxId(txid), normalizeChangeFeedOptions(options)));
+	}
+	async #beginImpl(mode) {
+		this.#ensureOpen();
+		const generation = this.#transactionGeneration;
+		const pending = callProxy(async () => {
+			const txId = await this.#entry.proxy.begin(mode);
+			const tx = new TransactionImpl(this.#entry, txId, mode, () => {
+				this.#transactions.delete(tx);
+			});
+			this.#transactions.add(tx);
+			if (this.#closed || this.#entry.invalidated) {
+				if (this.#entry.invalidated) tx.forceClose();
+				throw new DatabaseClosedError();
+			}
+			if (generation !== this.#transactionGeneration) {
+				await tx.rollbackIfOpen();
+				throw new TransactionClosedError();
+			}
+			return tx;
+		});
+		this.#pendingBegins.add(pending);
+		try {
+			return await pending;
+		} finally {
+			this.#pendingBegins.delete(pending);
+		}
+	}
+	async createStore(name, options = {}) {
+		assertPublicStoreName(name);
+		await this.#autocommit("readwrite", "createStore", [name, normalizeCreateStoreOptions(options)]);
+	}
+	async dropStore(name) {
+		assertPublicStoreName(name);
+		await this.#autocommit("readwrite", "dropStore", [name]);
+	}
+	async clearStore(name) {
+		assertPublicStoreName(name);
+		await this.#autocommit("readwrite", "clearStore", [name]);
+	}
+	async get(store, key) {
+		assertPublicStoreName(store);
+		return this.#autocommit("readonly", "get", [store, key]);
+	}
+	async getMany(store, keys) {
+		assertPublicStoreName(store);
+		return this.#autocommit("readonly", "getMany", [store, keys]);
+	}
+	async has(store, key) {
+		assertPublicStoreName(store);
+		return this.#autocommit("readonly", "has", [store, key]);
+	}
+	async put(store, key, value, options = {}) {
+		assertPublicStoreName(store);
+		await this.#autocommit("readwrite", "put", [
+			store,
+			key,
+			value,
+			normalizePutOptions(options)
+		]);
+	}
+	async delete(store, key) {
+		assertPublicStoreName(store);
+		return this.#autocommit("readwrite", "delete", [store, key]);
+	}
+	async scan(store, range = {}) {
+		assertPublicStoreName(store);
+		return this.#autocommit("readonly", "scan", [store, range]);
+	}
+	/** The transaction boundary stays in the worker, so one round trip is enough. */
+	async #autocommit(mode, command, args) {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.proxy.autocommit(mode, command, args));
+	}
+	async exportSnapshot(options = {}) {
+		this.#ensureOpen();
+		return callProxy(async () => {
+			const bytes = await this.#entry.proxy.exportSnapshot(normalizeExportSnapshotOptions(options));
+			return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+		});
+	}
+	async importSnapshot(data) {
+		this.#ensureOpen();
+		invalidateTransactions(this.#entry);
+		return callProxy(() => {
+			const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+			return this.#entry.proxy.importSnapshot(bytes);
+		});
+	}
+	async reset() {
+		this.#ensureOpen();
+		invalidateTransactions(this.#entry);
+		return callProxy(() => this.#entry.proxy.reset());
+	}
+	async compact() {
+		this.#ensureOpen();
+		invalidateTransactions(this.#entry);
+		return callProxy(() => this.#entry.proxy.compact());
+	}
+	async rebuild() {
+		this.#ensureOpen();
+		invalidateTransactions(this.#entry);
+		return callProxy(() => this.#entry.proxy.rebuild());
+	}
+	async stats() {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.proxy.stats());
+	}
+	async storageInfo() {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.proxy.storageInfo());
+	}
+	async requestPersistence() {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.proxy.requestPersistence());
+	}
+	async destroy() {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.destroy?.() ?? destroyDbWorker(this.#entry));
+	}
+	async setFailpoint(failpoint) {
+		this.#ensureOpen();
+		return callProxy(() => this.#entry.proxy.setFailpoint(failpoint));
+	}
+	subscribe(arg1, arg2, arg3) {
+		this.#ensureOpen();
+		if (typeof arg1 === "function") return this.#subscriptions.subscribe(arg1);
+		if (typeof arg2 === "function") return this.#subscriptions.subscribe(arg1, arg2);
+		if (arg2 instanceof Uint8Array && typeof arg3 === "function") return this.#subscriptions.subscribe(arg1, arg2, arg3);
+		throw new TypeError("subscribe() expects one of: (callback), (storeName, callback), (storeName, keyPrefix, callback)");
+	}
+	watch(arg1, arg2, arg3) {
+		if (typeof arg1 === "function") return this.subscribe(arg1);
+		if (typeof arg2 === "function") return this.subscribe(arg1, arg2);
+		if (arg2 instanceof Uint8Array && typeof arg3 === "function") return this.subscribe(arg1, arg2, arg3);
+		throw new TypeError("watch() expects one of: (callback), (storeName, callback), (storeName, keyPrefix, callback)");
+	}
+	close() {
+		if (this.#closePromise !== null) return this.#closePromise;
+		if (this.#closed) return Promise.resolve();
+		this.#closed = true;
+		this.#disposeRegistrySubscriptions();
+		this.#subscriptions.close();
+		this.#closePromise = this.#finishClose();
+		return this.#closePromise;
+	}
+	async #finishClose() {
+		await Promise.allSettled(Array.from(this.#pendingBegins));
+		let rollbackError = null;
+		const txs = Array.from(this.#transactions);
+		if (txs.length > 0) {
+			const results = await Promise.allSettled(txs.map((tx) => tx.rollbackIfOpen()));
+			for (const result of results) if (result.status === "rejected" && rollbackError === null) rollbackError = normalizeError(result.reason);
+		}
+		try {
+			await (this.#entry.release?.() ?? releaseDbWorker(this.#entry));
+		} catch (error) {
+			throw normalizeError(error);
+		}
+		if (rollbackError) throw rollbackError;
+	}
+	#disposeRegistrySubscriptions() {
+		this.#unsubscribeTxInvalidated?.();
+		this.#unsubscribeTxInvalidated = null;
+		this.#unsubscribeHandleInvalidated?.();
+		this.#unsubscribeHandleInvalidated = null;
+	}
+	#forceCloseTransactions() {
+		this.#transactionGeneration += 1;
+		for (const tx of Array.from(this.#transactions)) tx.forceClose();
+	}
+	#markInvalidated() {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#disposeRegistrySubscriptions();
+		this.#forceCloseTransactions();
+		this.#subscriptions.close();
+	}
+	#ensureOpen() {
+		if (this.#closed || this.#entry.invalidated) throw new DatabaseClosedError();
+	}
+};
+var MigrationCatalogTracker = class {
+	#created = /* @__PURE__ */ new Set();
+	#dropped = /* @__PURE__ */ new Set();
+	recordCreate(name) {
+		this.#dropped.delete(name);
+		this.#created.add(name);
+	}
+	recordDrop(name) {
+		if (this.#created.delete(name)) return;
+		this.#dropped.add(name);
+	}
+	apply(stores) {
+		const visible = new Set(stores);
+		for (const name of this.#created) visible.add(name);
+		for (const name of this.#dropped) visible.delete(name);
+		return Array.from(visible).sort(compareStringsByCodeUnit);
+	}
+};
+var MigrationTransactionImpl = class {
+	#inner;
+	#tracker;
+	constructor(inner, tracker) {
+		this.#inner = inner;
+		this.#tracker = tracker;
+	}
+	get mode() {
+		return this.#inner.mode;
+	}
+	async listIndexes() {
+		return this.#inner.listIndexes();
+	}
+	async get(store, key) {
+		return this.#inner.get(store, key);
+	}
+	async getMany(store, keys) {
+		return this.#inner.getMany(store, keys);
+	}
+	async has(store, key) {
+		return this.#inner.has(store, key);
+	}
+	async put(store, key, value, options = {}) {
+		await this.#inner.put(store, key, value, options);
+	}
+	async putMany(store, entries, options = {}) {
+		await this.#inner.putMany(store, entries, options);
+	}
+	async delete(store, key) {
+		return this.#inner.delete(store, key);
+	}
+	async deleteMany(store, keys) {
+		await this.#inner.deleteMany(store, keys);
+	}
+	async applyBatch(store, ops) {
+		await this.#inner.applyBatch(store, ops);
+	}
+	async scan(store, range = {}) {
+		return this.#inner.scan(store, range);
+	}
+	async getByIndex(store, indexName, key) {
+		return this.#inner.getByIndex(store, indexName, key);
+	}
+	scanByIndex(store, indexName, range = {}) {
+		return this.#inner.scanByIndex(store, indexName, range);
+	}
+	async createStore(name, options = {}) {
+		await this.#inner.createStore(name, options);
+		this.#tracker.recordCreate(name);
+	}
+	async dropStore(name) {
+		await this.#inner.dropStore(name);
+		this.#tracker.recordDrop(name);
+	}
+	async clearStore(name) {
+		await this.#inner.clearStore(name);
+	}
+	commit() {
+		return Promise.reject(migrationUnsupportedMethod("transaction.commit"));
+	}
+	rollback() {
+		return Promise.reject(migrationUnsupportedMethod("transaction.rollback"));
+	}
+};
+var MigrationDbImpl = class {
+	#db;
+	#transaction;
+	#tracker;
+	constructor(db, transaction, tracker) {
+		this.#db = db;
+		this.#transaction = transaction;
+		this.#tracker = tracker;
+	}
+	begin(_mode = "readonly") {
+		return Promise.reject(migrationUnsupportedMethod("db.begin"));
+	}
+	async createStore(name, options = {}) {
+		await this.#transaction.createStore(name, options);
+	}
+	async dropStore(name) {
+		await this.#transaction.dropStore(name);
+	}
+	async clearStore(name) {
+		await this.#transaction.clearStore(name);
+	}
+	async listStores() {
+		return this.#tracker.apply(await this.#db.listStores());
+	}
+	async listIndexes() {
+		return this.#transaction.listIndexes();
+	}
+	async getVersion() {
+		return this.#db.getVersion();
+	}
+	changesSince(_txid, _options = {}) {
+		return Promise.reject(migrationUnsupportedMethod("db.changesSince"));
+	}
+	async get(store, key) {
+		return this.#transaction.get(store, key);
+	}
+	async getMany(store, keys) {
+		return this.#transaction.getMany(store, keys);
+	}
+	async has(store, key) {
+		return this.#transaction.has(store, key);
+	}
+	async put(store, key, value, options = {}) {
+		await this.#transaction.put(store, key, value, options);
+	}
+	async delete(store, key) {
+		return this.#transaction.delete(store, key);
+	}
+	async scan(store, range = {}) {
+		return this.#transaction.scan(store, range);
+	}
+	exportSnapshot(_options = {}) {
+		return Promise.reject(migrationUnsupportedMethod("db.exportSnapshot"));
+	}
+	importSnapshot(_data) {
+		return Promise.reject(migrationUnsupportedMethod("db.importSnapshot"));
+	}
+	reset() {
+		return Promise.reject(migrationUnsupportedMethod("db.reset"));
+	}
+	compact() {
+		return Promise.reject(migrationUnsupportedMethod("db.compact"));
+	}
+	rebuild() {
+		return Promise.reject(migrationUnsupportedMethod("db.rebuild"));
+	}
+	async stats() {
+		return this.#db.stats();
+	}
+	async storageInfo() {
+		return this.#db.storageInfo();
+	}
+	async requestPersistence() {
+		return this.#db.requestPersistence();
+	}
+	close() {
+		return Promise.reject(migrationUnsupportedMethod("db.close"));
+	}
+	destroy() {
+		return Promise.reject(migrationUnsupportedMethod("db.destroy"));
+	}
+	setFailpoint(_failpoint) {
+		return Promise.reject(migrationUnsupportedMethod("db.setFailpoint"));
+	}
+	subscribe(_arg1, _arg2, _arg3) {
+		throw migrationUnsupportedMethod("db.subscribe");
+	}
+	watch(_arg1, _arg2, _arg3) {
+		throw migrationUnsupportedMethod("db.watch");
+	}
+};
+function migrationUnsupportedMethod(method) {
+	const error = /* @__PURE__ */ new Error(`${method}() is not available inside openDB() migrations; use the provided migration transaction and wait for openDB() to resolve`);
+	error.name = "InvalidStateError";
+	return error;
+}
+function normalizeDatabaseName(value, method) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError(`${method}() database name must be a non-empty string`);
+	return value;
+}
+var typeError = (message) => new TypeError(message);
+var invalidOpenOptionsError = (message) => new InvalidOpenOptionsError(message);
+function normalizeOptionsObject(options, message, createError = typeError) {
+	if (options === void 0) return {};
+	if (options === null || typeof options !== "object" || Array.isArray(options)) throw createError(message);
+	return options;
+}
+function normalizeNonNegativeSafeInteger(value, message, createError = typeError) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw createError(message);
+	return value;
+}
+function normalizeOptionalNonNegativeSafeInteger(value, message, createError) {
+	return value === void 0 ? void 0 : normalizeNonNegativeSafeInteger(value, message, createError);
+}
+function normalizeOpenOptionsInput(options) {
+	return normalizeOptionsObject(options, "open options must be an object", invalidOpenOptionsError);
+}
+function normalizeSchemaVersion(value) {
+	return normalizeOptionalNonNegativeSafeInteger(value, "version must be a non-negative safe integer", invalidOpenOptionsError);
+}
+function normalizePutOptions(options) {
+	const { ttl } = normalizeOptionsObject(options, "put options must be an object");
+	const normalizedTtl = normalizeOptionalNonNegativeSafeInteger(ttl, "ttl must be a non-negative safe integer");
+	return normalizedTtl === void 0 ? {} : { ttl: normalizedTtl };
+}
+function normalizeCompressionOptions(options, message) {
+	const { compression } = normalizeOptionsObject(options, message);
+	if (compression === void 0) return {};
+	if (compression !== false && compression !== "gzip" && compression !== "deflate") throw new TypeError("compression must be \"gzip\", \"deflate\", or false");
+	return { compression };
+}
+function normalizeCreateStoreOptions(options) {
+	return normalizeCompressionOptions(options, "createStore options must be an object");
+}
+function normalizeExportSnapshotOptions(options) {
+	return normalizeCompressionOptions(options, "exportSnapshot options must be an object");
+}
+function normalizeTxId(value) {
+	return normalizeNonNegativeSafeInteger(value, "txid must be a non-negative safe integer");
+}
+function normalizeChangeFeedOptions(options) {
+	const { stores, limit } = normalizeOptionsObject(options, "change feed options must be an object");
+	const normalized = {};
+	if (stores !== void 0) {
+		if (!Array.isArray(stores) || !stores.every((store) => typeof store === "string")) throw new TypeError("stores must be an array of strings");
+		for (const store of stores) assertPublicStoreName(store);
+		normalized.stores = [...stores];
+	}
+	const normalizedLimit = normalizeOptionalNonNegativeSafeInteger(limit, "limit must be a non-negative safe integer");
+	if (normalizedLimit !== void 0) normalized.limit = normalizedLimit;
+	return normalized;
+}
+function normalizeMigrateHook(value) {
+	if (value === void 0) return;
+	if (typeof value !== "function") throw new InvalidOpenOptionsError("migrate must be a function");
+	return value;
+}
+function normalizeRequestedIndexes(value) {
+	if (value === void 0) return;
+	return normalizeIndexDefinitions(value);
+}
+function indexDefinitionsMatch(left, right) {
+	return serializeNormalizedIndexDefinitions(left) === serializeNormalizedIndexDefinitions(right);
+}
+async function loadNormalizedIndexes(entry) {
+	return normalizeIndexDefinitions(await entry.proxy.getIndexes());
+}
+async function openDBWithWorker(name, options, acquire) {
+	const dbName = normalizeDatabaseName(name, "openDB");
+	const normalizedOptions = normalizeOpenOptionsInput(options);
+	const requestedVersion = normalizeSchemaVersion(normalizedOptions.version);
+	const migrate = normalizeMigrateHook(normalizedOptions.migrate);
+	const requestedIndexes = normalizeRequestedIndexes(normalizedOptions.indexes);
+	if (requestedVersion === void 0 && migrate !== void 0) throw new InvalidOpenOptionsError("migrate requires version");
+	if (requestedVersion === void 0 && requestedIndexes !== void 0) throw new InvalidOpenOptionsError("indexes requires version");
+	const entry = await acquire(dbName, normalizedOptions);
+	const db = new DBImpl(entry);
+	try {
+		await entry.proxy.acquireMigration?.();
+		try {
+			if (requestedVersion === void 0) return db;
+			const [currentVersion, currentIndexes] = await Promise.all([db.getVersion(), loadNormalizedIndexes(entry)]);
+			if (requestedVersion < currentVersion) throw new VersionError(`cannot open database ${dbName} at schema version ${requestedVersion}; current schema version is ${currentVersion}`);
+			if (requestedVersion === currentVersion) {
+				if (requestedIndexes !== void 0 && !indexDefinitionsMatch(requestedIndexes, currentIndexes)) throw new VersionError(`database ${dbName} is already at schema version ${currentVersion}, but the requested index catalog does not match the committed schema`);
+				return db;
+			}
+			if (entry.refs > 1) throw new DatabaseBusyError(`database ${dbName} is already open in this tab; close existing handles before migrating from version ${currentVersion} to ${requestedVersion}`);
+			if (!migrate) throw new VersionError(`database ${dbName} requires migration from version ${currentVersion} to ${requestedVersion}, but no migrate hook was provided`);
+			const targetIndexes = requestedIndexes ?? currentIndexes;
+			entry.schemaMigrationInProgress = true;
+			try {
+				await db.runSchemaMigration(currentVersion, requestedVersion, migrate, toPublicIndexDefinitions(targetIndexes));
+			} finally {
+				entry.schemaMigrationInProgress = false;
+			}
+			return db;
+		} finally {
+			await entry.proxy.releaseMigration?.();
+		}
+	} catch (error) {
+		try {
+			await db.close();
+		} catch {}
+		throw normalizeError(error);
+	}
+}
+//#endregion
+//#region src/node-worker-client.ts
+var NodeWorkerTransport = class {
+	proxy;
+	#worker;
+	#listeners = /* @__PURE__ */ new Map();
+	#exited;
+	#resolveExit;
+	#rejectExit;
+	#terminating = false;
+	#failureEmitted = false;
+	constructor(data, releaseLease) {
+		this.#exited = new Promise((resolve, reject) => {
+			this.#resolveExit = resolve;
+			this.#rejectExit = reject;
+		});
+		this.#exited.catch(() => {});
+		this.#worker = new Worker$1(new URL("./node-worker.mjs", import.meta.url), { workerData: data });
+		this.#worker.on("message", (data) => {
+			this.#emit("message", { data });
+		});
+		this.#worker.on("messageerror", () => {
+			this.#emit("messageerror", {});
+		});
+		this.#worker.on("error", (error) => {
+			this.#failureEmitted = true;
+			this.#emit("error", {
+				error,
+				message: error.message
+			});
+		});
+		this.#worker.once("exit", (code) => {
+			if (!this.#terminating && !this.#failureEmitted) {
+				const error = workerProtocolError("WorkerTerminatedError", `Node worker exited with code ${code}`);
+				this.#emit("error", {
+					error,
+					message: error.message
+				});
+			}
+			try {
+				releaseLease();
+				this.#resolveExit(code);
+			} catch (error) {
+				this.#rejectExit(error);
+			}
+		});
+		this.proxy = new WorkerProtocolClient(this, { readyTimeoutMs: Math.min(2147483647, 3e4 + data.ownerWaitMs) });
+	}
+	postMessage(message, transfer = []) {
+		this.#worker.postMessage(message, transfer);
+	}
+	addEventListener(type, listener) {
+		let listeners = this.#listeners.get(type);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			this.#listeners.set(type, listeners);
+		}
+		listeners.add(listener);
+	}
+	removeEventListener(type, listener) {
+		this.#listeners.get(type)?.delete(listener);
+	}
+	terminate() {
+		if (!this.#terminating) {
+			this.#terminating = true;
+			this.#worker.terminate().catch(this.#rejectExit);
+		}
+		return this.#exited;
+	}
+	#emit(type, event) {
+		for (const listener of Array.from(this.#listeners.get(type) ?? [])) if (typeof listener === "function") listener(event);
+		else listener.handleEvent(event);
+	}
+};
+//#endregion
+//#region src/node-storage.mjs
+var LOCK_DIRECTORY = ".moyodb.lock";
+var PENDING_PREFIX = ".moyodb.pending-";
+var TOKEN_PATTERN = /^[a-f\d]{8}-[a-f\d]{4}-[a-f\d]{4}-[a-f\d]{4}-[a-f\d]{12}$/i;
+function namedError(name, message, cause) {
+	const error = new Error(message, cause === void 0 ? void 0 : { cause });
+	error.name = name;
+	error.code = cause?.code ?? name;
+	return error;
+}
+function storageError(error) {
+	if ([
+		"NotFoundError",
+		"TypeMismatchError",
+		"SecurityError",
+		"DatabaseBusyError",
+		"StorageError"
+	].includes(error?.name)) return error;
+	if (error?.code === "ENOENT") return namedError("NotFoundError", error.message, error);
+	return namedError("StorageError", error?.message ?? String(error), error);
+}
+function validateDirectory(directory) {
+	if (typeof directory !== "string" || directory.length === 0 || directory.includes("\0")) throw new TypeError("directory must be a nonempty filesystem path");
+	return resolve(directory);
+}
+function validateToken(token) {
+	if (typeof token !== "string" || !TOKEN_PATTERN.test(token)) throw new TypeError("invalid storage lock token");
+	return token;
+}
+function entryStat(path, kind) {
+	const stat = fs.lstatSync(path);
+	if (stat.isSymbolicLink() || stat.isFile() && stat.nlink !== 1) throw namedError("SecurityError", "storage entries must not be links");
+	if (kind === "directory" && !stat.isDirectory() || kind === "file" && !stat.isFile()) throw namedError("TypeMismatchError", `storage entry is not a ${kind}`);
+	if (!stat.isDirectory() && !stat.isFile()) throw namedError("SecurityError", "unsupported storage entry type");
+	return stat;
+}
+function syncDirectory(path) {
+	if (process.platform === "win32") return;
+	const fd = fs.openSync(path, fs.constants.O_RDONLY | (fs.constants.O_DIRECTORY ?? 0));
+	try {
+		fs.fsyncSync(fd);
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+function readLease(directory, token) {
+	const lockDirectory = join(directory, LOCK_DIRECTORY);
+	entryStat(lockDirectory, "directory");
+	const recordPath = join(lockDirectory, `${validateToken(token)}.json`);
+	entryStat(recordPath, "file");
+	const owner = JSON.parse(fs.readFileSync(recordPath, "utf8"));
+	if (owner.token !== token || !Number.isSafeInteger(owner.pid) || owner.pid <= 0) throw namedError("DatabaseBusyError", "storage lock owner cannot be verified");
+	return {
+		lockDirectory,
+		recordPath,
+		owner
+	};
+}
+function removeLease(lease) {
+	fs.unlinkSync(lease.recordPath);
+	try {
+		fs.rmdirSync(lease.lockDirectory);
+	} catch (error) {
+		if (![
+			"ENOENT",
+			"ENOTEMPTY",
+			"EEXIST"
+		].includes(error?.code)) throw error;
+	}
+	syncDirectory(dirname(lease.lockDirectory));
+}
+function removeVacantLease(directory) {
+	const path = join(directory, LOCK_DIRECTORY);
+	try {
+		entryStat(path, "directory");
+		if (fs.readdirSync(path).length !== 0) return false;
+		fs.rmdirSync(path);
+		syncDirectory(directory);
+		return true;
+	} catch (error) {
+		if ([
+			"ENOENT",
+			"ENOTEMPTY",
+			"EEXIST"
+		].includes(error?.code)) return false;
+		throw error;
+	}
+}
+function removePendingLease(directory, token) {
+	const pending = join(directory, `${PENDING_PREFIX}${process.pid}-${token}`);
+	try {
+		entryStat(pending, "directory");
+	} catch (error) {
+		if (error?.code === "ENOENT") return false;
+		throw error;
+	}
+	const entries = fs.readdirSync(pending);
+	if (entries.length === 1 && entries[0] === `${token}.json`) {
+		const recordPath = join(pending, entries[0]);
+		entryStat(recordPath, "file");
+		fs.unlinkSync(recordPath);
+	} else if (entries.length !== 0) throw namedError("SecurityError", "pending storage lock contains unknown entries");
+	fs.rmdirSync(pending);
+	return true;
+}
+function releaseNodeStorageLease(directory, lockToken) {
+	const path = validateDirectory(directory);
+	validateToken(lockToken);
+	let lease;
+	let canonical;
+	try {
+		canonical = fs.realpathSync(path);
+		lease = readLease(canonical, lockToken);
+	} catch (error) {
+		if (error?.code === "ENOTDIR") return false;
+		if (error?.code === "ENOENT") {
+			if (!canonical) return false;
+			const removedPending = removePendingLease(canonical, lockToken);
+			return removeVacantLease(canonical) || removedPending;
+		}
+		throw storageError(error);
+	}
+	if (lease.owner.pid !== process.pid) return false;
+	try {
+		removeLease(lease);
+		removePendingLease(canonical, lockToken);
+		return true;
+	} catch (error) {
+		if (error?.code === "ENOENT") return false;
+		throw storageError(error);
+	}
+}
+//#endregion
+//#region src/node.ts
+var registry = /* @__PURE__ */ new Map();
+var lifecycleOperations = /* @__PURE__ */ new Map();
+function queueLifecycleOperation(key, operation) {
+	const result = (lifecycleOperations.get(key) ?? Promise.resolve()).then(operation);
+	const settled = result.then(() => void 0, () => void 0);
+	lifecycleOperations.set(key, settled);
+	settled.then(() => {
+		if (lifecycleOperations.get(key) === settled) lifecycleOperations.delete(key);
+	});
+	return result;
+}
+function validateName(name, method) {
+	if (typeof name !== "string" || name.length === 0) throw new TypeError(`${method}() database name must be a non-empty string`);
+	if (/[\uD800-\uDFFF]/u.test(name)) throw new TypeError(`${method}() database name must contain valid Unicode`);
+	if (Buffer.byteLength(name, "utf8") > 127) throw new TypeError(`${method}() database name must contain at most 127 UTF-8 bytes`);
+}
+function validateDirectoryOptions(options) {
+	if (options === null || typeof options !== "object" || Array.isArray(options)) throw new InvalidOpenOptionsError("Node options must contain directory");
+	const directory = options.directory;
+	if (typeof directory !== "string" || directory.length === 0 || directory.includes("\0")) throw new InvalidOpenOptionsError("directory must be a non-empty filesystem path");
+}
+async function databaseLocation(name, options) {
+	await mkdir(options.directory, { recursive: true });
+	const root = await realpath(options.directory);
+	const directory = join(root, "stackdb", Buffer.from(name, "utf8").toString("hex"));
+	return {
+		directory,
+		registryKey: process.platform === "win32" ? directory.toLowerCase() : directory
+	};
+}
+function invalidateEntry(entry) {
+	if (entry.invalidated) return;
+	entry.invalidated = true;
+	entry.refs = 0;
+	invalidateTransactions(entry);
+	for (const listener of Array.from(entry.handleInvalidationListeners)) listener();
+}
+function shutdownEntry(entry, reason) {
+	if (entry.shutdown) return entry.shutdown;
+	entry.proxy.dispose(reason);
+	entry.shutdown = Promise.resolve(entry.worker.terminate()).then(() => void 0);
+	return entry.shutdown;
+}
+function createEntry(dbName, directory, registryKey, options) {
+	const normalized = normalizeOptions({
+		...options,
+		workerMode: "dedicated"
+	});
+	const lockToken = randomUUID();
+	const channelName = `node:${createHash("sha256").update(registryKey).digest("hex")}`;
+	const worker = new NodeWorkerTransport({
+		directory,
+		dbName,
+		channelName,
+		lockToken,
+		ownerWaitMs: normalized.ownerWaitMs,
+		encodedDbName: Buffer.from(dbName, "utf8").toString("hex")
+	}, () => {
+		releaseNodeStorageLease(directory, lockToken);
+	});
+	const entry = {
+		dbName,
+		directory,
+		registryKey,
+		worker,
+		proxy: worker.proxy,
+		persistenceBridge: { close() {} },
+		options: normalized,
+		refs: 1,
+		invalidated: false,
+		schemaMigrationInProgress: false,
+		txInvalidationListeners: /* @__PURE__ */ new Set(),
+		handleInvalidationListeners: /* @__PURE__ */ new Set(),
+		channelName,
+		shutdown: null,
+		release: () => releaseEntry(entry),
+		destroy: () => queueLifecycleOperation(registryKey, () => destroyEntry(entry))
+	};
+	worker.proxy.setFatalHandler((error) => {
+		if (registry.get(registryKey) === entry) registry.delete(registryKey);
+		invalidateEntry(entry);
+		queueLifecycleOperation(registryKey, () => shutdownEntry(entry, error)).catch(() => {});
+	});
+	return entry;
+}
+async function acquireEntry(dbName, directory, registryKey, options) {
+	const normalized = normalizeOptions({
+		...options,
+		workerMode: "dedicated"
+	});
+	return queueLifecycleOperation(registryKey, async () => {
+		const existing = registry.get(registryKey);
+		if (existing && !existing.invalidated) {
+			if (existing.schemaMigrationInProgress) throw new DatabaseBusyError(`database ${dbName} is migrating; wait for openNodeDB() to resolve`);
+			assertCompatibleOptions(dbName, existing.options, normalized);
+			if (normalized.debugFailpoint !== null) await existing.proxy.setFailpoint(normalized.debugFailpoint);
+			existing.refs += 1;
+			return existing;
+		}
+		const entry = createEntry(dbName, directory, registryKey, options);
+		try {
+			await entry.proxy.open({
+				dbName,
+				options: normalized
+			});
+			if (entry.invalidated) throw new DatabaseClosedError();
+			registry.set(registryKey, entry);
+			return entry;
+		} catch (error) {
+			await shutdownEntry(entry, workerProtocolError("WorkerTerminatedError", "Node worker open failed"));
+			throw normalizeError(error);
+		}
+	});
+}
+async function releaseEntry(entry) {
+	return queueLifecycleOperation(entry.registryKey, async () => {
+		if (entry.invalidated || registry.get(entry.registryKey) !== entry) {
+			if (entry.shutdown) await entry.shutdown;
+			return;
+		}
+		entry.refs -= 1;
+		if (entry.refs > 0) return;
+		registry.delete(entry.registryKey);
+		try {
+			await entry.proxy.close();
+		} finally {
+			invalidateEntry(entry);
+			await shutdownEntry(entry, workerProtocolError("WorkerTerminatedError", "Node worker was released"));
+		}
+	});
+}
+async function destroyEntry(entry) {
+	if (entry.invalidated || registry.get(entry.registryKey) !== entry) throw new DatabaseClosedError();
+	registry.delete(entry.registryKey);
+	invalidateEntry(entry);
+	try {
+		await entry.proxy.destroy();
+	} finally {
+		await shutdownEntry(entry, workerProtocolError("WorkerTerminatedError", "Node database was destroyed"));
+	}
+}
+async function openNodeDB(name, options) {
+	validateName(name, "openNodeDB");
+	validateDirectoryOptions(options);
+	const { directory, registryKey } = await databaseLocation(name, options);
+	return openDBWithWorker(name, options, (dbName, openOptions) => acquireEntry(dbName, directory, registryKey, openOptions));
+}
+async function deleteNodeDB(name, options) {
+	validateName(name, "deleteNodeDB");
+	validateDirectoryOptions(options);
+	const { directory, registryKey } = await databaseLocation(name, options);
+	return queueLifecycleOperation(registryKey, async () => {
+		const existing = registry.get(registryKey);
+		if (existing) return destroyEntry(existing);
+		const entry = createEntry(name, directory, registryKey, {});
+		try {
+			await entry.proxy.deleteDB(name);
+		} finally {
+			await shutdownEntry(entry, workerProtocolError("WorkerTerminatedError", "Node delete worker was released"));
+		}
+	});
+}
+async function unsafeDebugCrashNodeWorker(name, options) {
+	validateName(name, "unsafeDebugCrashNodeWorker");
+	validateDirectoryOptions(options);
+	const { registryKey } = await databaseLocation(name, options);
+	return queueLifecycleOperation(registryKey, async () => {
+		const entry = registry.get(registryKey);
+		if (!entry) return false;
+		registry.delete(registryKey);
+		invalidateEntry(entry);
+		await shutdownEntry(entry, workerProtocolError("WorkerTerminatedError", "Node worker was terminated"));
+		return true;
+	});
+}
+//#endregion
+export { ChangeFeedCompactedError, ConstraintError, CorruptionError, DatabaseBusyError, DatabaseClosedError, INDEX_METADATA_STORE, IndexNotFoundError, InjectedFailureError, InternalError, InvalidOpenOptionsError, InvalidRangeError, KeyTooLargeError, MoyoDbError, ReadonlyTransactionError, RecordIndex, RecordStore, RecoveryRequiredError, ReservedStoreNameError, SerializationError, SqlSchemaError, SqlSyntaxError, SqlTypeError, StorageError, StoreExistsError, StoreNameTooLongError, StoreNotFoundError, TransactionClosedError, TransactionConflictError, UniqueIndexConstraintError, UnsupportedPlatformError, ValueTooLargeError, VersionError, WriteTransactionAlreadyOpenError, assertPublicStoreName, cloneNormalizedIndexDefinitions, compareNormalizedIndexDefinitions, compoundKey, compoundKeyCodec, compoundKeyRange, createIndexKeyExtractor, createRecordStore, createSqlClient, decodeIndexEntryKey, decodeIndexMetadataValue, decodeIndexedDocument, deleteNodeDB, encodeCompoundKeyParts, encodeIndexEntryKey, encodeIndexMetadataKey, encodeIndexMetadataValue, encodeIndexScalar, extractLogicalIndexKey, extractLogicalIndexKeyFromDocument, findIndexDefinition, indexDefinitionIdentity, indexKey, indexKeyExactRange, indexRangeToPhysicalRange, indexesForStore, isInternalStoreName, jsonDecode, jsonEncode, jsonRecordCodec, keyCodecs, normalizeError, normalizeIndexDefinitions, openNodeDB, openRecordStore, prefixRange, prefixSuccessor, scalarKeyCodec, serializeNormalizedIndexDefinitions, splitCompoundKey, toPublicIndexDefinitions, u64Key, unsafeDebugCrashNodeWorker, utf8Decode, utf8Encode, withRecordTransaction };
+
+//# sourceMappingURL=node.js.map