@moyodb/sdk 1.0.1 → 1.3.0

package/dist/node-engine.js

@@ -0,0 +1,2838 @@
+import { At as packedBinaryListBytes, Bt as unpackPackedOptionalValues, Et as isWorkerProtocolRequestMessage, F as utf8Encode, Ft as serializeWorkerError, Gt as isRecord, Ht as workerProtocolError, It as unpackPackedBatchOpKeys, Lt as unpackPackedBatchOps, Mt as packedScanRows, Pt as prepareWorkerResponsePayload, Rt as unpackPackedBinaryList, S as toPublicIndexDefinitions, St as isWorkerProtocolEnvelope, Tt as isWorkerProtocolRequestBatchMessage, Ut as clampTimerDelayMs, Vt as unpackPackedScanRows, _ as indexRangeToPhysicalRange, _t as decodeWorkerCommandPayload, a as createIndexKeyExtractor, b as normalizeIndexDefinitions, bt as isAutocommitCommand, c as decodeIndexedDocument, d as encodeIndexMetadataValue, dt as WORKER_PROTOCOL_READY, f as extractLogicalIndexKey, g as indexKeyExactRange, gt as captureWorkerPayload, ht as WORKER_PROTOCOL_RESPONSE_BATCH, i as compareNormalizedIndexDefinitions, jt as packedOptionalValues, kt as packedBatchOpsBytes, l as encodeIndexEntryKey, m as findIndexDefinition, mt as WORKER_PROTOCOL_RESPONSE, o as decodeIndexEntryKey, p as extractLogicalIndexKeyFromDocument, r as cloneNormalizedIndexDefinitions, s as decodeIndexMetadataValue, t as INDEX_METADATA_STORE, u as encodeIndexMetadataKey, xt as isWorkerCommand, y as isInternalStoreName, zt as unpackPackedBinaryPairKeys } from "./chunks/indexing-CKtbpaZn.js";
+//#region src/worker-server.ts
+/** The first argument identifies the transaction lane. */
+var TRANSACTION_COMMANDS = /* @__PURE__ */ new Set([
+	"commit",
+	"rollback",
+	"createStore",
+	"dropStore",
+	"clearStore",
+	"get",
+	"getMany",
+	"has",
+	"put",
+	"putMany",
+	"delete",
+	"deleteMany",
+	"applyBatch",
+	"scan",
+	"getByIndex",
+	"scanByIndex",
+	"scanByIndexPage",
+	"getIndexes",
+	"reconcileIndexes",
+	"setSchemaVersion"
+]);
+/** These commands require exclusive access to the open engine. */
+var EXCLUSIVE_COMMANDS = /* @__PURE__ */ new Set([
+	"open",
+	"close",
+	"destroy",
+	"importSnapshot",
+	"reset",
+	"compact",
+	"rebuild"
+]);
+/**
+* These commands do not use the open engine, so browser storage calls
+* can run without delaying its close.
+*/
+var UNSCHEDULED_COMMANDS = /* @__PURE__ */ new Set([
+	"deleteDB",
+	"storageInfo",
+	"requestPersistence"
+]);
+var noop = () => {};
+/**
+* Serializes each transaction lane, including awaited work. Readwrite
+* autocommits share one writer lane. Exclusive commands wait for scheduled
+* work and block later scheduled work until they finish.
+*/
+var RequestScheduler = class {
+	#lanes = /* @__PURE__ */ new Map();
+	#inFlight = /* @__PURE__ */ new Set();
+	#barrier = Promise.resolve();
+	#cursorLanes = /* @__PURE__ */ new Map();
+	schedule(command, args, task) {
+		if (UNSCHEDULED_COMMANDS.has(command)) return task();
+		if (EXCLUSIVE_COMMANDS.has(command)) {
+			if (this.#cursorLanes.size === 0) return this.#runExclusive(task);
+			return this.#runExclusive(async () => {
+				const result = await task();
+				this.#cursorLanes.clear();
+				return result;
+			});
+		}
+		if (command !== "scanPage" && command !== "closeCursor" && !((command === "commit" || command === "rollback") && this.#cursorLanes.size > 0)) return this.#runShared(laneFor(command, args), task);
+		const request = command === "scanPage" && isRecord(args[0]) ? args[0] : null;
+		const cursorId = request?.cursorId ?? (command === "closeCursor" ? args[0] : void 0);
+		const lane = (typeof cursorId === "number" ? this.#cursorLanes.get(cursorId) : void 0) ?? (request && typeof request.txId === "number" ? request.txId : typeof cursorId === "number" ? `cursor:${cursorId}` : laneFor(command, args));
+		return this.#runShared(lane, async () => {
+			try {
+				const result = await task();
+				if (request && isRecord(result)) {
+					if (typeof cursorId === "number") this.#cursorLanes.delete(cursorId);
+					if (typeof result.cursorId === "number") this.#cursorLanes.set(result.cursorId, lane ?? `cursor:${result.cursorId}`);
+				}
+				return result;
+			} finally {
+				if (command === "closeCursor" && typeof cursorId === "number") this.#cursorLanes.delete(cursorId);
+				if (command === "commit" || command === "rollback") {
+					for (const [cursor, ownerLane] of this.#cursorLanes) if (ownerLane === args[0]) this.#cursorLanes.delete(cursor);
+				}
+			}
+		});
+	}
+	#runShared(lane, task) {
+		const barrier = this.#barrier;
+		const previous = lane === null ? void 0 : this.#lanes.get(lane);
+		const result = (async () => {
+			await barrier;
+			if (previous) await previous;
+			return task();
+		})();
+		const settled = result.then(noop, noop);
+		this.#inFlight.add(settled);
+		if (lane !== null) this.#lanes.set(lane, settled);
+		settled.then(() => {
+			this.#inFlight.delete(settled);
+			if (lane !== null && this.#lanes.get(lane) === settled) this.#lanes.delete(lane);
+		});
+		return result;
+	}
+	#runExclusive(task) {
+		const previousBarrier = this.#barrier;
+		const pending = Array.from(this.#inFlight);
+		const result = (async () => {
+			await previousBarrier;
+			await Promise.all(pending);
+			return task();
+		})();
+		this.#barrier = result.then(noop, noop);
+		return result;
+	}
+};
+var AUTOCOMMIT_WRITER_LANE = "autocommit:readwrite";
+function laneFor(command, args) {
+	if (TRANSACTION_COMMANDS.has(command) && typeof args[0] === "number") return args[0];
+	if (command === "autocommit" && args[0] === "readwrite") return AUTOCOMMIT_WRITER_LANE;
+	return null;
+}
+var ResponseQueue = class {
+	scope;
+	queued = [];
+	queuedBytes = 0;
+	flushScheduled = false;
+	flushChannel = null;
+	closed = false;
+	constructor(scope) {
+		this.scope = scope;
+	}
+	enqueue = (response, transfer = []) => {
+		if (this.closed) return;
+		const captured = captureWorkerPayload(response, transfer);
+		if (this.queued.length > 0 && this.queuedBytes + captured.byteLength > 1048576) this.flush();
+		this.queued.push({
+			response: captured.value,
+			transfer: captured.transfer
+		});
+		this.queuedBytes += captured.byteLength;
+		if (!this.flushScheduled) {
+			this.flushScheduled = true;
+			queueMicrotask(() => {
+				if (this.closed || this.queued.length === 0) {
+					this.flushScheduled = false;
+					return;
+				}
+				this.flushChannel ??= this.createFlushChannel();
+				this.flushChannel.port2.postMessage(null);
+			});
+		}
+		if (this.queued.length >= 128 || this.queuedBytes >= 1048576) this.flush();
+	};
+	close() {
+		this.closed = true;
+		this.queued = [];
+		this.queuedBytes = 0;
+		this.flushChannel?.port1.close();
+		this.flushChannel?.port2.close();
+		this.flushChannel = null;
+	}
+	createFlushChannel() {
+		const channel = new MessageChannel();
+		channel.port1.addEventListener("message", () => {
+			this.flushScheduled = false;
+			this.flush();
+		});
+		channel.port1.start();
+		return channel;
+	}
+	flush() {
+		const queued = this.queued;
+		this.queued = [];
+		this.queuedBytes = 0;
+		if (this.closed || queued.length === 0) return;
+		const response = queued.length === 1 ? queued[0].response : {
+			type: WORKER_PROTOCOL_RESPONSE_BATCH,
+			version: 1,
+			responses: queued.map((entry) => entry.response)
+		};
+		const transfer = [];
+		for (const entry of queued) for (const buffer of entry.transfer) transfer.push(buffer);
+		postWorkerResponse(this.scope, response, transfer);
+	}
+};
+function exposeWorkerApi(api, scope = self) {
+	const scheduler = new RequestScheduler();
+	const responses = new ResponseQueue(scope);
+	const handleMessage = (event) => {
+		if (event.origin !== "" && event.origin !== scope.location.origin) return;
+		if (isWorkerProtocolRequestBatchMessage(event.data)) {
+			let remaining = event.data.requests.length;
+			const respond = (response, transfer) => {
+				responses.enqueue(response, transfer);
+				remaining -= 1;
+				if (remaining === 0) responses.flush();
+			};
+			for (const request of event.data.requests) dispatchWorkerRequest(scope, api, scheduler, request, respond);
+			return;
+		}
+		dispatchWorkerRequest(scope, api, scheduler, event.data);
+	};
+	scope.addEventListener("message", handleMessage);
+	scope.postMessage({
+		type: WORKER_PROTOCOL_READY,
+		version: 1,
+		batching: 1
+	});
+	return { close() {
+		scope.removeEventListener("message", handleMessage);
+		responses.close();
+	} };
+}
+async function dispatchWorkerRequest(scope, api, scheduler, data, respond = (response, transfer) => postWorkerResponse(scope, response, transfer)) {
+	if (!isWorkerProtocolEnvelope(data)) return;
+	const id = typeof data.id === "number" && Number.isSafeInteger(data.id) ? data.id : 0;
+	if (!isWorkerProtocolRequestMessage(data)) {
+		respond(errorResponse(id, workerProtocolError("WorkerProtocolError", "invalid worker protocol request")));
+		return;
+	}
+	if (!isWorkerCommand(data.command)) {
+		respond(errorResponse(data.id, workerProtocolError("WorkerProtocolError", `unsupported worker command: ${String(data.command)}`)));
+		return;
+	}
+	const command = data.command;
+	const args = data.args;
+	try {
+		let responseCommand = command;
+		let invoke;
+		if (command === "autocommit") {
+			const [mode, inner, innerArgs] = args;
+			if (mode !== "readonly" && mode !== "readwrite" || !isAutocommitCommand(inner) || !Array.isArray(innerArgs)) throw workerProtocolError("WorkerProtocolError", "invalid autocommit request");
+			assertImplemented(api, inner);
+			responseCommand = inner;
+			invoke = () => runAutocommit(api, mode, inner, innerArgs);
+		} else {
+			assertImplemented(api, command);
+			invoke = () => invokeCommand(api, command, args);
+		}
+		const result = await scheduler.schedule(command, args, invoke);
+		const responsePayload = prepareWorkerResponsePayload(responseCommand, result);
+		respond(successResponse(data.id, responsePayload.result), responsePayload.transfer);
+	} catch (error) {
+		respond(errorResponse(data.id, error));
+	}
+}
+function assertImplemented(api, command) {
+	if (typeof api[command] !== "function") throw workerProtocolError("WorkerProtocolError", `worker command is not implemented: ${command}`);
+}
+function invokeCommand(api, command, args) {
+	const packedResult = dispatchPackedCommand(api, command, args);
+	if (packedResult !== null) return packedResult;
+	return api[command].apply(api, decodeWorkerCommandPayload(command, args));
+}
+async function runAutocommit(api, mode, command, args) {
+	const txId = await api.begin(mode);
+	let result;
+	try {
+		result = await invokeCommand(api, command, [txId, ...args]);
+	} catch (error) {
+		try {
+			await api.rollback(txId);
+		} catch {}
+		throw error;
+	}
+	if (mode === "readwrite") await api.commit(txId);
+	else await api.rollback(txId);
+	return result;
+}
+function dispatchPackedCommand(api, command, args) {
+	const packedApi = api;
+	if (command === "getMany" || command === "deleteMany") {
+		const [txId, store, keys] = args;
+		if (typeof txId !== "number" || typeof store !== "string") return null;
+		const packedKeys = packedBinaryListBytes(keys);
+		if (packedKeys === null) return null;
+		if (command === "getMany" && typeof packedApi.getManyPacked === "function") return packedApi.getManyPacked(txId, store, packedKeys);
+		if (command === "deleteMany" && typeof packedApi.deleteManyPacked === "function") return packedApi.deleteManyPacked(txId, store, packedKeys);
+		return null;
+	}
+	if (command === "putMany") {
+		const [txId, store, entries, options] = args;
+		if (typeof txId !== "number" || typeof store !== "string" || typeof packedApi.putManyPacked !== "function") return null;
+		const packedEntries = packedBinaryListBytes(entries);
+		return packedEntries === null ? null : packedApi.putManyPacked(txId, store, packedEntries, options);
+	}
+	if (command === "applyBatch") {
+		const [txId, store, ops] = args;
+		if (typeof txId !== "number" || typeof store !== "string" || typeof packedApi.applyBatchPacked !== "function") return null;
+		const packedOps = packedBatchOpsBytes(ops);
+		return packedOps === null ? null : packedApi.applyBatchPacked(txId, store, packedOps);
+	}
+	return null;
+}
+function successResponse(id, result) {
+	return {
+		type: WORKER_PROTOCOL_RESPONSE,
+		version: 1,
+		id,
+		ok: true,
+		result
+	};
+}
+function errorResponse(id, error) {
+	return {
+		type: WORKER_PROTOCOL_RESPONSE,
+		version: 1,
+		id,
+		ok: false,
+		error: serializeWorkerError(error)
+	};
+}
+function postWorkerResponse(scope, response, transfer = []) {
+	if (transfer.length > 0) try {
+		scope.postMessage(response, transfer);
+		return;
+	} catch {}
+	scope.postMessage(response);
+}
+//#endregion
+//#region src/snappy.ts
+var BLOCK_SIZE = 65536;
+var HASH_SIZE = 16384;
+var MAX_LENGTH = 4294967295;
+var MATCH_TABLE = new Uint32Array(HASH_SIZE);
+function corrupt(message) {
+	const error = /* @__PURE__ */ new Error(`invalid Snappy block: ${message}`);
+	error.name = "CorruptionError";
+	return error;
+}
+function word(bytes, offset) {
+	return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
+}
+function hash(value, bits) {
+	return Math.imul(value, 2654435761) >>> 32 - bits;
+}
+function encodeSnappy(input) {
+	if (input.byteLength > MAX_LENGTH) throw new RangeError("Snappy input exceeds the 32-bit length limit");
+	const output = new Uint8Array(input.byteLength + Math.ceil(input.byteLength / 6) + 32);
+	let written = 0;
+	let remainingLength = input.byteLength;
+	while (remainingLength >= 128) {
+		output[written++] = remainingLength & 127 | 128;
+		remainingLength = Math.floor(remainingLength / 128);
+	}
+	output[written++] = remainingLength;
+	const literal = (start, end) => {
+		if (start === end) return;
+		let length = end - start - 1;
+		if (length < 60) output[written++] = length << 2;
+		else {
+			const lengthBytes = length <= 255 ? 1 : length <= 65535 ? 2 : length <= 16777215 ? 3 : 4;
+			output[written++] = 59 + lengthBytes << 2;
+			for (let index = 0; index < lengthBytes; index += 1) {
+				output[written++] = length & 255;
+				length >>>= 8;
+			}
+		}
+		output.set(input.subarray(start, end), written);
+		written += end - start;
+	};
+	const copy = (offset, length) => {
+		while (length > 0) {
+			const count = Math.min(length, 64);
+			if (count >= 4 && count <= 11 && offset < 2048) {
+				output[written++] = 1 | count - 4 << 2 | offset >>> 8 << 5;
+				output[written++] = offset & 255;
+			} else {
+				output[written++] = 2 | count - 1 << 2;
+				output[written++] = offset & 255;
+				output[written++] = offset >>> 8;
+			}
+			length -= count;
+		}
+	};
+	let hashBits = 8;
+	while (1 << hashBits < Math.min(input.byteLength, HASH_SIZE)) hashBits += 1;
+	const tableSize = 1 << hashBits;
+	const table = MATCH_TABLE;
+	for (let blockStart = 0; blockStart < input.byteLength; blockStart += BLOCK_SIZE) {
+		const blockEnd = Math.min(blockStart + BLOCK_SIZE, input.byteLength);
+		table.fill(0, 0, tableSize);
+		let position = blockStart;
+		let literalStart = blockStart;
+		let misses = 0;
+		while (position + 4 <= blockEnd) {
+			const current = word(input, position);
+			const slot = hash(current, hashBits);
+			const previous = table[slot];
+			table[slot] = position - blockStart + 1;
+			const candidate = blockStart + previous - 1;
+			if (previous === 0 || current !== word(input, candidate)) {
+				misses += 1;
+				position += 1 + Math.min(misses >>> 5, 64);
+				continue;
+			}
+			literal(literalStart, position);
+			const matchStart = position;
+			position += 4;
+			while (position < blockEnd && input[position] === input[candidate + position - matchStart]) position += 1;
+			copy(matchStart - candidate, position - matchStart);
+			literalStart = position;
+			misses = 0;
+			if (position + 4 <= blockEnd) table[hash(word(input, position - 1), hashBits)] = position - blockStart;
+		}
+		literal(literalStart, blockEnd);
+	}
+	return output.subarray(0, written);
+}
+function decodeSnappy(input, maxOutputBytes, expectedOutputBytes) {
+	if (!Number.isSafeInteger(maxOutputBytes) || maxOutputBytes < 0 || maxOutputBytes > MAX_LENGTH) throw new RangeError("invalid Snappy output limit");
+	let read = 0;
+	let length = 0;
+	for (let index = 0;; index += 1) {
+		if (read >= input.byteLength || index === 5) throw corrupt("truncated or invalid length");
+		const byte = input[read++];
+		if (index === 4 && byte > 15) throw corrupt("length exceeds 32 bits");
+		length += (byte & 127) * 2 ** (index * 7);
+		if (byte < 128) break;
+	}
+	if (length > maxOutputBytes) throw corrupt(`output exceeds ${maxOutputBytes} byte limit`);
+	if (expectedOutputBytes !== void 0 && length !== expectedOutputBytes) throw corrupt(`length mismatch: expected ${expectedOutputBytes} bytes, got ${length}`);
+	const output = new Uint8Array(length);
+	let written = 0;
+	while (read < input.byteLength) {
+		const tag = input[read++];
+		const kind = tag & 3;
+		if (kind === 0) {
+			let count = tag >>> 2;
+			if (count < 60) count += 1;
+			else {
+				const lengthBytes = count - 59;
+				if (lengthBytes > input.byteLength - read) throw corrupt("truncated literal length");
+				count = 1;
+				for (let index = 0; index < lengthBytes; index += 1) count += input[read++] * 2 ** (index * 8);
+			}
+			if (count > input.byteLength - read || count > length - written) throw corrupt("literal exceeds input or output");
+			output.set(input.subarray(read, read + count), written);
+			read += count;
+			written += count;
+			continue;
+		}
+		const offsetBytes = kind === 1 ? 1 : kind === 2 ? 2 : 4;
+		if (offsetBytes > input.byteLength - read) throw corrupt("truncated copy offset");
+		const count = kind === 1 ? 4 + (tag >>> 2 & 7) : 1 + (tag >>> 2);
+		let offset = kind === 1 ? (tag & 224) << 3 : 0;
+		for (let index = 0; index < offsetBytes; index += 1) offset += input[read++] * 2 ** (index * 8);
+		if (offset === 0 || offset > written || count > length - written) throw corrupt("copy exceeds output or has an invalid offset");
+		let copied = 0;
+		while (copied < count) {
+			const chunk = Math.min(offset + copied, count - copied);
+			output.copyWithin(written + copied, written - offset, written - offset + chunk);
+			copied += chunk;
+		}
+		written += count;
+	}
+	if (written !== length) throw corrupt(`length mismatch: expected ${length} bytes, got ${written}`);
+	return output;
+}
+//#endregion
+//#region src/compression.ts
+var STORE_RECORD_MAGIC = utf8Encode("BDBZVAL1");
+var SNAPSHOT_EXPORT_MAGIC = utf8Encode("BDBZSNP1");
+var ENVELOPE_VERSION = 1;
+var ENVELOPE_HEADER_SIZE = 18;
+var COMPRESSION_TAG_NONE = 0;
+var COMPRESSION_TAG_GZIP = 1;
+var COMPRESSION_TAG_DEFLATE = 2;
+var COMPRESSION_TAG_SNAPPY = 3;
+var STORE_FLAG_COMPRESSION_SHIFT = 2;
+var STORE_FLAG_COMPRESSION_MASK = 12;
+var STORE_VALUE_COMPRESSION_PREFLIGHT_WINDOW_BYTES = 1024;
+var MAX_DECOMPRESSED_STORE_VALUE_BYTES = 8388608;
+var MAX_DECOMPRESSED_SNAPSHOT_BYTES = 268435456;
+var CRC32_TABLE = (() => {
+	const table = /* @__PURE__ */ new Uint32Array(2048);
+	for (let index = 0; index < 256; index += 1) {
+		let crc = index;
+		for (let bit = 0; bit < 8; bit += 1) if ((crc & 1) !== 0) crc = crc >>> 1 ^ 3988292384;
+		else crc >>>= 1;
+		table[index] = crc >>> 0;
+	}
+	for (let index = 0; index < 256; index += 1) {
+		let crc = table[index];
+		for (let slice = 1; slice < 8; slice += 1) {
+			crc = crc >>> 8 ^ table[crc & 255];
+			table[slice * 256 + index] = crc >>> 0;
+		}
+	}
+	return table;
+})();
+function namedError(name, message) {
+	const error = new Error(message);
+	error.name = name;
+	return error;
+}
+function compressionTag(kind) {
+	switch (kind) {
+		case false: return COMPRESSION_TAG_NONE;
+		case "gzip": return COMPRESSION_TAG_GZIP;
+		case "deflate": return COMPRESSION_TAG_DEFLATE;
+		case "snappy": return COMPRESSION_TAG_SNAPPY;
+		default: throw namedError("InternalError", `unsupported compression kind: ${String(kind)}`);
+	}
+}
+function compressionKindFromTag(tag) {
+	switch (tag) {
+		case COMPRESSION_TAG_NONE: return false;
+		case COMPRESSION_TAG_GZIP: return "gzip";
+		case COMPRESSION_TAG_DEFLATE: return "deflate";
+		case COMPRESSION_TAG_SNAPPY: return "snappy";
+		default: throw namedError("CorruptionError", `invalid compression tag: ${tag}`);
+	}
+}
+function compressionRuntimeUnavailable() {
+	return namedError("UnsupportedPlatformError", "CompressionStream and DecompressionStream are required for moyodb compression");
+}
+function ensureCompressionRuntime() {
+	if (typeof CompressionStream !== "function" || typeof DecompressionStream !== "function") throw compressionRuntimeUnavailable();
+}
+function crc32(bytes) {
+	let crc = 4294967295;
+	let offset = 0;
+	const blockEnd = bytes.byteLength - 7;
+	for (; offset < blockEnd; offset += 8) {
+		const first = crc ^ bytes[offset] ^ bytes[offset + 1] << 8 ^ bytes[offset + 2] << 16 ^ bytes[offset + 3] << 24;
+		crc = CRC32_TABLE[1792 + (first & 255)] ^ CRC32_TABLE[1536 + (first >>> 8 & 255)] ^ CRC32_TABLE[1280 + (first >>> 16 & 255)] ^ CRC32_TABLE[1024 + (first >>> 24)] ^ CRC32_TABLE[768 + bytes[offset + 4]] ^ CRC32_TABLE[512 + bytes[offset + 5]] ^ CRC32_TABLE[256 + bytes[offset + 6]] ^ CRC32_TABLE[bytes[offset + 7]];
+	}
+	for (; offset < bytes.byteLength; offset += 1) crc = crc >>> 8 ^ CRC32_TABLE[(crc ^ bytes[offset]) & 255];
+	return (crc ^ 4294967295) >>> 0;
+}
+function buildEnvelope(magic, kindTag, rawLength, payload) {
+	const out = new Uint8Array(ENVELOPE_HEADER_SIZE + payload.byteLength);
+	writeEnvelope(out, 0, magic, kindTag, rawLength, payload);
+	return out;
+}
+function writeEnvelope(out, offset, magic, kindTag, rawLength, payload) {
+	const checksum = crc32(payload);
+	out.set(payload, offset + ENVELOPE_HEADER_SIZE);
+	out.set(magic, offset);
+	out[offset + 8] = ENVELOPE_VERSION;
+	out[offset + 9] = kindTag;
+	const view = new DataView(out.buffer, out.byteOffset + offset, ENVELOPE_HEADER_SIZE);
+	view.setUint32(10, rawLength, true);
+	view.setUint32(14, checksum, true);
+}
+function compressionIsProfitable(rawLength, compressedLength) {
+	return (compressedLength + ENVELOPE_HEADER_SIZE) * 100 <= rawLength * 90;
+}
+function snappyPreflightIsProfitable(value) {
+	if (value.byteLength < 65536) return true;
+	let compressedLength = 0;
+	for (let index = 0; index < 3; index += 1) {
+		const offset = Math.floor((value.byteLength - STORE_VALUE_COMPRESSION_PREFLIGHT_WINDOW_BYTES) * index / 2);
+		compressedLength += encodeSnappy(value.subarray(offset, offset + STORE_VALUE_COMPRESSION_PREFLIGHT_WINDOW_BYTES)).byteLength;
+	}
+	return compressionIsProfitable(STORE_VALUE_COMPRESSION_PREFLIGHT_WINDOW_BYTES * 3, compressedLength);
+}
+function buildStoreRecord(input, compressed, compression) {
+	if (!compressionIsProfitable(input.byteLength, compressed.byteLength)) return buildEnvelope(STORE_RECORD_MAGIC, COMPRESSION_TAG_NONE, input.byteLength, input);
+	return buildEnvelope(STORE_RECORD_MAGIC, compressionTag(compression), input.byteLength, compressed);
+}
+function validateStoreValueLength(value) {
+	if (value.byteLength > MAX_DECOMPRESSED_STORE_VALUE_BYTES) throw namedError("ValueTooLargeError", `value has ${value.byteLength} bytes, exceeding the ${MAX_DECOMPRESSED_STORE_VALUE_BYTES} byte limit`);
+}
+function prepareFastStoreValueRecord(value, compression) {
+	if (compression === false) return {
+		payload: value,
+		rawLength: value.byteLength,
+		byteLength: value.byteLength,
+		kindTag: null
+	};
+	validateStoreValueLength(value);
+	let payload = value;
+	let kindTag = COMPRESSION_TAG_NONE;
+	if (value.byteLength >= 1024 && snappyPreflightIsProfitable(value)) {
+		const compressed = encodeSnappy(value);
+		if (compressionIsProfitable(value.byteLength, compressed.byteLength)) {
+			payload = compressed;
+			kindTag = COMPRESSION_TAG_SNAPPY;
+		}
+	}
+	return {
+		payload,
+		rawLength: value.byteLength,
+		byteLength: ENVELOPE_HEADER_SIZE + payload.byteLength,
+		kindTag
+	};
+}
+function writePreparedStoreValueRecord(record, target, offset) {
+	if (!Number.isSafeInteger(offset) || offset < 0 || record.byteLength > target.byteLength - offset) throw namedError("InternalError", "prepared store value exceeds its destination");
+	if (record.kindTag === null) target.set(record.payload, offset);
+	else writeEnvelope(target, offset, STORE_RECORD_MAGIC, record.kindTag, record.rawLength, record.payload);
+	return offset + record.byteLength;
+}
+function copyBytes(bytes) {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy;
+}
+function byteStream(bytes) {
+	let offset = 0;
+	return new ReadableStream({ pull(controller) {
+		if (offset < bytes.byteLength) {
+			const end = Math.min(offset + 65536, bytes.byteLength);
+			controller.enqueue(bytes.subarray(offset, end));
+			offset = end;
+		}
+		if (offset === bytes.byteLength) controller.close();
+	} });
+}
+function readEnvelopeHeader(magic, bytes, strict = true) {
+	if (bytes.byteLength < magic.byteLength) return null;
+	for (let index = 0; index < magic.byteLength; index += 1) if (bytes[index] !== magic[index]) return null;
+	if (bytes.byteLength < ENVELOPE_HEADER_SIZE) {
+		if (strict) throw namedError("CorruptionError", `truncated compression envelope: expected at least ${ENVELOPE_HEADER_SIZE} bytes, got ${bytes.byteLength}`);
+		return null;
+	}
+	const view = new DataView(bytes.buffer, bytes.byteOffset, ENVELOPE_HEADER_SIZE);
+	return {
+		version: bytes[8],
+		kindTag: bytes[9],
+		rawLength: view.getUint32(10, true),
+		payloadChecksum: view.getUint32(14, true)
+	};
+}
+async function compressBytes(data, kind) {
+	ensureCompressionRuntime();
+	let stream;
+	try {
+		stream = byteStream(data).pipeThrough(new CompressionStream(kind));
+	} catch {
+		throw compressionRuntimeUnavailable();
+	}
+	try {
+		return new Uint8Array(await new Response(stream).arrayBuffer());
+	} catch (error) {
+		throw namedError("InternalError", `failed to compress bytes with ${kind}: ${String(error)}`);
+	}
+}
+async function decompressBytes(data, kind, label, maxOutputBytes) {
+	if (kind === "snappy") return decodeSnappy(data, maxOutputBytes ?? MAX_DECOMPRESSED_STORE_VALUE_BYTES, maxOutputBytes);
+	ensureCompressionRuntime();
+	let stream;
+	try {
+		stream = byteStream(copyBytes(data)).pipeThrough(new DecompressionStream(kind));
+	} catch {
+		throw compressionRuntimeUnavailable();
+	}
+	try {
+		return await readBoundedStream(stream, label, maxOutputBytes);
+	} catch (error) {
+		throw namedError("CorruptionError", `failed to decompress ${label}: ${String(error)}`);
+	}
+}
+async function readBoundedStream(stream, label, maxOutputBytes) {
+	const reader = stream.getReader();
+	const chunks = [];
+	let totalBytes = 0;
+	try {
+		for (let next = await reader.read(); !next.done; next = await reader.read()) {
+			const value = next.value;
+			totalBytes += value.byteLength;
+			if (maxOutputBytes !== void 0 && totalBytes > maxOutputBytes) {
+				await reader.cancel(`decompressed ${label} exceeded ${maxOutputBytes} bytes`);
+				throw namedError("CorruptionError", `decompressed ${label} exceeds ${maxOutputBytes} byte limit`);
+			}
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	if (chunks.length === 1) return chunks[0];
+	const out = new Uint8Array(totalBytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return out;
+}
+function compressionFromStoreFlags(flags) {
+	const encoded = (flags & STORE_FLAG_COMPRESSION_MASK) >>> STORE_FLAG_COMPRESSION_SHIFT;
+	switch (encoded) {
+		case 0: return false;
+		case 1: return "gzip";
+		case 2: return "deflate";
+		case 3: return "snappy";
+		default: throw namedError("CorruptionError", `invalid store compression flags: ${encoded}`);
+	}
+}
+async function encodeStoreValueRecord(value, compression) {
+	if (compression === false) return value;
+	if (compression === "snappy") {
+		const record = prepareFastStoreValueRecord(value, compression);
+		const output = new Uint8Array(record.byteLength);
+		writePreparedStoreValueRecord(record, output, 0);
+		return output;
+	}
+	validateStoreValueLength(value);
+	if (value.byteLength < 1024) return buildEnvelope(STORE_RECORD_MAGIC, COMPRESSION_TAG_NONE, value.byteLength, value);
+	const input = copyBytes(value);
+	return buildStoreRecord(input, await compressBytes(input, compression), compression);
+}
+async function decodeStoreValueRecord(value, options) {
+	const header = readEnvelopeHeader(STORE_RECORD_MAGIC, value, options.strict);
+	if (!header) return value;
+	if (header.version !== ENVELOPE_VERSION) {
+		if (options.strict) throw namedError("CorruptionError", `unsupported value record version: ${header.version}`);
+		return value;
+	}
+	let compression;
+	try {
+		compression = compressionKindFromTag(header.kindTag);
+	} catch (error) {
+		if (options.strict) throw error;
+		return value;
+	}
+	const payload = value.subarray(ENVELOPE_HEADER_SIZE);
+	if (crc32(payload) !== header.payloadChecksum) {
+		if (options.strict) throw namedError("CorruptionError", "value record checksum mismatch");
+		return value;
+	}
+	if (compression === false) {
+		if (payload.byteLength !== header.rawLength) {
+			if (options.strict) throw namedError("CorruptionError", `value record length mismatch: expected ${header.rawLength} bytes, got ${payload.byteLength}`);
+			return value;
+		}
+		return payload.slice();
+	}
+	if (header.rawLength > MAX_DECOMPRESSED_STORE_VALUE_BYTES) throw namedError("CorruptionError", `compressed value advertises ${header.rawLength} decompressed bytes, exceeding the ${MAX_DECOMPRESSED_STORE_VALUE_BYTES} byte limit`);
+	const decompressed = await decompressBytes(payload, compression, `value record (${compression})`, header.rawLength);
+	if (decompressed.byteLength !== header.rawLength) throw namedError("CorruptionError", `decompressed value length mismatch: expected ${header.rawLength} bytes, got ${decompressed.byteLength}`);
+	return decompressed;
+}
+async function wrapSnapshotWithCompression(snapshot, compression) {
+	if (compression === false) return snapshot;
+	if (!["gzip", "deflate"].includes(compression)) throw namedError("InternalError", `unsupported snapshot compression kind: ${String(compression)}`);
+	const input = copyBytes(snapshot);
+	const compressed = await compressBytes(input, compression);
+	return buildEnvelope(SNAPSHOT_EXPORT_MAGIC, compressionTag(compression), input.byteLength, compressed);
+}
+async function unwrapSnapshotCompression(snapshot) {
+	const header = readEnvelopeHeader(SNAPSHOT_EXPORT_MAGIC, snapshot);
+	if (!header) return snapshot;
+	if (header.version !== ENVELOPE_VERSION) throw namedError("CorruptionError", `unsupported snapshot compression version: ${header.version}`);
+	const compression = compressionKindFromTag(header.kindTag);
+	if (compression === false) throw namedError("CorruptionError", "snapshot compression envelope cannot store kind \"none\"");
+	if (compression === "snappy") throw namedError("CorruptionError", `invalid snapshot compression tag: ${header.kindTag}`);
+	const payload = snapshot.subarray(ENVELOPE_HEADER_SIZE);
+	if (crc32(payload) !== header.payloadChecksum) throw namedError("CorruptionError", "snapshot compression checksum mismatch");
+	if (header.rawLength > MAX_DECOMPRESSED_SNAPSHOT_BYTES) throw namedError("CorruptionError", `compressed snapshot advertises ${header.rawLength} decompressed bytes, exceeding the ${MAX_DECOMPRESSED_SNAPSHOT_BYTES} byte limit`);
+	const decompressed = await decompressBytes(payload, compression, `snapshot export (${compression})`, header.rawLength);
+	if (decompressed.byteLength !== header.rawLength) throw namedError("CorruptionError", `decompressed snapshot length mismatch: expected ${header.rawLength} bytes, got ${decompressed.byteLength}`);
+	return decompressed;
+}
+//#endregion
+//#region src/worker.ts
+function toWasmU64(value) {
+	return BigInt(value);
+}
+function fromWasmU64(value) {
+	return typeof value === "bigint" ? Number(value) : value;
+}
+function fromOptionalWasmU64(value) {
+	return value === null || value === void 0 ? null : fromWasmU64(value);
+}
+function toWasmPutOptions(options) {
+	return options.ttl === void 0 ? options : {
+		...options,
+		ttl: toWasmU64(options.ttl)
+	};
+}
+function toWasmRange(range) {
+	const normalized = {};
+	if (range.gt !== void 0) normalized.gt = range.gt;
+	if (range.gte !== void 0) normalized.gte = range.gte;
+	if (range.lt !== void 0) normalized.lt = range.lt;
+	if (range.lte !== void 0) normalized.lte = range.lte;
+	if (range.reverse !== void 0) normalized.reverse = range.reverse;
+	if (range.limit !== void 0) normalized.limit = range.limit;
+	return normalized;
+}
+var EMPTY_RANGE = {};
+var EMPTY_VALUE = /* @__PURE__ */ new Uint8Array(0);
+var MAX_ENGINE_KEY_BYTES = 1024;
+var MAX_PACKED_BYTES = 4294967295;
+var INDEX_PUT_BATCH_ROWS = 64;
+var INDEX_PUT_BATCH_BYTES = 4194304;
+var INDEX_SCAN_PAGE_ROWS = 256;
+var INDEX_SCAN_PAGE_BYTES = 8389662;
+var INDEX_SCAN_RAW_CHUNK_ROWS = 512;
+var RECONCILE_DOCUMENT_CACHE_BYTES = 4194304;
+var RECONCILE_DOCUMENT_CACHE_ROWS = 4096;
+var HEX_BYTE_STRINGS = Array.from({ length: 256 }, (_value, byte) => byte.toString(16).padStart(2, "0"));
+var COMPRESSED_READ_CONCURRENCY = 8;
+function getOrInsert(map, key, create) {
+	const existing = map.get(key);
+	if (existing !== void 0) return existing;
+	const created = create();
+	map.set(key, created);
+	return created;
+}
+var PERSISTENCE_BRIDGE_INIT = "moyodb:persistence-bridge:init";
+var PERSISTENCE_BRIDGE_REQUEST = "moyodb:persistence-bridge:request";
+var PERSISTENCE_BRIDGE_RESPONSE = "moyodb:persistence-bridge:response";
+function isPersistenceBridgeResponse(value) {
+	return isRecord(value) && value.type === PERSISTENCE_BRIDGE_RESPONSE && typeof value.id === "number" && typeof value.granted === "boolean";
+}
+var MainThreadPersistenceBridge = class {
+	port = null;
+	nextRequestId = 1;
+	pending = /* @__PURE__ */ new Map();
+	readyResolve = null;
+	ready;
+	constructor() {
+		this.ready = new Promise((resolve) => {
+			this.readyResolve = resolve;
+		});
+		self.addEventListener("message", this.handleInitMessage);
+	}
+	async persisted() {
+		return this.request("persisted");
+	}
+	async persist() {
+		return this.request("persist");
+	}
+	close() {
+		self.removeEventListener("message", this.handleInitMessage);
+		if (this.readyResolve) {
+			this.readyResolve(null);
+			this.readyResolve = null;
+		}
+		if (this.port) {
+			this.port.onmessage = null;
+			this.port.close();
+			this.port = null;
+		}
+		for (const pending of this.pending.values()) pending.resolve(false);
+		this.pending.clear();
+	}
+	async request(op) {
+		const port = await this.ready;
+		if (!port || this.port !== port) return false;
+		return new Promise((resolve) => {
+			const id = this.nextRequestId;
+			this.nextRequestId += 1;
+			this.pending.set(id, { resolve });
+			const request = {
+				type: PERSISTENCE_BRIDGE_REQUEST,
+				id,
+				op
+			};
+			try {
+				port.postMessage(request);
+			} catch {
+				this.pending.delete(id);
+				resolve(false);
+			}
+		});
+	}
+	handleInitMessage = (event) => {
+		if (event.origin !== "" && event.origin !== self.location.origin) return;
+		if (event.data?.type !== PERSISTENCE_BRIDGE_INIT) return;
+		if (event.ports.length === 0) return;
+		const port = event.ports[0];
+		if (this.port) {
+			port.close();
+			return;
+		}
+		this.port = port;
+		this.port.onmessage = this.handleResponse;
+		this.port.start();
+		self.removeEventListener("message", this.handleInitMessage);
+		this.readyResolve?.(port);
+		this.readyResolve = null;
+	};
+	handleResponse = (event) => {
+		const data = event.data;
+		if (!isPersistenceBridgeResponse(data)) return;
+		const pending = this.pending.get(data.id);
+		if (!pending) return;
+		this.pending.delete(data.id);
+		pending.resolve(Boolean(data.granted));
+	};
+};
+async function estimateOriginStorage() {
+	const storage = navigator.storage;
+	if (typeof storage.estimate !== "function") return {
+		usage: 0,
+		quota: 0
+	};
+	const estimate = await storage.estimate();
+	return {
+		usage: estimate.usage ?? 0,
+		quota: estimate.quota ?? 0
+	};
+}
+function bytesToHex(bytes) {
+	let out = "";
+	for (let index = 0; index < bytes.byteLength; index += 1) out += HEX_BYTE_STRINGS[bytes[index]];
+	return out;
+}
+function bytesEqual(left, right) {
+	if (left.byteLength !== right.byteLength) return false;
+	for (let index = 0; index < left.byteLength; index += 1) if (left[index] !== right[index]) return false;
+	return true;
+}
+function copyRange(range) {
+	const copy = toWasmRange(range);
+	for (const bound of [
+		"gt",
+		"gte",
+		"lt",
+		"lte"
+	]) {
+		const value = copy[bound];
+		if (value !== void 0) copy[bound] = value.slice();
+	}
+	return copy;
+}
+function rangesEqual(left, right) {
+	for (const bound of [
+		"gt",
+		"gte",
+		"lt",
+		"lte"
+	]) {
+		const a = left[bound];
+		const b = right[bound];
+		if (a === void 0 ? b !== void 0 : b === void 0 || !bytesEqual(a, b)) return false;
+	}
+	return left.reverse === right.reverse && left.limit === right.limit;
+}
+function normalizeWasmBytes(value) {
+	if (value instanceof Uint8Array) return value.byteOffset === 0 && value.byteLength === value.buffer.byteLength ? value : value.slice();
+	return new Uint8Array(value);
+}
+function errorName(error) {
+	if (!isRecord(error)) return null;
+	const candidate = error.name ?? error.code;
+	return typeof candidate === "string" ? candidate : null;
+}
+function isNamedError(error, name) {
+	return errorName(error) === name;
+}
+var INDEX_SNAPSHOT_TRAILER_MAGIC = utf8Encode("BDBIDX1");
+var indexSnapshotDecoder = new TextDecoder("utf-8", { fatal: true });
+function wrapSnapshotWithIndexDefinitions(snapshot, defs) {
+	if (defs.length === 0) return snapshot;
+	const manifest = utf8Encode(JSON.stringify(toPublicIndexDefinitions(defs)));
+	const lengthBuffer = /* @__PURE__ */ new ArrayBuffer(4);
+	new DataView(lengthBuffer).setUint32(0, manifest.byteLength, true);
+	const out = new Uint8Array(snapshot.byteLength + manifest.byteLength + 4 + INDEX_SNAPSHOT_TRAILER_MAGIC.byteLength);
+	let offset = 0;
+	out.set(snapshot, offset);
+	offset += snapshot.byteLength;
+	out.set(manifest, offset);
+	offset += manifest.byteLength;
+	out.set(new Uint8Array(lengthBuffer), offset);
+	offset += 4;
+	out.set(INDEX_SNAPSHOT_TRAILER_MAGIC, offset);
+	return out;
+}
+function unwrapSnapshotWithIndexDefinitions(data) {
+	const magicLength = INDEX_SNAPSHOT_TRAILER_MAGIC.byteLength;
+	if (data.byteLength < magicLength + 4) return {
+		snapshot: data,
+		indexes: []
+	};
+	const magicOffset = data.byteLength - magicLength;
+	if (!bytesEqual(data.subarray(magicOffset), INDEX_SNAPSHOT_TRAILER_MAGIC)) return {
+		snapshot: data,
+		indexes: []
+	};
+	const lengthOffset = magicOffset - 4;
+	if (lengthOffset < 0) return {
+		snapshot: data,
+		indexes: []
+	};
+	const manifestOffset = lengthOffset - new DataView(data.buffer, data.byteOffset + lengthOffset, 4).getUint32(0, true);
+	if (manifestOffset < 0) throw remoteError("CorruptionError", "invalid snapshot index trailer length");
+	let parsed;
+	try {
+		parsed = JSON.parse(indexSnapshotDecoder.decode(data.subarray(manifestOffset, lengthOffset)));
+	} catch (error) {
+		throw remoteError("CorruptionError", `invalid snapshot index trailer: ${String(error)}`);
+	}
+	return {
+		snapshot: data.subarray(0, manifestOffset),
+		indexes: normalizeIndexDefinitions(parsed)
+	};
+}
+function lifecycleEventChannel(dbName) {
+	return new BroadcastChannel(`db:${dbName}:events`);
+}
+function broadcastLifecycleEvent(dbName, type) {
+	const channel = lifecycleEventChannel(dbName);
+	try {
+		channel.postMessage({
+			type,
+			dbName,
+			txid: null
+		});
+	} finally {
+		channel.close();
+	}
+}
+var OwnershipLease = class {
+	releaseResolver = null;
+	requestPromise = null;
+	held = false;
+	async acquire(dbName, ownerWaitMs) {
+		const holdPromise = new Promise((resolve) => {
+			this.releaseResolver = resolve;
+		});
+		const lockName = `db:${dbName}:owner`;
+		if (ownerWaitMs === 0) {
+			let acquiredResolve = null;
+			const acquiredPromise = new Promise((resolve) => {
+				acquiredResolve = resolve;
+			});
+			const request = navigator.locks.request(lockName, {
+				mode: "exclusive",
+				ifAvailable: true
+			}, async (lock) => {
+				if (!lock) {
+					acquiredResolve?.(false);
+					return false;
+				}
+				this.held = true;
+				acquiredResolve?.(true);
+				await holdPromise;
+				return true;
+			});
+			if (!await acquiredPromise) throw remoteError("DatabaseBusyError", `database ${dbName} is already owned by another tab`);
+			this.requestPromise = request;
+			return;
+		}
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), clampTimerDelayMs(ownerWaitMs));
+		let acquiredResolve = null;
+		const acquiredPromise = new Promise((resolve) => {
+			acquiredResolve = resolve;
+		});
+		this.requestPromise = navigator.locks.request(lockName, {
+			mode: "exclusive",
+			signal: controller.signal
+		}, async (_lock) => {
+			clearTimeout(timeout);
+			this.held = true;
+			acquiredResolve?.();
+			await holdPromise;
+			return true;
+		});
+		try {
+			await Promise.race([acquiredPromise, this.requestPromise]);
+		} catch {
+			if (!this.held) throw remoteError("DatabaseBusyError", `timed out waiting for ownership of ${dbName}`);
+		}
+	}
+	async release() {
+		if (!this.held) return;
+		this.releaseResolver?.();
+		try {
+			await this.requestPromise;
+		} finally {
+			this.releaseResolver = null;
+			this.requestPromise = null;
+			this.held = false;
+		}
+	}
+};
+var DbWorker = class {
+	options;
+	dbName = null;
+	engine = null;
+	events = null;
+	lease = null;
+	wasmReady = null;
+	persistenceBridge;
+	txChanges = /* @__PURE__ */ new Map();
+	txModes = /* @__PURE__ */ new Map();
+	primaryCursors = /* @__PURE__ */ new Map();
+	nextPrimaryCursorId = 1;
+	/**
+	* Shared committed schema at begin. Reconciliation replaces the array;
+	* it never mutates the shared schema.
+	*/
+	txIndexSchemas = /* @__PURE__ */ new Map();
+	indexesBySchema = /* @__PURE__ */ new WeakMap();
+	txEnsuredRawStores = /* @__PURE__ */ new Map();
+	txIndexSchemaChanged = /* @__PURE__ */ new Set();
+	txStoreCompression = /* @__PURE__ */ new Map();
+	committedIndexes = null;
+	committedStoreCompression = null;
+	openOptions = null;
+	maintenanceOperation = null;
+	constructor(options = {}) {
+		this.options = options;
+		this.persistenceBridge = options.persistence ?? new MainThreadPersistenceBridge();
+	}
+	async open(request) {
+		if (this.engine) return;
+		assertSecureContext();
+		assertCapabilities();
+		this.dbName = request.dbName;
+		this.events = new BroadcastChannel(`db:${request.dbName}:events`);
+		this.lease = new OwnershipLease();
+		let engine = null;
+		try {
+			await this.lease.acquire(request.dbName, request.options.ownerWaitMs);
+			engine = new (await (this.loadWasm())).WasmEngine();
+			await engine.open(request.dbName, {
+				create_if_missing: request.options.createIfMissing,
+				cache_pages: request.options.cachePages
+			});
+			if (request.options.changeFeed) applyChangeFeedPolicy(engine, request.options.changeFeed);
+			if (request.options.debugFailpoint) engine.set_failpoint(request.options.debugFailpoint);
+			this.engine = engine;
+			this.openOptions = request.options;
+			this.clearRuntimeCaches();
+			this.maintenanceOperation = null;
+			this.events.postMessage({
+				type: "owner_changed",
+				dbName: request.dbName,
+				txid: null
+			});
+		} catch (err) {
+			await this.cleanupAfterFailedOpen(engine);
+			throw remapError(err);
+		}
+	}
+	async close() {
+		this.ensureNotInMaintenance();
+		const dbName = this.dbName;
+		this.clearRuntimeCaches();
+		try {
+			this.engine?.close();
+		} catch (err) {
+			throw remapError(err);
+		} finally {
+			this.engine = null;
+			if (dbName && this.events) this.events.postMessage({
+				type: "db_closed",
+				dbName,
+				txid: null
+			});
+			this.events?.close();
+			this.events = null;
+			if (dbName && this.lease) await this.lease.release();
+			if (dbName) broadcastLifecycleEvent(dbName, "owner_changed");
+			this.disposePersistenceBridge();
+			this.lease = null;
+			this.dbName = null;
+			this.openOptions = null;
+			this.maintenanceOperation = null;
+		}
+	}
+	async destroy() {
+		this.ensureNotInMaintenance();
+		const dbName = this.dbName;
+		if (!dbName) return;
+		let failure = null;
+		try {
+			this.rollbackAllTransactions();
+			this.engine?.abandon();
+			await (await this.loadWasm()).deleteDB(dbName);
+			broadcastLifecycleEvent(dbName, "db_deleted");
+		} catch (err) {
+			failure = err;
+		} finally {
+			this.engine = null;
+			this.clearRuntimeCaches();
+			this.events?.close();
+			this.events = null;
+			if (this.lease) try {
+				await this.lease.release();
+			} catch (err) {
+				if (failure === null) failure = err;
+			}
+			broadcastLifecycleEvent(dbName, "owner_changed");
+			this.disposePersistenceBridge();
+			this.lease = null;
+			this.dbName = null;
+			this.openOptions = null;
+			this.maintenanceOperation = null;
+		}
+		if (failure !== null) throw remapError(failure);
+	}
+	async deleteDB(dbName) {
+		assertSecureContext();
+		assertCapabilities();
+		const lease = new OwnershipLease();
+		let failure = null;
+		let acquired = false;
+		try {
+			await lease.acquire(dbName, 0);
+			acquired = true;
+			await (await this.loadWasm()).deleteDB(dbName);
+			broadcastLifecycleEvent(dbName, "db_deleted");
+		} catch (err) {
+			failure = err;
+		} finally {
+			try {
+				await lease.release();
+			} catch (err) {
+				if (failure === null) failure = err;
+			}
+			if (acquired) broadcastLifecycleEvent(dbName, "owner_changed");
+		}
+		if (failure !== null) throw remapError(failure);
+	}
+	begin(mode) {
+		this.recoverEngineIfNeeded();
+		const indexSchema = this.loadCommittedIndexSchema();
+		const storeCompression = this.loadCommittedStoreCompression();
+		const txId = fromWasmU64(this.withEngine((engine) => engine.begin_tx(mode)));
+		this.txChanges.set(txId, /* @__PURE__ */ new Map());
+		this.txModes.set(txId, mode);
+		this.txIndexSchemas.set(txId, indexSchema);
+		this.txStoreCompression.set(txId, {
+			owned: false,
+			values: storeCompression
+		});
+		return Promise.resolve(txId);
+	}
+	commit(txId) {
+		const tracked = this.txChanges.get(txId) ?? /* @__PURE__ */ new Map();
+		const indexOverride = this.txIndexSchemaChanged.has(txId) ? this.txIndexSchemas.get(txId) : void 0;
+		const storeCompressionSnapshot = this.txStoreCompression.get(txId);
+		const txMode = this.txModes.get(txId);
+		let txid;
+		try {
+			txid = fromWasmU64(this.withEngine((engine) => engine.commit_tx(toWasmU64(txId))));
+		} catch (err) {
+			try {
+				if (this.engine && !this.engine.needs_recovery()) this.withEngine((engine) => engine.rollback_tx(toWasmU64(txId)));
+			} catch {}
+			this.cleanupTxState(txId);
+			const recovery = this.recoverEngineIfNeeded();
+			if (!recovery?.pendingCommitted || recovery.pendingTxid === null || isNamedError(err, "RecoveryRequiredError") || isNamedError(err, "InjectedFailureError")) throw err;
+			txid = recovery.pendingTxid;
+		}
+		if (indexOverride) this.committedIndexes = cloneNormalizedIndexDefinitions(indexOverride);
+		if (txMode === "readwrite" && storeCompressionSnapshot) this.committedStoreCompression = storeCompressionSnapshot.values;
+		this.cleanupTxState(txId);
+		if (this.dbName && this.events) {
+			const event = {
+				type: "commit_applied",
+				dbName: this.dbName,
+				txid,
+				stores: this.finalizeTrackedChanges(tracked)
+			};
+			this.events.postMessage(event);
+		}
+		return Promise.resolve(txid);
+	}
+	rollback(txId) {
+		try {
+			this.withEngine((engine) => engine.rollback_tx(toWasmU64(txId)));
+		} finally {
+			this.cleanupTxState(txId);
+		}
+		return Promise.resolve();
+	}
+	async autocommit(mode, command, args) {
+		const txId = await this.begin(mode);
+		const method = this[command];
+		let result;
+		try {
+			result = await method.apply(this, [txId, ...args]);
+		} catch (error) {
+			try {
+				await this.rollback(txId);
+			} catch {}
+			throw error;
+		}
+		if (mode === "readwrite") await this.commit(txId);
+		else await this.rollback(txId);
+		return result;
+	}
+	createStore(txId, name, options = {}) {
+		const compression = isInternalStoreName(name) ? false : options.compression ?? "snappy";
+		this.txEnsuredRawStores.get(txId)?.delete(name);
+		this.withEngine((engine) => engine.create_store(toWasmU64(txId), name, { compression }));
+		this.recordStoreCompressionCreate(txId, name, compression);
+		this.ensureInternalStoresForStore(txId, name);
+		this.markStoreTouched(txId, name);
+		return Promise.resolve();
+	}
+	dropStore(txId, name) {
+		const defs = this.indexesForStoreInTx(txId, name);
+		this.txEnsuredRawStores.get(txId)?.delete(name);
+		this.withEngine((engine) => engine.drop_store(toWasmU64(txId), name));
+		this.recordStoreCompressionDrop(txId, name);
+		for (const def of defs) this.dropRawStoreIfExists(txId, def.internalStore);
+		this.recordStoreLevelChange(txId, name, "drop");
+		return Promise.resolve();
+	}
+	clearStore(txId, name) {
+		const defs = this.indexesForStoreInTx(txId, name);
+		this.txEnsuredRawStores.get(txId)?.delete(name);
+		this.withEngine((engine) => engine.clear_store(toWasmU64(txId), name));
+		for (const def of defs) this.clearRawStoreIfExists(txId, def.internalStore);
+		this.recordStoreLevelChange(txId, name, "clear");
+		return Promise.resolve();
+	}
+	async get(txId, store, key) {
+		return this.readStoreValue(txId, store, key);
+	}
+	async getMany(txId, store, keys) {
+		const values = this.withEngine((engine) => engine.get_many(toWasmU64(txId), store, keys));
+		const compressed = !isInternalStoreName(store) && this.storeCompressionForTx(txId, store) !== false;
+		for (let index = 0; index < values.length; index += 1) {
+			const value = values[index];
+			if (value !== null) values[index] = normalizeWasmBytes(value);
+		}
+		return compressed ? this.decodeStoreValues(txId, store, values) : values;
+	}
+	async getManyPacked(txId, store, packedKeys) {
+		const packed = normalizeWasmBytes(this.withEngine((engine) => engine.get_many_packed(toWasmU64(txId), store, packedKeys)));
+		if (isInternalStoreName(store) || this.storeCompressionForTx(txId, store) === false) return packedOptionalValues(packed);
+		return this.decodeStoreValues(txId, store, unpackPackedOptionalValues(packed));
+	}
+	has(txId, store, key) {
+		return Promise.resolve(this.withEngine((engine) => engine.has(toWasmU64(txId), store, key)));
+	}
+	async put(txId, store, key, value, options = {}) {
+		const defs = this.indexesForStoreInTx(txId, store);
+		if (defs.length === 0) {
+			const storedValue = await this.encodeStoreValueForWrite(txId, store, value);
+			const baselineExists = this.withEngine((engine) => engine.put(toWasmU64(txId), store, key, storedValue, toWasmPutOptions(options)));
+			this.recordPutChange(txId, store, key, baselineExists);
+			return;
+		}
+		await this.putIndexedMany(txId, store, [key, value], defs, options);
+	}
+	async putMany(txId, store, entries, options = {}) {
+		if (entries.length === 0) return;
+		const defs = this.indexesForStoreInTx(txId, store);
+		if (defs.length === 0) {
+			const storedEntries = await this.encodeEntriesForWrite(txId, store, entries);
+			let baselines;
+			try {
+				baselines = this.withEngine((engine) => engine.put_many(toWasmU64(txId), store, storedEntries, toWasmPutOptions(options)));
+			} catch (error) {
+				const partial = partialBooleanOutcomes(error);
+				this.recordPutChanges(txId, store, entries, partial);
+				throw error;
+			}
+			if (baselines.length !== entries.length) throw remoteError("InternalError", `put_many outcome count mismatch: ${baselines.length} != ${entries.length}`);
+			this.recordPutChanges(txId, store, entries, baselines);
+			return;
+		}
+		const items = new Array(entries.length * 2);
+		for (let index = 0; index < entries.length; index += 1) {
+			items[index * 2] = entries[index][0];
+			items[index * 2 + 1] = entries[index][1];
+		}
+		await this.putIndexedMany(txId, store, items, defs, options);
+	}
+	async putManyPacked(txId, store, packedEntries, options = {}) {
+		const defs = this.indexesForStoreInTx(txId, store);
+		if (defs.length !== 0) {
+			const items = unpackPackedBinaryList(packedEntries);
+			if (items.length % 2 !== 0) throw remoteError("WorkerProtocolError", "packed putMany payload has an odd item count");
+			await this.putIndexedMany(txId, store, items, defs, options);
+			return;
+		}
+		const items = this.storeCompressionForTx(txId, store) === false ? null : unpackPackedBinaryList(packedEntries);
+		if (items !== null && items.length % 2 !== 0) throw remoteError("WorkerProtocolError", "packed putMany payload has an odd item count");
+		const keys = items === null ? unpackPackedBinaryPairKeys(packedEntries) : items.filter((_item, index) => index % 2 === 0);
+		if (keys.length === 0) return;
+		const storedEntries = items === null ? packedEntries : await this.encodePackedEntriesForWrite(txId, store, items, keys);
+		let baselines;
+		try {
+			baselines = this.withEngine((engine) => engine.put_many_packed(toWasmU64(txId), store, storedEntries, toWasmPutOptions(options)));
+		} catch (error) {
+			const partial = partialBooleanOutcomes(error);
+			this.recordPutKeyChanges(txId, store, keys, partial);
+			throw error;
+		}
+		if (baselines.length !== keys.length) throw remoteError("InternalError", `put_many_packed outcome count mismatch: ${baselines.length} != ${keys.length}`);
+		this.recordPutKeyChanges(txId, store, keys, baselines);
+	}
+	async delete(txId, store, key) {
+		const defs = this.indexesForStoreInTx(txId, store);
+		const oldValue = defs.length === 0 ? null : await this.readStoreValue(txId, store, key);
+		const oldKeyFor = oldValue === null ? null : createIndexKeyExtractor(oldValue);
+		const oldLogicalKeys = oldKeyFor === null ? [] : defs.map((def) => ({
+			def,
+			logicalKey: oldKeyFor(def)
+		}));
+		if (!this.withEngine((engine) => engine.delete(toWasmU64(txId), store, key))) {
+			this.recordDeleteChange(txId, store, key, false);
+			return false;
+		}
+		for (const entry of oldLogicalKeys) if (entry.logicalKey !== null) this.deleteIndexEntryIfPresent(txId, entry.def, entry.logicalKey, key);
+		this.recordDeleteChange(txId, store, key, true);
+		return true;
+	}
+	async deleteMany(txId, store, keys) {
+		if (keys.length === 0) return;
+		if (this.indexesForStoreInTx(txId, store).length === 0) {
+			let deleted;
+			try {
+				deleted = this.withEngine((engine) => engine.delete_many(toWasmU64(txId), store, keys));
+			} catch (error) {
+				const partial = partialBooleanOutcomes(error);
+				for (let i = 0; i < partial.length && i < keys.length; i += 1) this.recordDeleteChange(txId, store, keys[i], partial[i]);
+				throw error;
+			}
+			if (deleted.length !== keys.length) throw remoteError("InternalError", `delete_many outcome count mismatch: ${deleted.length} != ${keys.length}`);
+			for (let i = 0; i < keys.length; i += 1) this.recordDeleteChange(txId, store, keys[i], deleted[i]);
+			return;
+		}
+		for (const key of keys) await this.delete(txId, store, key);
+	}
+	async deleteManyPacked(txId, store, packedKeys) {
+		const defs = this.indexesForStoreInTx(txId, store);
+		const keys = unpackPackedBinaryList(packedKeys);
+		if (keys.length === 0) return;
+		if (defs.length !== 0) {
+			await this.deleteMany(txId, store, keys);
+			return;
+		}
+		let deleted;
+		try {
+			deleted = this.withEngine((engine) => engine.delete_many_packed(toWasmU64(txId), store, packedKeys));
+		} catch (error) {
+			const partial = partialBooleanOutcomes(error);
+			for (let i = 0; i < partial.length && i < keys.length; i += 1) this.recordDeleteChange(txId, store, keys[i], partial[i]);
+			throw error;
+		}
+		if (deleted.length !== keys.length) throw remoteError("InternalError", `delete_many_packed outcome count mismatch: ${deleted.length} != ${keys.length}`);
+		for (let i = 0; i < keys.length; i += 1) this.recordDeleteChange(txId, store, keys[i], deleted[i] === 1);
+	}
+	async applyBatch(txId, store, ops) {
+		if (ops.length === 0) return;
+		if (this.indexesForStoreInTx(txId, store).length === 0) {
+			const storedOps = await this.encodeBatchOpsForWrite(txId, store, ops);
+			let outcomes;
+			try {
+				outcomes = this.withEngine((engine) => engine.apply_batch(toWasmU64(txId), store, storedOps));
+			} catch (error) {
+				this.recordBatchOutcomes(txId, store, ops, partialBatchOutcomes(error));
+				throw error;
+			}
+			if (outcomes.length !== ops.length) throw remoteError("InternalError", `apply_batch outcome count mismatch: ${outcomes.length} != ${ops.length}`);
+			this.recordBatchOutcomes(txId, store, ops, outcomes);
+			return;
+		}
+		for (const op of ops) if (op.kind === "put") await this.put(txId, store, op.key, op.value);
+		else await this.delete(txId, store, op.key);
+	}
+	async applyBatchPacked(txId, store, packedOps) {
+		if (this.indexesForStoreInTx(txId, store).length !== 0 || this.storeCompressionForTx(txId, store) !== false) {
+			const ops = unpackPackedBatchOps(packedOps);
+			if (ops.length === 0) return;
+			await this.applyBatch(txId, store, ops);
+			return;
+		}
+		const ops = unpackPackedBatchOpKeys(packedOps);
+		if (ops.length === 0) return;
+		let flags;
+		try {
+			flags = this.withEngine((engine) => engine.apply_batch_packed(toWasmU64(txId), store, packedOps));
+		} catch (error) {
+			this.recordBatchKeyOutcomes(txId, store, ops, partialBatchOutcomes(error));
+			throw error;
+		}
+		if (flags.length !== ops.length) throw remoteError("InternalError", `apply_batch_packed outcome count mismatch: ${flags.length} != ${ops.length}`);
+		for (let i = 0; i < ops.length; i += 1) {
+			const op = ops[i];
+			if (op.kind === "put") this.recordPutChange(txId, store, op.key, flags[i] === 1);
+			else this.recordDeleteChange(txId, store, op.key, flags[i] === 1);
+		}
+	}
+	async scan(txId, store, range) {
+		return this.readStoreScan(txId, store, range);
+	}
+	async scanPage(request) {
+		if (!Number.isSafeInteger(request.maxRows) || request.maxRows <= 0 || request.maxRows > MAX_PACKED_BYTES || !Number.isSafeInteger(request.maxBytes) || request.maxBytes < 4 || request.maxBytes > MAX_PACKED_BYTES) throw remoteError("InvalidRangeError", "scan page budgets must be positive u32 integers; maxBytes must be at least 4");
+		let cursorId = request.cursorId;
+		let cursor = cursorId === void 0 ? void 0 : this.primaryCursors.get(cursorId);
+		if (cursorId !== void 0) {
+			if (!cursor) throw remoteError("TransactionClosedError", "scan cursor is closed");
+			if (cursor.store !== request.store || cursor.callerTxId !== request.txId || !rangesEqual(cursor.range, request.range ?? EMPTY_RANGE)) throw remoteError("InvalidRangeError", "scan continuation does not match the cursor");
+		} else {
+			const ownsTx = request.txId === void 0;
+			const txId = request.txId ?? await this.begin("readonly");
+			const range = copyRange(request.range ?? EMPTY_RANGE);
+			let engineId;
+			try {
+				engineId = this.withEngine((engine) => engine.open_scan_cursor(toWasmU64(txId), request.store, toWasmRange(range), false));
+			} catch (error) {
+				if (ownsTx) try {
+					await this.rollback(txId);
+				} catch {}
+				throw error;
+			}
+			cursorId = this.nextPrimaryCursorId++;
+			cursor = {
+				engineId,
+				txId,
+				ownsTx,
+				store: request.store,
+				range,
+				callerTxId: request.txId
+			};
+			this.primaryCursors.set(cursorId, cursor);
+		}
+		try {
+			const page = this.withEngine((engine) => engine.scan_cursor_next(cursor.engineId, request.maxRows, request.maxBytes));
+			const packet = normalizeWasmBytes(page.packet);
+			const rowCount = packet.byteLength < 4 ? -1 : new DataView(packet.buffer, packet.byteOffset, 4).getUint32(0, true);
+			if (rowCount !== page.rowCount || rowCount > request.maxRows || packet.byteLength > request.maxBytes) throw remoteError("CorruptionError", "scan cursor returned an invalid page budget or count");
+			const rows = this.storeCompressionForTx(cursor.txId, cursor.store) !== false ? unpackPackedScanRows(packet) : null;
+			let bytes = packet.byteLength;
+			if (rows !== null) {
+				bytes = 4;
+				for (const row of rows) {
+					row.value = await this.decodeStoreValue(cursor.txId, cursor.store, row.value);
+					bytes += 8 + row.key.byteLength + row.value.byteLength;
+					if (bytes > request.maxBytes) throw remoteError("ValueTooLargeError", "decoded scan page exceeds maxBytes");
+				}
+			}
+			if (page.exhausted) await this.closeCursor(cursorId);
+			return {
+				rows: rows ?? packedScanRows(packet),
+				done: page.exhausted,
+				bytes,
+				...page.exhausted ? {} : { cursorId }
+			};
+		} catch (error) {
+			try {
+				await this.closeCursor(cursorId);
+			} catch {}
+			throw error;
+		}
+	}
+	async closeCursor(cursorId) {
+		const cursor = this.primaryCursors.get(cursorId);
+		if (!cursor) return;
+		this.primaryCursors.delete(cursorId);
+		try {
+			this.withEngine((engine) => engine.close_scan_cursor(cursor.engineId));
+		} finally {
+			if (cursor.ownsTx) await this.rollback(cursor.txId);
+		}
+	}
+	async getByIndex(txId, store, indexName, key) {
+		const def = this.resolveIndexDefinition(txId, store, indexName);
+		const page = await this.loadVisibleIndexPage(txId, def, {
+			gte: key,
+			lte: key
+		}, null, 1);
+		return page.rows.length === 0 ? null : page.rows[0].value;
+	}
+	async scanByIndex(txId, store, indexName, range = {}) {
+		const def = this.resolveIndexDefinition(txId, store, indexName);
+		const rows = [];
+		let remaining = range.limit ?? Number.POSITIVE_INFINITY;
+		let cursor = null;
+		while (remaining > 0) {
+			const page = await this.loadVisibleIndexPage(txId, def, range, cursor, Math.min(remaining, INDEX_SCAN_PAGE_ROWS));
+			rows.push(...page.rows);
+			remaining -= page.rows.length;
+			if (page.cursor === null) break;
+			cursor = page.cursor;
+		}
+		return rows;
+	}
+	async scanByIndexPage(txId, store, indexName, range, cursor, limit, maxBytes = INDEX_SCAN_PAGE_BYTES) {
+		if (!Number.isSafeInteger(limit) || limit <= 0) throw remoteError("InvalidRangeError", "index scan page limit must be a positive integer");
+		if (!Number.isSafeInteger(maxBytes) || maxBytes < 4 || maxBytes > MAX_PACKED_BYTES) throw remoteError("InvalidRangeError", "index scan page maxBytes must be a u32 integer of at least 4");
+		const def = this.resolveIndexDefinition(txId, store, indexName);
+		return this.loadVisibleIndexPage(txId, def, range, cursor, limit, maxBytes);
+	}
+	getIndexes(txId) {
+		return Promise.resolve(toPublicIndexDefinitions(txId === void 0 ? this.loadCommittedIndexSchema() : this.indexSchemaForTx(txId)));
+	}
+	async reconcileIndexes(txId, indexes) {
+		const target = normalizeIndexDefinitions(indexes);
+		this.ensureRawStore(txId, INDEX_METADATA_STORE);
+		const current = this.readIndexSchemaInTx(txId);
+		const targetStores = new Set(target.map((def) => def.internalStore));
+		for (const def of current) if (!targetStores.has(def.internalStore)) this.dropRawStoreIfExists(txId, def.internalStore);
+		this.clearRawStoreIfExists(txId, INDEX_METADATA_STORE);
+		let documentStore = null;
+		let cachedBytes = 0;
+		let sourceRows = null;
+		const canRefreshVisibility = typeof this.engine?.has_many === "function";
+		const documents = /* @__PURE__ */ new Map();
+		for (const def of target) {
+			if (documentStore !== def.store) {
+				documents.clear();
+				cachedBytes = 0;
+				sourceRows = null;
+				documentStore = def.store;
+			}
+			this.ensureRawStore(txId, def.internalStore);
+			this.clearRawStoreIfExists(txId, def.internalStore);
+			if (this.rawStoreExistsInTx(txId, def.store)) {
+				let rows;
+				if (sourceRows !== null) {
+					const visible = this.withEngine((engine) => engine.has_many(toWasmU64(txId), def.store, sourceRows.map((row) => row.key)));
+					if (visible.length !== sourceRows.length) throw remoteError("InternalError", `has_many outcome count mismatch: ${visible.length} != ${sourceRows.length}`);
+					rows = sourceRows.filter((_row, index) => visible[index]);
+				} else {
+					rows = await this.readStoreScan(txId, def.store, EMPTY_RANGE);
+					if (canRefreshVisibility && rows.length <= RECONCILE_DOCUMENT_CACHE_ROWS) {
+						let inputBytes = 0;
+						for (const row of rows) {
+							inputBytes += row.key.byteLength + row.value.byteLength;
+							if (inputBytes > RECONCILE_DOCUMENT_CACHE_BYTES) break;
+						}
+						if (inputBytes <= RECONCILE_DOCUMENT_CACHE_BYTES) sourceRows = rows;
+					}
+				}
+				for (const row of rows) {
+					const token = bytesToHex(row.key);
+					const cached = documents.get(token);
+					let document;
+					if (cached && (cached.bytes === row.value || bytesEqual(cached.bytes, row.value))) {
+						document = cached.document;
+						cached.bytes = row.value;
+					} else {
+						document = decodeIndexedDocument(row.value);
+						const previousBytes = cached?.inputBytes ?? 0;
+						const inputBytes = row.key.byteLength + row.value.byteLength;
+						if ((cached || documents.size < RECONCILE_DOCUMENT_CACHE_ROWS) && cachedBytes - previousBytes + inputBytes <= RECONCILE_DOCUMENT_CACHE_BYTES) {
+							documents.set(token, {
+								bytes: row.value,
+								inputBytes,
+								document
+							});
+							cachedBytes += inputBytes - previousBytes;
+						} else if (cached) {
+							documents.delete(token);
+							cachedBytes -= previousBytes;
+						}
+					}
+					const logicalKey = extractLogicalIndexKeyFromDocument(def, document);
+					if (logicalKey === null) continue;
+					await this.assertUniqueIndexAvailability(txId, def, logicalKey, row.key);
+					this.putIndexEntry(txId, def, this.buildIndexEntryKey(def, logicalKey, row.key), EMPTY_VALUE);
+				}
+			}
+			this.putRawValue(txId, INDEX_METADATA_STORE, encodeIndexMetadataKey(def.store, def.name), encodeIndexMetadataValue(def));
+		}
+		this.txIndexSchemas.set(txId, cloneNormalizedIndexDefinitions(target));
+		this.txIndexSchemaChanged.add(txId);
+	}
+	listStores() {
+		return Promise.resolve(this.currentStoreNames());
+	}
+	getVersion() {
+		return Promise.resolve(fromWasmU64(this.withEngine((engine) => engine.get_schema_version())));
+	}
+	async changesSince(txId, options = {}) {
+		const visibleStores = options.stores?.filter((store) => !isInternalStoreName(store));
+		const engineOptions = {
+			...options,
+			stores: visibleStores ? [...visibleStores] : void 0,
+			limit: visibleStores ? options.limit : void 0
+		};
+		const feed = this.withEngine((engine) => engine.changes_since(toWasmU64(txId), engineOptions));
+		const allowedStores = visibleStores ? new Set(visibleStores) : null;
+		const changes = [];
+		for (const change of feed.changes) {
+			if (isInternalStoreName(change.store)) continue;
+			if (allowedStores && !allowedStores.has(change.store)) continue;
+			const key = options.limit === void 0 || changes.length < options.limit ? normalizeWasmBytes(change.key) : null;
+			let value;
+			if (change.value !== void 0) value = await this.decodeStoreValueForFeed(change.store, normalizeWasmBytes(change.value));
+			if (key === null) continue;
+			changes.push({
+				txId: fromWasmU64(change.txId),
+				store: change.store,
+				key,
+				kind: change.kind,
+				value
+			});
+		}
+		return {
+			latestTxId: fromWasmU64(feed.latestTxId),
+			changes
+		};
+	}
+	setSchemaVersion(txId, version) {
+		this.withEngine((engine) => engine.set_schema_version(toWasmU64(txId), toWasmU64(version)));
+		return Promise.resolve();
+	}
+	async exportSnapshot(options = {}) {
+		const defs = cloneNormalizedIndexDefinitions(this.loadCommittedIndexSchema());
+		return await wrapSnapshotWithCompression(wrapSnapshotWithIndexDefinitions(normalizeWasmBytes(this.withEngine((engine) => engine.export_snapshot())), defs), options.compression ?? false);
+	}
+	async importSnapshot(data) {
+		this.rollbackAllTransactions();
+		const parsed = unwrapSnapshotWithIndexDefinitions(await unwrapSnapshotCompression(data));
+		this.withEngine((engine) => engine.import_snapshot(parsed.snapshot));
+		this.committedIndexes = [];
+		this.committedStoreCompression = null;
+		await this.applyCommittedIndexSchema(parsed.indexes);
+	}
+	async reset() {
+		const dbName = this.dbName;
+		if (!dbName) throw remoteError("InternalError", "engine is not open");
+		const defs = cloneNormalizedIndexDefinitions(this.loadCommittedIndexSchema());
+		this.rollbackAllTransactions();
+		const stores = this.currentStoreNames().map((store) => ({
+			store,
+			changes: [{
+				key: /* @__PURE__ */ new Uint8Array(0),
+				kind: "clear"
+			}]
+		}));
+		const txid = fromWasmU64(this.withEngine((engine) => engine.reset()));
+		this.committedIndexes = [];
+		await this.applyCommittedIndexSchema(defs);
+		if (this.events) {
+			const event = {
+				type: "commit_applied",
+				dbName,
+				txid,
+				stores
+			};
+			this.events.postMessage(event);
+		}
+	}
+	async compact() {
+		return this.runCompactionOperation("compact");
+	}
+	async rebuild() {
+		return this.runCompactionOperation("rebuild");
+	}
+	stats() {
+		const stats = this.withEngine((engine) => engine.stats());
+		return Promise.resolve({
+			...stats,
+			db_id: fromWasmU64(stats.db_id),
+			catalog_root_page_id: fromWasmU64(stats.catalog_root_page_id),
+			next_page_id: fromWasmU64(stats.next_page_id),
+			last_committed_txid: fromWasmU64(stats.last_committed_txid),
+			last_replayed_wal_offset: fromWasmU64(stats.last_replayed_wal_offset),
+			manifest_len: fromWasmU64(stats.manifest_len),
+			main_len: fromWasmU64(stats.main_len),
+			wal_len: fromWasmU64(stats.wal_len),
+			health: normalizeEngineHealth(stats.health),
+			store_count: this.currentStoreNames().length
+		});
+	}
+	async storageInfo() {
+		const [dbSize, estimate, persisted] = await Promise.all([
+			this.dbDirectorySize(),
+			estimateOriginStorage(),
+			this.persistenceBridge.persisted()
+		]);
+		return {
+			dbSize,
+			originUsage: estimate.usage,
+			originQuota: estimate.quota,
+			persisted
+		};
+	}
+	async requestPersistence() {
+		return this.persistenceBridge.persist();
+	}
+	setFailpoint(failpoint) {
+		this.withEngine((engine) => engine.set_failpoint(failpoint));
+		return Promise.resolve();
+	}
+	requireDbName() {
+		if (!this.dbName) throw remoteError("InternalError", "engine is not open");
+		return this.dbName;
+	}
+	ensureNotInMaintenance() {
+		if (!this.maintenanceOperation) return;
+		throw remoteError("DatabaseBusyError", `database ${this.dbName ?? "database"} is busy: ${this.maintenanceOperation} in progress`);
+	}
+	currentCachePages() {
+		return this.openOptions?.cachePages ?? 256;
+	}
+	async dbDirectorySize() {
+		return (await this.loadWasm()).dbDirectorySize(this.requireDbName());
+	}
+	async applyCommittedIndexSchema(defs) {
+		const normalized = cloneNormalizedIndexDefinitions(defs);
+		if (normalized.length === 0) {
+			this.committedIndexes = [];
+			return;
+		}
+		const txId = fromWasmU64(this.withEngine((engine) => engine.begin_tx("readwrite"), { allowDuringMaintenance: true }));
+		this.txChanges.set(txId, /* @__PURE__ */ new Map());
+		this.txModes.set(txId, "readwrite");
+		this.txStoreCompression.set(txId, {
+			owned: false,
+			values: this.loadCommittedStoreCompression()
+		});
+		try {
+			await this.reconcileIndexes(txId, toPublicIndexDefinitions(normalized));
+			this.withEngine((engine) => engine.commit_tx(toWasmU64(txId)), { allowDuringMaintenance: true });
+			this.committedIndexes = cloneNormalizedIndexDefinitions(normalized);
+		} catch (error) {
+			try {
+				this.withEngine((engine) => engine.rollback_tx(toWasmU64(txId)), { allowDuringMaintenance: true });
+			} catch {}
+			throw error;
+		} finally {
+			this.cleanupTxState(txId);
+		}
+	}
+	/**
+	* Publishes a fresh generation only if the active generation has not changed.
+	* A failed swap may have reached storage; read the control file before cleanup.
+	* After publication, abandon the old engine to avoid a checkpoint into inactive files.
+	*/
+	async runCompactionOperation(operation) {
+		const dbName = this.requireDbName();
+		if (this.maintenanceOperation) throw remoteError("DatabaseBusyError", `database ${dbName} is busy: ${this.maintenanceOperation} in progress`);
+		this.maintenanceOperation = operation;
+		const start = performance.now();
+		const wasm = await this.loadWasm();
+		let rebuiltEngine = null;
+		let generationName = null;
+		let published = false;
+		try {
+			const sizeBefore = await wasm.dbDirectorySize(dbName);
+			const defs = cloneNormalizedIndexDefinitions(this.loadCommittedIndexSchema());
+			this.rollbackAllTransactions({ allowDuringMaintenance: true });
+			const expectedGeneration = await wasm.readActiveGeneration(dbName);
+			generationName = (await wasm.prepareRebuildTarget(dbName)).generationName;
+			rebuiltEngine = new wasm.WasmEngine();
+			await rebuiltEngine.openGeneration(dbName, generationName, {
+				create_if_missing: true,
+				cache_pages: this.currentCachePages()
+			});
+			const target = rebuiltEngine;
+			this.withEngine((engine) => operation === "rebuild" ? engine.compact_into_skipping_stores(target, [...defs.map((def) => def.internalStore), INDEX_METADATA_STORE]) : engine.compact_into(target), { allowDuringMaintenance: true });
+			if (operation === "rebuild" && defs.length > 0) {
+				const previousEngine = this.engine;
+				const previousMaintenance = this.maintenanceOperation;
+				this.engine = target;
+				this.maintenanceOperation = null;
+				try {
+					this.committedIndexes = [];
+					this.committedStoreCompression = null;
+					await this.applyCommittedIndexSchema(defs);
+				} finally {
+					this.engine = previousEngine;
+					this.maintenanceOperation = previousMaintenance;
+					this.committedStoreCompression = null;
+				}
+			}
+			try {
+				await wasm.swapActiveGeneration(dbName, generationName, expectedGeneration);
+				published = true;
+			} catch (swapError) {
+				published = await readActiveGenerationOrNull(wasm, dbName) === generationName;
+				if (!published) throw swapError;
+			}
+			const previousEngine = this.engine;
+			this.engine = rebuiltEngine;
+			rebuiltEngine = null;
+			this.committedIndexes = defs;
+			this.committedStoreCompression = null;
+			try {
+				previousEngine?.abandon();
+			} catch {}
+			try {
+				await wasm.cleanupInactiveEntries(dbName);
+			} catch {}
+			const sizeAfter = await wasm.dbDirectorySize(dbName);
+			return {
+				sizeBefore,
+				sizeAfter,
+				reclaimedBytes: Math.max(0, sizeBefore - sizeAfter),
+				durationMs: performance.now() - start
+			};
+		} catch (error) {
+			if (!published) {
+				this.committedIndexes = null;
+				this.committedStoreCompression = null;
+				try {
+					rebuiltEngine?.abandon();
+				} catch {}
+				if (generationName !== null) {
+					const active = await readActiveGenerationOrNull(wasm, dbName);
+					if (active !== void 0 && active !== generationName) try {
+						await wasm.cleanupInactiveEntries(dbName);
+					} catch {}
+				}
+			}
+			throw remapError(error);
+		} finally {
+			this.maintenanceOperation = null;
+		}
+	}
+	/**
+	* Returns null when no recovery is needed. A recovery attempt invalidates
+	* all open transactions, even if recovery fails.
+	*/
+	recoverEngineIfNeeded() {
+		const engine = this.engine;
+		if (!engine || !engine.needs_recovery()) return null;
+		let report;
+		try {
+			report = engine.recover();
+		} catch (error) {
+			throw remoteError("RecoveryRequiredError", `database ${this.dbName ?? ""} needs recovery and recovery failed: ${remapError(error).message}`);
+		} finally {
+			this.clearRuntimeCaches();
+		}
+		return {
+			pendingTxid: fromOptionalWasmU64(report.pendingTxid),
+			pendingCommitted: report.pendingCommitted === true
+		};
+	}
+	cleanupTxState(txId) {
+		for (const [cursorId, cursor] of this.primaryCursors) if (cursor.txId === txId) {
+			this.primaryCursors.delete(cursorId);
+			try {
+				this.engine?.close_scan_cursor(cursor.engineId);
+			} catch {}
+		}
+		this.txChanges.delete(txId);
+		this.txModes.delete(txId);
+		this.txIndexSchemas.delete(txId);
+		this.txEnsuredRawStores.delete(txId);
+		this.txIndexSchemaChanged.delete(txId);
+		this.txStoreCompression.delete(txId);
+	}
+	getOrCreateTrackedTxn(txId) {
+		return getOrInsert(this.txChanges, txId, () => /* @__PURE__ */ new Map());
+	}
+	getOrCreateTrackedStore(txId, store) {
+		return getOrInsert(this.getOrCreateTrackedTxn(txId), store, () => ({
+			touched: false,
+			storeLevel: null,
+			keys: /* @__PURE__ */ new Map()
+		}));
+	}
+	recordStoreLevelChange(txId, store, kind) {
+		if (isInternalStoreName(store)) return;
+		const trackedStore = this.getOrCreateTrackedStore(txId, store);
+		trackedStore.touched = true;
+		trackedStore.storeLevel = kind;
+		trackedStore.keys.clear();
+	}
+	recordPutChange(txId, store, key, baselineExists) {
+		this.recordKeyChange(txId, store, key, baselineExists, "put");
+	}
+	recordPutChanges(txId, store, entries, baselines) {
+		if (isInternalStoreName(store)) return;
+		const trackedStore = this.getOrCreateTrackedStore(txId, store);
+		trackedStore.touched = true;
+		const count = Math.min(entries.length, baselines.length);
+		for (let i = 0; i < count; i += 1) this.setTrackedKeyChange(trackedStore, entries[i][0], baselines[i], "put");
+	}
+	recordPutKeyChanges(txId, store, keys, baselines) {
+		if (isInternalStoreName(store)) return;
+		const trackedStore = this.getOrCreateTrackedStore(txId, store);
+		trackedStore.touched = true;
+		const count = Math.min(keys.length, baselines.length);
+		for (let i = 0; i < count; i += 1) this.setTrackedKeyChange(trackedStore, keys[i], baselines[i] === true || baselines[i] === 1, "put");
+	}
+	recordDeleteChange(txId, store, key, deleted) {
+		if (deleted) this.recordKeyChange(txId, store, key, true, "delete");
+	}
+	recordKeyChange(txId, store, key, baselineExists, finalKind) {
+		if (isInternalStoreName(store)) return;
+		const trackedStore = this.getOrCreateTrackedStore(txId, store);
+		trackedStore.touched = true;
+		this.setTrackedKeyChange(trackedStore, key, baselineExists, finalKind);
+	}
+	setTrackedKeyChange(trackedStore, key, baselineExists, finalKind) {
+		const keyId = bytesToHex(key);
+		const existing = trackedStore.keys.get(keyId);
+		trackedStore.keys.set(keyId, {
+			key: existing?.key ?? key.slice(),
+			baselineExists: existing?.baselineExists ?? baselineExists,
+			finalKind
+		});
+	}
+	markStoreTouched(txId, store) {
+		if (isInternalStoreName(store)) return;
+		this.getOrCreateTrackedStore(txId, store).touched = true;
+	}
+	recordBatchOutcomes(txId, store, ops, outcomes) {
+		for (let i = 0; i < outcomes.length && i < ops.length; i += 1) {
+			const op = ops[i];
+			const outcome = outcomes[i];
+			if (op.kind === "put" && outcome.kind === "put") this.recordPutChange(txId, store, op.key, outcome.baselineExists);
+			else if (op.kind === "delete" && outcome.kind === "delete") this.recordDeleteChange(txId, store, op.key, outcome.deleted);
+		}
+	}
+	recordBatchKeyOutcomes(txId, store, ops, outcomes) {
+		for (let i = 0; i < outcomes.length && i < ops.length; i += 1) {
+			const op = ops[i];
+			const outcome = outcomes[i];
+			if (op.kind === "put" && outcome.kind === "put") this.recordPutChange(txId, store, op.key, outcome.baselineExists);
+			else if (op.kind === "delete" && outcome.kind === "delete") this.recordDeleteChange(txId, store, op.key, outcome.deleted);
+		}
+	}
+	finalizeTrackedChanges(tracked) {
+		const stores = [];
+		for (const [store, trackedStore] of tracked) {
+			if (!trackedStore.touched || isInternalStoreName(store)) continue;
+			const changes = [];
+			if (trackedStore.storeLevel !== null) changes.push({
+				key: /* @__PURE__ */ new Uint8Array(0),
+				kind: trackedStore.storeLevel
+			});
+			for (const change of trackedStore.keys.values()) {
+				if (change.finalKind === "delete" && !change.baselineExists) continue;
+				changes.push({
+					key: change.key,
+					kind: change.finalKind
+				});
+			}
+			stores.push({
+				store,
+				changes
+			});
+		}
+		return stores;
+	}
+	rollbackAllTransactions(options = {}) {
+		if (!this.engine || this.txChanges.size === 0) {
+			this.clearTxCaches();
+			return;
+		}
+		const txIds = Array.from(this.txChanges.keys());
+		for (const txId of txIds) try {
+			this.withEngine((engine) => engine.rollback_tx(toWasmU64(txId)), options);
+		} finally {
+			this.cleanupTxState(txId);
+		}
+	}
+	currentStoreNames() {
+		return this.allRawStoreNames().filter((store) => !isInternalStoreName(store));
+	}
+	allRawStoreNames() {
+		return this.withEngine((engine) => engine.list_stores());
+	}
+	loadCommittedStoreCompression() {
+		if (this.committedStoreCompression) return this.committedStoreCompression;
+		const rows = this.withEngine((engine) => engine.list_store_configs());
+		const loaded = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			if (typeof row.name !== "string") throw remoteError("CorruptionError", "invalid store config row: missing name");
+			const flags = typeof row.flags === "bigint" ? Number(row.flags) : row.flags;
+			if (typeof flags !== "number" || !Number.isSafeInteger(flags) || flags < 0) throw remoteError("CorruptionError", `invalid store flags for ${row.name}`);
+			loaded.set(row.name, compressionFromStoreFlags(flags));
+		}
+		this.committedStoreCompression = loaded;
+		return loaded;
+	}
+	ensureTxStoreCompression(txId) {
+		const snapshot = this.txStoreCompression.get(txId);
+		if (snapshot?.owned) return snapshot.values;
+		const values = new Map(snapshot?.values);
+		this.txStoreCompression.set(txId, {
+			owned: true,
+			values
+		});
+		return values;
+	}
+	recordStoreCompressionCreate(txId, store, compression) {
+		if (isInternalStoreName(store)) return;
+		this.ensureTxStoreCompression(txId).set(store, compression);
+	}
+	recordStoreCompressionDrop(txId, store) {
+		if (isInternalStoreName(store)) return;
+		this.ensureTxStoreCompression(txId).delete(store);
+	}
+	storeCompressionForTx(txId, store) {
+		if (isInternalStoreName(store)) return false;
+		const snapshot = this.txStoreCompression.get(txId);
+		if (snapshot) return snapshot.values.get(store) ?? false;
+		return this.loadCommittedStoreCompression().get(store) ?? false;
+	}
+	async encodeEntriesForWrite(txId, store, entries) {
+		if (isInternalStoreName(store)) return entries;
+		const compression = this.storeCompressionForTx(txId, store);
+		if (compression === false) return entries;
+		const storedEntries = [];
+		for (const [key, value] of entries) storedEntries.push([key, await encodeStoreValueRecord(value, compression)]);
+		return storedEntries;
+	}
+	async encodePackedEntriesForWrite(txId, store, items, keys) {
+		const records = new Array(items.length / 2);
+		for (let index = 0; index < records.length; index += 1) {
+			const value = this.preparePutValue(txId, store, items[index * 2 + 1]);
+			records[index] = value instanceof Promise ? await value : value;
+		}
+		return this.packPreparedPutEntries(keys, records);
+	}
+	preparePutValue(txId, store, value) {
+		const compression = this.storeCompressionForTx(txId, store);
+		return compression === "snappy" || compression === false ? prepareFastStoreValueRecord(value, compression) : encodeStoreValueRecord(value, compression);
+	}
+	packPreparedPutEntries(keys, records) {
+		let total = 4 + keys.length * 8;
+		for (let index = 0; index < keys.length; index += 1) {
+			total += keys[index].byteLength + records[index].byteLength;
+			if (total > MAX_PACKED_BYTES) throw remoteError("WorkerProtocolError", "compressed packed putMany exceeds the u32 byte limit");
+		}
+		const bytes = new Uint8Array(total);
+		const view = new DataView(bytes.buffer);
+		view.setUint32(0, keys.length * 2, true);
+		let offset = 4 + keys.length * 8;
+		for (let index = 0; index < records.length; index += 1) {
+			const key = keys[index];
+			const record = records[index];
+			view.setUint32(4 + index * 8, key.byteLength, true);
+			view.setUint32(8 + index * 8, record.byteLength, true);
+			bytes.set(key, offset);
+			offset += key.byteLength;
+			if (record instanceof Uint8Array) {
+				bytes.set(record, offset);
+				offset += record.byteLength;
+			} else offset = writePreparedStoreValueRecord(record, bytes, offset);
+		}
+		return bytes;
+	}
+	async putIndexedMany(txId, store, items, defs, options) {
+		let keys = [];
+		let values = [];
+		let indexOps = [];
+		let bytes = 4;
+		const pendingPrimaries = /* @__PURE__ */ new Set();
+		const pendingUniqueKeys = /* @__PURE__ */ new Set();
+		const flush = () => {
+			if (keys.length === 0) return;
+			const batchKeys = keys;
+			const batchValues = values;
+			const batchOps = indexOps;
+			keys = [];
+			values = [];
+			indexOps = [];
+			bytes = 4;
+			pendingPrimaries.clear();
+			pendingUniqueKeys.clear();
+			const packet = this.packPreparedPutEntries(batchKeys, batchValues);
+			let baselines;
+			try {
+				baselines = this.withEngine((engine) => engine.put_many_indexed_packed(toWasmU64(txId), store, packet, batchOps, toWasmPutOptions(options)));
+			} catch (error) {
+				const partial = partialBooleanOutcomes(error);
+				if (partial.length > 0) this.recordPutKeyChanges(txId, store, batchKeys, partial);
+				throw error;
+			}
+			if (baselines.length !== batchKeys.length) throw remoteError("InternalError", `put_many_indexed_packed outcome count mismatch: ${baselines.length} != ${batchKeys.length}`);
+			this.recordPutKeyChanges(txId, store, batchKeys, baselines);
+		};
+		for (let index = 0; index < items.length / 2; index += 1) {
+			const key = items[index * 2];
+			const value = items[index * 2 + 1];
+			const primaryToken = bytesToHex(key);
+			if (pendingPrimaries.has(primaryToken)) flush();
+			try {
+				const oldValue = await this.readStoreValue(txId, store, key);
+				const oldKeyFor = oldValue === null ? null : createIndexKeyExtractor(oldValue);
+				const newKeyFor = createIndexKeyExtractor(value);
+				const plans = defs.map((def) => ({
+					def,
+					oldLogicalKey: oldKeyFor === null ? null : oldKeyFor(def),
+					newLogicalKey: newKeyFor(def),
+					newPhysicalKey: null
+				}));
+				if (plans.some((plan) => plan.def.unique && plan.newLogicalKey !== null && pendingUniqueKeys.has(`${plan.def.internalStore}:${bytesToHex(plan.newLogicalKey)}`))) {
+					flush();
+					index -= 1;
+					continue;
+				}
+				this.ensureInternalStoresForDefinitions(txId, defs);
+				for (const plan of plans) {
+					if (plan.newLogicalKey === null) continue;
+					plan.newPhysicalKey = this.buildIndexEntryKey(plan.def, plan.newLogicalKey, key);
+					if (plan.oldLogicalKey === null || !bytesEqual(plan.oldLogicalKey, plan.newLogicalKey)) await this.assertUniqueIndexAvailability(txId, plan.def, plan.newLogicalKey, key);
+				}
+				const preparedValue = this.preparePutValue(txId, store, value);
+				const storedValue = preparedValue instanceof Promise ? await preparedValue : preparedValue;
+				const ops = [];
+				for (const plan of plans) if (plan.oldLogicalKey !== null && (plan.newLogicalKey === null || !bytesEqual(plan.oldLogicalKey, plan.newLogicalKey))) ops.push({
+					store: plan.def.internalStore,
+					kind: "delete",
+					key: encodeIndexEntryKey(plan.oldLogicalKey, key)
+				});
+				for (const plan of plans) {
+					if (plan.newPhysicalKey !== null) ops.push({
+						store: plan.def.internalStore,
+						kind: "put",
+						key: plan.newPhysicalKey
+					});
+					if (plan.def.unique) {
+						for (const logicalKey of [plan.oldLogicalKey, plan.newLogicalKey]) if (logicalKey !== null) pendingUniqueKeys.add(`${plan.def.internalStore}:${bytesToHex(logicalKey)}`);
+					}
+				}
+				keys.push(key);
+				values.push(storedValue);
+				indexOps.push(ops);
+				bytes += 8 + key.byteLength + storedValue.byteLength;
+				for (const op of ops) bytes += op.key.byteLength;
+				pendingPrimaries.add(primaryToken);
+			} catch (error) {
+				flush();
+				throw error;
+			}
+			if (options.ttl !== void 0 || keys.length >= INDEX_PUT_BATCH_ROWS || bytes >= INDEX_PUT_BATCH_BYTES) flush();
+		}
+		flush();
+	}
+	async encodeBatchOpsForWrite(txId, store, ops) {
+		if (isInternalStoreName(store)) return ops;
+		const compression = this.storeCompressionForTx(txId, store);
+		if (compression === false) return ops;
+		const storedOps = [];
+		for (const op of ops) storedOps.push(op.kind === "put" ? {
+			kind: "put",
+			key: op.key,
+			value: await encodeStoreValueRecord(op.value, compression)
+		} : op);
+		return storedOps;
+	}
+	async encodeStoreValueForWrite(txId, store, value) {
+		if (isInternalStoreName(store)) return value;
+		return encodeStoreValueRecord(value, this.storeCompressionForTx(txId, store));
+	}
+	async decodeStoreValue(txId, store, value) {
+		if (isInternalStoreName(store)) return value;
+		if (this.storeCompressionForTx(txId, store) === false) return value;
+		return decodeStoreValueRecord(value, { strict: true });
+	}
+	async decodeStoreValueForFeed(store, value) {
+		if (isInternalStoreName(store)) return value;
+		return decodeStoreValueRecord(value, { strict: (this.loadCommittedStoreCompression().get(store) ?? false) !== false });
+	}
+	async readStoreValue(txId, store, key) {
+		const value = this.readRawValue(txId, store, key);
+		return value === null ? null : this.decodeStoreValue(txId, store, value);
+	}
+	async readStoreScan(txId, store, range) {
+		const rows = this.readRawScan(txId, store, range);
+		if (isInternalStoreName(store) || this.storeCompressionForTx(txId, store) === false) return rows;
+		const values = rows.map((row) => row.value);
+		await this.decodeStoreValues(txId, store, values);
+		for (let index = 0; index < rows.length; index += 1) rows[index].value = values[index];
+		return rows;
+	}
+	async decodeStoreValues(txId, store, values) {
+		const state = {
+			next: 0,
+			failed: false,
+			failure: void 0
+		};
+		const decodeNext = async () => {
+			while (!state.failed && state.next < values.length) {
+				const index = state.next++;
+				const value = values[index];
+				if (value === null) continue;
+				try {
+					values[index] = await this.decodeStoreValue(txId, store, value);
+				} catch (error) {
+					if (!state.failed) {
+						state.failed = true;
+						state.failure = error;
+					}
+				}
+			}
+		};
+		await Promise.all(Array.from({ length: Math.min(COMPRESSED_READ_CONCURRENCY, values.length) }, decodeNext));
+		if (state.failed) throw state.failure;
+		return values;
+	}
+	indexesForStoreInTx(txId, store) {
+		const schema = this.indexSchemaForTx(txId);
+		let byStore = this.indexesBySchema.get(schema);
+		if (!byStore) {
+			byStore = /* @__PURE__ */ new Map();
+			for (const def of schema) {
+				const defs = byStore.get(def.store);
+				if (defs) defs.push(def);
+				else byStore.set(def.store, [def]);
+			}
+			this.indexesBySchema.set(schema, byStore);
+		}
+		return byStore.get(store) ?? [];
+	}
+	resolveIndexDefinition(txId, store, indexName) {
+		if (!this.rawStoreExistsInTx(txId, store)) throw remoteError("StoreNotFoundError", `store not found: ${store}`);
+		const def = findIndexDefinition(this.indexesForStoreInTx(txId, store), store, indexName);
+		if (!def) throw remoteError("IndexNotFoundError", `index not found: ${store}.${indexName}`);
+		return def;
+	}
+	indexSchemaForTx(txId) {
+		const override = this.txIndexSchemas.get(txId);
+		if (override) return override;
+		if (this.committedIndexes) return this.committedIndexes;
+		const loaded = this.readIndexSchemaInTx(txId);
+		this.committedIndexes = cloneNormalizedIndexDefinitions(loaded);
+		return this.committedIndexes;
+	}
+	loadCommittedIndexSchema() {
+		if (this.committedIndexes) return this.committedIndexes;
+		const txId = fromWasmU64(this.withEngine((engine) => engine.begin_tx("readonly")));
+		try {
+			const loaded = this.readIndexSchemaInTx(txId);
+			this.committedIndexes = cloneNormalizedIndexDefinitions(loaded);
+			return this.committedIndexes;
+		} finally {
+			this.withEngine((engine) => engine.rollback_tx(toWasmU64(txId)));
+		}
+	}
+	readIndexSchemaInTx(txId) {
+		if (!this.rawStoreExistsInTx(txId, "__browserdb:indexes")) return [];
+		const defs = this.readRawScan(txId, INDEX_METADATA_STORE, EMPTY_RANGE).map((row) => decodeIndexMetadataValue(row.value));
+		defs.sort(compareNormalizedIndexDefinitions);
+		return defs;
+	}
+	rawStoreExistsInTx(txId, store) {
+		try {
+			this.readRawScan(txId, store, { limit: 0 });
+			return true;
+		} catch (error) {
+			if (isNamedError(error, "StoreNotFoundError")) return false;
+			throw error;
+		}
+	}
+	ensureRawStore(txId, store) {
+		const cacheable = this.txModes.get(txId) === "readwrite";
+		if (cacheable && this.txEnsuredRawStores.get(txId)?.has(store)) return;
+		this.ignoreNamedError("StoreExistsError", () => {
+			this.withEngine((engine) => engine.create_store(toWasmU64(txId), store));
+		});
+		if (cacheable) getOrInsert(this.txEnsuredRawStores, txId, () => /* @__PURE__ */ new Set()).add(store);
+	}
+	clearRawStoreIfExists(txId, store) {
+		try {
+			this.withEngine((engine) => engine.clear_store(toWasmU64(txId), store));
+		} catch (error) {
+			if (!isNamedError(error, "StoreNotFoundError")) throw error;
+			this.txEnsuredRawStores.get(txId)?.delete(store);
+		}
+	}
+	dropRawStoreIfExists(txId, store) {
+		this.txEnsuredRawStores.get(txId)?.delete(store);
+		this.ignoreNamedError("StoreNotFoundError", () => {
+			this.withEngine((engine) => engine.drop_store(toWasmU64(txId), store));
+		});
+	}
+	ensureInternalStoresForDefinitions(txId, defs) {
+		for (const def of defs) this.ensureRawStore(txId, def.internalStore);
+	}
+	ensureInternalStoresForStore(txId, store) {
+		this.ensureInternalStoresForDefinitions(txId, this.indexesForStoreInTx(txId, store));
+	}
+	readRawValue(txId, store, key) {
+		const value = this.withEngine((engine) => engine.get(toWasmU64(txId), store, key));
+		return value === null ? null : normalizeWasmBytes(value);
+	}
+	readRawScan(txId, store, range) {
+		const rows = this.withEngine((engine) => engine.scan(toWasmU64(txId), store, toWasmRange(range)));
+		for (const row of rows) {
+			row.key = normalizeWasmBytes(row.key);
+			row.value = normalizeWasmBytes(row.value);
+		}
+		return rows;
+	}
+	readIndexKeyScan(txId, store, range) {
+		if (typeof this.engine?.open_scan_cursor !== "function" || typeof this.engine?.scan_cursor_next !== "function" || typeof this.engine?.close_scan_cursor !== "function") return this.readRawScan(txId, store, range);
+		const maxRows = range.limit ?? INDEX_SCAN_RAW_CHUNK_ROWS;
+		const maxBytes = 4 + maxRows * 1032;
+		const cursorId = this.withEngine((engine) => engine.open_scan_cursor(toWasmU64(txId), store, toWasmRange(range), true));
+		try {
+			const page = this.withEngine((engine) => engine.scan_cursor_next(cursorId, maxRows, maxBytes));
+			const packet = normalizeWasmBytes(page.packet);
+			const rows = unpackPackedScanRows(packet);
+			if (rows.length !== page.rowCount || rows.length > maxRows || packet.byteLength > maxBytes || rows.some((row) => row.value.byteLength !== 0)) throw remoteError("CorruptionError", "index key cursor returned an invalid page");
+			return rows;
+		} finally {
+			this.withEngine((engine) => engine.close_scan_cursor(cursorId));
+		}
+	}
+	putRawValue(txId, store, key, value) {
+		this.withEngine((engine) => engine.put(toWasmU64(txId), store, key, value));
+	}
+	putIndexEntry(txId, def, physicalKey, value) {
+		if (typeof this.engine?.put_index_entry_checked === "function") {
+			const primaryKey = decodeIndexEntryKey(physicalKey).primaryKey;
+			const state = this.readNativeValueState(txId, def.store, primaryKey);
+			if (state?.revisionKnown) {
+				this.withEngine((engine) => engine.put_index_entry_checked(toWasmU64(txId), def.store, def.internalStore, primaryKey, physicalKey, state.revisionEpoch, state.revisionOrdinal));
+				return;
+			}
+		}
+		this.putRawValue(txId, def.internalStore, physicalKey, value);
+	}
+	readNativeValueState(txId, store, key) {
+		if (typeof this.engine?.get_many_value_states !== "function") return null;
+		try {
+			const keys = new Uint8Array(8 + key.byteLength);
+			const keyView = new DataView(keys.buffer);
+			keyView.setUint32(0, 1, true);
+			keyView.setUint32(4, key.byteLength, true);
+			keys.set(key, 8);
+			const packet = normalizeWasmBytes(this.withEngine((engine) => engine.get_many_value_states(toWasmU64(txId), store, keys)));
+			return this.decodeNativeValueStates(packet, 1)?.[0] ?? null;
+		} catch {
+			return null;
+		}
+	}
+	packNativeKeys(keys) {
+		let total = 4 + keys.length * 4;
+		for (const key of keys) total += key.byteLength;
+		const packet = new Uint8Array(total);
+		const view = new DataView(packet.buffer);
+		view.setUint32(0, keys.length, true);
+		let offset = 4 + keys.length * 4;
+		for (let index = 0; index < keys.length; index += 1) {
+			const key = keys[index];
+			view.setUint32(4 + index * 4, key.byteLength, true);
+			packet.set(key, offset);
+			offset += key.byteLength;
+		}
+		return packet;
+	}
+	decodeNativeValueStates(packet, count) {
+		if (packet.byteLength !== 4 + count * 32) return null;
+		const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+		if (view.getUint32(0, true) !== count) return null;
+		const states = new Array(count);
+		for (let index = 0; index < count; index += 1) {
+			const offset = 4 + index * 32;
+			const flags = view.getUint32(offset, true);
+			const revisionEpoch = view.getBigUint64(offset + 12, true);
+			const revisionOrdinal = view.getBigUint64(offset + 20, true);
+			if ((flags & -8) !== 0 || (flags & 3) === 3 || (flags & 4) !== 0 && ((flags & 3) === 0 || revisionEpoch === 0n || revisionOrdinal === 0n)) return null;
+			states[index] = {
+				live: (flags & 1) !== 0,
+				expired: (flags & 2) !== 0,
+				revisionKnown: (flags & 4) !== 0,
+				expiresAt: view.getBigUint64(offset + 4, true),
+				revisionEpoch,
+				revisionOrdinal,
+				maxValueBytes: view.getUint32(offset + 28, true)
+			};
+		}
+		return states;
+	}
+	inspectIndexedValue(txId, def, physicalKey, primaryKey) {
+		const primary = this.readNativeValueState(txId, def.store, primaryKey);
+		if (primary === null) return "unknown";
+		if (!primary.live) {
+			if (primary.expired && this.txModes.get(txId) === "readwrite") {
+				if (this.withEngine((engine) => engine.has(toWasmU64(txId), def.store, primaryKey))) return "unknown";
+			}
+			return "missing";
+		}
+		if (!primary.revisionKnown) return "unknown";
+		const index = this.readNativeValueState(txId, def.internalStore, physicalKey);
+		return index?.live && index.revisionKnown && index.revisionEpoch === primary.revisionEpoch && index.revisionOrdinal === primary.revisionOrdinal ? "trusted" : "unknown";
+	}
+	deleteIndexEntryIfPresent(txId, def, logicalKey, primaryKey) {
+		const physicalKey = this.buildIndexEntryKey(def, logicalKey, primaryKey);
+		this.ignoreNamedError("StoreNotFoundError", () => {
+			this.withEngine((engine) => engine.delete(toWasmU64(txId), def.internalStore, physicalKey));
+		});
+	}
+	buildIndexEntryKey(def, logicalKey, primaryKey) {
+		const physicalKey = encodeIndexEntryKey(logicalKey, primaryKey);
+		if (physicalKey.byteLength > MAX_ENGINE_KEY_BYTES) throw remoteError("KeyTooLargeError", `index key too large for ${def.store}.${def.name}`);
+		return physicalKey;
+	}
+	async assertUniqueIndexAvailability(txId, def, logicalKey, primaryKey) {
+		if (!def.unique) return;
+		const physical = indexKeyExactRange(logicalKey);
+		let cursor = null;
+		let chunkLimit = 1;
+		for (;;) {
+			const range = {
+				...physical,
+				limit: chunkLimit
+			};
+			if (cursor !== null) {
+				range.gt = cursor;
+				delete range.gte;
+			}
+			const rows = this.readIndexKeyScan(txId, def.internalStore, range);
+			for (const row of rows) {
+				cursor = row.key;
+				const decoded = decodeIndexEntryKey(row.key);
+				if (bytesEqual(decoded.primaryKey, primaryKey)) continue;
+				const state = this.inspectIndexedValue(txId, def, row.key, decoded.primaryKey);
+				if (state === "missing") {
+					this.cleanupStaleIndexRow(txId, def, row.key);
+					continue;
+				}
+				if (state === "trusted") throw remoteError("UniqueIndexConstraintError", `unique index constraint violation on ${def.store}.${def.name}`);
+				const value = await this.readStoreValue(txId, def.store, decoded.primaryKey);
+				if (value === null) {
+					this.cleanupStaleIndexRow(txId, def, row.key);
+					continue;
+				}
+				const currentLogicalKey = extractLogicalIndexKey(def, value);
+				if (currentLogicalKey === null || !bytesEqual(currentLogicalKey, logicalKey)) {
+					this.cleanupStaleIndexRow(txId, def, row.key);
+					continue;
+				}
+				throw remoteError("UniqueIndexConstraintError", `unique index constraint violation on ${def.store}.${def.name}`);
+			}
+			if (rows.length < chunkLimit) return;
+			chunkLimit = Math.min(INDEX_SCAN_RAW_CHUNK_ROWS, chunkLimit * 2);
+		}
+	}
+	/**
+	* Resumes after a physical index key in the scan direction. Bounded raw
+	* chunks prevent stale entries from forcing the whole range into memory.
+	* The output limit counts only live rows.
+	*/
+	async loadVisibleIndexPage(txId, def, range, cursor, limit, maxBytes = INDEX_SCAN_PAGE_BYTES) {
+		const { limit: _ignored, ...withoutLimit } = range;
+		const physical = indexRangeToPhysicalRange(withoutLimit);
+		const reverse = physical.reverse === true;
+		let resumeAfter = cursor;
+		const visible = [];
+		let outputBytes = 4;
+		let staleChunkFloor = 1;
+		for (;;) {
+			const chunkLimit = Math.min(INDEX_SCAN_RAW_CHUNK_ROWS, Math.max(limit - visible.length, staleChunkFloor));
+			const chunkRange = {
+				...physical,
+				limit: chunkLimit
+			};
+			if (resumeAfter !== null) {
+				if (reverse) {
+					delete chunkRange.lte;
+					chunkRange.lt = resumeAfter;
+				} else {
+					delete chunkRange.gte;
+					chunkRange.gt = resumeAfter;
+				}
+			}
+			let rawRows;
+			try {
+				rawRows = this.readIndexKeyScan(txId, def.internalStore, chunkRange);
+			} catch (error) {
+				if (isNamedError(error, "StoreNotFoundError")) return {
+					rows: [],
+					cursor: null
+				};
+				throw error;
+			}
+			const visibleBefore = visible.length;
+			let batchStart = 0;
+			let batchEnd = 0;
+			let batch = null;
+			for (let index = 0; index < rawRows.length; index += 1) {
+				if (index === batchEnd) {
+					batchStart = index;
+					batch = this.readIndexPrimaryValues(txId, def, rawRows, index, Math.min(rawRows.length, index + limit - visible.length), maxBytes - outputBytes);
+					batchEnd = index + (batch?.entries.length ?? 1);
+				}
+				const row = rawRows[index];
+				const resolved = batch ? await this.resolveVisibleIndexedValue(txId, def, row.key, batch.entries[index - batchStart], batch.values[index - batchStart], batch.trusted[index - batchStart]) : await this.resolveVisibleIndexedRow(txId, def, row.key);
+				if (batch !== null) batch.values[index - batchStart] = null;
+				if (!resolved) {
+					resumeAfter = row.key;
+					continue;
+				}
+				const nextBytes = outputBytes + 8 + resolved.key.byteLength + resolved.value.byteLength;
+				if (nextBytes > maxBytes) {
+					if (visible.length === 0) throw remoteError("ValueTooLargeError", "indexed scan row exceeds maxBytes");
+					if (resumeAfter === null) throw remoteError("InternalError", "indexed scan lost its continuation key");
+					return {
+						rows: visible,
+						cursor: resumeAfter.slice()
+					};
+				}
+				visible.push(resolved);
+				outputBytes = nextBytes;
+				resumeAfter = row.key;
+				if (visible.length >= limit) return {
+					rows: visible,
+					cursor: row.key.slice()
+				};
+			}
+			if (rawRows.length < chunkLimit) return {
+				rows: visible,
+				cursor: null
+			};
+			staleChunkFloor = visible.length === visibleBefore ? Math.min(INDEX_SCAN_RAW_CHUNK_ROWS, chunkLimit * 2) : 1;
+		}
+	}
+	readIndexPrimaryValues(txId, def, rows, start, end, remainingBytes) {
+		if (this.txModes.get(txId) !== "readonly" || end - start <= 1 || typeof this.engine?.get_many_value_sizes !== "function" && typeof this.engine?.get_many_value_states !== "function") return null;
+		let entries;
+		let values;
+		let trusted;
+		let loaded;
+		let selectedIndices;
+		try {
+			entries = rows.slice(start, end).map((row) => decodeIndexEntryKey(row.key));
+			const packedKeys = this.packNativeKeys(entries.map((entry) => entry.primaryKey));
+			let primaryStates = null;
+			let indexStates = null;
+			let sizes;
+			if (typeof this.engine?.get_many_value_states === "function") {
+				primaryStates = this.decodeNativeValueStates(normalizeWasmBytes(this.withEngine((engine) => engine.get_many_value_states(toWasmU64(txId), def.store, packedKeys))), entries.length);
+				if (primaryStates === null) return null;
+				sizes = Uint32Array.from(primaryStates, (state) => state.live ? state.maxValueBytes : MAX_PACKED_BYTES);
+				if (primaryStates.some((state) => state.live && state.revisionKnown)) {
+					const indexKeys = this.packNativeKeys(rows.slice(start, end).map((row) => row.key));
+					indexStates = this.decodeNativeValueStates(normalizeWasmBytes(this.withEngine((engine) => engine.get_many_value_states(toWasmU64(txId), def.internalStore, indexKeys))), entries.length);
+					if (indexStates === null) return null;
+				}
+			} else sizes = this.withEngine((engine) => engine.get_many_value_sizes(toWasmU64(txId), def.store, packedKeys));
+			if (sizes.length !== entries.length) return null;
+			let selected = 0;
+			for (const entry of entries) {
+				const size = sizes[selected];
+				if (!Number.isSafeInteger(size) || size < 0 || size > MAX_PACKED_BYTES) return null;
+				const required = size === MAX_PACKED_BYTES ? 0 : 8 + entry.primaryKey.byteLength + size;
+				if (required > remainingBytes) break;
+				remainingBytes -= required;
+				selected += 1;
+			}
+			if (selected <= 1) return null;
+			entries.length = selected;
+			trusted = new Array(selected).fill(false);
+			const selectedKeys = [];
+			selectedIndices = [];
+			values = new Array(selected).fill(null);
+			for (let index = 0; index < selected; index += 1) {
+				const primary = primaryStates?.[index];
+				if (primary === void 0 || primary.live) {
+					selectedKeys.push(entries[index].primaryKey);
+					selectedIndices.push(index);
+				}
+				const proof = indexStates?.[index];
+				trusted[index] = Boolean(primary?.live && primary.revisionKnown && proof?.live && proof.revisionKnown && primary.revisionEpoch === proof.revisionEpoch && primary.revisionOrdinal === proof.revisionOrdinal);
+			}
+			loaded = selectedKeys.length === 0 ? [] : this.withEngine((engine) => engine.get_many(toWasmU64(txId), def.store, selectedKeys));
+		} catch {
+			return null;
+		}
+		if (loaded.length !== selectedIndices.length) throw remoteError("InternalError", `get_many outcome count mismatch: ${loaded.length} != ${selectedIndices.length}`);
+		for (let index = 0; index < loaded.length; index += 1) {
+			values[selectedIndices[index]] = loaded[index];
+			loaded[index] = null;
+		}
+		return {
+			entries,
+			values,
+			trusted
+		};
+	}
+	async resolveVisibleIndexedRow(txId, def, physicalKey) {
+		const decoded = decodeIndexEntryKey(physicalKey);
+		const state = this.inspectIndexedValue(txId, def, physicalKey, decoded.primaryKey);
+		if (state === "missing") {
+			this.cleanupStaleIndexRow(txId, def, physicalKey);
+			return null;
+		}
+		const value = this.readRawValue(txId, def.store, decoded.primaryKey);
+		return this.resolveVisibleIndexedValue(txId, def, physicalKey, decoded, value, state === "trusted");
+	}
+	async resolveVisibleIndexedValue(txId, def, physicalKey, decoded, rawValue, trusted = false) {
+		if (rawValue === null) {
+			this.cleanupStaleIndexRow(txId, def, physicalKey);
+			return null;
+		}
+		const value = await this.decodeStoreValue(txId, def.store, normalizeWasmBytes(rawValue));
+		if (!trusted) {
+			const currentLogicalKey = extractLogicalIndexKey(def, value);
+			if (currentLogicalKey === null || !bytesEqual(currentLogicalKey, decoded.logicalKey)) {
+				this.cleanupStaleIndexRow(txId, def, physicalKey);
+				return null;
+			}
+		}
+		return {
+			key: decoded.primaryKey,
+			value
+		};
+	}
+	cleanupStaleIndexRow(txId, def, physicalKey) {
+		if (this.txModes.get(txId) !== "readwrite") return;
+		try {
+			this.withEngine((engine) => engine.delete(toWasmU64(txId), def.internalStore, physicalKey));
+		} catch {}
+	}
+	async loadWasm() {
+		if (!this.wasmReady) this.wasmReady = this.options.loadWasm ? this.options.loadWasm() : (async () => {
+			const moduleUrl = new URL("/engine/moyodb_engine.js", import.meta.url).href;
+			const wasmUrl = new URL("/engine/moyodb_engine_bg.wasm", import.meta.url).href;
+			const wasmModule = await import(
+				/* @vite-ignore */
+				moduleUrl
+);
+			await wasmModule.default({ module_or_path: wasmUrl });
+			return wasmModule;
+		})();
+		return this.wasmReady;
+	}
+	withEngine(fn, options = {}) {
+		if (this.maintenanceOperation && !options.allowDuringMaintenance) this.ensureNotInMaintenance();
+		if (!this.engine) throw remoteError("InternalError", "engine is not open");
+		try {
+			return fn(this.engine);
+		} catch (err) {
+			throw remapError(err);
+		}
+	}
+	ignoreNamedError(name, fn) {
+		try {
+			fn();
+		} catch (error) {
+			if (isNamedError(error, name)) return;
+			throw error;
+		}
+	}
+	clearTxCaches() {
+		this.primaryCursors.clear();
+		this.txChanges.clear();
+		this.txModes.clear();
+		this.txIndexSchemas.clear();
+		this.txEnsuredRawStores.clear();
+		this.txIndexSchemaChanged.clear();
+		this.txStoreCompression.clear();
+	}
+	clearRuntimeCaches() {
+		this.clearTxCaches();
+		this.committedIndexes = null;
+		this.committedStoreCompression = null;
+	}
+	async cleanupAfterFailedOpen(engine) {
+		try {
+			engine?.abandon();
+		} catch {}
+		this.engine = null;
+		this.clearRuntimeCaches();
+		this.events?.close();
+		this.events = null;
+		if (this.lease) try {
+			await this.lease.release();
+		} catch {}
+		this.lease = null;
+		this.disposePersistenceBridge();
+		this.dbName = null;
+		this.openOptions = null;
+		this.maintenanceOperation = null;
+	}
+	disposePersistenceBridge() {
+		this.persistenceBridge.close();
+	}
+};
+function assertCapabilities() {
+	if (typeof navigator.storage.getDirectory !== "function") throw remoteError("UnsupportedPlatformError", "navigator.storage.getDirectory is unavailable");
+	if (typeof BroadcastChannel === "undefined") throw remoteError("UnsupportedPlatformError", "BroadcastChannel is unavailable");
+	if (typeof FileSystemFileHandle === "undefined" || typeof FileSystemFileHandle.prototype.createSyncAccessHandle !== "function") throw remoteError("UnsupportedPlatformError", "createSyncAccessHandle is unavailable");
+}
+function assertSecureContext() {
+	if (!self.isSecureContext) throw remoteError("UnsupportedPlatformError", "moyodb requires a secure context (HTTPS)");
+}
+function remoteError(code, message) {
+	const error = new Error(message);
+	error.name = code;
+	Object.defineProperty(error, "code", {
+		value: code,
+		enumerable: true,
+		configurable: true
+	});
+	return error;
+}
+function applyChangeFeedPolicy(engine, settings) {
+	const current = engine.change_feed_policy();
+	const currentRetain = fromOptionalWasmU64(current.retainTxids);
+	if (current.enabled === settings.enabled && (!settings.enabled || currentRetain === settings.retainTxids)) return;
+	const txId = engine.begin_tx("readwrite");
+	try {
+		engine.set_change_feed_policy(txId, {
+			enabled: settings.enabled,
+			retainTxids: settings.retainTxids
+		});
+		engine.commit_tx(txId);
+	} catch (error) {
+		try {
+			engine.rollback_tx(txId);
+		} catch {}
+		throw remapError(error);
+	}
+}
+/** Active generation, null for legacy storage, undefined if reading fails. */
+async function readActiveGenerationOrNull(wasm, dbName) {
+	try {
+		return await wasm.readActiveGeneration(dbName);
+	} catch {
+		return;
+	}
+}
+function normalizeEngineHealth(health) {
+	if (health.state === "recoveryRequired") return {
+		state: "recoveryRequired",
+		reason: health.reason,
+		pendingTxid: fromOptionalWasmU64(health.pendingTxid)
+	};
+	return { state: health.state };
+}
+function partialBooleanOutcomes(error) {
+	if (!isRecord(error) || !Array.isArray(error.partial)) return [];
+	return error.partial.filter((value) => typeof value === "boolean");
+}
+function partialBatchOutcomes(error) {
+	if (!isRecord(error) || !Array.isArray(error.partial)) return [];
+	return error.partial.filter((value) => {
+		if (!isRecord(value) || typeof value.kind !== "string") return false;
+		return value.kind === "put" && typeof value.baselineExists === "boolean" || value.kind === "delete" && typeof value.deleted === "boolean";
+	});
+}
+function remapError(err) {
+	if (err instanceof Error) return err;
+	if (isRecord(err)) {
+		const error = remoteError(typeof err.code === "string" ? err.code : typeof err.name === "string" ? err.name : "Error", typeof err.message === "string" ? err.message : "Unknown error");
+		if ("partial" in err) Object.defineProperty(error, "partial", {
+			value: err.partial,
+			enumerable: true,
+			configurable: true
+		});
+		return error;
+	}
+	return remoteError("Error", String(err));
+}
+//#endregion
+export { DbWorker, exposeWorkerApi };
+
+//# sourceMappingURL=node-engine.js.map