@moyodb/sdk 1.0.0 → 1.1.0

package/dist/node-engine.js

@@ -0,0 +1,2213 @@
+import { A as prefixRange, At as packedBinaryListBytes, Bt as unpackPackedOptionalValues, Et as isWorkerProtocolRequestMessage, F as utf8Encode, Ft as unpackPackedBatchOpKeys, It as unpackPackedBatchOps, Lt as unpackPackedBinaryList, Nt as prepareWorkerResponsePayload, Pt as serializeWorkerError, Rt as unpackPackedBinaryPairKeys, S as toPublicIndexDefinitions, St as isWorkerProtocolEnvelope, Tt as isWorkerProtocolRequestBatchMessage, Ut as isRecord, Vt as workerProtocolError, _ 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 unpackPackedBinaryPairs } from "./chunks/indexing-BzmFhWXs.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();
+	schedule(command, args, task) {
+		if (UNSCHEDULED_COMMANDS.has(command)) return task();
+		if (EXCLUSIVE_COMMANDS.has(command)) return this.#runExclusive(task);
+		return this.#runShared(laneFor(command, args), task);
+	}
+	#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/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 STORE_FLAG_COMPRESSION_SHIFT = 2;
+var STORE_FLAG_COMPRESSION_MASK = 12;
+var MAX_DECOMPRESSED_STORE_VALUE_BYTES = 8388608;
+var MAX_DECOMPRESSED_SNAPSHOT_BYTES = 268435456;
+var CRC32_TABLE = (() => {
+	const table = /* @__PURE__ */ new Uint32Array(256);
+	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;
+	}
+	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;
+		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";
+		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;
+	for (const byte of bytes) crc = crc >>> 8 ^ CRC32_TABLE[(crc ^ byte) & 255];
+	return (crc ^ 4294967295) >>> 0;
+}
+function buildEnvelope(magic, kindTag, rawLength, payload) {
+	const out = new Uint8Array(ENVELOPE_HEADER_SIZE + payload.byteLength);
+	out.set(magic, 0);
+	out[8] = ENVELOPE_VERSION;
+	out[9] = kindTag;
+	const view = new DataView(out.buffer, out.byteOffset, ENVELOPE_HEADER_SIZE);
+	view.setUint32(10, rawLength, true);
+	view.setUint32(14, crc32(payload), true);
+	out.set(payload, ENVELOPE_HEADER_SIZE);
+	return out;
+}
+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) {
+	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";
+		default: throw namedError("CorruptionError", `invalid store compression flags: ${encoded}`);
+	}
+}
+async function encodeStoreValueRecord(value, compression) {
+	if (compression === false) return 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`);
+	if (value.byteLength < 1024) return buildEnvelope(STORE_RECORD_MAGIC, COMPRESSION_TAG_NONE, value.byteLength, value);
+	const input = copyBytes(value);
+	const compressed = await compressBytes(input, compression);
+	if (compressed.byteLength >= input.byteLength) return buildEnvelope(STORE_RECORD_MAGIC, COMPRESSION_TAG_NONE, input.byteLength, input);
+	return buildEnvelope(STORE_RECORD_MAGIC, compressionTag(compression), input.byteLength, compressed);
+}
+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;
+	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\"");
+	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 INDEX_SCAN_PAGE_ROWS = 256;
+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 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(), 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();
+	/**
+	* 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 = options.compression ?? false;
+		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;
+		}
+		const oldValue = await this.readStoreValue(txId, store, key);
+		const oldKeyFor = oldValue === null ? null : createIndexKeyExtractor(oldValue);
+		const newKeyFor = createIndexKeyExtractor(value);
+		const plans = defs.map((def) => {
+			return {
+				def,
+				oldLogicalKey: oldKeyFor === null ? null : oldKeyFor(def),
+				newLogicalKey: newKeyFor(def),
+				newPhysicalKey: null
+			};
+		});
+		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)) continue;
+			await this.assertUniqueIndexAvailability(txId, plan.def, plan.newLogicalKey, key);
+		}
+		const storedValue = await this.encodeStoreValueForWrite(txId, store, value);
+		const baselineExists = this.withEngine((engine) => engine.put(toWasmU64(txId), store, key, storedValue, toWasmPutOptions(options)));
+		for (const plan of plans) {
+			if (plan.oldLogicalKey === null) continue;
+			if (plan.newLogicalKey !== null && bytesEqual(plan.oldLogicalKey, plan.newLogicalKey)) continue;
+			this.deleteIndexEntryIfPresent(txId, plan.def, plan.oldLogicalKey, key);
+		}
+		for (const plan of plans) {
+			if (plan.newLogicalKey === null) continue;
+			if (plan.oldLogicalKey !== null && bytesEqual(plan.oldLogicalKey, plan.newLogicalKey)) continue;
+			if (plan.newPhysicalKey === null) throw remoteError("InternalError", "missing index entry key");
+			this.putIndexEntry(txId, plan.def, plan.newPhysicalKey, EMPTY_VALUE);
+		}
+		this.recordPutChange(txId, store, key, baselineExists);
+	}
+	async putMany(txId, store, entries, options = {}) {
+		if (entries.length === 0) return;
+		if (this.indexesForStoreInTx(txId, store).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;
+		}
+		for (const [key, value] of entries) await this.put(txId, store, key, value, options);
+	}
+	async putManyPacked(txId, store, packedEntries, options = {}) {
+		if (this.indexesForStoreInTx(txId, store).length !== 0 || this.storeCompressionForTx(txId, store) !== false) {
+			await this.putMany(txId, store, unpackPackedBinaryPairs(packedEntries), options);
+			return;
+		}
+		const keys = unpackPackedBinaryPairKeys(packedEntries);
+		if (keys.length === 0) return;
+		let baselines;
+		try {
+			baselines = this.withEngine((engine) => engine.put_many_packed(toWasmU64(txId), store, packedEntries, 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 getByIndex(txId, store, indexName, key) {
+		const def = this.resolveIndexDefinition(txId, store, indexName);
+		const page = await this.loadVisibleIndexPage(txId, def, prefixRange(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) {
+		if (!Number.isSafeInteger(limit) || limit <= 0) throw remoteError("InvalidRangeError", "index scan page limit must be a positive integer");
+		const def = this.resolveIndexDefinition(txId, store, indexName);
+		return this.loadVisibleIndexPage(txId, def, range, cursor, limit);
+	}
+	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) {
+		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 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;
+	}
+	putRawValue(txId, store, key, value) {
+		this.withEngine((engine) => engine.put(toWasmU64(txId), store, key, value));
+	}
+	putIndexEntry(txId, def, physicalKey, value) {
+		this.putRawValue(txId, def.internalStore, physicalKey, value);
+	}
+	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.readRawScan(txId, def.internalStore, range);
+			for (const row of rows) {
+				cursor = row.key;
+				const decoded = decodeIndexEntryKey(row.key);
+				if (bytesEqual(decoded.primaryKey, primaryKey)) continue;
+				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) {
+		const { limit: _ignored, ...withoutLimit } = range;
+		const physical = indexRangeToPhysicalRange(withoutLimit);
+		const reverse = physical.reverse === true;
+		let resumeAfter = cursor;
+		const visible = [];
+		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.readRawScan(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;
+					batchEnd = Math.min(rawRows.length, index + limit - visible.length);
+					batch = this.readIndexPrimaryValues(txId, def, rawRows, batchStart, batchEnd);
+				}
+				const row = rawRows[index];
+				resumeAfter = row.key;
+				const resolved = batch ? await this.resolveVisibleIndexedValue(txId, def, row.key, batch.entries[index - batchStart], batch.values[index - batchStart]) : await this.resolveVisibleIndexedRow(txId, def, row.key);
+				if (!resolved) continue;
+				visible.push(resolved);
+				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) {
+		if (this.txModes.get(txId) !== "readonly" || end - start <= 1) return null;
+		let entries;
+		let values;
+		try {
+			entries = rows.slice(start, end).map((row) => decodeIndexEntryKey(row.key));
+			values = this.withEngine((engine) => engine.get_many(toWasmU64(txId), def.store, entries.map((entry) => entry.primaryKey)));
+		} catch {
+			return null;
+		}
+		if (values.length !== entries.length) throw remoteError("InternalError", `get_many outcome count mismatch: ${values.length} != ${entries.length}`);
+		return {
+			entries,
+			values
+		};
+	}
+	async resolveVisibleIndexedRow(txId, def, physicalKey) {
+		const decoded = decodeIndexEntryKey(physicalKey);
+		const value = this.readRawValue(txId, def.store, decoded.primaryKey);
+		return this.resolveVisibleIndexedValue(txId, def, physicalKey, decoded, value);
+	}
+	async resolveVisibleIndexedValue(txId, def, physicalKey, decoded, rawValue) {
+		if (rawValue === null) {
+			this.cleanupStaleIndexRow(txId, def, physicalKey);
+			return null;
+		}
+		const value = await this.decodeStoreValue(txId, def.store, normalizeWasmBytes(rawValue));
+		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.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