@moyodb/sdk 1.4.0 → 1.5.0

package/dist/node-engine.js

@@ -1,4 +1,4 @@
-import { At as packedBinaryListBytes, Bt as unpackPackedOptionalValues, Et as isWorkerProtocolRequestMessage, F as utf8Encode, Ft as serializeWorkerError, Gt as isRecord, Ht as workerProtocolError, It as unpackPackedBatchOpKeys, Lt as unpackPackedBatchOps, Mt as packedScanRows, Pt as prepareWorkerResponsePayload, Rt as unpackPackedBinaryList, S as toPublicIndexDefinitions, St as isWorkerProtocolEnvelope, Tt as isWorkerProtocolRequestBatchMessage, Ut as clampTimerDelayMs, Vt as unpackPackedScanRows, _ as indexRangeToPhysicalRange, _t as decodeWorkerCommandPayload, a as createIndexKeyExtractor, b as normalizeIndexDefinitions, bt as isAutocommitCommand, c as decodeIndexedDocument, d as encodeIndexMetadataValue, dt as WORKER_PROTOCOL_READY, f as extractLogicalIndexKey, g as indexKeyExactRange, gt as captureWorkerPayload, ht as WORKER_PROTOCOL_RESPONSE_BATCH, i as compareNormalizedIndexDefinitions, jt as packedOptionalValues, kt as packedBatchOpsBytes, l as encodeIndexEntryKey, m as findIndexDefinition, mt as WORKER_PROTOCOL_RESPONSE, o as decodeIndexEntryKey, p as extractLogicalIndexKeyFromDocument, r as cloneNormalizedIndexDefinitions, s as decodeIndexMetadataValue, t as INDEX_METADATA_STORE, u as encodeIndexMetadataKey, xt as isWorkerCommand, y as isInternalStoreName, zt as unpackPackedBinaryPairKeys } from "./chunks/indexing-B0duqlUs.js";
+import { Bt as unpackPackedBinaryList, Ct as isWorkerCommand, Dt as isWorkerProtocolRequestBatchMessage, Gt as clampTimerDelayMs, Ht as unpackPackedOptionalValues, It as prepareWorkerResponsePayload, L as utf8Encode, Lt as serializeWorkerError, Mt as packedBinaryListBytes, Nt as packedOptionalValues, Ot as isWorkerProtocolRequestMessage, Pt as packedScanRows, Rt as unpackPackedBatchOpKeys, S as normalizeIndexDefinitions, St as isAutocommitCommand, Ut as unpackPackedScanRows, Vt as unpackPackedBinaryPairKeys, Wt as workerProtocolError, _t as WORKER_PROTOCOL_RESPONSE_BATCH, a as cloneNormalizedIndexDefinitions, c as decodeIndexEntryKey, d as encodeIndexEntryKey, f as encodeIndexMetadataKey, g as findIndexDefinition, gt as WORKER_PROTOCOL_RESPONSE, h as extractLogicalIndexKeyFromDocument, i as assertValidScanRange, jt as packedBatchOpsBytes, l as decodeIndexMetadataValue, m as extractLogicalIndexKey, o as compareNormalizedIndexDefinitions, p as encodeIndexMetadataValue, pt as WORKER_PROTOCOL_READY, qt as isRecord, s as createIndexKeyExtractor, t as INDEX_METADATA_STORE, u as decodeIndexedDocument, v as indexKeyExactRange, vt as captureWorkerPayload, w as toPublicIndexDefinitions, wt as isWorkerProtocolEnvelope, x as isInternalStoreName, y as indexRangeToPhysicalRange, yt as decodeWorkerCommandPayload, zt as unpackPackedBatchOps } from "./chunks/indexing-DdpU69Fd.js";
 //#region src/worker-server.ts
 /** The first argument identifies the transaction lane. */
 var TRANSACTION_COMMANDS = /* @__PURE__ */ new Set([
@@ -128,10 +128,20 @@ var ResponseQueue = class {
 	constructor(scope) {
 		this.scope = scope;
 	}
-	enqueue = (response, transfer = []) => {
+	enqueue(response, transfer = [], flushNow = false) {
 		if (this.closed) return;
-		const captured = captureWorkerPayload(response, transfer);
-		if (this.queued.length > 0 && this.queuedBytes + captured.byteLength > 1048576) this.flush();
+		const byteLength = payloadBytes(response);
+		if (this.queued.length > 0 && this.queuedBytes + byteLength > 1048576) this.flush();
+		if (flushNow || this.queued.length + 1 >= 128 || this.queuedBytes + byteLength >= 1048576) {
+			this.queued.push({
+				response,
+				transfer
+			});
+			this.queuedBytes += byteLength;
+			this.flush();
+			return;
+		}
+		const captured = snapshotQueuedPayload(response, transfer);
 		this.queued.push({
 			response: captured.value,
 			transfer: captured.transfer
@@ -148,8 +158,7 @@ var ResponseQueue = class {
 				this.flushChannel.port2.postMessage(null);
 			});
 		}
-		if (this.queued.length >= 128 || this.queuedBytes >= 1048576) this.flush();
-	};
+	}
 	close() {
 		this.closed = true;
 		this.queued = [];
@@ -190,9 +199,8 @@ function exposeWorkerApi(api, scope = self) {
 		if (isWorkerProtocolRequestBatchMessage(event.data)) {
 			let remaining = event.data.requests.length;
 			const respond = (response, transfer) => {
-				responses.enqueue(response, transfer);
 				remaining -= 1;
-				if (remaining === 0) responses.flush();
+				responses.enqueue(response, transfer, remaining === 0);
 			};
 			for (const request of event.data.requests) dispatchWorkerRequest(scope, api, scheduler, request, respond);
 			return;
@@ -316,6 +324,203 @@ function postWorkerResponse(scope, response, transfer = []) {
 	} catch {}
 	scope.postMessage(response);
 }
+var STANDARD_VIEW_CONSTRUCTORS = /* @__PURE__ */ new Set([
+	DataView,
+	Uint8Array,
+	Uint8ClampedArray,
+	Uint16Array,
+	Uint32Array,
+	Int8Array,
+	Int16Array,
+	Int32Array,
+	Float32Array,
+	Float64Array,
+	BigInt64Array,
+	BigUint64Array
+]);
+/**
+* Freeze a queued payload so the later postMessage is its only structured clone.
+* Listed buffers move now. Other ArrayBuffers are copied. SharedArrayBuffers stay shared.
+*/
+function snapshotQueuedPayload(value, transfer) {
+	const moving = /* @__PURE__ */ new Set();
+	for (const item of transfer) {
+		if (!(item instanceof ArrayBuffer) || isResizableBuffer(item)) return captureWorkerPayload(value, transfer);
+		moving.add(item);
+	}
+	const geometries = /* @__PURE__ */ new Map();
+	if (!isPlainPayload(value, geometries, /* @__PURE__ */ new WeakSet())) return captureWorkerPayload(value, transfer);
+	const relocated = /* @__PURE__ */ new Map();
+	for (const buffer of moving) relocated.set(buffer, moveArrayBuffer(buffer));
+	const owned = [];
+	const seen = /* @__PURE__ */ new WeakMap();
+	const cloneValue = (item) => {
+		if (item === null || typeof item !== "object") return item;
+		const existing = seen.get(item);
+		if (existing !== void 0) return existing;
+		if (typeof SharedArrayBuffer !== "undefined" && item instanceof SharedArrayBuffer) {
+			seen.set(item, item);
+			return item;
+		}
+		if (item instanceof ArrayBuffer) {
+			const next = relocated.get(item) ?? item.slice(0);
+			seen.set(item, next);
+			owned.push(next);
+			return next;
+		}
+		if (ArrayBuffer.isView(item)) {
+			const geometry = geometries.get(item);
+			if (!geometry) throw workerProtocolError("WorkerProtocolError", "worker payload could not be queued");
+			const buffer = item.buffer;
+			const out = retargetView(item, typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer ? buffer : cloneValue(buffer), geometry);
+			seen.set(item, out);
+			return out;
+		}
+		if (Array.isArray(item)) {
+			const out = new Array(item.length);
+			seen.set(item, out);
+			for (let index = 0; index < item.length; index += 1) if (index in item) out[index] = cloneValue(item[index]);
+			return out;
+		}
+		const out = Object.getPrototypeOf(item) === null ? Object.create(null) : {};
+		seen.set(item, out);
+		const record = item;
+		for (const key in record) if (Object.prototype.hasOwnProperty.call(record, key)) out[key] = cloneValue(record[key]);
+		return out;
+	};
+	const cloned = cloneValue(value);
+	return {
+		value: cloned,
+		transfer: owned,
+		byteLength: payloadBytes(cloned)
+	};
+}
+function payloadBytes(value) {
+	let byteLength = 0;
+	const seen = /* @__PURE__ */ new WeakSet();
+	const visit = (item) => {
+		if (!Number.isFinite(byteLength)) return;
+		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) 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)) {
+			if (Object.getPrototypeOf(item) !== Array.prototype || hasExtraKeys(item)) {
+				byteLength = Number.POSITIVE_INFINITY;
+				return;
+			}
+			for (let index = 0; index < item.length; index += 1) {
+				const descriptor = Object.getOwnPropertyDescriptor(item, String(index));
+				if (descriptor && !("value" in descriptor)) {
+					byteLength = Number.POSITIVE_INFINITY;
+					return;
+				}
+				visit(descriptor?.value);
+			}
+		} 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)) {
+				const descriptor = Object.getOwnPropertyDescriptor(record, key);
+				if (key === "__proto__" || !descriptor || !("value" in descriptor)) {
+					byteLength = Number.POSITIVE_INFINITY;
+					return;
+				}
+				byteLength += 8 + key.length * 2;
+				visit(descriptor.value);
+			}
+		}
+	};
+	visit(value);
+	return byteLength;
+}
+function isPlainPayload(value, geometries, seen) {
+	if (typeof value === "function" || typeof value === "symbol") return false;
+	if (value === null || typeof value !== "object") return true;
+	if (seen.has(value)) return true;
+	seen.add(value);
+	if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) return !isResizableBuffer(value);
+	if (value instanceof ArrayBuffer) return !isResizableBuffer(value);
+	if (ArrayBuffer.isView(value)) {
+		if (!isStandardView(value)) return false;
+		const buffer = value.buffer;
+		if (typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer) {
+			if (isResizableBuffer(buffer)) return false;
+			geometries.set(value, viewGeometry(value));
+			return true;
+		}
+		if (!(buffer instanceof ArrayBuffer) || isResizableBuffer(buffer)) return false;
+		geometries.set(value, viewGeometry(value));
+		return true;
+	}
+	if (value instanceof Map || value instanceof Set || value instanceof Date || value instanceof RegExp) return false;
+	if (Array.isArray(value)) {
+		if (hasExtraKeys(value) || hasEnumerableSymbols(value)) return false;
+		for (const child of value) if (!isPlainPayload(child, geometries, seen)) return false;
+		return true;
+	}
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return false;
+	if (hasEnumerableSymbols(value)) return false;
+	const record = value;
+	for (const key in record) if (Object.prototype.hasOwnProperty.call(record, key) && !isPlainPayload(record[key], geometries, seen)) return false;
+	return true;
+}
+function hasExtraKeys(value) {
+	const record = value;
+	for (const key in record) {
+		if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+		const index = Number(key);
+		if (!Number.isInteger(index) || index < 0 || index >= value.length || String(index) !== key) return true;
+	}
+	return false;
+}
+function hasEnumerableSymbols(value) {
+	for (const symbol of Object.getOwnPropertySymbols(value)) if (Object.prototype.propertyIsEnumerable.call(value, symbol)) return true;
+	return false;
+}
+function isStandardView(view) {
+	return STANDARD_VIEW_CONSTRUCTORS.has(view.constructor);
+}
+function viewGeometry(view) {
+	if (view instanceof DataView) return {
+		offset: view.byteOffset,
+		length: view.byteLength,
+		dataView: true
+	};
+	return {
+		offset: view.byteOffset,
+		length: view.length,
+		dataView: false
+	};
+}
+function retargetView(view, buffer, geometry) {
+	if (geometry.dataView) return new DataView(buffer, geometry.offset, geometry.length);
+	const Typed = view.constructor;
+	return new Typed(buffer, geometry.offset, geometry.length);
+}
+function moveArrayBuffer(buffer) {
+	const movable = buffer;
+	if (typeof movable.transfer === "function") return movable.transfer();
+	return structuredClone(buffer, { transfer: [buffer] });
+}
+function isResizableBuffer(buffer) {
+	return buffer.resizable === true;
+}
 //#endregion
 //#region src/snappy.ts
 var BLOCK_SIZE = 65536;
