@moyodb/sdk 1.1.0 → 1.3.0

package/dist/node-engine.js

@@ -1,4 +1,4 @@
-import { A as prefixRange, At as packedBinaryListBytes, Bt as unpackPackedOptionalValues, Et as isWorkerProtocolRequestMessage, F as utf8Encode, Ft as unpackPackedBatchOpKeys, It as unpackPackedBatchOps, Lt as unpackPackedBinaryList, Nt as prepareWorkerResponsePayload, Pt as serializeWorkerError, Rt as unpackPackedBinaryPairKeys, S as toPublicIndexDefinitions, St as isWorkerProtocolEnvelope, Tt as isWorkerProtocolRequestBatchMessage, Ut as isRecord, Vt as workerProtocolError, _ as indexRangeToPhysicalRange, _t as decodeWorkerCommandPayload, a as createIndexKeyExtractor, b as normalizeIndexDefinitions, bt as isAutocommitCommand, c as decodeIndexedDocument, d as encodeIndexMetadataValue, dt as WORKER_PROTOCOL_READY, f as extractLogicalIndexKey, g as indexKeyExactRange, gt as captureWorkerPayload, ht as WORKER_PROTOCOL_RESPONSE_BATCH, i as compareNormalizedIndexDefinitions, jt as packedOptionalValues, kt as packedBatchOpsBytes, l as encodeIndexEntryKey, m as findIndexDefinition, mt as WORKER_PROTOCOL_RESPONSE, o as decodeIndexEntryKey, p as extractLogicalIndexKeyFromDocument, r as cloneNormalizedIndexDefinitions, s as decodeIndexMetadataValue, t as INDEX_METADATA_STORE, u as encodeIndexMetadataKey, xt as isWorkerCommand, y as isInternalStoreName, zt as unpackPackedBinaryPairs } from "./chunks/indexing-BzmFhWXs.js";
+import { At as packedBinaryListBytes, Bt as unpackPackedOptionalValues, Et as isWorkerProtocolRequestMessage, F as utf8Encode, Ft as serializeWorkerError, Gt as isRecord, Ht as workerProtocolError, It as unpackPackedBatchOpKeys, Lt as unpackPackedBatchOps, Mt as packedScanRows, Pt as prepareWorkerResponsePayload, Rt as unpackPackedBinaryList, S as toPublicIndexDefinitions, St as isWorkerProtocolEnvelope, Tt as isWorkerProtocolRequestBatchMessage, Ut as clampTimerDelayMs, Vt as unpackPackedScanRows, _ as indexRangeToPhysicalRange, _t as decodeWorkerCommandPayload, a as createIndexKeyExtractor, b as normalizeIndexDefinitions, bt as isAutocommitCommand, c as decodeIndexedDocument, d as encodeIndexMetadataValue, dt as WORKER_PROTOCOL_READY, f as extractLogicalIndexKey, g as indexKeyExactRange, gt as captureWorkerPayload, ht as WORKER_PROTOCOL_RESPONSE_BATCH, i as compareNormalizedIndexDefinitions, jt as packedOptionalValues, kt as packedBatchOpsBytes, l as encodeIndexEntryKey, m as findIndexDefinition, mt as WORKER_PROTOCOL_RESPONSE, o as decodeIndexEntryKey, p as extractLogicalIndexKeyFromDocument, r as cloneNormalizedIndexDefinitions, s as decodeIndexMetadataValue, t as INDEX_METADATA_STORE, u as encodeIndexMetadataKey, xt as isWorkerCommand, y as isInternalStoreName, zt as unpackPackedBinaryPairKeys } from "./chunks/indexing-CKtbpaZn.js";
 //#region src/worker-server.ts
 /** The first argument identifies the transaction lane. */
 var TRANSACTION_COMMANDS = /* @__PURE__ */ new Set([
@@ -52,10 +52,36 @@ var RequestScheduler = class {
 	#lanes = /* @__PURE__ */ new Map();
 	#inFlight = /* @__PURE__ */ new Set();
 	#barrier = Promise.resolve();
+	#cursorLanes = /* @__PURE__ */ new Map();
 	schedule(command, args, task) {
 		if (UNSCHEDULED_COMMANDS.has(command)) return task();
-		if (EXCLUSIVE_COMMANDS.has(command)) return this.#runExclusive(task);
-		return this.#runShared(laneFor(command, args), task);
+		if (EXCLUSIVE_COMMANDS.has(command)) {
+			if (this.#cursorLanes.size === 0) return this.#runExclusive(task);
+			return this.#runExclusive(async () => {
+				const result = await task();
+				this.#cursorLanes.clear();
+				return result;
+			});
+		}
+		if (command !== "scanPage" && command !== "closeCursor" && !((command === "commit" || command === "rollback") && this.#cursorLanes.size > 0)) return this.#runShared(laneFor(command, args), task);
+		const request = command === "scanPage" && isRecord(args[0]) ? args[0] : null;
+		const cursorId = request?.cursorId ?? (command === "closeCursor" ? args[0] : void 0);
+		const lane = (typeof cursorId === "number" ? this.#cursorLanes.get(cursorId) : void 0) ?? (request && typeof request.txId === "number" ? request.txId : typeof cursorId === "number" ? `cursor:${cursorId}` : laneFor(command, args));
+		return this.#runShared(lane, async () => {
+			try {
+				const result = await task();
+				if (request && isRecord(result)) {
+					if (typeof cursorId === "number") this.#cursorLanes.delete(cursorId);
+					if (typeof result.cursorId === "number") this.#cursorLanes.set(result.cursorId, lane ?? `cursor:${result.cursorId}`);
+				}
+				return result;
+			} finally {
+				if (command === "closeCursor" && typeof cursorId === "number") this.#cursorLanes.delete(cursorId);
+				if (command === "commit" || command === "rollback") {
+					for (const [cursor, ownerLane] of this.#cursorLanes) if (ownerLane === args[0]) this.#cursorLanes.delete(cursor);
+				}
+			}
+		});
 	}
 	#runShared(lane, task) {
 		const barrier = this.#barrier;
@@ -291,6 +317,146 @@ function postWorkerResponse(scope, response, transfer = []) {
 	scope.postMessage(response);
 }
 //#endregion
+//#region src/snappy.ts
+var BLOCK_SIZE = 65536;
+var HASH_SIZE = 16384;
+var MAX_LENGTH = 4294967295;
+var MATCH_TABLE = new Uint32Array(HASH_SIZE);
+function corrupt(message) {
+	const error = /* @__PURE__ */ new Error(`invalid Snappy block: ${message}`);
+	error.name = "CorruptionError";
+	return error;
+}
+function word(bytes, offset) {
+	return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
+}
+function hash(value, bits) {
+	return Math.imul(value, 2654435761) >>> 32 - bits;
+}
+function encodeSnappy(input) {
+	if (input.byteLength > MAX_LENGTH) throw new RangeError("Snappy input exceeds the 32-bit length limit");
+	const output = new Uint8Array(input.byteLength + Math.ceil(input.byteLength / 6) + 32);
+	let written = 0;
+	let remainingLength = input.byteLength;
+	while (remainingLength >= 128) {
+		output[written++] = remainingLength & 127 | 128;
+		remainingLength = Math.floor(remainingLength / 128);
+	}
+	output[written++] = remainingLength;
+	const literal = (start, end) => {
+		if (start === end) return;
+		let length = end - start - 1;
+		if (length < 60) output[written++] = length << 2;
+		else {
+			const lengthBytes = length <= 255 ? 1 : length <= 65535 ? 2 : length <= 16777215 ? 3 : 4;
+			output[written++] = 59 + lengthBytes << 2;
+			for (let index = 0; index < lengthBytes; index += 1) {
+				output[written++] = length & 255;
+				length >>>= 8;
+			}
+		}
+		output.set(input.subarray(start, end), written);
+		written += end - start;
+	};
+	const copy = (offset, length) => {
+		while (length > 0) {
+			const count = Math.min(length, 64);
+			if (count >= 4 && count <= 11 && offset < 2048) {
+				output[written++] = 1 | count - 4 << 2 | offset >>> 8 << 5;
+				output[written++] = offset & 255;
+			} else {
+				output[written++] = 2 | count - 1 << 2;
+				output[written++] = offset & 255;
+				output[written++] = offset >>> 8;
+			}
+			length -= count;
+		}
+	};
+	let hashBits = 8;
+	while (1 << hashBits < Math.min(input.byteLength, HASH_SIZE)) hashBits += 1;
+	const tableSize = 1 << hashBits;
+	const table = MATCH_TABLE;
+	for (let blockStart = 0; blockStart < input.byteLength; blockStart += BLOCK_SIZE) {
+		const blockEnd = Math.min(blockStart + BLOCK_SIZE, input.byteLength);
+		table.fill(0, 0, tableSize);
+		let position = blockStart;
+		let literalStart = blockStart;
+		let misses = 0;
+		while (position + 4 <= blockEnd) {
+			const current = word(input, position);
+			const slot = hash(current, hashBits);
+			const previous = table[slot];
+			table[slot] = position - blockStart + 1;
+			const candidate = blockStart + previous - 1;
+			if (previous === 0 || current !== word(input, candidate)) {
+				misses += 1;
+				position += 1 + Math.min(misses >>> 5, 64);
+				continue;
+			}
+			literal(literalStart, position);
+			const matchStart = position;
+			position += 4;
+			while (position < blockEnd && input[position] === input[candidate + position - matchStart]) position += 1;
+			copy(matchStart - candidate, position - matchStart);
+			literalStart = position;
+			misses = 0;
+			if (position + 4 <= blockEnd) table[hash(word(input, position - 1), hashBits)] = position - blockStart;
+		}
+		literal(literalStart, blockEnd);
+	}
+	return output.subarray(0, written);
+}
+function decodeSnappy(input, maxOutputBytes, expectedOutputBytes) {
+	if (!Number.isSafeInteger(maxOutputBytes) || maxOutputBytes < 0 || maxOutputBytes > MAX_LENGTH) throw new RangeError("invalid Snappy output limit");
+	let read = 0;
+	let length = 0;
+	for (let index = 0;; index += 1) {
+		if (read >= input.byteLength || index === 5) throw corrupt("truncated or invalid length");
+		const byte = input[read++];
+		if (index === 4 && byte > 15) throw corrupt("length exceeds 32 bits");
+		length += (byte & 127) * 2 ** (index * 7);
+		if (byte < 128) break;
+	}
+	if (length > maxOutputBytes) throw corrupt(`output exceeds ${maxOutputBytes} byte limit`);
+	if (expectedOutputBytes !== void 0 && length !== expectedOutputBytes) throw corrupt(`length mismatch: expected ${expectedOutputBytes} bytes, got ${length}`);
+	const output = new Uint8Array(length);
+	let written = 0;
+	while (read < input.byteLength) {
+		const tag = input[read++];
+		const kind = tag & 3;
+		if (kind === 0) {
+			let count = tag >>> 2;
+			if (count < 60) count += 1;
+			else {
+				const lengthBytes = count - 59;
+				if (lengthBytes > input.byteLength - read) throw corrupt("truncated literal length");
+				count = 1;
+				for (let index = 0; index < lengthBytes; index += 1) count += input[read++] * 2 ** (index * 8);
+			}
+			if (count > input.byteLength - read || count > length - written) throw corrupt("literal exceeds input or output");
+			output.set(input.subarray(read, read + count), written);
+			read += count;
+			written += count;
+			continue;
+		}
+		const offsetBytes = kind === 1 ? 1 : kind === 2 ? 2 : 4;
+		if (offsetBytes > input.byteLength - read) throw corrupt("truncated copy offset");
+		const count = kind === 1 ? 4 + (tag >>> 2 & 7) : 1 + (tag >>> 2);
+		let offset = kind === 1 ? (tag & 224) << 3 : 0;
+		for (let index = 0; index < offsetBytes; index += 1) offset += input[read++] * 2 ** (index * 8);
+		if (offset === 0 || offset > written || count > length - written) throw corrupt("copy exceeds output or has an invalid offset");
+		let copied = 0;
+		while (copied < count) {
+			const chunk = Math.min(offset + copied, count - copied);
+			output.copyWithin(written + copied, written - offset, written - offset + chunk);
+			copied += chunk;
+		}
+		written += count;
+	}
+	if (written !== length) throw corrupt(`length mismatch: expected ${length} bytes, got ${written}`);
+	return output;
+}
+//#endregion
 //#region src/compression.ts
 var STORE_RECORD_MAGIC = utf8Encode("BDBZVAL1");
 var SNAPSHOT_EXPORT_MAGIC = utf8Encode("BDBZSNP1");
@@ -299,18 +465,27 @@ var ENVELOPE_HEADER_SIZE = 18;
 var COMPRESSION_TAG_NONE = 0;
 var COMPRESSION_TAG_GZIP = 1;
 var COMPRESSION_TAG_DEFLATE = 2;
+var COMPRESSION_TAG_SNAPPY = 3;
 var STORE_FLAG_COMPRESSION_SHIFT = 2;
 var STORE_FLAG_COMPRESSION_MASK = 12;
+var STORE_VALUE_COMPRESSION_PREFLIGHT_WINDOW_BYTES = 1024;
 var MAX_DECOMPRESSED_STORE_VALUE_BYTES = 8388608;
 var MAX_DECOMPRESSED_SNAPSHOT_BYTES = 268435456;
 var CRC32_TABLE = (() => {
-	const table = /* @__PURE__ */ new Uint32Array(256);
+	const table = /* @__PURE__ */ new Uint32Array(2048);
 	for (let index = 0; index < 256; index += 1) {
 		let crc = index;
 		for (let bit = 0; bit < 8; bit += 1) if ((crc & 1) !== 0) crc = crc >>> 1 ^ 3988292384;
 		else crc >>>= 1;
 		table[index] = crc >>> 0;
 	}
+	for (let index = 0; index < 256; index += 1) {
+		let crc = table[index];
+		for (let slice = 1; slice < 8; slice += 1) {
+			crc = crc >>> 8 ^ table[crc & 255];
+			table[slice * 256 + index] = crc >>> 0;
+		}
+	}
 	return table;
 })();
 function namedError(name, message) {
@@ -323,6 +498,7 @@ function compressionTag(kind) {
 		case false: return COMPRESSION_TAG_NONE;
 		case "gzip": return COMPRESSION_TAG_GZIP;
 		case "deflate": return COMPRESSION_TAG_DEFLATE;
+		case "snappy": return COMPRESSION_TAG_SNAPPY;
 		default: throw namedError("InternalError", `unsupported compression kind: ${String(kind)}`);
 	}
 }
@@ -331,6 +507,7 @@ function compressionKindFromTag(tag) {
 		case COMPRESSION_TAG_NONE: return false;
 		case COMPRESSION_TAG_GZIP: return "gzip";
 		case COMPRESSION_TAG_DEFLATE: return "deflate";
+		case COMPRESSION_TAG_SNAPPY: return "snappy";
 		default: throw namedError("CorruptionError", `invalid compression tag: ${tag}`);
 	}
 }
@@ -342,20 +519,79 @@ function ensureCompressionRuntime() {
 }
 function crc32(bytes) {
 	let crc = 4294967295;
-	for (const byte of bytes) crc = crc >>> 8 ^ CRC32_TABLE[(crc ^ byte) & 255];
+	let offset = 0;
+	const blockEnd = bytes.byteLength - 7;
+	for (; offset < blockEnd; offset += 8) {
+		const first = crc ^ bytes[offset] ^ bytes[offset + 1] << 8 ^ bytes[offset + 2] << 16 ^ bytes[offset + 3] << 24;
+		crc = CRC32_TABLE[1792 + (first & 255)] ^ CRC32_TABLE[1536 + (first >>> 8 & 255)] ^ CRC32_TABLE[1280 + (first >>> 16 & 255)] ^ CRC32_TABLE[1024 + (first >>> 24)] ^ CRC32_TABLE[768 + bytes[offset + 4]] ^ CRC32_TABLE[512 + bytes[offset + 5]] ^ CRC32_TABLE[256 + bytes[offset + 6]] ^ CRC32_TABLE[bytes[offset + 7]];
+	}
+	for (; offset < bytes.byteLength; offset += 1) crc = crc >>> 8 ^ CRC32_TABLE[(crc ^ bytes[offset]) & 255];
 	return (crc ^ 4294967295) >>> 0;
 }
 function buildEnvelope(magic, kindTag, rawLength, payload) {
 	const out = new Uint8Array(ENVELOPE_HEADER_SIZE + payload.byteLength);
-	out.set(magic, 0);
-	out[8] = ENVELOPE_VERSION;
-	out[9] = kindTag;
-	const view = new DataView(out.buffer, out.byteOffset, ENVELOPE_HEADER_SIZE);
-	view.setUint32(10, rawLength, true);
-	view.setUint32(14, crc32(payload), true);
-	out.set(payload, ENVELOPE_HEADER_SIZE);
+	writeEnvelope(out, 0, magic, kindTag, rawLength, payload);
 	return out;
 }
+function writeEnvelope(out, offset, magic, kindTag, rawLength, payload) {
+	const checksum = crc32(payload);
+	out.set(payload, offset + ENVELOPE_HEADER_SIZE);
+	out.set(magic, offset);
+	out[offset + 8] = ENVELOPE_VERSION;
+	out[offset + 9] = kindTag;
+	const view = new DataView(out.buffer, out.byteOffset + offset, ENVELOPE_HEADER_SIZE);
+	view.setUint32(10, rawLength, true);
+	view.setUint32(14, checksum, true);
+}
+function compressionIsProfitable(rawLength, compressedLength) {
+	return (compressedLength + ENVELOPE_HEADER_SIZE) * 100 <= rawLength * 90;
+}
+function snappyPreflightIsProfitable(value) {
+	if (value.byteLength < 65536) return true;
+	let compressedLength = 0;
+	for (let index = 0; index < 3; index += 1) {
+		const offset = Math.floor((value.byteLength - STORE_VALUE_COMPRESSION_PREFLIGHT_WINDOW_BYTES) * index / 2);
+		compressedLength += encodeSnappy(value.subarray(offset, offset + STORE_VALUE_COMPRESSION_PREFLIGHT_WINDOW_BYTES)).byteLength;
+	}
+	return compressionIsProfitable(STORE_VALUE_COMPRESSION_PREFLIGHT_WINDOW_BYTES * 3, compressedLength);
+}
+function buildStoreRecord(input, compressed, compression) {
+	if (!compressionIsProfitable(input.byteLength, compressed.byteLength)) return buildEnvelope(STORE_RECORD_MAGIC, COMPRESSION_TAG_NONE, input.byteLength, input);
+	return buildEnvelope(STORE_RECORD_MAGIC, compressionTag(compression), input.byteLength, compressed);
+}
+function validateStoreValueLength(value) {
+	if (value.byteLength > MAX_DECOMPRESSED_STORE_VALUE_BYTES) throw namedError("ValueTooLargeError", `value has ${value.byteLength} bytes, exceeding the ${MAX_DECOMPRESSED_STORE_VALUE_BYTES} byte limit`);
+}
+function prepareFastStoreValueRecord(value, compression) {
+	if (compression === false) return {
+		payload: value,
+		rawLength: value.byteLength,
+		byteLength: value.byteLength,
+		kindTag: null
+	};
+	validateStoreValueLength(value);
+	let payload = value;
+	let kindTag = COMPRESSION_TAG_NONE;
+	if (value.byteLength >= 1024 && snappyPreflightIsProfitable(value)) {
+		const compressed = encodeSnappy(value);
+		if (compressionIsProfitable(value.byteLength, compressed.byteLength)) {
+			payload = compressed;
+			kindTag = COMPRESSION_TAG_SNAPPY;
+		}
+	}
+	return {
+		payload,
+		rawLength: value.byteLength,
+		byteLength: ENVELOPE_HEADER_SIZE + payload.byteLength,
+		kindTag
+	};
+}
+function writePreparedStoreValueRecord(record, target, offset) {
+	if (!Number.isSafeInteger(offset) || offset < 0 || record.byteLength > target.byteLength - offset) throw namedError("InternalError", "prepared store value exceeds its destination");
+	if (record.kindTag === null) target.set(record.payload, offset);
+	else writeEnvelope(target, offset, STORE_RECORD_MAGIC, record.kindTag, record.rawLength, record.payload);
+	return offset + record.byteLength;
+}
 function copyBytes(bytes) {
 	const copy = new Uint8Array(bytes.byteLength);
 	copy.set(bytes);
@@ -402,6 +638,7 @@ async function compressBytes(data, kind) {
 	}
 }
 async function decompressBytes(data, kind, label, maxOutputBytes) {
+	if (kind === "snappy") return decodeSnappy(data, maxOutputBytes ?? MAX_DECOMPRESSED_STORE_VALUE_BYTES, maxOutputBytes);
 	ensureCompressionRuntime();
 	let stream;
 	try {
@@ -447,17 +684,22 @@ function compressionFromStoreFlags(flags) {
 		case 0: return false;
 		case 1: return "gzip";
 		case 2: return "deflate";
+		case 3: return "snappy";
 		default: throw namedError("CorruptionError", `invalid store compression flags: ${encoded}`);
 	}
 }
 async function encodeStoreValueRecord(value, compression) {
 	if (compression === false) return value;
-	if (value.byteLength > MAX_DECOMPRESSED_STORE_VALUE_BYTES) throw namedError("ValueTooLargeError", `value has ${value.byteLength} bytes, exceeding the ${MAX_DECOMPRESSED_STORE_VALUE_BYTES} byte limit`);
+	if (compression === "snappy") {
+		const record = prepareFastStoreValueRecord(value, compression);
+		const output = new Uint8Array(record.byteLength);
+		writePreparedStoreValueRecord(record, output, 0);
+		return output;
+	}
+	validateStoreValueLength(value);
 	if (value.byteLength < 1024) return buildEnvelope(STORE_RECORD_MAGIC, COMPRESSION_TAG_NONE, value.byteLength, value);
 	const input = copyBytes(value);
-	const compressed = await compressBytes(input, compression);
-	if (compressed.byteLength >= input.byteLength) return buildEnvelope(STORE_RECORD_MAGIC, COMPRESSION_TAG_NONE, input.byteLength, input);
-	return buildEnvelope(STORE_RECORD_MAGIC, compressionTag(compression), input.byteLength, compressed);
+	return buildStoreRecord(input, await compressBytes(input, compression), compression);
 }
 async function decodeStoreValueRecord(value, options) {
 	const header = readEnvelopeHeader(STORE_RECORD_MAGIC, value, options.strict);
@@ -492,6 +734,7 @@ 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)}`);
 	const input = copyBytes(snapshot);
 	const compressed = await compressBytes(input, compression);
 	return buildEnvelope(SNAPSHOT_EXPORT_MAGIC, compressionTag(compression), input.byteLength, compressed);
@@ -502,6 +745,7 @@ async function unwrapSnapshotCompression(snapshot) {
 	if (header.version !== ENVELOPE_VERSION) throw namedError("CorruptionError", `unsupported snapshot compression version: ${header.version}`);
 	const compression = compressionKindFromTag(header.kindTag);
 	if (compression === false) throw namedError("CorruptionError", "snapshot compression envelope cannot store kind \"none\"");
+	if (compression === "snappy") throw namedError("CorruptionError", `invalid snapshot compression tag: ${header.kindTag}`);
 	const payload = snapshot.subarray(ENVELOPE_HEADER_SIZE);
 	if (crc32(payload) !== header.payloadChecksum) throw namedError("CorruptionError", "snapshot compression checksum mismatch");
 	if (header.rawLength > MAX_DECOMPRESSED_SNAPSHOT_BYTES) throw namedError("CorruptionError", `compressed snapshot advertises ${header.rawLength} decompressed bytes, exceeding the ${MAX_DECOMPRESSED_SNAPSHOT_BYTES} byte limit`);
@@ -539,7 +783,11 @@ function toWasmRange(range) {
 var EMPTY_RANGE = {};
 var EMPTY_VALUE = /* @__PURE__ */ new Uint8Array(0);
 var MAX_ENGINE_KEY_BYTES = 1024;
+var MAX_PACKED_BYTES = 4294967295;
+var INDEX_PUT_BATCH_ROWS = 64;
+var INDEX_PUT_BATCH_BYTES = 4194304;
 var INDEX_SCAN_PAGE_ROWS = 256;
+var INDEX_SCAN_PAGE_BYTES = 8389662;
 var INDEX_SCAN_RAW_CHUNK_ROWS = 512;
 var RECONCILE_DOCUMENT_CACHE_BYTES = 4194304;
 var RECONCILE_DOCUMENT_CACHE_ROWS = 4096;
@@ -657,6 +905,32 @@ function bytesEqual(left, right) {
 	for (let index = 0; index < left.byteLength; index += 1) if (left[index] !== right[index]) return false;
 	return true;
 }
+function copyRange(range) {
+	const copy = toWasmRange(range);
+	for (const bound of [
+		"gt",
+		"gte",
+		"lt",
+		"lte"
+	]) {
+		const value = copy[bound];
+		if (value !== void 0) copy[bound] = value.slice();
+	}
+	return copy;
+}
+function rangesEqual(left, right) {
+	for (const bound of [
+		"gt",
+		"gte",
+		"lt",
+		"lte"
+	]) {
+		const a = left[bound];
+		const b = right[bound];
+		if (a === void 0 ? b !== void 0 : b === void 0 || !bytesEqual(a, b)) return false;
+	}
+	return left.reverse === right.reverse && left.limit === right.limit;
+}
 function normalizeWasmBytes(value) {
 	if (value instanceof Uint8Array) return value.byteOffset === 0 && value.byteLength === value.buffer.byteLength ? value : value.slice();
 	return new Uint8Array(value);
@@ -763,7 +1037,7 @@ var OwnershipLease = class {
 			return;
 		}
 		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), ownerWaitMs);
+		const timeout = setTimeout(() => controller.abort(), clampTimerDelayMs(ownerWaitMs));
 		let acquiredResolve = null;
 		const acquiredPromise = new Promise((resolve) => {
 			acquiredResolve = resolve;
@@ -806,6 +1080,8 @@ var DbWorker = class {
 	persistenceBridge;
 	txChanges = /* @__PURE__ */ new Map();
 	txModes = /* @__PURE__ */ new Map();
+	primaryCursors = /* @__PURE__ */ new Map();
+	nextPrimaryCursorId = 1;
 	/**
 	* Shared committed schema at begin. Reconciliation replaces the array;
 	* it never mutates the shared schema.
@@ -1004,7 +1280,7 @@ var DbWorker = class {
 		return result;
 	}
 	createStore(txId, name, options = {}) {
-		const compression = options.compression ?? false;
+		const compression = isInternalStoreName(name) ? false : options.compression ?? "snappy";
 		this.txEnsuredRawStores.get(txId)?.delete(name);
 		this.withEngine((engine) => engine.create_store(toWasmU64(txId), name, { compression }));
 		this.recordStoreCompressionCreate(txId, name, compression);
@@ -1057,42 +1333,12 @@ var DbWorker = class {
 			this.recordPutChange(txId, store, key, baselineExists);
 			return;
 		}
-		const oldValue = await this.readStoreValue(txId, store, key);
-		const oldKeyFor = oldValue === null ? null : createIndexKeyExtractor(oldValue);
-		const newKeyFor = createIndexKeyExtractor(value);
-		const plans = defs.map((def) => {
-			return {
-				def,
-				oldLogicalKey: oldKeyFor === null ? null : oldKeyFor(def),
-				newLogicalKey: newKeyFor(def),
-				newPhysicalKey: null
-			};
-		});
-		this.ensureInternalStoresForDefinitions(txId, defs);
-		for (const plan of plans) {
-			if (plan.newLogicalKey === null) continue;
-			plan.newPhysicalKey = this.buildIndexEntryKey(plan.def, plan.newLogicalKey, key);
-			if (plan.oldLogicalKey !== null && bytesEqual(plan.oldLogicalKey, plan.newLogicalKey)) continue;
-			await this.assertUniqueIndexAvailability(txId, plan.def, plan.newLogicalKey, key);
-		}
-		const storedValue = await this.encodeStoreValueForWrite(txId, store, value);
-		const baselineExists = this.withEngine((engine) => engine.put(toWasmU64(txId), store, key, storedValue, toWasmPutOptions(options)));
-		for (const plan of plans) {
-			if (plan.oldLogicalKey === null) continue;
-			if (plan.newLogicalKey !== null && bytesEqual(plan.oldLogicalKey, plan.newLogicalKey)) continue;
-			this.deleteIndexEntryIfPresent(txId, plan.def, plan.oldLogicalKey, key);
-		}
-		for (const plan of plans) {
-			if (plan.newLogicalKey === null) continue;
-			if (plan.oldLogicalKey !== null && bytesEqual(plan.oldLogicalKey, plan.newLogicalKey)) continue;
-			if (plan.newPhysicalKey === null) throw remoteError("InternalError", "missing index entry key");
-			this.putIndexEntry(txId, plan.def, plan.newPhysicalKey, EMPTY_VALUE);
-		}
-		this.recordPutChange(txId, store, key, baselineExists);
+		await this.putIndexedMany(txId, store, [key, value], defs, options);
 	}
 	async putMany(txId, store, entries, options = {}) {
 		if (entries.length === 0) return;
-		if (this.indexesForStoreInTx(txId, store).length === 0) {
+		const defs = this.indexesForStoreInTx(txId, store);
+		if (defs.length === 0) {
 			const storedEntries = await this.encodeEntriesForWrite(txId, store, entries);
 			let baselines;
 			try {
@@ -1106,18 +1352,29 @@ var DbWorker = class {
 			this.recordPutChanges(txId, store, entries, baselines);
 			return;
 		}
-		for (const [key, value] of entries) await this.put(txId, store, key, value, options);
+		const items = new Array(entries.length * 2);
+		for (let index = 0; index < entries.length; index += 1) {
+			items[index * 2] = entries[index][0];
+			items[index * 2 + 1] = entries[index][1];
+		}
+		await this.putIndexedMany(txId, store, items, defs, options);
 	}
 	async putManyPacked(txId, store, packedEntries, options = {}) {
-		if (this.indexesForStoreInTx(txId, store).length !== 0 || this.storeCompressionForTx(txId, store) !== false) {
-			await this.putMany(txId, store, unpackPackedBinaryPairs(packedEntries), options);
+		const defs = this.indexesForStoreInTx(txId, store);
+		if (defs.length !== 0) {
+			const items = unpackPackedBinaryList(packedEntries);
+			if (items.length % 2 !== 0) throw remoteError("WorkerProtocolError", "packed putMany payload has an odd item count");
+			await this.putIndexedMany(txId, store, items, defs, options);
 			return;
 		}
-		const keys = unpackPackedBinaryPairKeys(packedEntries);
+		const items = this.storeCompressionForTx(txId, store) === false ? null : unpackPackedBinaryList(packedEntries);
+		if (items !== null && items.length % 2 !== 0) throw remoteError("WorkerProtocolError", "packed putMany payload has an odd item count");
+		const keys = items === null ? unpackPackedBinaryPairKeys(packedEntries) : items.filter((_item, index) => index % 2 === 0);
 		if (keys.length === 0) return;
+		const storedEntries = items === null ? packedEntries : await this.encodePackedEntriesForWrite(txId, store, items, keys);
 		let baselines;
 		try {
-			baselines = this.withEngine((engine) => engine.put_many_packed(toWasmU64(txId), store, packedEntries, toWasmPutOptions(options)));
+			baselines = this.withEngine((engine) => engine.put_many_packed(toWasmU64(txId), store, storedEntries, toWasmPutOptions(options)));
 		} catch (error) {
 			const partial = partialBooleanOutcomes(error);
 			this.recordPutKeyChanges(txId, store, keys, partial);
@@ -1222,9 +1479,82 @@ var DbWorker = class {
 	async scan(txId, store, range) {
 		return this.readStoreScan(txId, store, range);
 	}
+	async scanPage(request) {
+		if (!Number.isSafeInteger(request.maxRows) || request.maxRows <= 0 || request.maxRows > MAX_PACKED_BYTES || !Number.isSafeInteger(request.maxBytes) || request.maxBytes < 4 || request.maxBytes > MAX_PACKED_BYTES) throw remoteError("InvalidRangeError", "scan page budgets must be positive u32 integers; maxBytes must be at least 4");
+		let cursorId = request.cursorId;
+		let cursor = cursorId === void 0 ? void 0 : this.primaryCursors.get(cursorId);
+		if (cursorId !== void 0) {
+			if (!cursor) throw remoteError("TransactionClosedError", "scan cursor is closed");
+			if (cursor.store !== request.store || cursor.callerTxId !== request.txId || !rangesEqual(cursor.range, request.range ?? EMPTY_RANGE)) throw remoteError("InvalidRangeError", "scan continuation does not match the cursor");
+		} else {
+			const ownsTx = request.txId === void 0;
+			const txId = request.txId ?? await this.begin("readonly");
+			const range = copyRange(request.range ?? EMPTY_RANGE);
+			let engineId;
+			try {
+				engineId = this.withEngine((engine) => engine.open_scan_cursor(toWasmU64(txId), request.store, toWasmRange(range), false));
+			} catch (error) {
+				if (ownsTx) try {
+					await this.rollback(txId);
+				} catch {}
+				throw error;
+			}
+			cursorId = this.nextPrimaryCursorId++;
+			cursor = {
+				engineId,
+				txId,
+				ownsTx,
+				store: request.store,
+				range,
+				callerTxId: request.txId
+			};
+			this.primaryCursors.set(cursorId, cursor);
+		}
+		try {
+			const page = this.withEngine((engine) => engine.scan_cursor_next(cursor.engineId, request.maxRows, request.maxBytes));
+			const packet = normalizeWasmBytes(page.packet);
+			const rowCount = packet.byteLength < 4 ? -1 : new DataView(packet.buffer, packet.byteOffset, 4).getUint32(0, true);
+			if (rowCount !== page.rowCount || rowCount > request.maxRows || packet.byteLength > request.maxBytes) throw remoteError("CorruptionError", "scan cursor returned an invalid page budget or count");
+			const rows = this.storeCompressionForTx(cursor.txId, cursor.store) !== false ? unpackPackedScanRows(packet) : null;
+			let bytes = packet.byteLength;
+			if (rows !== null) {
+				bytes = 4;
+				for (const row of rows) {
+					row.value = await this.decodeStoreValue(cursor.txId, cursor.store, row.value);
+					bytes += 8 + row.key.byteLength + row.value.byteLength;
+					if (bytes > request.maxBytes) throw remoteError("ValueTooLargeError", "decoded scan page exceeds maxBytes");
+				}
+			}
+			if (page.exhausted) await this.closeCursor(cursorId);
+			return {
+				rows: rows ?? packedScanRows(packet),
+				done: page.exhausted,
+				bytes,
+				...page.exhausted ? {} : { cursorId }
+			};
+		} catch (error) {
+			try {
+				await this.closeCursor(cursorId);
+			} catch {}
+			throw error;
+		}
+	}
+	async closeCursor(cursorId) {
+		const cursor = this.primaryCursors.get(cursorId);
+		if (!cursor) return;
+		this.primaryCursors.delete(cursorId);
+		try {
+			this.withEngine((engine) => engine.close_scan_cursor(cursor.engineId));
+		} finally {
+			if (cursor.ownsTx) await this.rollback(cursor.txId);
+		}
+	}
 	async getByIndex(txId, store, indexName, key) {
 		const def = this.resolveIndexDefinition(txId, store, indexName);
-		const page = await this.loadVisibleIndexPage(txId, def, prefixRange(key), null, 1);
+		const page = await this.loadVisibleIndexPage(txId, def, {
+			gte: key,
+			lte: key
+		}, null, 1);
 		return page.rows.length === 0 ? null : page.rows[0].value;
 	}
 	async scanByIndex(txId, store, indexName, range = {}) {
@@ -1241,10 +1571,11 @@ var DbWorker = class {
 		}
 		return rows;
 	}
-	async scanByIndexPage(txId, store, indexName, range, cursor, limit) {
+	async scanByIndexPage(txId, store, indexName, range, cursor, limit, maxBytes = INDEX_SCAN_PAGE_BYTES) {
 		if (!Number.isSafeInteger(limit) || limit <= 0) throw remoteError("InvalidRangeError", "index scan page limit must be a positive integer");
+		if (!Number.isSafeInteger(maxBytes) || maxBytes < 4 || maxBytes > MAX_PACKED_BYTES) throw remoteError("InvalidRangeError", "index scan page maxBytes must be a u32 integer of at least 4");
 		const def = this.resolveIndexDefinition(txId, store, indexName);
-		return this.loadVisibleIndexPage(txId, def, range, cursor, limit);
+		return this.loadVisibleIndexPage(txId, def, range, cursor, limit, maxBytes);
 	}
 	getIndexes(txId) {
 		return Promise.resolve(toPublicIndexDefinitions(txId === void 0 ? this.loadCommittedIndexSchema() : this.indexSchemaForTx(txId)));
@@ -1587,6 +1918,12 @@ var DbWorker = class {
 		};
 	}
 	cleanupTxState(txId) {
+		for (const [cursorId, cursor] of this.primaryCursors) if (cursor.txId === txId) {
+			this.primaryCursors.delete(cursorId);
+			try {
+				this.engine?.close_scan_cursor(cursor.engineId);
+			} catch {}
+		}
 		this.txChanges.delete(txId);
 		this.txModes.delete(txId);
 		this.txIndexSchemas.delete(txId);
@@ -1752,6 +2089,130 @@ var DbWorker = class {
 		for (const [key, value] of entries) storedEntries.push([key, await encodeStoreValueRecord(value, compression)]);
 		return storedEntries;
 	}
+	async encodePackedEntriesForWrite(txId, store, items, keys) {
+		const records = new Array(items.length / 2);
+		for (let index = 0; index < records.length; index += 1) {
+			const value = this.preparePutValue(txId, store, items[index * 2 + 1]);
+			records[index] = value instanceof Promise ? await value : value;
+		}
+		return this.packPreparedPutEntries(keys, records);
+	}
+	preparePutValue(txId, store, value) {
+		const compression = this.storeCompressionForTx(txId, store);
+		return compression === "snappy" || compression === false ? prepareFastStoreValueRecord(value, compression) : encodeStoreValueRecord(value, compression);
+	}
+	packPreparedPutEntries(keys, records) {
+		let total = 4 + keys.length * 8;
+		for (let index = 0; index < keys.length; index += 1) {
+			total += keys[index].byteLength + records[index].byteLength;
+			if (total > MAX_PACKED_BYTES) throw remoteError("WorkerProtocolError", "compressed packed putMany exceeds the u32 byte limit");
+		}
+		const bytes = new Uint8Array(total);
+		const view = new DataView(bytes.buffer);
+		view.setUint32(0, keys.length * 2, true);
+		let offset = 4 + keys.length * 8;
+		for (let index = 0; index < records.length; index += 1) {
+			const key = keys[index];
+			const record = records[index];
+			view.setUint32(4 + index * 8, key.byteLength, true);
+			view.setUint32(8 + index * 8, record.byteLength, true);
+			bytes.set(key, offset);
+			offset += key.byteLength;
+			if (record instanceof Uint8Array) {
+				bytes.set(record, offset);
+				offset += record.byteLength;
+			} else offset = writePreparedStoreValueRecord(record, bytes, offset);
+		}
+		return bytes;
+	}
+	async putIndexedMany(txId, store, items, defs, options) {
+		let keys = [];
+		let values = [];
+		let indexOps = [];
+		let bytes = 4;
+		const pendingPrimaries = /* @__PURE__ */ new Set();
+		const pendingUniqueKeys = /* @__PURE__ */ new Set();
+		const flush = () => {
+			if (keys.length === 0) return;
+			const batchKeys = keys;
+			const batchValues = values;
+			const batchOps = indexOps;
+			keys = [];
+			values = [];
+			indexOps = [];
+			bytes = 4;
+			pendingPrimaries.clear();
+			pendingUniqueKeys.clear();
+			const packet = this.packPreparedPutEntries(batchKeys, batchValues);
+			let baselines;
+			try {
+				baselines = this.withEngine((engine) => engine.put_many_indexed_packed(toWasmU64(txId), store, packet, batchOps, toWasmPutOptions(options)));
+			} catch (error) {
+				const partial = partialBooleanOutcomes(error);
+				if (partial.length > 0) this.recordPutKeyChanges(txId, store, batchKeys, partial);
+				throw error;
+			}
+			if (baselines.length !== batchKeys.length) throw remoteError("InternalError", `put_many_indexed_packed outcome count mismatch: ${baselines.length} != ${batchKeys.length}`);
+			this.recordPutKeyChanges(txId, store, batchKeys, baselines);
+		};
+		for (let index = 0; index < items.length / 2; index += 1) {
+			const key = items[index * 2];
+			const value = items[index * 2 + 1];
+			const primaryToken = bytesToHex(key);
+			if (pendingPrimaries.has(primaryToken)) flush();
+			try {
+				const oldValue = await this.readStoreValue(txId, store, key);
+				const oldKeyFor = oldValue === null ? null : createIndexKeyExtractor(oldValue);
+				const newKeyFor = createIndexKeyExtractor(value);
+				const plans = defs.map((def) => ({
+					def,
+					oldLogicalKey: oldKeyFor === null ? null : oldKeyFor(def),
+					newLogicalKey: newKeyFor(def),
+					newPhysicalKey: null
+				}));
+				if (plans.some((plan) => plan.def.unique && plan.newLogicalKey !== null && pendingUniqueKeys.has(`${plan.def.internalStore}:${bytesToHex(plan.newLogicalKey)}`))) {
+					flush();
+					index -= 1;
+					continue;
+				}
+				this.ensureInternalStoresForDefinitions(txId, defs);
+				for (const plan of plans) {
+					if (plan.newLogicalKey === null) continue;
+					plan.newPhysicalKey = this.buildIndexEntryKey(plan.def, plan.newLogicalKey, key);
+					if (plan.oldLogicalKey === null || !bytesEqual(plan.oldLogicalKey, plan.newLogicalKey)) await this.assertUniqueIndexAvailability(txId, plan.def, plan.newLogicalKey, key);
+				}
+				const preparedValue = this.preparePutValue(txId, store, value);
+				const storedValue = preparedValue instanceof Promise ? await preparedValue : preparedValue;
+				const ops = [];
+				for (const plan of plans) if (plan.oldLogicalKey !== null && (plan.newLogicalKey === null || !bytesEqual(plan.oldLogicalKey, plan.newLogicalKey))) ops.push({
+					store: plan.def.internalStore,
+					kind: "delete",
+					key: encodeIndexEntryKey(plan.oldLogicalKey, key)
+				});
+				for (const plan of plans) {
+					if (plan.newPhysicalKey !== null) ops.push({
+						store: plan.def.internalStore,
+						kind: "put",
+						key: plan.newPhysicalKey
+					});
+					if (plan.def.unique) {
+						for (const logicalKey of [plan.oldLogicalKey, plan.newLogicalKey]) if (logicalKey !== null) pendingUniqueKeys.add(`${plan.def.internalStore}:${bytesToHex(logicalKey)}`);
+					}
+				}
+				keys.push(key);
+				values.push(storedValue);
+				indexOps.push(ops);
+				bytes += 8 + key.byteLength + storedValue.byteLength;
+				for (const op of ops) bytes += op.key.byteLength;
+				pendingPrimaries.add(primaryToken);
+			} catch (error) {
+				flush();
+				throw error;
+			}
+			if (options.ttl !== void 0 || keys.length >= INDEX_PUT_BATCH_ROWS || bytes >= INDEX_PUT_BATCH_BYTES) flush();
+		}
+		flush();
+	}
 	async encodeBatchOpsForWrite(txId, store, ops) {
 		if (isInternalStoreName(store)) return ops;
 		const compression = this.storeCompressionForTx(txId, store);
@@ -1908,12 +2369,100 @@ var DbWorker = class {
 		}
 		return rows;
 	}
+	readIndexKeyScan(txId, store, range) {
+		if (typeof this.engine?.open_scan_cursor !== "function" || typeof this.engine?.scan_cursor_next !== "function" || typeof this.engine?.close_scan_cursor !== "function") return this.readRawScan(txId, store, range);
+		const maxRows = range.limit ?? INDEX_SCAN_RAW_CHUNK_ROWS;
+		const maxBytes = 4 + maxRows * 1032;
+		const cursorId = this.withEngine((engine) => engine.open_scan_cursor(toWasmU64(txId), store, toWasmRange(range), true));
+		try {
+			const page = this.withEngine((engine) => engine.scan_cursor_next(cursorId, maxRows, maxBytes));
+			const packet = normalizeWasmBytes(page.packet);
+			const rows = unpackPackedScanRows(packet);
+			if (rows.length !== page.rowCount || rows.length > maxRows || packet.byteLength > maxBytes || rows.some((row) => row.value.byteLength !== 0)) throw remoteError("CorruptionError", "index key cursor returned an invalid page");
+			return rows;
+		} finally {
+			this.withEngine((engine) => engine.close_scan_cursor(cursorId));
+		}
+	}
 	putRawValue(txId, store, key, value) {
 		this.withEngine((engine) => engine.put(toWasmU64(txId), store, key, value));
 	}
 	putIndexEntry(txId, def, physicalKey, value) {
+		if (typeof this.engine?.put_index_entry_checked === "function") {
+			const primaryKey = decodeIndexEntryKey(physicalKey).primaryKey;
+			const state = this.readNativeValueState(txId, def.store, primaryKey);
+			if (state?.revisionKnown) {
+				this.withEngine((engine) => engine.put_index_entry_checked(toWasmU64(txId), def.store, def.internalStore, primaryKey, physicalKey, state.revisionEpoch, state.revisionOrdinal));
+				return;
+			}
+		}
 		this.putRawValue(txId, def.internalStore, physicalKey, value);
 	}
+	readNativeValueState(txId, store, key) {
+		if (typeof this.engine?.get_many_value_states !== "function") return null;
+		try {
+			const keys = new Uint8Array(8 + key.byteLength);
+			const keyView = new DataView(keys.buffer);
+			keyView.setUint32(0, 1, true);
+			keyView.setUint32(4, key.byteLength, true);
+			keys.set(key, 8);
+			const packet = normalizeWasmBytes(this.withEngine((engine) => engine.get_many_value_states(toWasmU64(txId), store, keys)));
+			return this.decodeNativeValueStates(packet, 1)?.[0] ?? null;
+		} catch {
+			return null;
+		}
+	}
+	packNativeKeys(keys) {
+		let total = 4 + keys.length * 4;
+		for (const key of keys) total += key.byteLength;
+		const packet = new Uint8Array(total);
+		const view = new DataView(packet.buffer);
+		view.setUint32(0, keys.length, true);
+		let offset = 4 + keys.length * 4;
+		for (let index = 0; index < keys.length; index += 1) {
+			const key = keys[index];
+			view.setUint32(4 + index * 4, key.byteLength, true);
+			packet.set(key, offset);
+			offset += key.byteLength;
+		}
+		return packet;
+	}
+	decodeNativeValueStates(packet, count) {
+		if (packet.byteLength !== 4 + count * 32) return null;
+		const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+		if (view.getUint32(0, true) !== count) return null;
+		const states = new Array(count);
+		for (let index = 0; index < count; index += 1) {
+			const offset = 4 + index * 32;
+			const flags = view.getUint32(offset, true);
+			const revisionEpoch = view.getBigUint64(offset + 12, true);
+			const revisionOrdinal = view.getBigUint64(offset + 20, true);
+			if ((flags & -8) !== 0 || (flags & 3) === 3 || (flags & 4) !== 0 && ((flags & 3) === 0 || revisionEpoch === 0n || revisionOrdinal === 0n)) return null;
+			states[index] = {
+				live: (flags & 1) !== 0,
+				expired: (flags & 2) !== 0,
+				revisionKnown: (flags & 4) !== 0,
+				expiresAt: view.getBigUint64(offset + 4, true),
+				revisionEpoch,
+				revisionOrdinal,
+				maxValueBytes: view.getUint32(offset + 28, true)
+			};
+		}
+		return states;
+	}
+	inspectIndexedValue(txId, def, physicalKey, primaryKey) {
+		const primary = this.readNativeValueState(txId, def.store, primaryKey);
+		if (primary === null) return "unknown";
+		if (!primary.live) {
+			if (primary.expired && this.txModes.get(txId) === "readwrite") {
+				if (this.withEngine((engine) => engine.has(toWasmU64(txId), def.store, primaryKey))) return "unknown";
+			}
+			return "missing";
+		}
+		if (!primary.revisionKnown) return "unknown";
+		const index = this.readNativeValueState(txId, def.internalStore, physicalKey);
+		return index?.live && index.revisionKnown && index.revisionEpoch === primary.revisionEpoch && index.revisionOrdinal === primary.revisionOrdinal ? "trusted" : "unknown";
+	}
 	deleteIndexEntryIfPresent(txId, def, logicalKey, primaryKey) {
 		const physicalKey = this.buildIndexEntryKey(def, logicalKey, primaryKey);
 		this.ignoreNamedError("StoreNotFoundError", () => {
@@ -1939,11 +2488,17 @@ var DbWorker = class {
 				range.gt = cursor;
 				delete range.gte;
 			}
-			const rows = this.readRawScan(txId, def.internalStore, range);
+			const rows = this.readIndexKeyScan(txId, def.internalStore, range);
 			for (const row of rows) {
 				cursor = row.key;
 				const decoded = decodeIndexEntryKey(row.key);
 				if (bytesEqual(decoded.primaryKey, primaryKey)) continue;
+				const state = this.inspectIndexedValue(txId, def, row.key, decoded.primaryKey);
+				if (state === "missing") {
+					this.cleanupStaleIndexRow(txId, def, row.key);
+					continue;
+				}
+				if (state === "trusted") throw remoteError("UniqueIndexConstraintError", `unique index constraint violation on ${def.store}.${def.name}`);
 				const value = await this.readStoreValue(txId, def.store, decoded.primaryKey);
 				if (value === null) {
 					this.cleanupStaleIndexRow(txId, def, row.key);
@@ -1965,12 +2520,13 @@ 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) {
+	async loadVisibleIndexPage(txId, def, range, cursor, limit, maxBytes = INDEX_SCAN_PAGE_BYTES) {
 		const { limit: _ignored, ...withoutLimit } = range;
 		const physical = indexRangeToPhysicalRange(withoutLimit);
 		const reverse = physical.reverse === true;
 		let resumeAfter = cursor;
 		const visible = [];
+		let outputBytes = 4;
 		let staleChunkFloor = 1;
 		for (;;) {
 			const chunkLimit = Math.min(INDEX_SCAN_RAW_CHUNK_ROWS, Math.max(limit - visible.length, staleChunkFloor));
@@ -1989,7 +2545,7 @@ var DbWorker = class {
 			}
 			let rawRows;
 			try {
-				rawRows = this.readRawScan(txId, def.internalStore, chunkRange);
+				rawRows = this.readIndexKeyScan(txId, def.internalStore, chunkRange);
 			} catch (error) {
 				if (isNamedError(error, "StoreNotFoundError")) return {
 					rows: [],
@@ -2004,14 +2560,28 @@ var DbWorker = class {
 			for (let index = 0; index < rawRows.length; index += 1) {
 				if (index === batchEnd) {
 					batchStart = index;
-					batchEnd = Math.min(rawRows.length, index + limit - visible.length);
-					batch = this.readIndexPrimaryValues(txId, def, rawRows, batchStart, batchEnd);
+					batch = this.readIndexPrimaryValues(txId, def, rawRows, index, Math.min(rawRows.length, index + limit - visible.length), maxBytes - outputBytes);
+					batchEnd = index + (batch?.entries.length ?? 1);
 				}
 				const row = rawRows[index];
-				resumeAfter = row.key;
-				const resolved = batch ? await this.resolveVisibleIndexedValue(txId, def, row.key, batch.entries[index - batchStart], batch.values[index - batchStart]) : await this.resolveVisibleIndexedRow(txId, def, row.key);
-				if (!resolved) continue;
+				const resolved = batch ? await this.resolveVisibleIndexedValue(txId, def, row.key, batch.entries[index - batchStart], batch.values[index - batchStart], batch.trusted[index - batchStart]) : await this.resolveVisibleIndexedRow(txId, def, row.key);
+				if (batch !== null) batch.values[index - batchStart] = null;
+				if (!resolved) {
+					resumeAfter = row.key;
+					continue;
+				}
+				const nextBytes = outputBytes + 8 + resolved.key.byteLength + resolved.value.byteLength;
+				if (nextBytes > maxBytes) {
+					if (visible.length === 0) throw remoteError("ValueTooLargeError", "indexed scan row exceeds maxBytes");
+					if (resumeAfter === null) throw remoteError("InternalError", "indexed scan lost its continuation key");
+					return {
+						rows: visible,
+						cursor: resumeAfter.slice()
+					};
+				}
 				visible.push(resolved);
+				outputBytes = nextBytes;
+				resumeAfter = row.key;
 				if (visible.length >= limit) return {
 					rows: visible,
 					cursor: row.key.slice()
@@ -2024,37 +2594,91 @@ var DbWorker = class {
 			staleChunkFloor = visible.length === visibleBefore ? Math.min(INDEX_SCAN_RAW_CHUNK_ROWS, chunkLimit * 2) : 1;
 		}
 	}
-	readIndexPrimaryValues(txId, def, rows, start, end) {
-		if (this.txModes.get(txId) !== "readonly" || end - start <= 1) return null;
+	readIndexPrimaryValues(txId, def, rows, start, end, remainingBytes) {
+		if (this.txModes.get(txId) !== "readonly" || end - start <= 1 || typeof this.engine?.get_many_value_sizes !== "function" && typeof this.engine?.get_many_value_states !== "function") return null;
 		let entries;
 		let values;
+		let trusted;
+		let loaded;
+		let selectedIndices;
 		try {
 			entries = rows.slice(start, end).map((row) => decodeIndexEntryKey(row.key));
-			values = this.withEngine((engine) => engine.get_many(toWasmU64(txId), def.store, entries.map((entry) => entry.primaryKey)));
+			const packedKeys = this.packNativeKeys(entries.map((entry) => entry.primaryKey));
+			let primaryStates = null;
+			let indexStates = null;
+			let sizes;
+			if (typeof this.engine?.get_many_value_states === "function") {
+				primaryStates = this.decodeNativeValueStates(normalizeWasmBytes(this.withEngine((engine) => engine.get_many_value_states(toWasmU64(txId), def.store, packedKeys))), entries.length);
+				if (primaryStates === null) return null;
+				sizes = Uint32Array.from(primaryStates, (state) => state.live ? state.maxValueBytes : MAX_PACKED_BYTES);
+				if (primaryStates.some((state) => state.live && state.revisionKnown)) {
+					const indexKeys = this.packNativeKeys(rows.slice(start, end).map((row) => row.key));
+					indexStates = this.decodeNativeValueStates(normalizeWasmBytes(this.withEngine((engine) => engine.get_many_value_states(toWasmU64(txId), def.internalStore, indexKeys))), entries.length);
+					if (indexStates === null) return null;
+				}
+			} else sizes = this.withEngine((engine) => engine.get_many_value_sizes(toWasmU64(txId), def.store, packedKeys));
+			if (sizes.length !== entries.length) return null;
+			let selected = 0;
+			for (const entry of entries) {
+				const size = sizes[selected];
+				if (!Number.isSafeInteger(size) || size < 0 || size > MAX_PACKED_BYTES) return null;
+				const required = size === MAX_PACKED_BYTES ? 0 : 8 + entry.primaryKey.byteLength + size;
+				if (required > remainingBytes) break;
+				remainingBytes -= required;
+				selected += 1;
+			}
+			if (selected <= 1) return null;
+			entries.length = selected;
+			trusted = new Array(selected).fill(false);
+			const selectedKeys = [];
+			selectedIndices = [];
+			values = new Array(selected).fill(null);
+			for (let index = 0; index < selected; index += 1) {
+				const primary = primaryStates?.[index];
+				if (primary === void 0 || primary.live) {
+					selectedKeys.push(entries[index].primaryKey);
+					selectedIndices.push(index);
+				}
+				const proof = indexStates?.[index];
+				trusted[index] = Boolean(primary?.live && primary.revisionKnown && proof?.live && proof.revisionKnown && primary.revisionEpoch === proof.revisionEpoch && primary.revisionOrdinal === proof.revisionOrdinal);
+			}
+			loaded = selectedKeys.length === 0 ? [] : this.withEngine((engine) => engine.get_many(toWasmU64(txId), def.store, selectedKeys));
 		} catch {
 			return null;
 		}
-		if (values.length !== entries.length) throw remoteError("InternalError", `get_many outcome count mismatch: ${values.length} != ${entries.length}`);
+		if (loaded.length !== selectedIndices.length) throw remoteError("InternalError", `get_many outcome count mismatch: ${loaded.length} != ${selectedIndices.length}`);
+		for (let index = 0; index < loaded.length; index += 1) {
+			values[selectedIndices[index]] = loaded[index];
+			loaded[index] = null;
+		}
 		return {
 			entries,
-			values
+			values,
+			trusted
 		};
 	}
 	async resolveVisibleIndexedRow(txId, def, physicalKey) {
 		const decoded = decodeIndexEntryKey(physicalKey);
+		const state = this.inspectIndexedValue(txId, def, physicalKey, decoded.primaryKey);
+		if (state === "missing") {
+			this.cleanupStaleIndexRow(txId, def, physicalKey);
+			return null;
+		}
 		const value = this.readRawValue(txId, def.store, decoded.primaryKey);
-		return this.resolveVisibleIndexedValue(txId, def, physicalKey, decoded, value);
+		return this.resolveVisibleIndexedValue(txId, def, physicalKey, decoded, value, state === "trusted");
 	}
-	async resolveVisibleIndexedValue(txId, def, physicalKey, decoded, rawValue) {
+	async resolveVisibleIndexedValue(txId, def, physicalKey, decoded, rawValue, trusted = false) {
 		if (rawValue === null) {
 			this.cleanupStaleIndexRow(txId, def, physicalKey);
 			return null;
 		}
 		const value = await this.decodeStoreValue(txId, def.store, normalizeWasmBytes(rawValue));
-		const currentLogicalKey = extractLogicalIndexKey(def, value);
-		if (currentLogicalKey === null || !bytesEqual(currentLogicalKey, decoded.logicalKey)) {
-			this.cleanupStaleIndexRow(txId, def, physicalKey);
-			return null;
+		if (!trusted) {
+			const currentLogicalKey = extractLogicalIndexKey(def, value);
+			if (currentLogicalKey === null || !bytesEqual(currentLogicalKey, decoded.logicalKey)) {
+				this.cleanupStaleIndexRow(txId, def, physicalKey);
+				return null;
+			}
 		}
 		return {
 			key: decoded.primaryKey,
@@ -2098,6 +2722,7 @@ var DbWorker = class {
 		}
 	}
 	clearTxCaches() {
+		this.primaryCursors.clear();
 		this.txChanges.clear();
 		this.txModes.clear();
 		this.txIndexSchemas.clear();