@moyodb/sdk 1.0.0 → 1.1.0

package/dist/chunks/indexing-BzmFhWXs.js

@@ -0,0 +1,1576 @@
+//#region src/internal.ts
+function isRecord(value) {
+	return value !== null && typeof value === "object";
+}
+function compareStringsByCodeUnit(left, right) {
+	if (left < right) return -1;
+	return left > right ? 1 : 0;
+}
+var WORKER_PROTOCOL_READY = "moyodb:worker-protocol:ready";
+var WORKER_PROTOCOL_REQUEST = "moyodb:worker-protocol:request";
+var WORKER_PROTOCOL_RESPONSE = "moyodb:worker-protocol:response";
+var WORKER_PROTOCOL_REQUEST_BATCH = "moyodb:worker-protocol:request-batch";
+var WORKER_PROTOCOL_RESPONSE_BATCH = "moyodb:worker-protocol:response-batch";
+var MAX_WORKER_BATCH_BYTES = 1048576;
+var WORKER_COMMANDS = [
+	"open",
+	"close",
+	"destroy",
+	"deleteDB",
+	"begin",
+	"commit",
+	"rollback",
+	"autocommit",
+	"createStore",
+	"dropStore",
+	"clearStore",
+	"get",
+	"getMany",
+	"has",
+	"put",
+	"putMany",
+	"delete",
+	"deleteMany",
+	"applyBatch",
+	"scan",
+	"getByIndex",
+	"scanByIndex",
+	"scanByIndexPage",
+	"getIndexes",
+	"reconcileIndexes",
+	"listStores",
+	"getVersion",
+	"changesSince",
+	"setSchemaVersion",
+	"exportSnapshot",
+	"importSnapshot",
+	"reset",
+	"compact",
+	"rebuild",
+	"stats",
+	"storageInfo",
+	"requestPersistence",
+	"setFailpoint"
+];
+var AUTOCOMMIT_COMMAND_SET = /* @__PURE__ */ new Set([
+	"get",
+	"getMany",
+	"has",
+	"put",
+	"putMany",
+	"delete",
+	"deleteMany",
+	"applyBatch",
+	"scan",
+	"getByIndex",
+	"scanByIndex",
+	"createStore",
+	"dropStore",
+	"clearStore"
+]);
+function isAutocommitCommand(value) {
+	return typeof value === "string" && AUTOCOMMIT_COMMAND_SET.has(value);
+}
+var PACKED_BINARY_LIST_V1 = "moyodb:packed-binary-list:v1";
+var PACKED_NULLABLE_BINARY_LIST_V1 = "moyodb:packed-nullable-binary-list:v1";
+var PACKED_SCAN_ROWS_V1 = "moyodb:packed-scan-rows:v1";
+var PACKED_BATCH_OPS_V1 = "moyodb:packed-batch-ops:v1";
+var PACKED_OPTIONAL_VALUES_V1 = "moyodb:packed-optional-values:v1";
+var BATCH_OP_DELETE = 0;
+var BATCH_OP_PUT = 1;
+var U32_MAX = 4294967295;
+var MAX_PACKED_RESPONSE_BYTES = 16777216;
+var EMPTY_TRANSFERABLES = [];
+var WORKER_COMMAND_SET = new Set(WORKER_COMMANDS);
+function isWorkerCommand(value) {
+	return typeof value === "string" && WORKER_COMMAND_SET.has(value);
+}
+function isWorkerProtocolReadyMessage(value) {
+	return isWorkerProtocolReadyEnvelope(value) && value.version === 1 && (value.batching === void 0 || value.batching === 1);
+}
+function isWorkerProtocolReadyEnvelope(value) {
+	return isRecord(value) && value.type === "moyodb:worker-protocol:ready";
+}
+function isWorkerProtocolResponseMessage(value) {
+	return isRecord(value) && value.type === "moyodb:worker-protocol:response" && value.version === 1 && typeof value.id === "number" && Number.isSafeInteger(value.id) && typeof value.ok === "boolean";
+}
+function isWorkerProtocolRequestMessage(value) {
+	return isRecord(value) && value.type === "moyodb:worker-protocol:request" && value.version === 1 && typeof value.id === "number" && Number.isSafeInteger(value.id) && typeof value.command === "string" && Array.isArray(value.args);
+}
+function isWorkerProtocolRequestBatchMessage(value) {
+	return isWorkerProtocolBatch(value, WORKER_PROTOCOL_REQUEST_BATCH, "requests");
+}
+function isWorkerProtocolResponseBatchMessage(value) {
+	if (!isWorkerProtocolBatch(value, "moyodb:worker-protocol:response-batch", "responses")) return false;
+	for (const response of value.responses) if (!isWorkerProtocolResponseMessage(response)) return false;
+	return true;
+}
+function isWorkerProtocolBatch(value, type, items) {
+	return isRecord(value) && value.type === type && value.version === 1 && Array.isArray(value[items]) && value[items].length > 0 && value[items].length <= 128;
+}
+function isWorkerProtocolEnvelope(value) {
+	return isRecord(value) && (value.type === "moyodb:worker-protocol:request" || value.type === "moyodb:worker-protocol:response" || value.type === "moyodb:worker-protocol:request-batch" || value.type === "moyodb:worker-protocol:response-batch" || value.type === "moyodb:worker-protocol:ready");
+}
+function serializeWorkerError(error) {
+	if (isRecord(error)) {
+		const code = stringOrUndefined(error.code);
+		return {
+			name: stringOrUndefined(error.name) ?? code ?? "Error",
+			code,
+			message: stringOrUndefined(error.message) ?? "Unknown error",
+			stack: stringOrUndefined(error.stack)
+		};
+	}
+	return {
+		name: "Error",
+		message: String(error)
+	};
+}
+function deserializeWorkerError(error) {
+	if (!isRecord(error) || typeof error.name !== "string" || typeof error.message !== "string" || error.code !== void 0 && typeof error.code !== "string" || error.stack !== void 0 && typeof error.stack !== "string") throw workerProtocolError("WorkerProtocolError", "invalid serialized worker error");
+	const deserialized = new Error(error.message);
+	deserialized.name = error.name || error.code || "Error";
+	if (error.stack) deserialized.stack = error.stack;
+	if (error.code) Object.defineProperty(deserialized, "code", {
+		value: error.code,
+		enumerable: true,
+		configurable: true
+	});
+	return deserialized;
+}
+function workerProtocolError(name, message, code = name) {
+	const error = new Error(message);
+	error.name = name;
+	Object.defineProperty(error, "code", {
+		value: code,
+		enumerable: true,
+		configurable: true
+	});
+	return error;
+}
+function prepareWorkerCommandPayload(command, args) {
+	if (command === "autocommit") {
+		const [mode, inner, innerArgs] = args;
+		if (isAutocommitCommand(inner) && Array.isArray(innerArgs)) {
+			const prepared = prepareWorkerCommandPayload(inner, [0, ...innerArgs]);
+			return {
+				args: [
+					mode,
+					inner,
+					prepared.args.slice(1)
+				],
+				transfer: prepared.transfer
+			};
+		}
+	}
+	if (command === "get" || command === "has" || command === "delete" || command === "getByIndex" || command === "put") {
+		const keyIndex = command === "getByIndex" ? 3 : 2;
+		let copiedArgs = null;
+		let transfer = null;
+		for (let index = keyIndex; index <= (command === "put" ? 3 : keyIndex); index += 1) {
+			const value = args[index];
+			if (value instanceof Uint8Array && value.buffer instanceof ArrayBuffer && (value.byteOffset !== 0 || value.byteLength !== value.buffer.byteLength)) {
+				const owned = copyToOwnedUint8Array(value);
+				copiedArgs ??= [...args];
+				copiedArgs[index] = owned;
+				(transfer ??= []).push(owned.buffer);
+			}
+		}
+		if (copiedArgs !== null) return {
+			args: copiedArgs,
+			transfer: transfer ?? EMPTY_TRANSFERABLES
+		};
+	}
+	if (command === "importSnapshot") {
+		const data = args[0];
+		if (data instanceof Uint8Array) {
+			const owned = copyToOwnedUint8Array(data);
+			return {
+				args: [owned],
+				transfer: [owned.buffer]
+			};
+		}
+	}
+	if (command === "getMany" || command === "deleteMany") {
+		const [txId, store, keys] = args;
+		if (Array.isArray(keys) && keys.length > 0) {
+			const packed = packBinaryList(keys);
+			return {
+				args: [
+					txId,
+					store,
+					packed
+				],
+				transfer: [packed.bytes.buffer]
+			};
+		}
+	}
+	if (command === "putMany") {
+		const [txId, store, entries, options] = args;
+		if (Array.isArray(entries) && entries.length > 0) {
+			const packed = packBinaryPairs(entries);
+			return {
+				args: [
+					txId,
+					store,
+					packed,
+					options
+				],
+				transfer: [packed.bytes.buffer]
+			};
+		}
+	}
+	if (command === "applyBatch") {
+		const [txId, store, ops] = args;
+		if (Array.isArray(ops) && ops.length > 0) {
+			const packed = packBatchOps(ops);
+			return {
+				args: [
+					txId,
+					store,
+					packed
+				],
+				transfer: [packed.bytes.buffer]
+			};
+		}
+	}
+	return {
+		args,
+		transfer: EMPTY_TRANSFERABLES
+	};
+}
+function decodeWorkerCommandPayload(command, args) {
+	if (command === "autocommit") {
+		const [mode, inner, innerArgs] = args;
+		if (isAutocommitCommand(inner) && Array.isArray(innerArgs)) return [
+			mode,
+			inner,
+			decodeWorkerCommandPayload(inner, [0, ...innerArgs]).slice(1)
+		];
+	}
+	if (command === "getMany" || command === "deleteMany") {
+		const [txId, store, keys] = args;
+		if (!Array.isArray(keys)) {
+			if (!isPackedBinaryList(keys)) throw workerProtocolError("WorkerProtocolError", "invalid packed binary-list argument");
+			return [
+				txId,
+				store,
+				unpackBinaryList(keys)
+			];
+		}
+	}
+	if (command === "putMany") {
+		const [txId, store, entries, options] = args;
+		if (!Array.isArray(entries)) {
+			if (!isPackedBinaryList(entries)) throw workerProtocolError("WorkerProtocolError", "invalid packed putMany argument");
+			return [
+				txId,
+				store,
+				unpackBinaryPairs(entries),
+				options
+			];
+		}
+	}
+	if (command === "applyBatch") {
+		const [txId, store, ops] = args;
+		if (!Array.isArray(ops)) {
+			if (!isPackedBatchOps(ops)) throw workerProtocolError("WorkerProtocolError", "invalid packed batch argument");
+			return [
+				txId,
+				store,
+				unpackBatchOps(ops)
+			];
+		}
+	}
+	return args;
+}
+function packedBinaryListBytes(value) {
+	return isPackedBinaryList(value) ? value.bytes : null;
+}
+function packedBatchOpsBytes(value) {
+	return isPackedBatchOps(value) ? value.bytes : null;
+}
+function unpackPackedBinaryList(bytes) {
+	return unpackBinaryList({
+		__moyodbPacked: PACKED_BINARY_LIST_V1,
+		bytes
+	});
+}
+function unpackPackedBinaryPairs(bytes) {
+	return unpackBinaryPairs({
+		__moyodbPacked: PACKED_BINARY_LIST_V1,
+		bytes
+	});
+}
+function unpackPackedBinaryPairKeys(bytes) {
+	return unpackBinaryPairKeys({
+		__moyodbPacked: PACKED_BINARY_LIST_V1,
+		bytes
+	});
+}
+function unpackPackedBatchOps(bytes) {
+	return unpackBatchOps({
+		__moyodbPacked: PACKED_BATCH_OPS_V1,
+		bytes
+	});
+}
+function unpackPackedBatchOpKeys(bytes) {
+	return unpackBatchOpKeys({
+		__moyodbPacked: PACKED_BATCH_OPS_V1,
+		bytes
+	});
+}
+function packedOptionalValues(bytes) {
+	return {
+		__moyodbPacked: PACKED_OPTIONAL_VALUES_V1,
+		bytes
+	};
+}
+function unpackPackedOptionalValues(bytes) {
+	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 4) throw workerProtocolError("WorkerProtocolError", "invalid packed optional-values payload");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const count = view.getUint32(0, true);
+	const payloadOffset = checkedAdd(4, checkedByteCount(count, 4, "packed optional-values metadata"), "packed optional-values header");
+	if (payloadOffset > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed optional-values metadata exceeds payload length");
+	const items = new Array(count);
+	let readOffset = payloadOffset;
+	for (let index = 0; index < count; index += 1) {
+		const byteLength = view.getUint32(4 + index * 4, true);
+		if (byteLength === U32_MAX) {
+			items[index] = null;
+			continue;
+		}
+		const end = readOffset + byteLength;
+		if (end > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed optional-values item exceeds payload length");
+		items[index] = bytes.subarray(readOffset, end);
+		readOffset = end;
+	}
+	if (readOffset !== bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed optional-values payload has trailing bytes");
+	return items;
+}
+function prepareWorkerResponsePayload(command, result) {
+	if (command === "getMany" && isPackedOptionalValues(result)) return {
+		result,
+		transfer: collectDirectBinaryTransferable(result.bytes)
+	};
+	if (command === "scanByIndexPage") {
+		const page = result;
+		if (isRecord(page) && Array.isArray(page.rows)) {
+			const packed = page.rows.length > 0 ? packScanRows(page.rows) : null;
+			const response = {
+				rows: packed ?? page.rows,
+				cursor: page.cursor
+			};
+			const transfer = packed ? [packed.bytes.buffer] : collectTransferablesForValue(page.rows);
+			const cursorBuffer = directBinaryTransferable(page.cursor);
+			return {
+				result: response,
+				transfer: cursorBuffer === null ? transfer : [...transfer, cursorBuffer]
+			};
+		}
+	}
+	if (command === "getMany") {
+		const values = result;
+		if (Array.isArray(values) && values.length > 0) {
+			const packed = packNullableBinaryList(values);
+			if (packed) return {
+				result: packed,
+				transfer: [packed.bytes.buffer]
+			};
+		}
+		return {
+			result,
+			transfer: collectTransferablesForValue(result)
+		};
+	}
+	if (command === "scan" || command === "scanByIndex") {
+		const rows = result;
+		if (Array.isArray(rows) && rows.length > 0) {
+			const packed = packScanRows(rows);
+			if (packed) return {
+				result: packed,
+				transfer: [packed.bytes.buffer]
+			};
+		}
+		return {
+			result,
+			transfer: collectTransferablesForValue(result)
+		};
+	}
+	if (command === "get" || command === "getByIndex" || command === "exportSnapshot") return {
+		result,
+		transfer: collectDirectBinaryTransferable(result)
+	};
+	if (command === "changesSince") return {
+		result,
+		transfer: collectChangeFeedTransferables(result)
+	};
+	return {
+		result,
+		transfer: []
+	};
+}
+function decodeWorkerResponsePayload(command, result) {
+	if (command === "getMany" && isPackedNullableBinaryList(result)) return unpackNullableBinaryList(result);
+	if (command === "getMany" && isPackedOptionalValues(result)) return unpackPackedOptionalValues(result.bytes);
+	if (command === "getMany" && !Array.isArray(result)) throw workerProtocolError("WorkerProtocolError", "invalid packed getMany response");
+	if (command === "scanByIndexPage") {
+		if (!isRecord(result) || !Array.isArray(result.rows) && !isPackedScanRows(result.rows) || result.cursor !== null && !(result.cursor instanceof Uint8Array)) throw workerProtocolError("WorkerProtocolError", "invalid packed index scan page response");
+		return {
+			rows: isPackedScanRows(result.rows) ? unpackScanRows(result.rows) : result.rows,
+			cursor: result.cursor
+		};
+	}
+	if ((command === "scan" || command === "scanByIndex") && isPackedScanRows(result)) return unpackScanRows(result);
+	if ((command === "scan" || command === "scanByIndex") && !Array.isArray(result)) throw workerProtocolError("WorkerProtocolError", "invalid packed scan response");
+	return result;
+}
+function collectTransferablesForValue(value) {
+	const direct = directBinaryTransferable(value);
+	if (direct !== null) return [direct];
+	if (value === null || value === void 0 || typeof value !== "object") return EMPTY_TRANSFERABLES;
+	const buffers = /* @__PURE__ */ new Set();
+	collectTransferableBuffers(value, buffers, /* @__PURE__ */ new WeakSet());
+	return buffers.size === 0 ? EMPTY_TRANSFERABLES : Array.from(buffers);
+}
+/**
+* Capture the message before batching can observe later mutations. Listed
+* transferables move into the snapshot; other ArrayBuffers are cloned.
+* SharedArrayBuffers remain shared. byteLength is a batch-size estimate.
+*/
+function captureWorkerPayload(value, transfer) {
+	const captured = transfer.length > 0 ? structuredClone(value, { transfer: transfer.length === 1 ? transfer : Array.from(new Set(transfer)) }) : structuredClone(value);
+	const buffers = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new WeakSet();
+	let byteLength = 0;
+	const visit = (item) => {
+		if (typeof item === "string") {
+			byteLength += 8 + item.length * 2;
+			return;
+		}
+		if (item === null || typeof item !== "object") {
+			byteLength += 8;
+			return;
+		}
+		if (seen.has(item)) return;
+		seen.add(item);
+		byteLength += 8;
+		if (item instanceof ArrayBuffer) {
+			buffers.add(item);
+			byteLength += item.byteLength;
+		} else if (typeof SharedArrayBuffer !== "undefined" && item instanceof SharedArrayBuffer) byteLength += item.byteLength;
+		else if (ArrayBuffer.isView(item)) visit(item.buffer);
+		else if (Array.isArray(item)) for (const child of item) visit(child);
+		else if (item instanceof Map) for (const [key, child] of item) {
+			visit(key);
+			visit(child);
+		}
+		else if (item instanceof Set) for (const child of item) visit(child);
+		else {
+			const record = item;
+			for (const key in record) if (Object.prototype.hasOwnProperty.call(record, key)) {
+				byteLength += 8 + key.length * 2;
+				visit(record[key]);
+			}
+		}
+	};
+	visit(captured);
+	return {
+		value: captured,
+		transfer: buffers.size === 0 ? EMPTY_TRANSFERABLES : Array.from(buffers),
+		byteLength
+	};
+}
+function collectDirectBinaryTransferable(value) {
+	const direct = directBinaryTransferable(value);
+	return direct === null ? EMPTY_TRANSFERABLES : [direct];
+}
+function directBinaryTransferable(value) {
+	if (value instanceof ArrayBuffer) return value;
+	if (ArrayBuffer.isView(value)) {
+		const buffer = value.buffer;
+		if (buffer instanceof ArrayBuffer && value.byteOffset === 0 && value.byteLength === buffer.byteLength) return buffer;
+	}
+	return null;
+}
+function collectChangeFeedTransferables(value) {
+	if (!isRecord(value) || !Array.isArray(value.changes) || value.changes.length === 0) return EMPTY_TRANSFERABLES;
+	let buffers = null;
+	for (const change of value.changes) {
+		if (!isRecord(change)) continue;
+		const key = directBinaryTransferable(change.key);
+		if (key !== null) {
+			buffers ??= /* @__PURE__ */ new Set();
+			buffers.add(key);
+		}
+		const changedValue = directBinaryTransferable(change.value);
+		if (changedValue !== null) {
+			buffers ??= /* @__PURE__ */ new Set();
+			buffers.add(changedValue);
+		}
+	}
+	return buffers === null || buffers.size === 0 ? EMPTY_TRANSFERABLES : Array.from(buffers);
+}
+function collectTransferableBuffers(value, buffers, seen) {
+	if (value === null || value === void 0) return;
+	if (value instanceof ArrayBuffer) {
+		buffers.add(value);
+		return;
+	}
+	if (ArrayBuffer.isView(value)) {
+		const buffer = value.buffer;
+		if (buffer instanceof ArrayBuffer && value.byteOffset === 0 && value.byteLength === buffer.byteLength) buffers.add(buffer);
+		return;
+	}
+	if (typeof value !== "object") return;
+	const object = value;
+	if (seen.has(object)) return;
+	seen.add(object);
+	if (Array.isArray(value)) {
+		for (const item of value) collectTransferableBuffers(item, buffers, seen);
+		return;
+	}
+	const record = value;
+	for (const key in record) if (Object.prototype.hasOwnProperty.call(record, key)) collectTransferableBuffers(record[key], buffers, seen);
+}
+function packBinaryPairs(entries) {
+	const entryCount = entries.length;
+	const count = checkedU32(entryCount * 2, "packed putMany item count");
+	const metadataBytes = checkedByteCount(count, 4, "packed putMany metadata");
+	let payloadBytes = 0;
+	for (let index = 0; index < entryCount; index += 1) {
+		const entry = entries[index];
+		const key = entry[0];
+		const value = entry[1];
+		if (!(key instanceof Uint8Array) || !(value instanceof Uint8Array)) throw workerProtocolError("WorkerProtocolError", "putMany entry key/value is not a Uint8Array");
+		const keyLength = checkedU32(key.byteLength, "putMany key length");
+		const valueLength = checkedU32(value.byteLength, "putMany value length");
+		payloadBytes += keyLength + valueLength;
+		if (payloadBytes > U32_MAX) throw workerProtocolError("WorkerProtocolError", "packed putMany payload exceeds 32-bit payload limit");
+	}
+	const payloadOffset = checkedAdd(4, metadataBytes, "packed putMany header");
+	const totalBytes = checkedAdd(payloadOffset, payloadBytes, "packed putMany total");
+	const bytes = new Uint8Array(totalBytes);
+	const view = new DataView(bytes.buffer);
+	view.setUint32(0, count, true);
+	let metadataOffset = 4;
+	let writeOffset = payloadOffset;
+	for (let index = 0; index < entryCount; index += 1) {
+		const entry = entries[index];
+		const key = entry[0];
+		const value = entry[1];
+		const keyLength = key.byteLength;
+		const valueLength = value.byteLength;
+		view.setUint32(metadataOffset, keyLength, true);
+		metadataOffset += 4;
+		view.setUint32(metadataOffset, valueLength, true);
+		metadataOffset += 4;
+		bytes.set(key, writeOffset);
+		writeOffset += keyLength;
+		bytes.set(value, writeOffset);
+		writeOffset += valueLength;
+	}
+	return {
+		__moyodbPacked: PACKED_BINARY_LIST_V1,
+		bytes
+	};
+}
+function packBinaryList(items) {
+	const count = items.length;
+	const metadataBytes = checkedByteCount(count, 4, "packed binary-list metadata");
+	let payloadBytes = 0;
+	for (let index = 0; index < count; index += 1) {
+		const item = items[index];
+		if (!(item instanceof Uint8Array)) throw workerProtocolError("WorkerProtocolError", "binary-list payload item is not a Uint8Array");
+		const itemLength = checkedU32(item.byteLength, "binary-list item length");
+		payloadBytes += itemLength;
+		if (payloadBytes > U32_MAX) throw workerProtocolError("WorkerProtocolError", "packed binary-list payload exceeds 32-bit payload limit");
+	}
+	const payloadOffset = checkedAdd(4, metadataBytes, "packed binary-list header");
+	const totalBytes = checkedAdd(payloadOffset, payloadBytes, "packed binary-list total");
+	const bytes = new Uint8Array(totalBytes);
+	const view = new DataView(bytes.buffer);
+	view.setUint32(0, count, true);
+	let metadataOffset = 4;
+	let writeOffset = payloadOffset;
+	for (let index = 0; index < count; index += 1) {
+		const item = items[index];
+		const itemLength = item.byteLength;
+		view.setUint32(metadataOffset, itemLength, true);
+		metadataOffset += 4;
+		bytes.set(item, writeOffset);
+		writeOffset += itemLength;
+	}
+	return {
+		__moyodbPacked: PACKED_BINARY_LIST_V1,
+		bytes
+	};
+}
+function unpackBinaryList(payload) {
+	const bytes = payload.bytes;
+	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 4) throw workerProtocolError("WorkerProtocolError", "invalid packed binary-list payload");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const count = view.getUint32(0, true);
+	const payloadOffset = checkedAdd(4, checkedByteCount(count, 4, "packed binary-list metadata"), "packed binary-list header");
+	if (payloadOffset > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed binary-list metadata exceeds payload length");
+	const items = new Array(count);
+	let metadataOffset = 4;
+	let readOffset = payloadOffset;
+	for (let index = 0; index < count; index += 1) {
+		const byteLength = view.getUint32(metadataOffset, true);
+		metadataOffset += 4;
+		const end = readOffset + byteLength;
+		if (end > U32_MAX || end > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed binary-list item exceeds payload length");
+		items[index] = bytes.subarray(readOffset, end);
+		readOffset = end;
+	}
+	if (readOffset !== bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed binary-list payload has trailing bytes");
+	return items;
+}
+function unpackBinaryPairs(payload) {
+	const bytes = payload.bytes;
+	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 4) throw workerProtocolError("WorkerProtocolError", "invalid packed putMany payload");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const itemCount = view.getUint32(0, true);
+	if (itemCount % 2 !== 0) throw workerProtocolError("WorkerProtocolError", "packed putMany payload has an odd item count");
+	const payloadOffset = checkedAdd(4, checkedByteCount(itemCount, 4, "packed putMany metadata"), "packed putMany header");
+	if (payloadOffset > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed putMany metadata exceeds payload length");
+	const entryCount = itemCount / 2;
+	const entries = new Array(entryCount);
+	let metadataOffset = 4;
+	let readOffset = payloadOffset;
+	for (let index = 0; index < entryCount; index += 1) {
+		const keyLength = view.getUint32(metadataOffset, true);
+		const valueLength = view.getUint32(metadataOffset + 4, true);
+		metadataOffset += 8;
+		const keyEnd = readOffset + keyLength;
+		if (keyEnd > U32_MAX || keyEnd > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed putMany key exceeds payload length");
+		const valueEnd = keyEnd + valueLength;
+		if (valueEnd > U32_MAX || valueEnd > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed putMany value exceeds payload length");
+		entries[index] = [bytes.subarray(readOffset, keyEnd), bytes.subarray(keyEnd, valueEnd)];
+		readOffset = valueEnd;
+	}
+	if (readOffset !== bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed putMany payload has trailing bytes");
+	return entries;
+}
+function unpackBinaryPairKeys(payload) {
+	const bytes = payload.bytes;
+	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 4) throw workerProtocolError("WorkerProtocolError", "invalid packed putMany payload");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const itemCount = view.getUint32(0, true);
+	if (itemCount % 2 !== 0) throw workerProtocolError("WorkerProtocolError", "packed putMany payload has an odd item count");
+	const payloadOffset = checkedAdd(4, checkedByteCount(itemCount, 4, "packed putMany metadata"), "packed putMany header");
+	if (payloadOffset > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed putMany metadata exceeds payload length");
+	const entryCount = itemCount / 2;
+	const keys = new Array(entryCount);
+	let metadataOffset = 4;
+	let readOffset = payloadOffset;
+	for (let index = 0; index < entryCount; index += 1) {
+		const keyLength = view.getUint32(metadataOffset, true);
+		const valueLength = view.getUint32(metadataOffset + 4, true);
+		metadataOffset += 8;
+		const keyEnd = readOffset + keyLength;
+		if (keyEnd > U32_MAX || keyEnd > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed putMany key exceeds payload length");
+		const valueEnd = keyEnd + valueLength;
+		if (valueEnd > U32_MAX || valueEnd > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed putMany value exceeds payload length");
+		keys[index] = bytes.subarray(readOffset, keyEnd);
+		readOffset = valueEnd;
+	}
+	if (readOffset !== bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed putMany payload has trailing bytes");
+	return keys;
+}
+function packNullableBinaryList(items) {
+	const count = items.length;
+	const metadataBytes = checkedByteCount(count, 5, "packed nullable binary-list metadata");
+	let payloadBytes = 0;
+	for (let index = 0; index < count; index += 1) {
+		const item = items[index];
+		if (item === null) continue;
+		if (!(item instanceof Uint8Array)) throw workerProtocolError("WorkerProtocolError", "nullable binary-list payload item is not a Uint8Array or null");
+		const itemLength = checkedU32(item.byteLength, "nullable binary-list item length");
+		payloadBytes += itemLength;
+		if (payloadBytes > U32_MAX) throw workerProtocolError("WorkerProtocolError", "packed nullable binary-list payload exceeds 32-bit payload limit");
+	}
+	const payloadOffset = checkedAdd(4, metadataBytes, "packed nullable binary-list header");
+	const totalBytes = checkedAdd(payloadOffset, payloadBytes, "packed nullable binary-list total");
+	if (totalBytes > MAX_PACKED_RESPONSE_BYTES) return null;
+	const bytes = new Uint8Array(totalBytes);
+	const view = new DataView(bytes.buffer);
+	view.setUint32(0, count, true);
+	let metadataOffset = 4;
+	let writeOffset = payloadOffset;
+	for (let index = 0; index < count; index += 1) {
+		const item = items[index];
+		if (item === null) {
+			view.setUint8(metadataOffset, 0);
+			view.setUint32(metadataOffset + 1, 0, true);
+			metadataOffset += 5;
+			continue;
+		}
+		const itemLength = item.byteLength;
+		view.setUint8(metadataOffset, 1);
+		view.setUint32(metadataOffset + 1, itemLength, true);
+		metadataOffset += 5;
+		bytes.set(item, writeOffset);
+		writeOffset += itemLength;
+	}
+	return {
+		__moyodbPacked: PACKED_NULLABLE_BINARY_LIST_V1,
+		bytes
+	};
+}
+function unpackNullableBinaryList(payload) {
+	const bytes = payload.bytes;
+	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 4) throw workerProtocolError("WorkerProtocolError", "invalid packed nullable binary-list payload");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const count = view.getUint32(0, true);
+	const payloadOffset = checkedAdd(4, checkedByteCount(count, 5, "packed nullable binary-list metadata"), "packed nullable binary-list header");
+	if (payloadOffset > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed nullable binary-list metadata exceeds payload length");
+	const items = new Array(count);
+	let metadataOffset = 4;
+	let readOffset = payloadOffset;
+	for (let index = 0; index < count; index += 1) {
+		const present = view.getUint8(metadataOffset);
+		const byteLength = view.getUint32(metadataOffset + 1, true);
+		metadataOffset += 5;
+		if (present === 0) {
+			if (byteLength !== 0) throw workerProtocolError("WorkerProtocolError", "packed nullable binary-list null item has a payload length");
+			items[index] = null;
+			continue;
+		}
+		if (present !== 1) throw workerProtocolError("WorkerProtocolError", `packed nullable binary-list item has invalid presence byte: ${present}`);
+		const end = readOffset + byteLength;
+		if (end > U32_MAX || end > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed nullable binary-list item exceeds payload length");
+		items[index] = bytes.subarray(readOffset, end);
+		readOffset = end;
+	}
+	if (readOffset !== bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed nullable binary-list payload has trailing bytes");
+	return items;
+}
+function packScanRows(rows) {
+	const count = rows.length;
+	const metadataBytes = checkedByteCount(count, 8, "packed scan row metadata");
+	let payloadBytes = 0;
+	for (let index = 0; index < count; index += 1) {
+		const row = rows[index];
+		if (!isRecord(row) || !(row.key instanceof Uint8Array) || !(row.value instanceof Uint8Array)) throw workerProtocolError("WorkerProtocolError", "scan row payload key/value is not a Uint8Array");
+		const keyLength = checkedU32(row.key.byteLength, "scan row key length");
+		const valueLength = checkedU32(row.value.byteLength, "scan row value length");
+		payloadBytes += keyLength + valueLength;
+		if (payloadBytes > U32_MAX) throw workerProtocolError("WorkerProtocolError", "packed scan row payload exceeds 32-bit payload limit");
+	}
+	const payloadOffset = checkedAdd(4, metadataBytes, "packed scan row header");
+	const totalBytes = checkedAdd(payloadOffset, payloadBytes, "packed scan row total");
+	if (totalBytes > MAX_PACKED_RESPONSE_BYTES) return null;
+	const bytes = new Uint8Array(totalBytes);
+	const view = new DataView(bytes.buffer);
+	view.setUint32(0, count, true);
+	let metadataOffset = 4;
+	let writeOffset = payloadOffset;
+	for (let index = 0; index < count; index += 1) {
+		const row = rows[index];
+		const key = row.key;
+		const value = row.value;
+		const keyLength = key.byteLength;
+		const valueLength = value.byteLength;
+		view.setUint32(metadataOffset, keyLength, true);
+		view.setUint32(metadataOffset + 4, valueLength, true);
+		metadataOffset += 8;
+		bytes.set(key, writeOffset);
+		writeOffset += keyLength;
+		bytes.set(value, writeOffset);
+		writeOffset += valueLength;
+	}
+	return {
+		__moyodbPacked: PACKED_SCAN_ROWS_V1,
+		bytes
+	};
+}
+function unpackScanRows(payload) {
+	const bytes = payload.bytes;
+	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 4) throw workerProtocolError("WorkerProtocolError", "invalid packed scan row payload");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const count = view.getUint32(0, true);
+	const payloadOffset = checkedAdd(4, checkedByteCount(count, 8, "packed scan row metadata"), "packed scan row header");
+	if (payloadOffset > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed scan row metadata exceeds payload length");
+	const rows = new Array(count);
+	let metadataOffset = 4;
+	let readOffset = payloadOffset;
+	for (let index = 0; index < count; index += 1) {
+		const keyLength = view.getUint32(metadataOffset, true);
+		const valueLength = view.getUint32(metadataOffset + 4, true);
+		metadataOffset += 8;
+		const keyEnd = readOffset + keyLength;
+		if (keyEnd > U32_MAX || keyEnd > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed scan row key exceeds payload length");
+		const valueEnd = keyEnd + valueLength;
+		if (valueEnd > U32_MAX || valueEnd > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed scan row value exceeds payload length");
+		rows[index] = {
+			key: bytes.subarray(readOffset, keyEnd),
+			value: bytes.subarray(keyEnd, valueEnd)
+		};
+		readOffset = valueEnd;
+	}
+	if (readOffset !== bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed scan row payload has trailing bytes");
+	return rows;
+}
+function packBatchOps(ops) {
+	const count = ops.length;
+	const metadataBytes = checkedByteCount(count, 9, "packed batch metadata");
+	let payloadBytes = 0;
+	for (let index = 0; index < count; index += 1) {
+		const op = ops[index];
+		if (!isRecord(op) || op.kind !== "put" && op.kind !== "delete") throw workerProtocolError("WorkerProtocolError", "batch operation kind is not put or delete");
+		if (!(op.key instanceof Uint8Array)) throw workerProtocolError("WorkerProtocolError", "batch operation key is not a Uint8Array");
+		const keyLength = checkedU32(op.key.byteLength, "batch operation key length");
+		payloadBytes += keyLength;
+		if (payloadBytes > U32_MAX) throw workerProtocolError("WorkerProtocolError", "packed batch payload exceeds 32-bit payload limit");
+		if (op.kind === "put") {
+			if (!(op.value instanceof Uint8Array)) throw workerProtocolError("WorkerProtocolError", "batch put value is not a Uint8Array");
+			const valueLength = checkedU32(op.value.byteLength, "batch put value length");
+			payloadBytes += valueLength;
+			if (payloadBytes > U32_MAX) throw workerProtocolError("WorkerProtocolError", "packed batch payload exceeds 32-bit payload limit");
+		}
+	}
+	const payloadOffset = checkedAdd(4, metadataBytes, "packed batch header");
+	const totalBytes = checkedAdd(payloadOffset, payloadBytes, "packed batch total");
+	const bytes = new Uint8Array(totalBytes);
+	const view = new DataView(bytes.buffer);
+	view.setUint32(0, count, true);
+	let metadataOffset = 4;
+	let writeOffset = payloadOffset;
+	for (let index = 0; index < count; index += 1) {
+		const op = ops[index];
+		const key = op.key;
+		const keyLength = key.byteLength;
+		const valueLength = op.kind === "put" ? op.value.byteLength : 0;
+		view.setUint8(metadataOffset, op.kind === "put" ? BATCH_OP_PUT : BATCH_OP_DELETE);
+		view.setUint32(metadataOffset + 1, keyLength, true);
+		view.setUint32(metadataOffset + 5, valueLength, true);
+		metadataOffset += 9;
+		bytes.set(key, writeOffset);
+		writeOffset += keyLength;
+		if (op.kind === "put") {
+			bytes.set(op.value, writeOffset);
+			writeOffset += valueLength;
+		}
+	}
+	return {
+		__moyodbPacked: PACKED_BATCH_OPS_V1,
+		bytes
+	};
+}
+function unpackBatchOps(payload) {
+	const bytes = payload.bytes;
+	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 4) throw workerProtocolError("WorkerProtocolError", "invalid packed batch payload");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const count = view.getUint32(0, true);
+	const payloadOffset = checkedAdd(4, checkedByteCount(count, 9, "packed batch metadata"), "packed batch header");
+	if (payloadOffset > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed batch metadata exceeds payload length");
+	const ops = new Array(count);
+	let metadataOffset = 4;
+	let readOffset = payloadOffset;
+	for (let index = 0; index < count; index += 1) {
+		const kind = view.getUint8(metadataOffset);
+		const keyLength = view.getUint32(metadataOffset + 1, true);
+		const valueLength = view.getUint32(metadataOffset + 5, true);
+		metadataOffset += 9;
+		const keyEnd = readOffset + keyLength;
+		if (keyEnd > U32_MAX || keyEnd > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed batch key exceeds payload length");
+		const key = bytes.subarray(readOffset, keyEnd);
+		readOffset = keyEnd;
+		if (kind === BATCH_OP_DELETE) {
+			if (valueLength !== 0) throw workerProtocolError("WorkerProtocolError", "packed delete operation has a value payload");
+			ops[index] = {
+				kind: "delete",
+				key
+			};
+			continue;
+		}
+		if (kind !== BATCH_OP_PUT) throw workerProtocolError("WorkerProtocolError", `packed batch operation has invalid kind byte: ${kind}`);
+		const valueEnd = readOffset + valueLength;
+		if (valueEnd > U32_MAX || valueEnd > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed batch value exceeds payload length");
+		ops[index] = {
+			kind: "put",
+			key,
+			value: bytes.subarray(readOffset, valueEnd)
+		};
+		readOffset = valueEnd;
+	}
+	if (readOffset !== bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed batch payload has trailing bytes");
+	return ops;
+}
+function unpackBatchOpKeys(payload) {
+	const bytes = payload.bytes;
+	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 4) throw workerProtocolError("WorkerProtocolError", "invalid packed batch payload");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const count = view.getUint32(0, true);
+	const payloadOffset = checkedAdd(4, checkedByteCount(count, 9, "packed batch metadata"), "packed batch header");
+	if (payloadOffset > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed batch metadata exceeds payload length");
+	const ops = new Array(count);
+	let metadataOffset = 4;
+	let readOffset = payloadOffset;
+	for (let index = 0; index < count; index += 1) {
+		const kind = view.getUint8(metadataOffset);
+		const keyLength = view.getUint32(metadataOffset + 1, true);
+		const valueLength = view.getUint32(metadataOffset + 5, true);
+		metadataOffset += 9;
+		const keyEnd = readOffset + keyLength;
+		if (keyEnd > U32_MAX || keyEnd > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed batch key exceeds payload length");
+		const key = bytes.subarray(readOffset, keyEnd);
+		readOffset = keyEnd;
+		if (kind === BATCH_OP_DELETE) {
+			if (valueLength !== 0) throw workerProtocolError("WorkerProtocolError", "packed delete operation has a value payload");
+			ops[index] = {
+				kind: "delete",
+				key
+			};
+			continue;
+		}
+		if (kind !== BATCH_OP_PUT) throw workerProtocolError("WorkerProtocolError", `packed batch operation has invalid kind byte: ${kind}`);
+		const valueEnd = readOffset + valueLength;
+		if (valueEnd > U32_MAX || valueEnd > bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed batch value exceeds payload length");
+		ops[index] = {
+			kind: "put",
+			key
+		};
+		readOffset = valueEnd;
+	}
+	if (readOffset !== bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed batch payload has trailing bytes");
+	return ops;
+}
+function isPackedBinaryList(value) {
+	return isRecord(value) && value.__moyodbPacked === PACKED_BINARY_LIST_V1 && value.bytes instanceof Uint8Array;
+}
+function isPackedNullableBinaryList(value) {
+	return isRecord(value) && value.__moyodbPacked === PACKED_NULLABLE_BINARY_LIST_V1 && value.bytes instanceof Uint8Array;
+}
+function isPackedScanRows(value) {
+	return isRecord(value) && value.__moyodbPacked === PACKED_SCAN_ROWS_V1 && value.bytes instanceof Uint8Array;
+}
+function isPackedBatchOps(value) {
+	return isRecord(value) && value.__moyodbPacked === PACKED_BATCH_OPS_V1 && value.bytes instanceof Uint8Array;
+}
+function isPackedOptionalValues(value) {
+	return isRecord(value) && value.__moyodbPacked === PACKED_OPTIONAL_VALUES_V1 && value.bytes instanceof Uint8Array;
+}
+function checkedByteCount(count, itemBytes, what) {
+	if (!Number.isSafeInteger(count) || count < 0) throw workerProtocolError("WorkerProtocolError", `${what} count is invalid: ${count}`);
+	return checkedU32(count * itemBytes, what);
+}
+function checkedAdd(left, right, what) {
+	return checkedU32(left + right, what);
+}
+function checkedU32(value, what) {
+	if (!Number.isSafeInteger(value) || value < 0 || value > U32_MAX) throw workerProtocolError("WorkerProtocolError", `${what} exceeds 32-bit payload limit`);
+	return value;
+}
+function copyToOwnedUint8Array(value) {
+	const owned = new Uint8Array(value.byteLength);
+	owned.set(value);
+	return owned;
+}
+function stringOrUndefined(value) {
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+//#region src/errors.ts
+var MoyoDbError = class extends Error {
+	constructor(name, message) {
+		super(message);
+		this.name = name;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+var UnsupportedPlatformError = class extends MoyoDbError {
+	constructor(message) {
+		super("UnsupportedPlatformError", message);
+	}
+};
+var DatabaseBusyError = class extends MoyoDbError {
+	constructor(message) {
+		super("DatabaseBusyError", message);
+	}
+};
+var CorruptionError = class extends MoyoDbError {
+	constructor(message) {
+		super("CorruptionError", message);
+	}
+};
+var StoreExistsError = class extends MoyoDbError {
+	constructor(message) {
+		super("StoreExistsError", message);
+	}
+};
+var StoreNotFoundError = class extends MoyoDbError {
+	constructor(message) {
+		super("StoreNotFoundError", message);
+	}
+};
+var IndexNotFoundError = class extends MoyoDbError {
+	constructor(message) {
+		super("IndexNotFoundError", message);
+	}
+};
+var ConstraintError = class extends MoyoDbError {
+	constructor(message) {
+		super("ConstraintError", message);
+	}
+};
+var UniqueIndexConstraintError = class extends ConstraintError {
+	constructor(message) {
+		super(message);
+		this.name = "UniqueIndexConstraintError";
+	}
+};
+var WriteTransactionAlreadyOpenError = class extends MoyoDbError {
+	constructor(message = "write transaction already open") {
+		super("WriteTransactionAlreadyOpenError", message);
+	}
+};
+var TransactionConflictError = class extends MoyoDbError {
+	constructor(message = "transaction snapshot is stale; start a new transaction") {
+		super("TransactionConflictError", message);
+	}
+};
+var ReadonlyTransactionError = class extends MoyoDbError {
+	constructor(message = "readonly transaction cannot perform this operation") {
+		super("ReadonlyTransactionError", message);
+	}
+};
+var TransactionClosedError = class extends MoyoDbError {
+	constructor(message = "transaction is already closed") {
+		super("TransactionClosedError", message);
+	}
+};
+var DatabaseClosedError = class extends MoyoDbError {
+	constructor(message = "database handle is closed") {
+		super("DatabaseClosedError", message);
+	}
+};
+var ValueTooLargeError = class extends MoyoDbError {
+	constructor(message) {
+		super("ValueTooLargeError", message);
+	}
+};
+var KeyTooLargeError = class extends MoyoDbError {
+	constructor(message) {
+		super("KeyTooLargeError", message);
+	}
+};
+var StoreNameTooLongError = class extends MoyoDbError {
+	constructor(message) {
+		super("StoreNameTooLongError", message);
+	}
+};
+var ReservedStoreNameError = class extends MoyoDbError {
+	constructor(message) {
+		super("ReservedStoreNameError", message);
+	}
+};
+var InvalidRangeError = class extends MoyoDbError {
+	constructor(message) {
+		super("InvalidRangeError", message);
+	}
+};
+var StorageError = class extends MoyoDbError {
+	constructor(message) {
+		super("StorageError", message);
+	}
+};
+var SerializationError = class extends MoyoDbError {
+	constructor(message) {
+		super("SerializationError", message);
+	}
+};
+var InjectedFailureError = class extends MoyoDbError {
+	constructor(message) {
+		super("InjectedFailureError", message);
+	}
+};
+var ChangeFeedCompactedError = class extends MoyoDbError {
+	constructor(message) {
+		super("ChangeFeedCompactedError", message);
+	}
+};
+/**
+* The engine state could not be trusted, or automatic recovery failed.
+* A failed commit may already be durable. The worker attempts recovery before
+* a new transaction and after a failed commit. Recovery discards all open transactions.
+*/
+var RecoveryRequiredError = class extends MoyoDbError {
+	constructor(message) {
+		super("RecoveryRequiredError", message);
+	}
+};
+var InternalError = class extends MoyoDbError {
+	constructor(message) {
+		super("InternalError", message);
+	}
+};
+var InvalidOpenOptionsError = class extends MoyoDbError {
+	constructor(message) {
+		super("InvalidOpenOptionsError", message);
+	}
+};
+var VersionError = class extends MoyoDbError {
+	constructor(message) {
+		super("VersionError", message);
+	}
+};
+var ERROR_CONSTRUCTORS = {
+	UnsupportedPlatformError,
+	DatabaseBusyError,
+	CorruptionError,
+	StoreExistsError,
+	StoreNotFoundError,
+	IndexNotFoundError,
+	ConstraintError,
+	UniqueIndexConstraintError,
+	WriteTransactionAlreadyOpenError,
+	TransactionConflictError,
+	ReadonlyTransactionError,
+	TransactionClosedError,
+	DatabaseClosedError,
+	ValueTooLargeError,
+	KeyTooLargeError,
+	StoreNameTooLongError,
+	ReservedStoreNameError,
+	InvalidRangeError,
+	StorageError,
+	SerializationError,
+	InjectedFailureError,
+	ChangeFeedCompactedError,
+	RecoveryRequiredError,
+	InternalError,
+	InvalidOpenOptionsError,
+	VersionError
+};
+function instantiateError(code, message) {
+	if (Object.prototype.hasOwnProperty.call(ERROR_CONSTRUCTORS, code)) {
+		const ErrorConstructor = ERROR_CONSTRUCTORS[code];
+		return new ErrorConstructor(message);
+	}
+	const err = new Error(message);
+	err.name = code;
+	return err;
+}
+function normalizeError(error) {
+	if (error instanceof MoyoDbError) return error;
+	if (error instanceof Error) {
+		if (error.name === "Error") return error;
+		return instantiateError(error.name, error.message);
+	}
+	const payload = error;
+	return instantiateError(payload?.code ?? payload?.name ?? "Error", payload?.message ?? String(error));
+}
+//#endregion
+//#region src/codec.ts
+var encoder$1 = new TextEncoder();
+var decoder = new TextDecoder();
+var jsonDecoder = new TextDecoder("utf-8", { fatal: true });
+var TYPE_NULL = 16;
+var TYPE_FALSE = 32;
+var TYPE_TRUE = 33;
+var TYPE_NUMBER = 48;
+var TYPE_STRING = 64;
+var TYPE_BYTES = 80;
+var COMPOUND_ESCAPE = 0;
+var COMPOUND_ESCAPE_CONT = 255;
+var COMPOUND_TERM = 0;
+var F64_MASK = BigInt("0xffffffffffffffff");
+function utf8Encode(value) {
+	return encoder$1.encode(value);
+}
+function utf8Decode(bytes) {
+	return decoder.decode(bytes);
+}
+function jsonEncode(value) {
+	const serialized = JSON.stringify(value);
+	if (serialized === void 0) throw new TypeError("value has no JSON representation");
+	return utf8Encode(serialized);
+}
+function jsonDecode(bytes) {
+	return JSON.parse(jsonDecoder.decode(bytes));
+}
+function u64Key(value) {
+	if (typeof value === "number" && (!Number.isSafeInteger(value) || value < 0)) throw new RangeError("u64Key number inputs must be safe non-negative integers; use bigint for larger values");
+	const asBigInt = typeof value === "bigint" ? value : BigInt(value);
+	if (asBigInt < 0n) throw new RangeError("u64Key only accepts non-negative values");
+	if (asBigInt > F64_MASK) throw new RangeError("u64Key value exceeds the unsigned 64-bit range");
+	const buf = /* @__PURE__ */ new ArrayBuffer(8);
+	new DataView(buf).setBigUint64(0, asBigInt, false);
+	return new Uint8Array(buf);
+}
+function isCompoundKeyPartList(value) {
+	return Array.isArray(value);
+}
+function indexKey(value) {
+	if (isCompoundKeyPartList(value)) return compoundKey(...value);
+	return encodeCompoundKeyPart(value);
+}
+function compoundKey(...parts) {
+	return encodeCompoundBytes(parts.map((part) => encodeCompoundKeyPart(part)));
+}
+function encodeIndexScalar(value) {
+	return encodeCompoundKeyPart(value);
+}
+function encodeCompoundKeyParts(parts) {
+	return encodeCompoundBytes(parts);
+}
+function splitCompoundKey(key) {
+	const parts = [];
+	const current = [];
+	for (let index = 0; index < key.length; index += 1) {
+		const byte = key[index];
+		if (byte !== COMPOUND_ESCAPE) {
+			current.push(byte);
+			continue;
+		}
+		const next = key[index + 1];
+		if (next === COMPOUND_ESCAPE_CONT) {
+			current.push(COMPOUND_ESCAPE);
+			index += 1;
+			continue;
+		}
+		if (next === COMPOUND_TERM) {
+			parts.push(Uint8Array.from(current));
+			current.length = 0;
+			index += 1;
+			continue;
+		}
+		throw new TypeError("invalid compound key encoding");
+	}
+	if (current.length !== 0) throw new TypeError("compound key terminated unexpectedly");
+	return parts;
+}
+function prefixSuccessor(prefix) {
+	const out = prefix.slice();
+	for (let index = out.length - 1; index >= 0; index -= 1) if (out[index] !== 255) {
+		out[index] += 1;
+		return out.subarray(0, index + 1);
+	}
+	return null;
+}
+function prefixRange(prefix) {
+	const upper = prefixSuccessor(prefix);
+	return upper ? {
+		gte: prefix,
+		lt: upper
+	} : { gte: prefix };
+}
+function compoundKeyRange(...parts) {
+	return prefixRange(compoundKey(...parts));
+}
+function encodeCompoundKeyPart(value) {
+	if (value === null) return Uint8Array.of(TYPE_NULL);
+	if (typeof value === "boolean") return Uint8Array.of(value ? TYPE_TRUE : TYPE_FALSE);
+	if (typeof value === "number") return encodeSortableNumber(value);
+	if (typeof value === "string") {
+		for (const character of value) {
+			const codePoint = character.codePointAt(0);
+			if (codePoint >= 55296 && codePoint <= 57343) throw new TypeError("compound key string parts must contain valid Unicode scalar values");
+		}
+		const body = utf8Encode(value);
+		const out = new Uint8Array(1 + body.length);
+		out[0] = TYPE_STRING;
+		out.set(body, 1);
+		return out;
+	}
+	if (value instanceof Uint8Array) {
+		const out = new Uint8Array(1 + value.length);
+		out[0] = TYPE_BYTES;
+		out.set(value, 1);
+		return out;
+	}
+	throw new TypeError("compound key parts must be string, number, boolean, null, or Uint8Array");
+}
+function encodeCompoundBytes(parts) {
+	let length = 0;
+	for (const part of parts) {
+		for (const byte of part) length += byte === COMPOUND_ESCAPE ? 2 : 1;
+		length += 2;
+	}
+	const out = new Uint8Array(length);
+	let offset = 0;
+	for (const part of parts) {
+		for (const byte of part) if (byte === COMPOUND_ESCAPE) {
+			out[offset] = COMPOUND_ESCAPE;
+			out[offset + 1] = COMPOUND_ESCAPE_CONT;
+			offset += 2;
+		} else {
+			out[offset] = byte;
+			offset += 1;
+		}
+		out[offset] = COMPOUND_TERM;
+		out[offset + 1] = COMPOUND_TERM;
+		offset += 2;
+	}
+	return out;
+}
+function encodeSortableNumber(value) {
+	if (!Number.isFinite(value)) throw new TypeError("compound key number parts must be finite");
+	const normalized = Object.is(value, -0) ? 0 : value;
+	const buffer = /* @__PURE__ */ new ArrayBuffer(9);
+	const view = new DataView(buffer);
+	view.setUint8(0, TYPE_NUMBER);
+	view.setFloat64(1, normalized, false);
+	let bits = view.getBigUint64(1, false);
+	bits = (bits & 1n << 63n) !== 0n ? ~bits & F64_MASK : bits ^ 1n << 63n;
+	view.setBigUint64(1, bits, false);
+	return new Uint8Array(buffer);
+}
+//#endregion
+//#region src/indexing.ts
+var encoder = new TextEncoder();
+var fatalDecoder = new TextDecoder("utf-8", { fatal: true });
+var MISSING = Symbol("moyodb.indexing.missing");
+var FNV64_OFFSET = BigInt("0xcbf29ce484222325");
+var FNV64_PRIME = BigInt("0x100000001b3");
+var FNV64_MASK = BigInt("0xffffffffffffffff");
+var INTERNAL_STORE_PREFIX = "__browserdb:";
+var INTERNAL_INDEX_STORE_PREFIX = "__browserdb:index:";
+var INDEX_METADATA_STORE = "__browserdb:indexes";
+function isInternalStoreName(name) {
+	return name.startsWith(INTERNAL_STORE_PREFIX);
+}
+function assertPublicStoreName(name) {
+	if (isInternalStoreName(name)) throw new ReservedStoreNameError(`reserved store name: ${name}`);
+}
+function normalizeIndexDefinitions(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new InvalidOpenOptionsError("indexes must be an array");
+	const normalized = [];
+	const identities = /* @__PURE__ */ new Set();
+	const internalStores = /* @__PURE__ */ new Map();
+	for (const entry of value) {
+		if (entry === null || typeof entry !== "object" || Array.isArray(entry)) throw new InvalidOpenOptionsError("each index definition must be an object");
+		const { store, name, keyPath, unique } = entry;
+		if (typeof store !== "string" || store.length === 0) throw new InvalidOpenOptionsError("index store must be a non-empty string");
+		if (typeof name !== "string" || name.length === 0) throw new InvalidOpenOptionsError("index name must be a non-empty string");
+		assertPublicStoreName(store);
+		const keyPathInfo = normalizeIndexKeyPath(keyPath);
+		if (unique !== void 0 && typeof unique !== "boolean") throw new InvalidOpenOptionsError("index unique must be a boolean");
+		const def = {
+			store,
+			name,
+			keyPath: keyPathInfo.paths,
+			compound: keyPathInfo.compound,
+			unique: unique ?? false,
+			internalStore: makeInternalIndexStoreName(store, name)
+		};
+		const identity = indexDefinitionIdentity(def.store, def.name);
+		if (identities.has(identity)) throw new InvalidOpenOptionsError(`duplicate index definition ${def.store}.${def.name}`);
+		identities.add(identity);
+		const mappedIdentity = internalStores.get(def.internalStore);
+		if (mappedIdentity && mappedIdentity !== identity) throw new InvalidOpenOptionsError(`index definitions ${mappedIdentity} and ${identity} map to the same internal store ${def.internalStore}`);
+		internalStores.set(def.internalStore, identity);
+		normalized.push(def);
+	}
+	normalized.sort(compareNormalizedIndexDefinitions);
+	return normalized;
+}
+function compareNormalizedIndexDefinitions(left, right) {
+	const storeCompare = compareStringsByCodeUnit(left.store, right.store);
+	if (storeCompare !== 0) return storeCompare;
+	const nameCompare = compareStringsByCodeUnit(left.name, right.name);
+	if (nameCompare !== 0) return nameCompare;
+	const uniqueCompare = Number(left.unique) - Number(right.unique);
+	if (uniqueCompare !== 0) return uniqueCompare;
+	return compareStringsByCodeUnit(serializeIndexKeyPath(left), serializeIndexKeyPath(right));
+}
+function indexDefinitionIdentity(store, name) {
+	return JSON.stringify([store, name]);
+}
+function findIndexDefinition(defs, store, name) {
+	return defs.find((def) => def.store === store && def.name === name) ?? null;
+}
+function indexesForStore(defs, store) {
+	return defs.filter((def) => def.store === store);
+}
+function encodeIndexMetadataKey(store, name) {
+	return encodeCompoundKeyParts([utf8Encode(store), utf8Encode(name)]);
+}
+function encodeIndexMetadataValue(def) {
+	return utf8Encode(JSON.stringify(toPublicIndexDefinition(def)));
+}
+function decodeIndexMetadataValue(bytes) {
+	let parsed;
+	try {
+		parsed = JSON.parse(fatalDecoder.decode(bytes));
+		const [def] = normalizeIndexDefinitions([parsed]);
+		return def;
+	} catch (error) {
+		throw new SerializationError(`invalid persisted index metadata: ${String(error)}`);
+	}
+}
+function encodeIndexEntryKey(logicalIndexKey, primaryKey) {
+	return encodeCompoundKeyParts([logicalIndexKey, primaryKey]);
+}
+function decodeIndexEntryKey(bytes) {
+	let parts;
+	try {
+		parts = splitCompoundKey(bytes);
+	} catch (error) {
+		throw new SerializationError(`invalid index entry key encoding: ${String(error)}`);
+	}
+	if (parts.length !== 2) throw new SerializationError("invalid index entry key encoding");
+	return {
+		logicalKey: parts[0],
+		primaryKey: parts[1]
+	};
+}
+function indexKeyExactRange(logicalIndexKey) {
+	return prefixRange(encodeCompoundKeyParts([logicalIndexKey]));
+}
+function indexRangeToPhysicalRange(range = {}) {
+	validateIndexRangeShape(range);
+	const physical = {};
+	if (range.reverse !== void 0) physical.reverse = range.reverse;
+	if (range.limit !== void 0) physical.limit = range.limit;
+	if (range.gte) physical.gte = encodeCompoundKeyParts([range.gte]);
+	if (range.gt) {
+		const lower = prefixSuccessor(encodeCompoundKeyParts([range.gt]));
+		if (lower) physical.gte = lower;
+	}
+	if (range.lt) physical.lt = encodeCompoundKeyParts([range.lt]);
+	if (range.lte) {
+		const upper = prefixSuccessor(encodeCompoundKeyParts([range.lte]));
+		if (upper) physical.lt = upper;
+	}
+	return physical;
+}
+function extractLogicalIndexKey(def, valueBytes) {
+	return extractLogicalIndexKeyFromDocument(def, decodeIndexedDocument(valueBytes));
+}
+/**
+* Reuse the decoded document only within one synchronous mutation plan.
+* Lazy decoding preserves validation order. Do not retain the extractor
+* across operations or an await.
+*/
+function createIndexKeyExtractor(valueBytes) {
+	let decoded = false;
+	let documentValue;
+	return (def) => {
+		if (!decoded) {
+			documentValue = decodeIndexedDocument(valueBytes);
+			decoded = true;
+		}
+		return extractLogicalIndexKeyFromDocument(def, documentValue);
+	};
+}
+function extractLogicalIndexKeyFromDocument(def, documentValue) {
+	if (def.compound) {
+		const parts = [];
+		for (const keyPath of def.keyPath) {
+			const resolved = resolveKeyPath(documentValue, keyPath);
+			if (resolved === MISSING) return null;
+			parts.push(encodeDocumentIndexValue(resolved));
+		}
+		return encodeCompoundKeyParts(parts);
+	}
+	const resolved = resolveKeyPath(documentValue, def.keyPath[0]);
+	if (resolved === MISSING) return null;
+	return encodeDocumentIndexValue(resolved);
+}
+function serializeNormalizedIndexDefinitions(defs) {
+	return JSON.stringify(toPublicIndexDefinitions(defs));
+}
+function cloneNormalizedIndexDefinitions(defs) {
+	return defs.map((def) => ({
+		store: def.store,
+		name: def.name,
+		keyPath: [...def.keyPath],
+		compound: def.compound,
+		unique: def.unique,
+		internalStore: def.internalStore
+	}));
+}
+function toPublicIndexDefinitions(defs) {
+	return defs.map(toPublicIndexDefinition);
+}
+function toPublicIndexDefinition(def) {
+	return {
+		store: def.store,
+		name: def.name,
+		keyPath: def.compound ? [...def.keyPath] : def.keyPath[0],
+		unique: def.unique
+	};
+}
+function normalizeIndexKeyPath(value) {
+	if (typeof value === "string") {
+		validateSingleKeyPath(value);
+		return {
+			paths: [value],
+			compound: false
+		};
+	}
+	if (!Array.isArray(value) || value.length === 0 || !value.every((item) => typeof item === "string")) throw new InvalidOpenOptionsError("index keyPath must be a non-empty string or non-empty string[]");
+	for (const path of value) validateSingleKeyPath(path);
+	return {
+		paths: [...value],
+		compound: true
+	};
+}
+function validateSingleKeyPath(value) {
+	if (value.length === 0) throw new InvalidOpenOptionsError("index keyPath strings must be non-empty");
+	if (value.startsWith(".") || value.endsWith(".") || value.includes("..")) throw new InvalidOpenOptionsError(`invalid index keyPath: ${value}`);
+}
+function serializeIndexKeyPath(def) {
+	return def.compound ? `[${def.keyPath.join(",")}]` : def.keyPath[0];
+}
+function makeInternalIndexStoreName(store, name) {
+	const candidate = `${INTERNAL_INDEX_STORE_PREFIX}${base64Url(utf8Encode(store))}:${base64Url(utf8Encode(name))}`;
+	if (encoder.encode(candidate).length <= 255) return candidate;
+	return `${INTERNAL_INDEX_STORE_PREFIX}h:${fnv1a64Hex(utf8Encode(`${store}\u0000${name}`))}`;
+}
+function base64Url(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/u, "");
+}
+function fnv1a64Hex(bytes) {
+	let hash = FNV64_OFFSET;
+	for (const byte of bytes) {
+		hash ^= BigInt(byte);
+		hash = hash * FNV64_PRIME & FNV64_MASK;
+	}
+	return hash.toString(16).padStart(16, "0");
+}
+function decodeIndexedDocument(bytes) {
+	try {
+		return JSON.parse(fatalDecoder.decode(bytes));
+	} catch (error) {
+		throw new SerializationError(`indexed values must be valid UTF-8 JSON: ${String(error)}`);
+	}
+}
+function resolveKeyPath(root, keyPath) {
+	let current = root;
+	for (const segment of keyPath.split(".")) {
+		if (current === null || current === void 0) return MISSING;
+		const target = Object(current);
+		if (!Object.hasOwn(target, segment)) return MISSING;
+		current = Reflect.get(target, segment);
+	}
+	return current;
+}
+function encodeDocumentIndexValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Uint8Array) try {
+		return encodeIndexScalar(value);
+	} catch (error) {
+		if (error instanceof TypeError) throw new SerializationError(`invalid indexed keyPath value: ${error.message}`);
+		throw error;
+	}
+	throw new SerializationError(`indexed keyPath values must resolve to string, number, boolean, null, or Uint8Array; got ${describeValue(value)}`);
+}
+function describeValue(value) {
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+function validateIndexRangeShape(range) {
+	if (range.gt !== void 0 && range.gte !== void 0) throw new TypeError("index range cannot specify both gt and gte");
+	if (range.lt !== void 0 && range.lte !== void 0) throw new TypeError("index range cannot specify both lt and lte");
+}
+//#endregion
+export { StoreExistsError as $, prefixRange as A, packedBinaryListBytes as At, DatabaseClosedError as B, unpackPackedOptionalValues as Bt, compoundKey as C, isWorkerProtocolReadyEnvelope as Ct, indexKey as D, isWorkerProtocolResponseBatchMessage as Dt, encodeIndexScalar as E, isWorkerProtocolRequestMessage as Et, utf8Encode as F, unpackPackedBatchOpKeys as Ft, InvalidRangeError as G, InjectedFailureError as H, compareStringsByCodeUnit as Ht, ChangeFeedCompactedError as I, unpackPackedBatchOps as It, ReadonlyTransactionError as J, KeyTooLargeError as K, ConstraintError as L, unpackPackedBinaryList as Lt, splitCompoundKey as M, prepareWorkerCommandPayload as Mt, u64Key as N, prepareWorkerResponsePayload as Nt, jsonDecode as O, isWorkerProtocolResponseMessage as Ot, utf8Decode as P, serializeWorkerError as Pt, StorageError as Q, CorruptionError as R, unpackPackedBinaryPairKeys as Rt, toPublicIndexDefinitions as S, isWorkerProtocolEnvelope as St, encodeCompoundKeyParts as T, isWorkerProtocolRequestBatchMessage as Tt, InternalError as U, isRecord as Ut, IndexNotFoundError as V, workerProtocolError as Vt, InvalidOpenOptionsError as W, ReservedStoreNameError as X, RecoveryRequiredError as Y, SerializationError as Z, indexRangeToPhysicalRange as _, decodeWorkerCommandPayload as _t, createIndexKeyExtractor as a, UnsupportedPlatformError as at, normalizeIndexDefinitions as b, isAutocommitCommand as bt, decodeIndexedDocument as c, WriteTransactionAlreadyOpenError as ct, encodeIndexMetadataValue as d, WORKER_PROTOCOL_READY as dt, StoreNameTooLongError as et, extractLogicalIndexKey as f, WORKER_PROTOCOL_REQUEST as ft, indexKeyExactRange as g, captureWorkerPayload as gt, indexDefinitionIdentity as h, WORKER_PROTOCOL_RESPONSE_BATCH as ht, compareNormalizedIndexDefinitions as i, UniqueIndexConstraintError as it, prefixSuccessor as j, packedOptionalValues as jt, jsonEncode as k, packedBatchOpsBytes as kt, encodeIndexEntryKey as l, normalizeError as lt, findIndexDefinition as m, WORKER_PROTOCOL_RESPONSE as mt, assertPublicStoreName as n, TransactionClosedError as nt, decodeIndexEntryKey as o, ValueTooLargeError as ot, extractLogicalIndexKeyFromDocument as p, WORKER_PROTOCOL_REQUEST_BATCH as pt, MoyoDbError as q, cloneNormalizedIndexDefinitions as r, TransactionConflictError as rt, decodeIndexMetadataValue as s, VersionError as st, INDEX_METADATA_STORE as t, StoreNotFoundError as tt, encodeIndexMetadataKey as u, MAX_WORKER_BATCH_BYTES as ut, indexesForStore as v, decodeWorkerResponsePayload as vt, compoundKeyRange as w, isWorkerProtocolReadyMessage as wt, serializeNormalizedIndexDefinitions as x, isWorkerCommand as xt, isInternalStoreName as y, deserializeWorkerError as yt, DatabaseBusyError as z, unpackPackedBinaryPairs as zt };
+
+//# sourceMappingURL=indexing-BzmFhWXs.js.map