@moyodb/sdk 1.3.0 → 1.5.0

package/dist/chunks/{indexing-CKtbpaZn.js → indexing-DdpU69Fd.js}

@@ -143,22 +143,21 @@ function deserializeWorkerError(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
-	});
+	if (error.code) defineErrorCode(deserialized, error.code);
 	return deserialized;
 }
 function workerProtocolError(name, message, code = name) {
 	const error = new Error(message);
 	error.name = name;
+	defineErrorCode(error, code);
+	return error;
+}
+function defineErrorCode(error, code) {
 	Object.defineProperty(error, "code", {
 		value: code,
 		enumerable: true,
 		configurable: true
 	});
-	return error;
 }
 function prepareWorkerCommandPayload(command, args) {
 	if (command === "autocommit") {
@@ -263,7 +262,7 @@ function decodeWorkerCommandPayload(command, args) {
 	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");
+			if (!isPackedPayload(keys, PACKED_BINARY_LIST_V1)) throw workerProtocolError("WorkerProtocolError", "invalid packed binary-list argument");
 			return [
 				txId,
 				store,
@@ -274,11 +273,11 @@ function decodeWorkerCommandPayload(command, args) {
 	if (command === "putMany") {
 		const [txId, store, entries, options] = args;
 		if (!Array.isArray(entries)) {
-			if (!isPackedBinaryList(entries)) throw workerProtocolError("WorkerProtocolError", "invalid packed putMany argument");
+			if (!isPackedPayload(entries, PACKED_BINARY_LIST_V1)) throw workerProtocolError("WorkerProtocolError", "invalid packed putMany argument");
 			return [
 				txId,
 				store,
-				unpackBinaryPairs(entries),
+				unpackPutManyPayload(entries, false),
 				options
 			];
 		}
@@ -286,21 +285,21 @@ function decodeWorkerCommandPayload(command, args) {
 	if (command === "applyBatch") {
 		const [txId, store, ops] = args;
 		if (!Array.isArray(ops)) {
-			if (!isPackedBatchOps(ops)) throw workerProtocolError("WorkerProtocolError", "invalid packed batch argument");
+			if (!isPackedPayload(ops, PACKED_BATCH_OPS_V1)) throw workerProtocolError("WorkerProtocolError", "invalid packed batch argument");
 			return [
 				txId,
 				store,
-				unpackBatchOps(ops)
+				unpackBatchPayload(ops, false)
 			];
 		}
 	}
 	return args;
 }
 function packedBinaryListBytes(value) {
-	return isPackedBinaryList(value) ? value.bytes : null;
+	return isPackedPayload(value, PACKED_BINARY_LIST_V1) ? value.bytes : null;
 }
 function packedBatchOpsBytes(value) {
-	return isPackedBatchOps(value) ? value.bytes : null;
+	return isPackedPayload(value, PACKED_BATCH_OPS_V1) ? value.bytes : null;
 }
 function unpackPackedBinaryList(bytes) {
 	return unpackBinaryList({
@@ -309,22 +308,22 @@ function unpackPackedBinaryList(bytes) {
 	});
 }
 function unpackPackedBinaryPairKeys(bytes) {
-	return unpackBinaryPairKeys({
+	return unpackPutManyPayload({
 		__moyodbPacked: PACKED_BINARY_LIST_V1,
 		bytes
-	});
+	}, true);
 }
 function unpackPackedBatchOps(bytes) {
-	return unpackBatchOps({
+	return unpackBatchPayload({
 		__moyodbPacked: PACKED_BATCH_OPS_V1,
 		bytes
-	});
+	}, false);
 }
 function unpackPackedBatchOpKeys(bytes) {
-	return unpackBatchOpKeys({
+	return unpackBatchPayload({
 		__moyodbPacked: PACKED_BATCH_OPS_V1,
 		bytes
-	});
+	}, true);
 }
 function packedOptionalValues(bytes) {
 	return {
@@ -355,13 +354,13 @@ function unpackPackedOptionalValues(bytes) {
 	return items;
 }
 function prepareWorkerResponsePayload(command, result) {
-	if ((command === "scan" || command === "scanByIndex") && (isPackedEngineScanRows(result) || isPackedScanRows(result))) return {
+	if ((command === "scan" || command === "scanByIndex") && (isPackedEngineScanRows(result) || isPackedPayload(result, PACKED_SCAN_ROWS_V1))) return {
 		result,
 		transfer: collectDirectBinaryTransferable(result.bytes)
 	};
 	if (command === "scanPage") {
 		const page = result;
-		if (isRecord(page) && (isPackedEngineScanRows(page.rows) || isPackedScanRows(page.rows))) return {
+		if (isRecord(page) && (isPackedEngineScanRows(page.rows) || isPackedPayload(page.rows, PACKED_SCAN_ROWS_V1))) return {
 			result: page,
 			transfer: collectDirectBinaryTransferable(page.rows.bytes)
 		};
@@ -376,13 +375,13 @@ function prepareWorkerResponsePayload(command, result) {
 			};
 		}
 	}
-	if (command === "getMany" && isPackedOptionalValues(result)) return {
+	if (command === "getMany" && isPackedPayload(result, PACKED_OPTIONAL_VALUES_V1)) return {
 		result,
 		transfer: collectDirectBinaryTransferable(result.bytes)
 	};
 	if (command === "scanByIndexPage") {
 		const page = result;
-		if (isRecord(page) && isPackedScanRows(page.rows)) return {
+		if (isRecord(page) && isPackedPayload(page.rows, PACKED_SCAN_ROWS_V1)) return {
 			result: page,
 			transfer: collectTransferablesForValue(page)
 		};
@@ -444,7 +443,7 @@ function prepareWorkerResponsePayload(command, result) {
 function decodeWorkerResponsePayload(command, result) {
 	if (command === "scanPage") {
 		if (!isRecord(result) || typeof result.done !== "boolean" || typeof result.bytes !== "number" || !Number.isSafeInteger(result.bytes) || result.bytes < 4 || result.cursorId !== void 0 && (typeof result.cursorId !== "number" || !Number.isSafeInteger(result.cursorId) || result.cursorId <= 0) || (result.done ? result.cursorId !== void 0 : result.cursorId === void 0)) throw workerProtocolError("WorkerProtocolError", "invalid scan page response");
-		const rows = isPackedEngineScanRows(result.rows) ? unpackPackedScanRows(result.rows.bytes) : isPackedScanRows(result.rows) ? unpackScanRows(result.rows) : result.rows;
+		const rows = isPackedEngineScanRows(result.rows) ? unpackPackedScanRows(result.rows.bytes) : isPackedPayload(result.rows, PACKED_SCAN_ROWS_V1) ? unpackScanRows(result.rows) : result.rows;
 		if (!Array.isArray(rows)) throw workerProtocolError("WorkerProtocolError", "invalid scan page rows");
 		let bytes = 4;
 		for (const row of rows) {
@@ -460,17 +459,17 @@ function decodeWorkerResponsePayload(command, result) {
 		};
 	}
 	if ((command === "scan" || command === "scanByIndex") && isPackedEngineScanRows(result)) return unpackPackedScanRows(result.bytes);
-	if (command === "getMany" && isPackedNullableBinaryList(result)) return unpackNullableBinaryList(result);
-	if (command === "getMany" && isPackedOptionalValues(result)) return unpackPackedOptionalValues(result.bytes);
+	if (command === "getMany" && isPackedPayload(result, PACKED_NULLABLE_BINARY_LIST_V1)) return unpackNullableBinaryList(result);
+	if (command === "getMany" && isPackedPayload(result, PACKED_OPTIONAL_VALUES_V1)) 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");
+		if (!isRecord(result) || !Array.isArray(result.rows) && !isPackedPayload(result.rows, PACKED_SCAN_ROWS_V1) || 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,
+			rows: isPackedPayload(result.rows, PACKED_SCAN_ROWS_V1) ? unpackScanRows(result.rows) : result.rows,
 			cursor: result.cursor
 		};
 	}
-	if ((command === "scan" || command === "scanByIndex") && isPackedScanRows(result)) return unpackScanRows(result);
+	if ((command === "scan" || command === "scanByIndex") && isPackedPayload(result, PACKED_SCAN_ROWS_V1)) return unpackScanRows(result);
 	if ((command === "scan" || command === "scanByIndex") && !Array.isArray(result)) throw workerProtocolError("WorkerProtocolError", "invalid packed scan response");
 	return result;
 }
@@ -709,7 +708,7 @@ function unpackBinaryList(payload) {
 	if (readOffset !== bytes.byteLength) throw workerProtocolError("WorkerProtocolError", "packed binary-list payload has trailing bytes");
 	return items;
 }
-function unpackBinaryPairs(payload) {
+function unpackPutManyPayload(payload, keysOnly) {
 	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);
@@ -729,38 +728,13 @@ function unpackBinaryPairs(payload) {
 		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)];
+		if (keysOnly) entries[index] = bytes.subarray(readOffset, keyEnd);
+		else 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");
@@ -941,7 +915,7 @@ function packBatchOps(ops) {
 		bytes
 	};
 }
-function unpackBatchOps(payload) {
+function unpackBatchPayload(payload, keysOnly) {
 	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);
@@ -971,69 +945,22 @@ function unpackBatchOps(payload) {
 		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] = {
+		if (keysOnly) ops[index] = {
 			kind: "put",
-			key,
-			value: bytes.subarray(readOffset, valueEnd)
+			key
 		};
-		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] = {
+		else ops[index] = {
 			kind: "put",
-			key
+			key,
+			value: bytes.subarray(readOffset, valueEnd)
 		};
 		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 isPackedPayload(value, tag) {
+	return isRecord(value) && value.__moyodbPacked === tag && value.bytes instanceof Uint8Array;
 }
 function checkedByteCount(count, itemBytes, what) {
 	if (!Number.isSafeInteger(count) || count < 0) throw workerProtocolError("WorkerProtocolError", `${what} count is invalid: ${count}`);
@@ -1247,7 +1174,7 @@ function normalizeError(error) {
 }
 //#endregion
 //#region src/codec.ts
-var encoder$1 = new TextEncoder();
+var encoder = new TextEncoder();
 var decoder = new TextDecoder();
 var jsonDecoder = new TextDecoder("utf-8", { fatal: true });
 var TYPE_NULL = 16;
@@ -1260,8 +1187,10 @@ var COMPOUND_ESCAPE = 0;
 var COMPOUND_ESCAPE_CONT = 255;
 var COMPOUND_TERM = 0;
 var F64_MASK = BigInt("0xffffffffffffffff");
+var sortableNumberBytes = /* @__PURE__ */ new Uint8Array(9);
+var sortableNumberView = new DataView(sortableNumberBytes.buffer);
 function utf8Encode(value) {
-	return encoder$1.encode(value);
+	return encoder.encode(value);
 }
 function utf8Decode(bytes) {
 	return decoder.decode(bytes);
@@ -1287,11 +1216,11 @@ function isCompoundKeyPartList(value) {
 	return Array.isArray(value);
 }
 function indexKey(value) {
-	if (isCompoundKeyPartList(value)) return compoundKey(...value);
+	if (isCompoundKeyPartList(value)) return encodeCompoundKeyList(value);
 	return encodeCompoundKeyPart(value);
 }
 function compoundKey(...parts) {
-	return encodeCompoundBytes(parts.map((part) => encodeCompoundKeyPart(part)));
+	return encodeCompoundKeyList(parts);
 }
 function encodeIndexScalar(value) {
 	return encodeCompoundKeyPart(value);
@@ -1301,37 +1230,55 @@ function encodeCompoundKeyParts(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;
+	let index = 0;
+	while (index < key.length) {
+		const start = index;
+		let length = 0;
+		let closed = false;
+		for (; index < key.length; index += 1) {
+			if (key[index] !== COMPOUND_ESCAPE) {
+				length += 1;
+				continue;
+			}
+			const next = key[index + 1];
+			if (next === COMPOUND_ESCAPE_CONT) {
+				length += 1;
+				index += 1;
+				continue;
+			}
+			if (next === COMPOUND_TERM) {
+				index += 2;
+				closed = true;
+				break;
+			}
+			throw new TypeError("invalid compound key encoding");
 		}
-		if (next === COMPOUND_TERM) {
-			parts.push(Uint8Array.from(current));
-			current.length = 0;
-			index += 1;
-			continue;
+		if (!closed) throw new TypeError("compound key terminated unexpectedly");
+		const part = new Uint8Array(length);
+		let offset = 0;
+		for (let cursor = start; cursor < index - 2; cursor += 1) {
+			const byte = key[cursor];
+			if (byte !== COMPOUND_ESCAPE) {
+				part[offset] = byte;
+				offset += 1;
+				continue;
+			}
+			part[offset] = COMPOUND_ESCAPE;
+			offset += 1;
+			cursor += 1;
 		}
-		throw new TypeError("invalid compound key encoding");
+		parts.push(part);
 	}
-	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;
+	let end = prefix.length;
+	while (end > 0 && prefix[end - 1] === 255) end -= 1;
+	if (end === 0) return null;
+	const out = new Uint8Array(end);
+	out.set(end === prefix.length ? prefix : prefix.subarray(0, end));
+	out[end - 1] += 1;
+	return out;
 }
 function prefixRange(prefix) {
 	const upper = prefixSuccessor(prefix);
@@ -1347,17 +1294,7 @@ 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 (typeof value === "string") return encodeStringKey(value);
 	if (value instanceof Uint8Array) {
 		const out = new Uint8Array(1 + value.length);
 		out[0] = TYPE_BYTES;
@@ -1366,16 +1303,64 @@ function encodeCompoundKeyPart(value) {
 	}
 	throw new TypeError("compound key parts must be string, number, boolean, null, or Uint8Array");
 }
-function encodeCompoundBytes(parts) {
+function encodeCompoundKeyList(parts) {
 	let length = 0;
-	for (const part of parts) {
-		for (const byte of part) length += byte === COMPOUND_ESCAPE ? 2 : 1;
-		length += 2;
+	for (let index = 0; index < parts.length; index += 1) length += compoundPartEncodedLength(parts[index]);
+	const out = new Uint8Array(length);
+	let offset = 0;
+	for (let index = 0; index < parts.length; index += 1) offset = writeCompoundPart$1(out, offset, parts[index]);
+	return out;
+}
+function compoundPartEncodedLength(value) {
+	if (value === null || typeof value === "boolean") return 3;
+	if (typeof value === "number") {
+		writeSortableNumber(sortableNumberView, value);
+		return escapedByteLength(sortableNumberBytes) + 2;
+	}
+	if (typeof value === "string") return 1 + walkUtf8(value, null, 0, true) + 2;
+	if (value instanceof Uint8Array) return 1 + escapedByteLength(value) + 2;
+	throw new TypeError("compound key parts must be string, number, boolean, null, or Uint8Array");
+}
+function writeCompoundPart$1(out, offset, value) {
+	if (value === null) {
+		out[offset] = TYPE_NULL;
+		return writeTerminator(out, offset + 1);
+	}
+	if (typeof value === "boolean") {
+		out[offset] = value ? TYPE_TRUE : TYPE_FALSE;
+		return writeTerminator(out, offset + 1);
+	}
+	if (typeof value === "number") {
+		writeSortableNumber(sortableNumberView, value);
+		return writeTerminator(out, writeEscapedBytes(out, offset, sortableNumberBytes));
+	}
+	if (typeof value === "string") {
+		out[offset] = TYPE_STRING;
+		return writeTerminator(out, walkUtf8(value, out, offset + 1, true));
+	}
+	if (value instanceof Uint8Array) {
+		out[offset] = TYPE_BYTES;
+		return writeTerminator(out, writeEscapedBytes(out, offset + 1, value));
 	}
+	throw new TypeError("compound key parts must be string, number, boolean, null, or Uint8Array");
+}
+function encodeCompoundBytes(parts) {
+	let length = 0;
+	for (let index = 0; index < parts.length; index += 1) length += escapedByteLength(parts[index]) + 2;
 	const out = new Uint8Array(length);
 	let offset = 0;
-	for (const part of parts) {
-		for (const byte of part) if (byte === COMPOUND_ESCAPE) {
+	for (let index = 0; index < parts.length; index += 1) offset = writeTerminator(out, writeEscapedBytes(out, offset, parts[index]));
+	return out;
+}
+function escapedByteLength(bytes) {
+	let extra = 0;
+	for (let index = 0; index < bytes.length; index += 1) if (bytes[index] === COMPOUND_ESCAPE) extra += 1;
+	return bytes.length + extra;
+}
+function writeEscapedBytes(out, offset, bytes) {
+	for (let index = 0; index < bytes.length; index += 1) {
+		const byte = bytes[index];
+		if (byte === COMPOUND_ESCAPE) {
 			out[offset] = COMPOUND_ESCAPE;
 			out[offset + 1] = COMPOUND_ESCAPE_CONT;
 			offset += 2;
@@ -1383,27 +1368,86 @@ function encodeCompoundBytes(parts) {
 			out[offset] = byte;
 			offset += 1;
 		}
-		out[offset] = COMPOUND_TERM;
-		out[offset + 1] = COMPOUND_TERM;
-		offset += 2;
 	}
+	return offset;
+}
+function writeTerminator(out, offset) {
+	out[offset] = COMPOUND_TERM;
+	out[offset + 1] = COMPOUND_TERM;
+	return offset + 2;
+}
+function encodeStringKey(value) {
+	const length = walkUtf8(value, null, 0, false);
+	const out = new Uint8Array(1 + length);
+	out[0] = TYPE_STRING;
+	walkUtf8(value, out, 1, false);
 	return out;
 }
+function walkUtf8(value, out, offset, escapeNul) {
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code <= 127) {
+			if (escapeNul && code === 0) {
+				if (out !== null) {
+					out[offset] = COMPOUND_ESCAPE;
+					out[offset + 1] = COMPOUND_ESCAPE_CONT;
+				}
+				offset += 2;
+			} else {
+				if (out !== null) out[offset] = code;
+				offset += 1;
+			}
+			continue;
+		}
+		if (code <= 2047) {
+			if (out !== null) {
+				out[offset] = 192 | code >> 6;
+				out[offset + 1] = 128 | code & 63;
+			}
+			offset += 2;
+			continue;
+		}
+		if (code >= 55296 && code <= 56319) {
+			const next = value.charCodeAt(index + 1);
+			if (next >= 56320 && next <= 57343) {
+				const point = (code - 55296 << 10) + (next - 56320) + 65536;
+				if (out !== null) {
+					out[offset] = 240 | point >> 18;
+					out[offset + 1] = 128 | point >> 12 & 63;
+					out[offset + 2] = 128 | point >> 6 & 63;
+					out[offset + 3] = 128 | point & 63;
+				}
+				offset += 4;
+				index += 1;
+				continue;
+			}
+		}
+		if (code >= 55296 && code <= 57343) throw new TypeError("compound key string parts must contain valid Unicode scalar values");
+		if (out !== null) {
+			out[offset] = 224 | code >> 12;
+			out[offset + 1] = 128 | code >> 6 & 63;
+			out[offset + 2] = 128 | code & 63;
+		}
+		offset += 3;
+	}
+	return offset;
+}
 function encodeSortableNumber(value) {
+	const bytes = /* @__PURE__ */ new Uint8Array(9);
+	writeSortableNumber(new DataView(bytes.buffer), value);
+	return bytes;
+}
+function writeSortableNumber(view, 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");
@@ -1486,37 +1530,50 @@ function decodeIndexMetadataValue(bytes) {
 	}
 }
 function encodeIndexEntryKey(logicalIndexKey, primaryKey) {
-	return encodeCompoundKeyParts([logicalIndexKey, primaryKey]);
+	const out = new Uint8Array(compoundEncodedLength(logicalIndexKey) + compoundEncodedLength(primaryKey));
+	writeCompoundPart(out, writeCompoundPart(out, 0, logicalIndexKey), primaryKey);
+	return out;
 }
 function decodeIndexEntryKey(bytes) {
-	let parts;
 	try {
-		parts = splitCompoundKey(bytes);
+		return decodeTwoPartIndexKey(bytes);
 	} catch (error) {
+		if (error instanceof SerializationError) throw 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]));
+	const gte = encodeCompoundPrefix(logicalIndexKey);
+	const lt = advanceEncodedPrefix(gte.slice());
+	return lt ? {
+		gte,
+		lt
+	} : { gte };
+}
+/** WASM `usize` is 32-bit, so this is the largest limit the engine can accept. */
+var MAX_ENGINE_SCAN_LIMIT = 4294967295;
+/**
+* Bounds and limits follow the engine `RangeSpec` contract.
+* Conflicting bounds and a limit the engine cannot store are `InvalidRangeError`.
+*/
+function assertValidScanRange(range = {}) {
+	if (range.gt !== void 0 && range.gte !== void 0) throw new InvalidRangeError("range cannot include both gt and gte");
+	if (range.lt !== void 0 && range.lte !== void 0) throw new InvalidRangeError("range cannot include both lt and lte");
+	if (range.limit !== void 0 && (!Number.isSafeInteger(range.limit) || range.limit < 0 || range.limit > 4294967295)) throw new InvalidRangeError("limit must be an integer between 0 and 4294967295");
 }
 function indexRangeToPhysicalRange(range = {}) {
-	validateIndexRangeShape(range);
+	assertValidScanRange(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.gte) physical.gte = encodeCompoundPrefix(range.gte);
 	if (range.gt) {
-		const lower = prefixSuccessor(encodeCompoundKeyParts([range.gt]));
+		const lower = advanceEncodedPrefix(encodeCompoundPrefix(range.gt));
 		if (lower) physical.gte = lower;
 	}
-	if (range.lt) physical.lt = encodeCompoundKeyParts([range.lt]);
+	if (range.lt) physical.lt = encodeCompoundPrefix(range.lt);
 	if (range.lte) {
-		const upper = prefixSuccessor(encodeCompoundKeyParts([range.lte]));
+		const upper = advanceEncodedPrefix(encodeCompoundPrefix(range.lte));
 		if (upper) physical.lt = upper;
 	}
 	return physical;
@@ -1602,7 +1659,7 @@ function serializeIndexKeyPath(def) {
 }
 function makeInternalIndexStoreName(store, name) {
 	const candidate = `${INTERNAL_INDEX_STORE_PREFIX}${base64Url(utf8Encode(store))}:${base64Url(utf8Encode(name))}`;
-	if (encoder.encode(candidate).length <= 255) return candidate;
+	if (utf8Encode(candidate).length <= 255) return candidate;
 	return `${INTERNAL_INDEX_STORE_PREFIX}h:${fnv1a64Hex(utf8Encode(`${store}\u0000${name}`))}`;
 }
 function base64Url(bytes) {
@@ -1647,11 +1704,113 @@ 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");
+var INDEX_KEY_ESCAPE = 0;
+var INDEX_KEY_ESCAPE_CONT = 255;
+var INDEX_KEY_TERM = 0;
+function compoundEncodedLength(part) {
+	let zeros = 0;
+	const length = part.length;
+	for (let index = 0; index < length; index += 1) if (part[index] === INDEX_KEY_ESCAPE) zeros += 1;
+	return length + zeros + 2;
+}
+function writeCompoundPart(out, offset, part) {
+	const length = part.length;
+	for (let index = 0; index < length; index += 1) {
+		const byte = part[index];
+		if (byte === INDEX_KEY_ESCAPE) {
+			out[offset] = INDEX_KEY_ESCAPE;
+			out[offset + 1] = INDEX_KEY_ESCAPE_CONT;
+			offset += 2;
+		} else {
+			out[offset] = byte;
+			offset += 1;
+		}
+	}
+	out[offset] = INDEX_KEY_TERM;
+	out[offset + 1] = INDEX_KEY_TERM;
+	return offset + 2;
+}
+function encodeCompoundPrefix(part) {
+	const out = new Uint8Array(compoundEncodedLength(part));
+	writeCompoundPart(out, 0, part);
+	return out;
+}
+function advanceEncodedPrefix(prefix) {
+	for (let index = prefix.length - 1; index >= 0; index -= 1) if (prefix[index] !== 255) {
+		prefix[index] += 1;
+		return index + 1 === prefix.length ? prefix : prefix.subarray(0, index + 1);
+	}
+	return null;
+}
+function decodeTwoPartIndexKey(bytes) {
+	const cursor = {
+		unescaped: 0,
+		end: 0
+	};
+	if (!readCompoundPart(bytes, 0, cursor)) throw new SerializationError("invalid index entry key encoding");
+	const logicalLength = cursor.unescaped;
+	const primaryStart = cursor.end;
+	if (!readCompoundPart(bytes, primaryStart, cursor)) throw new SerializationError("invalid index entry key encoding");
+	const primaryLength = cursor.unescaped;
+	let end = cursor.end;
+	if (end !== bytes.length) for (;;) {
+		if (!readCompoundPart(bytes, end, cursor)) throw new SerializationError("invalid index entry key encoding");
+		if (cursor.end <= end) throw new TypeError("invalid compound key encoding");
+		end = cursor.end;
+		if (end === bytes.length) throw new SerializationError("invalid index entry key encoding");
+	}
+	const logicalKey = new Uint8Array(logicalLength);
+	const primaryKey = new Uint8Array(primaryLength);
+	copyUnescapedPart(bytes, 0, logicalKey);
+	copyUnescapedPart(bytes, primaryStart, primaryKey);
+	return {
+		logicalKey,
+		primaryKey
+	};
+}
+function readCompoundPart(bytes, start, cursor) {
+	if (start >= bytes.length) return false;
+	let unescaped = 0;
+	for (let index = start; index < bytes.length; index += 1) {
+		if (bytes[index] !== INDEX_KEY_ESCAPE) {
+			unescaped += 1;
+			continue;
+		}
+		const next = bytes[index + 1];
+		if (next === INDEX_KEY_ESCAPE_CONT) {
+			unescaped += 1;
+			index += 1;
+			continue;
+		}
+		if (next === INDEX_KEY_TERM) {
+			cursor.unescaped = unescaped;
+			cursor.end = index + 2;
+			return true;
+		}
+		throw new TypeError("invalid compound key encoding");
+	}
+	throw new TypeError("compound key terminated unexpectedly");
+}
+function copyUnescapedPart(bytes, start, out) {
+	const needed = out.length;
+	let offset = 0;
+	for (let index = start; offset < needed; index += 1) {
+		const byte = bytes[index];
+		if (byte !== INDEX_KEY_ESCAPE) {
+			out[offset] = byte;
+			offset += 1;
+			continue;
+		}
+		if (bytes[index + 1] === INDEX_KEY_ESCAPE_CONT) {
+			out[offset] = INDEX_KEY_ESCAPE;
+			offset += 1;
+			index += 1;
+			continue;
+		}
+		return;
+	}
 }
 //#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, serializeWorkerError as Ft, InvalidRangeError as G, isRecord as Gt, InjectedFailureError as H, workerProtocolError as Ht, ChangeFeedCompactedError as I, unpackPackedBatchOpKeys as It, ReadonlyTransactionError as J, KeyTooLargeError as K, ConstraintError as L, unpackPackedBatchOps as Lt, splitCompoundKey as M, packedScanRows as Mt, u64Key as N, prepareWorkerCommandPayload as Nt, jsonDecode as O, isWorkerProtocolResponseMessage as Ot, utf8Decode as P, prepareWorkerResponsePayload as Pt, StorageError as Q, CorruptionError as R, unpackPackedBinaryList as Rt, toPublicIndexDefinitions as S, isWorkerProtocolEnvelope as St, encodeCompoundKeyParts as T, isWorkerProtocolRequestBatchMessage as Tt, InternalError as U, clampTimerDelayMs as Ut, IndexNotFoundError as V, unpackPackedScanRows as Vt, InvalidOpenOptionsError as W, compareStringsByCodeUnit as Wt, 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, unpackPackedBinaryPairKeys as zt };
+export { SerializationError as $, jsonDecode as A, isWorkerProtocolResponseMessage as At, CorruptionError as B, unpackPackedBinaryList as Bt, serializeNormalizedIndexDefinitions as C, isWorkerCommand as Ct, encodeCompoundKeyParts as D, isWorkerProtocolRequestBatchMessage as Dt, compoundKeyRange as E, isWorkerProtocolReadyMessage as Et, u64Key as F, prepareWorkerCommandPayload as Ft, InternalError as G, clampTimerDelayMs as Gt, DatabaseClosedError as H, unpackPackedOptionalValues as Ht, utf8Decode as I, prepareWorkerResponsePayload as It, KeyTooLargeError as J, InvalidOpenOptionsError as K, compareStringsByCodeUnit as Kt, utf8Encode as L, serializeWorkerError as Lt, prefixRange as M, packedBinaryListBytes as Mt, prefixSuccessor as N, packedOptionalValues as Nt, encodeIndexScalar as O, isWorkerProtocolRequestMessage as Ot, splitCompoundKey as P, packedScanRows as Pt, ReservedStoreNameError as Q, ChangeFeedCompactedError as R, unpackPackedBatchOpKeys as Rt, normalizeIndexDefinitions as S, isAutocommitCommand as St, compoundKey as T, isWorkerProtocolReadyEnvelope as Tt, IndexNotFoundError as U, unpackPackedScanRows as Ut, DatabaseBusyError as V, unpackPackedBinaryPairKeys as Vt, InjectedFailureError as W, workerProtocolError as Wt, ReadonlyTransactionError as X, MoyoDbError as Y, RecoveryRequiredError as Z, indexDefinitionIdentity as _, WORKER_PROTOCOL_RESPONSE_BATCH as _t, cloneNormalizedIndexDefinitions as a, TransactionConflictError as at, indexesForStore as b, decodeWorkerResponsePayload as bt, decodeIndexEntryKey as c, ValueTooLargeError as ct, encodeIndexEntryKey as d, normalizeError as dt, StorageError as et, encodeIndexMetadataKey as f, MAX_WORKER_BATCH_BYTES as ft, findIndexDefinition as g, WORKER_PROTOCOL_RESPONSE as gt, extractLogicalIndexKeyFromDocument as h, WORKER_PROTOCOL_REQUEST_BATCH as ht, assertValidScanRange as i, TransactionClosedError as it, jsonEncode as j, packedBatchOpsBytes as jt, indexKey as k, isWorkerProtocolResponseBatchMessage as kt, decodeIndexMetadataValue as l, VersionError as lt, extractLogicalIndexKey as m, WORKER_PROTOCOL_REQUEST as mt, MAX_ENGINE_SCAN_LIMIT as n, StoreNameTooLongError as nt, compareNormalizedIndexDefinitions as o, UniqueIndexConstraintError as ot, encodeIndexMetadataValue as p, WORKER_PROTOCOL_READY as pt, InvalidRangeError as q, isRecord as qt, assertPublicStoreName as r, StoreNotFoundError as rt, createIndexKeyExtractor as s, UnsupportedPlatformError as st, INDEX_METADATA_STORE as t, StoreExistsError as tt, decodeIndexedDocument as u, WriteTransactionAlreadyOpenError as ut, indexKeyExactRange as v, captureWorkerPayload as vt, toPublicIndexDefinitions as w, isWorkerProtocolEnvelope as wt, isInternalStoreName as x, deserializeWorkerError as xt, indexRangeToPhysicalRange as y, decodeWorkerCommandPayload as yt, ConstraintError as z, unpackPackedBatchOps as zt };
 
-//# sourceMappingURL=indexing-CKtbpaZn.js.map
+//# sourceMappingURL=indexing-DdpU69Fd.js.map