@@ -543,6 +748,25 @@ function writeEnvelope(out, offset, magic, kindTag, rawLength, payload) {
 	view.setUint32(10, rawLength, true);
 	view.setUint32(14, checksum, true);
 }
+function writeEnvelopeHeader(out, magic, kindTag, rawLength, payload) {
+	const checksum = crc32(payload);
+	out.set(magic);
+	out[8] = ENVELOPE_VERSION;
+	out[9] = kindTag;
+	const view = new DataView(out.buffer, out.byteOffset, ENVELOPE_HEADER_SIZE);
+	view.setUint32(10, rawLength, true);
+	view.setUint32(14, checksum, true);
+}
+function envelopeFromChunks(magic, kindTag, rawLength, chunks, totalBytes) {
+	const out = new Uint8Array(ENVELOPE_HEADER_SIZE + totalBytes);
+	let offset = ENVELOPE_HEADER_SIZE;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	writeEnvelopeHeader(out, magic, kindTag, rawLength, out.subarray(ENVELOPE_HEADER_SIZE));
+	return out;
+}
 function compressionIsProfitable(rawLength, compressedLength) {
 	return (compressedLength + ENVELOPE_HEADER_SIZE) * 100 <= rawLength * 90;
 }
@@ -555,10 +779,6 @@ function snappyPreflightIsProfitable(value) {
 	}
 	return compressionIsProfitable(STORE_VALUE_COMPRESSION_PREFLIGHT_WINDOW_BYTES * 3, compressedLength);
 }
-function buildStoreRecord(input, compressed, compression) {
-	if (!compressionIsProfitable(input.byteLength, compressed.byteLength)) return buildEnvelope(STORE_RECORD_MAGIC, COMPRESSION_TAG_NONE, input.byteLength, input);
-	return buildEnvelope(STORE_RECORD_MAGIC, compressionTag(compression), input.byteLength, compressed);
-}
 function validateStoreValueLength(value) {
 	if (value.byteLength > MAX_DECOMPRESSED_STORE_VALUE_BYTES) throw namedError("ValueTooLargeError", `value has ${value.byteLength} bytes, exceeding the ${MAX_DECOMPRESSED_STORE_VALUE_BYTES} byte limit`);
 }
@@ -623,19 +843,41 @@ function readEnvelopeHeader(magic, bytes, strict = true) {
 		payloadChecksum: view.getUint32(14, true)
 	};
 }
-async function compressBytes(data, kind) {
+async function collectCompressed(input, kind, stopAtBytes) {
 	ensureCompressionRuntime();
 	let stream;
 	try {
-		stream = byteStream(data).pipeThrough(new CompressionStream(kind));
+		stream = byteStream(input).pipeThrough(new CompressionStream(kind));
 	} catch {
 		throw compressionRuntimeUnavailable();
 	}
+	const reader = stream.getReader();
+	const chunks = [];
+	let totalBytes = 0;
+	let stopped = false;
 	try {
-		return new Uint8Array(await new Response(stream).arrayBuffer());
+		for (let next = await reader.read(); !next.done; next = await reader.read()) {
+			const part = next.value;
+			totalBytes += part.byteLength;
+			if (stopAtBytes !== void 0 && totalBytes >= stopAtBytes) {
+				stopped = true;
+				await reader.cancel("compressed output is not smaller than the raw payload");
+				break;
+			}
+			chunks.push(part);
+		}
 	} catch (error) {
-		throw namedError("InternalError", `failed to compress bytes with ${kind}: ${String(error)}`);
+		if (!stopped) throw namedError("InternalError", `failed to compress bytes with ${kind}: ${String(error)}`);
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
 	}
+	if (stopped || stopAtBytes !== void 0 && totalBytes >= stopAtBytes) return null;
+	return {
+		chunks,
+		totalBytes
+	};
 }
 async function decompressBytes(data, kind, label, maxOutputBytes) {
 	if (kind === "snappy") return decodeSnappy(data, maxOutputBytes ?? MAX_DECOMPRESSED_STORE_VALUE_BYTES, maxOutputBytes);
@@ -689,6 +931,7 @@ function compressionFromStoreFlags(flags) {
 	}
 }
 async function encodeStoreValueRecord(value, compression) {
+	validateStoreValueLength(value);
 	if (compression === false) return value;
 	if (compression === "snappy") {
 		const record = prepareFastStoreValueRecord(value, compression);
@@ -696,10 +939,16 @@ async function encodeStoreValueRecord(value, compression) {
 		writePreparedStoreValueRecord(record, output, 0);
 		return output;
 	}
-	validateStoreValueLength(value);
 	if (value.byteLength < 1024) return buildEnvelope(STORE_RECORD_MAGIC, COMPRESSION_TAG_NONE, value.byteLength, value);
-	const input = copyBytes(value);
-	return buildStoreRecord(input, await compressBytes(input, compression), compression);
+	const stored = new Uint8Array(ENVELOPE_HEADER_SIZE + value.byteLength);
+	const payload = stored.subarray(ENVELOPE_HEADER_SIZE);
+	payload.set(value);
+	const compressed = await collectCompressed(payload, compression, payload.byteLength);
+	if (compressed === null || !compressionIsProfitable(payload.byteLength, compressed.totalBytes)) {
+		writeEnvelopeHeader(stored, STORE_RECORD_MAGIC, COMPRESSION_TAG_NONE, payload.byteLength, payload);
+		return stored;
+	}
+	return envelopeFromChunks(STORE_RECORD_MAGIC, compressionTag(compression), payload.byteLength, compressed.chunks, compressed.totalBytes);
 }
 async function decodeStoreValueRecord(value, options) {
 	const header = readEnvelopeHeader(STORE_RECORD_MAGIC, value, options.strict);
@@ -735,9 +984,11 @@ async function decodeStoreValueRecord(value, options) {
 async function wrapSnapshotWithCompression(snapshot, compression) {
 	if (compression === false) return snapshot;
 	if (!["gzip", "deflate"].includes(compression)) throw namedError("InternalError", `unsupported snapshot compression kind: ${String(compression)}`);
+	if (snapshot.byteLength > MAX_DECOMPRESSED_SNAPSHOT_BYTES) throw namedError("SerializationError", `snapshot has ${snapshot.byteLength} bytes, exceeding the ${MAX_DECOMPRESSED_SNAPSHOT_BYTES} byte limit`);
 	const input = copyBytes(snapshot);
-	const compressed = await compressBytes(input, compression);
-	return buildEnvelope(SNAPSHOT_EXPORT_MAGIC, compressionTag(compression), input.byteLength, compressed);
+	const compressed = await collectCompressed(input, compression);
+	if (compressed === null) throw namedError("InternalError", `failed to compress bytes with ${compression}`);
+	return envelopeFromChunks(SNAPSHOT_EXPORT_MAGIC, compressionTag(compression), input.byteLength, compressed.chunks, compressed.totalBytes);
 }
 async function unwrapSnapshotCompression(snapshot) {
 	const header = readEnvelopeHeader(SNAPSHOT_EXPORT_MAGIC, snapshot);
@@ -773,6 +1024,7 @@ function toWasmPutOptions(options) {
 	};
 }
 function toWasmRange(range) {
+	assertValidScanRange(range);
 	const normalized = {};
 	if (range.gt !== void 0) normalized.gt = range.gt;
 	if (range.gte !== void 0) normalized.gte = range.gte;
@@ -788,6 +1040,7 @@ var MAX_ENGINE_KEY_BYTES = 1024;
 var MAX_PACKED_BYTES = 4294967295;
 var INDEX_PUT_BATCH_ROWS = 64;
 var INDEX_PUT_BATCH_BYTES = 4194304;
+var MAX_PLAIN_STORE_VALUE_BYTES = 8388608;
 var INDEX_SCAN_PAGE_ROWS = 256;
 var INDEX_SCAN_PAGE_BYTES = 8389662;
 var INDEX_SCAN_RAW_CHUNK_ROWS = 512;
@@ -933,6 +1186,29 @@ function rangesEqual(left, right) {
 	}
 	return left.reverse === right.reverse && left.limit === right.limit;
 }
+function sameBound(cached, next) {
+	if (cached === void 0 || next === void 0) return cached === next;
+	return bytesEqual(cached, next);
+}
+function copyBound(value) {
+	return value === void 0 ? void 0 : value.slice();
+}
+function compoundEntryKeyLength(logicalKey, primaryKey) {
+	return escapedPartLength(logicalKey) + escapedPartLength(primaryKey);
+}
+function escapedPartLength(part) {
+	let length = 2;
+	for (let index = 0; index < part.length; index += 1) length += part[index] === 0 ? 2 : 1;
+	return length;
+}
+function limitPlainStoreValue(value) {
+	if (value.byteLength > MAX_PLAIN_STORE_VALUE_BYTES) {
+		const error = /* @__PURE__ */ new Error(`stored value has ${value.byteLength} bytes, exceeding the ${MAX_PLAIN_STORE_VALUE_BYTES} byte limit`);
+		error.name = "ValueTooLargeError";
+		throw error;
+	}
+	return value;
+}
 function normalizeWasmBytes(value) {
 	if (value instanceof Uint8Array) return value.byteOffset === 0 && value.byteLength === value.buffer.byteLength ? value : value.slice();
 	return new Uint8Array(value);
@@ -1090,6 +1366,9 @@ var DbWorker = class {
 	*/
 	txIndexSchemas = /* @__PURE__ */ new Map();
 	indexesBySchema = /* @__PURE__ */ new WeakMap();
+	/** Readonly scans reuse a resolved index; readwrite scans recheck so TTL staging still runs. */
+	readonlyIndexCache = /* @__PURE__ */ new Map();
+	indexBoundCache = null;
 	txEnsuredRawStores = /* @__PURE__ */ new Map();
 	txIndexSchemaChanged = /* @__PURE__ */ new Set();
 	txStoreCompression = /* @__PURE__ */ new Map();
@@ -1328,9 +1607,14 @@ var DbWorker = class {
 		return Promise.resolve(this.withEngine((engine) => engine.has(toWasmU64(txId), store, key)));
 	}
 	async put(txId, store, key, value, options = {}) {
-		const defs = this.indexesForStoreInTx(txId, store);
+		await this.putEntry(txId, store, key, value, options);
+	}
+	async putEntry(txId, store, key, value, options, knownDefs, knownCompression) {
+		const defs = knownDefs ?? this.indexesForStoreInTx(txId, store);
+		const compression = knownCompression ?? this.storeCompressionForTx(txId, store);
 		if (defs.length === 0) {
-			const storedValue = await this.encodeStoreValueForWrite(txId, store, value);
+			const preparedValue = this.prepareStoredValue(store, value, compression);
+			const storedValue = preparedValue instanceof Uint8Array ? preparedValue : await preparedValue;
 			const baselineExists = this.withEngine((engine) => engine.put(toWasmU64(txId), store, key, storedValue, toWasmPutOptions(options)));
 			this.recordPutChange(txId, store, key, baselineExists);
 			return;
@@ -1522,7 +1806,7 @@ var DbWorker = class {
 			if (rows !== null) {
 				bytes = 4;
 				for (const row of rows) {
-					row.value = await this.decodeStoreValue(cursor.txId, cursor.store, row.value);
+					row.value = await decodeStoreValueRecord(row.value, { strict: true });
 					bytes += 8 + row.key.byteLength + row.value.byteLength;
 					if (bytes > request.maxBytes) throw remoteError("ValueTooLargeError", "decoded scan page exceeds maxBytes");
 				}
@@ -1560,12 +1844,15 @@ var DbWorker = class {
 		return page.rows.length === 0 ? null : page.rows[0].value;
 	}
 	async scanByIndex(txId, store, indexName, range = {}) {
+		assertValidScanRange(range);
 		const def = this.resolveIndexDefinition(txId, store, indexName);
 		const rows = [];
 		let remaining = range.limit ?? Number.POSITIVE_INFINITY;
+		if (remaining <= 0) return rows;
+		const physical = this.physicalIndexRange(txId, def, range);
 		let cursor = null;
 		while (remaining > 0) {
-			const page = await this.loadVisibleIndexPage(txId, def, range, cursor, Math.min(remaining, INDEX_SCAN_PAGE_ROWS));
+			const page = await this.loadVisibleIndexPage(txId, def, range, cursor, Math.min(remaining, INDEX_SCAN_PAGE_ROWS), INDEX_SCAN_PAGE_BYTES, physical);
 			rows.push(...page.rows);
 			remaining -= page.rows.length;
 			if (page.cursor === null) break;
@@ -1577,7 +1864,7 @@ var DbWorker = class {
 		if (!Number.isSafeInteger(limit) || limit <= 0) throw remoteError("InvalidRangeError", "index scan page limit must be a positive integer");
 		if (!Number.isSafeInteger(maxBytes) || maxBytes < 4 || maxBytes > MAX_PACKED_BYTES) throw remoteError("InvalidRangeError", "index scan page maxBytes must be a u32 integer of at least 4");
 		const def = this.resolveIndexDefinition(txId, store, indexName);
-		return this.loadVisibleIndexPage(txId, def, range, cursor, limit, maxBytes);
+		return this.loadVisibleIndexPage(txId, def, range, cursor, limit, maxBytes, this.physicalIndexRange(txId, def, range));
 	}
 	getIndexes(txId) {
 		return Promise.resolve(toPublicIndexDefinitions(txId === void 0 ? this.loadCommittedIndexSchema() : this.indexSchemaForTx(txId)));
@@ -1927,9 +2214,11 @@ var DbWorker = class {
 		this.txChanges.delete(txId);
 		this.txModes.delete(txId);
 		this.txIndexSchemas.delete(txId);
+		this.readonlyIndexCache.delete(txId);
 		this.txEnsuredRawStores.delete(txId);
 		this.txIndexSchemaChanged.delete(txId);
 		this.txStoreCompression.delete(txId);
+		if (this.indexBoundCache?.txId === txId) this.indexBoundCache = null;
 	}
 	getOrCreateTrackedTxn(txId) {
 		return getOrInsert(this.txChanges, txId, () => /* @__PURE__ */ new Map());
@@ -2217,22 +2506,20 @@ var DbWorker = class {
 		} : op);
 		return storedOps;
 	}
-	async encodeStoreValueForWrite(txId, store, value) {
-		if (isInternalStoreName(store)) return value;
-		return encodeStoreValueRecord(value, this.storeCompressionForTx(txId, store));
-	}
-	async decodeStoreValue(txId, store, value) {
+	prepareStoredValue(store, value, compression) {
 		if (isInternalStoreName(store)) return value;
-		if (this.storeCompressionForTx(txId, store) === false) return value;
-		return decodeStoreValueRecord(value, { strict: true });
+		if (compression === false) return limitPlainStoreValue(value);
+		return encodeStoreValueRecord(value, compression);
 	}
 	async decodeStoreValueForFeed(store, value) {
 		if (isInternalStoreName(store)) return value;
 		return decodeStoreValueRecord(value, { strict: (this.loadCommittedStoreCompression().get(store) ?? false) !== false });
 	}
-	async readStoreValue(txId, store, key) {
+	async readStoreValue(txId, store, key, knownCompression) {
 		const value = this.readRawValue(txId, store, key);
-		return value === null ? null : this.decodeStoreValue(txId, store, value);
+		if (value === null || isInternalStoreName(store)) return value;
+		if ((knownCompression ?? this.storeCompressionForTx(txId, store)) === false) return value;
+		return await decodeStoreValueRecord(value, { strict: true });
 	}
 	async readStoreScan(txId, store, range) {
 		const rows = this.readRawScan(txId, store, range);
@@ -2242,7 +2529,7 @@ var DbWorker = class {
 		for (let index = 0; index < rows.length; index += 1) rows[index].value = values[index];
 		return rows;
 	}
-	async decodeStoreValues(txId, store, values) {
+	async decodeStoreValues(_txId, _store, values) {
 		const state = {
 			next: 0,
 			failed: false,
@@ -2254,7 +2541,7 @@ var DbWorker = class {
 				const value = values[index];
 				if (value === null) continue;
 				try {
-					values[index] = await this.decodeStoreValue(txId, store, value);
+					values[index] = await decodeStoreValueRecord(value, { strict: true });
 				} catch (error) {
 					if (!state.failed) {
 						state.failed = true;
@@ -2282,11 +2569,42 @@ var DbWorker = class {
 		return byStore.get(store) ?? [];
 	}
 	resolveIndexDefinition(txId, store, indexName) {
+		if (this.txModes.get(txId) === "readonly") {
+			const byStore = this.readonlyIndexCache.get(txId)?.get(store);
+			if (byStore) {
+				const cached = byStore.get(indexName);
+				if (cached) return cached;
+				const def = findIndexDefinition(this.indexesForStoreInTx(txId, store), store, indexName);
+				if (!def) throw remoteError("IndexNotFoundError", `index not found: ${store}.${indexName}`);
+				byStore.set(indexName, def);
+				return def;
+			}
+		}
 		if (!this.rawStoreExistsInTx(txId, store)) throw remoteError("StoreNotFoundError", `store not found: ${store}`);
 		const def = findIndexDefinition(this.indexesForStoreInTx(txId, store), store, indexName);
 		if (!def) throw remoteError("IndexNotFoundError", `index not found: ${store}.${indexName}`);
+		if (this.txModes.get(txId) === "readonly") getOrInsert(getOrInsert(this.readonlyIndexCache, txId, () => /* @__PURE__ */ new Map()), store, () => /* @__PURE__ */ new Map()).set(indexName, def);
 		return def;
 	}
+	physicalIndexRange(txId, def, range) {
+		assertValidScanRange(range);
+		const reverse = range.reverse === true;
+		const cached = this.indexBoundCache;
+		if (cached !== null && cached.txId === txId && cached.def === def && cached.reverse === reverse && sameBound(cached.gt, range.gt) && sameBound(cached.gte, range.gte) && sameBound(cached.lt, range.lt) && sameBound(cached.lte, range.lte)) return cached.physical;
+		const { limit: _ignored, ...withoutLimit } = range;
+		const physical = indexRangeToPhysicalRange(withoutLimit);
+		this.indexBoundCache = {
+			txId,
+			def,
+			reverse,
+			gt: copyBound(range.gt),
+			gte: copyBound(range.gte),
+			lt: copyBound(range.lt),
+			lte: copyBound(range.lte),
+			physical
+		};
+		return physical;
+	}
 	indexSchemaForTx(txId) {
 		const override = this.txIndexSchemas.get(txId);
 		if (override) return override;
@@ -2466,7 +2784,10 @@ var DbWorker = class {
 		if (physicalKey.byteLength > MAX_ENGINE_KEY_BYTES) throw remoteError("KeyTooLargeError", `index key too large for ${def.store}.${def.name}`);
 		return physicalKey;
 	}
-	async assertUniqueIndexAvailability(txId, def, logicalKey, primaryKey) {
+	assertIndexEntryKeySize(def, logicalKey, primaryKey) {
+		if (compoundEntryKeyLength(logicalKey, primaryKey) > MAX_ENGINE_KEY_BYTES) throw remoteError("KeyTooLargeError", `index key too large for ${def.store}.${def.name}`);
+	}
+	async assertUniqueIndexAvailability(txId, def, logicalKey, primaryKey, knownCompression) {
 		if (!def.unique) return;
 		const physical = indexKeyExactRange(logicalKey);
 		let cursor = null;
@@ -2491,7 +2812,7 @@ var DbWorker = class {
 					continue;
 				}
 				if (state === "trusted") throw remoteError("UniqueIndexConstraintError", `unique index constraint violation on ${def.store}.${def.name}`);
-				const value = await this.readStoreValue(txId, def.store, decoded.primaryKey);
+				const value = await this.readStoreValue(txId, def.store, decoded.primaryKey, knownCompression);
 				if (value === null) {
 					this.cleanupStaleIndexRow(txId, def, row.key);
 					continue;
@@ -2512,10 +2833,11 @@ var DbWorker = class {
 	* chunks prevent stale entries from forcing the whole range into memory.
 	* The output limit counts only live rows.
 	*/
-	async loadVisibleIndexPage(txId, def, range, cursor, limit, maxBytes = INDEX_SCAN_PAGE_BYTES) {
+	async loadVisibleIndexPage(txId, def, range, cursor, limit, maxBytes = INDEX_SCAN_PAGE_BYTES, physicalRange) {
 		const { limit: _ignored, ...withoutLimit } = range;
-		const physical = indexRangeToPhysicalRange(withoutLimit);
+		const physical = physicalRange ?? indexRangeToPhysicalRange(withoutLimit);
 		const reverse = physical.reverse === true;
+		const compression = this.storeCompressionForTx(txId, def.store);
 		let resumeAfter = cursor;
 		const visible = [];
 		let outputBytes = 4;
@@ -2554,9 +2876,10 @@ var DbWorker = class {
 					batchStart = index;
 					batch = this.readIndexPrimaryValues(txId, def, rawRows, index, Math.min(rawRows.length, index + limit - visible.length), maxBytes - outputBytes);
 					batchEnd = index + (batch?.entries.length ?? 1);
+					if (batch && compression !== false) this.stabilizeWasmValues(batch.values);
 				}
 				const row = rawRows[index];
-				const resolved = batch ? await this.resolveVisibleIndexedValue(txId, def, row.key, batch.entries[index - batchStart], batch.values[index - batchStart], batch.trusted[index - batchStart]) : await this.resolveVisibleIndexedRow(txId, def, row.key);
+				const resolved = batch ? await this.resolveVisibleIndexedValue(txId, def, row.key, batch.entries[index - batchStart], batch.values[index - batchStart], batch.trusted[index - batchStart], compression, true) : await this.visibleIndexedRow(txId, def, row.key, compression);
 				if (batch !== null) batch.values[index - batchStart] = null;
 				if (!resolved) {
 					resumeAfter = row.key;
@@ -2576,7 +2899,7 @@ var DbWorker = class {
 				resumeAfter = row.key;
 				if (visible.length >= limit) return {
 					rows: visible,
-					cursor: row.key.slice()
+					cursor: row.key
 				};
 			}
 			if (rawRows.length < chunkLimit) return {
@@ -2649,7 +2972,13 @@ var DbWorker = class {
 			trusted
 		};
 	}
-	async resolveVisibleIndexedRow(txId, def, physicalKey) {
+	stabilizeWasmValues(values) {
+		for (let index = 0; index < values.length; index += 1) {
+			const value = values[index];
+			if (value !== null) values[index] = normalizeWasmBytes(value);
+		}
+	}
+	visibleIndexedRow(txId, def, physicalKey, compression) {
 		const decoded = decodeIndexEntryKey(physicalKey);
 		const state = this.inspectIndexedValue(txId, def, physicalKey, decoded.primaryKey);
 		if (state === "missing") {
@@ -2657,14 +2986,18 @@ var DbWorker = class {
 			return null;
 		}
 		const value = this.readRawValue(txId, def.store, decoded.primaryKey);
-		return this.resolveVisibleIndexedValue(txId, def, physicalKey, decoded, value, state === "trusted");
+		return this.resolveVisibleIndexedValue(txId, def, physicalKey, decoded, value, state === "trusted", compression, true);
 	}
-	async resolveVisibleIndexedValue(txId, def, physicalKey, decoded, rawValue, trusted = false) {
+	resolveVisibleIndexedValue(txId, def, physicalKey, decoded, rawValue, trusted = false, compression, stable) {
 		if (rawValue === null) {
 			this.cleanupStaleIndexRow(txId, def, physicalKey);
 			return null;
 		}
-		const value = await this.decodeStoreValue(txId, def.store, normalizeWasmBytes(rawValue));
+		const bytes = stable ? rawValue : normalizeWasmBytes(rawValue);
+		if (compression === false) return this.finishVisibleIndexedValue(txId, def, physicalKey, decoded, bytes, trusted);
+		return decodeStoreValueRecord(bytes, { strict: true }).then((value) => this.finishVisibleIndexedValue(txId, def, physicalKey, decoded, value, trusted));
+	}
+	finishVisibleIndexedValue(txId, def, physicalKey, decoded, value, trusted) {
 		if (!trusted) {
 			const currentLogicalKey = extractLogicalIndexKey(def, value);
 			if (currentLogicalKey === null || !bytesEqual(currentLogicalKey, decoded.logicalKey)) {
@@ -2718,6 +3051,8 @@ var DbWorker = class {
 		this.txChanges.clear();
 		this.txModes.clear();
 		this.txIndexSchemas.clear();
+		this.readonlyIndexCache.clear();
+		this.indexBoundCache = null;
 		this.txEnsuredRawStores.clear();
 		this.txIndexSchemaChanged.clear();
 		this.txStoreCompression.clear();