@moyodb/sdk 1.4.0 → 1.5.0

package/dist/node.js

@@ -1,4 +1,4 @@
-import { $ as StoreExistsError, A as prefixRange, B as DatabaseClosedError, C as compoundKey, Ct as isWorkerProtocolReadyEnvelope, D as indexKey, Dt as isWorkerProtocolResponseBatchMessage, E as encodeIndexScalar, F as utf8Encode, G as InvalidRangeError, Gt as isRecord$1, H as InjectedFailureError, Ht as workerProtocolError, I as ChangeFeedCompactedError, J as ReadonlyTransactionError, K as KeyTooLargeError, L as ConstraintError, M as splitCompoundKey, N as u64Key, Nt as prepareWorkerCommandPayload, O as jsonDecode, Ot as isWorkerProtocolResponseMessage, P as utf8Decode, Q as StorageError, R as CorruptionError, S as toPublicIndexDefinitions, T as encodeCompoundKeyParts, U as InternalError, Ut as clampTimerDelayMs, V as IndexNotFoundError, W as InvalidOpenOptionsError, Wt as compareStringsByCodeUnit, X as ReservedStoreNameError, Y as RecoveryRequiredError, Z as SerializationError, _ as indexRangeToPhysicalRange, a as createIndexKeyExtractor, at as UnsupportedPlatformError, b as normalizeIndexDefinitions, c as decodeIndexedDocument, ct as WriteTransactionAlreadyOpenError, d as encodeIndexMetadataValue, et as StoreNameTooLongError, f as extractLogicalIndexKey, ft as WORKER_PROTOCOL_REQUEST, g as indexKeyExactRange, gt as captureWorkerPayload, h as indexDefinitionIdentity, i as compareNormalizedIndexDefinitions, it as UniqueIndexConstraintError, j as prefixSuccessor, k as jsonEncode, l as encodeIndexEntryKey, lt as normalizeError, m as findIndexDefinition, n as assertPublicStoreName, nt as TransactionClosedError, o as decodeIndexEntryKey, ot as ValueTooLargeError, p as extractLogicalIndexKeyFromDocument, pt as WORKER_PROTOCOL_REQUEST_BATCH, q as MoyoDbError, r as cloneNormalizedIndexDefinitions, rt as TransactionConflictError, s as decodeIndexMetadataValue, st as VersionError, t as INDEX_METADATA_STORE, tt as StoreNotFoundError, u as encodeIndexMetadataKey, v as indexesForStore, vt as decodeWorkerResponsePayload, w as compoundKeyRange, wt as isWorkerProtocolReadyMessage, x as serializeNormalizedIndexDefinitions, y as isInternalStoreName, yt as deserializeWorkerError, z as DatabaseBusyError } from "./chunks/indexing-B0duqlUs.js";
+import { $ as SerializationError, A as jsonDecode, At as isWorkerProtocolResponseMessage, B as CorruptionError, C as serializeNormalizedIndexDefinitions, D as encodeCompoundKeyParts, E as compoundKeyRange, Et as isWorkerProtocolReadyMessage, F as u64Key, Ft as prepareWorkerCommandPayload, G as InternalError, Gt as clampTimerDelayMs, H as DatabaseClosedError, I as utf8Decode, J as KeyTooLargeError, K as InvalidOpenOptionsError, Kt as compareStringsByCodeUnit, L as utf8Encode, M as prefixRange, N as prefixSuccessor, O as encodeIndexScalar, P as splitCompoundKey, Q as ReservedStoreNameError, R as ChangeFeedCompactedError, S as normalizeIndexDefinitions, T as compoundKey, Tt as isWorkerProtocolReadyEnvelope, U as IndexNotFoundError, V as DatabaseBusyError, W as InjectedFailureError, Wt as workerProtocolError, X as ReadonlyTransactionError, Y as MoyoDbError, Z as RecoveryRequiredError, _ as indexDefinitionIdentity, a as cloneNormalizedIndexDefinitions, at as TransactionConflictError, b as indexesForStore, bt as decodeWorkerResponsePayload, c as decodeIndexEntryKey, ct as ValueTooLargeError, d as encodeIndexEntryKey, dt as normalizeError, et as StorageError, f as encodeIndexMetadataKey, g as findIndexDefinition, h as extractLogicalIndexKeyFromDocument, ht as WORKER_PROTOCOL_REQUEST_BATCH, i as assertValidScanRange, it as TransactionClosedError, j as jsonEncode, k as indexKey, kt as isWorkerProtocolResponseBatchMessage, l as decodeIndexMetadataValue, lt as VersionError, m as extractLogicalIndexKey, mt as WORKER_PROTOCOL_REQUEST, n as MAX_ENGINE_SCAN_LIMIT, nt as StoreNameTooLongError, o as compareNormalizedIndexDefinitions, ot as UniqueIndexConstraintError, p as encodeIndexMetadataValue, q as InvalidRangeError, qt as isRecord$1, r as assertPublicStoreName, rt as StoreNotFoundError, s as createIndexKeyExtractor, st as UnsupportedPlatformError, t as INDEX_METADATA_STORE, tt as StoreExistsError, u as decodeIndexedDocument, ut as WriteTransactionAlreadyOpenError, v as indexKeyExactRange, vt as captureWorkerPayload, w as toPublicIndexDefinitions, x as isInternalStoreName, xt as deserializeWorkerError, y as indexRangeToPhysicalRange, z as ConstraintError } from "./chunks/indexing-DdpU69Fd.js";
 import { createHash, randomUUID } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
@@ -277,7 +277,7 @@ var WorkerProtocolClient = class {
 			}, this.requestTimeoutMs) : null;
 			this.pending.set(id, {
 				command: responseCommand,
-				resolve: (value) => resolve(value),
+				resolve,
 				reject,
 				timeout
 			});
@@ -291,9 +291,21 @@ var WorkerProtocolClient = class {
 		});
 	}
 	queueRequest(message, transfer) {
-		const captured = captureWorkerPayload(message, transfer);
 		if (!this.pending.has(message.id)) return;
-		if (this.queuedRequests.length > 0 && this.queuedBytes + captured.byteLength > 1048576) this.flushRequests();
+		const byteLength = payloadBytes(message);
+		if (this.queuedRequests.length > 0 && this.queuedBytes + byteLength > 1048576) this.flushRequests();
+		if (this.queuedRequests.length + 1 >= 128 || this.queuedBytes + byteLength >= 1048576) {
+			this.queuedRequests.push({
+				message,
+				transfer,
+				byteLength
+			});
+			this.queuedBytes += byteLength;
+			this.flushRequests();
+			return;
+		}
+		const captured = snapshotQueuedPayload(message, transfer);
+		if (!this.pending.has(message.id)) return;
 		this.queuedRequests.push({
 			message: captured.value,
 			transfer: captured.transfer,
@@ -307,7 +319,6 @@ var WorkerProtocolClient = class {
 				this.flushRequests();
 			});
 		}
-		if (this.queuedRequests.length >= 128 || this.queuedBytes >= 1048576) this.flushRequests();
 	}
 	flushRequests() {
 		const queued = this.queuedRequests;
@@ -417,6 +428,203 @@ var WorkerProtocolClient = class {
 		if (notifyFatal) this.fatalHandler?.(reason);
 	}
 };
+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/registry.ts
 var VALID_FAILPOINTS = /* @__PURE__ */ new Set([
@@ -493,10 +701,15 @@ function normalizeOptions(options = {}) {
 function sameChangeFeed(left, right) {
 	return left?.enabled === right?.enabled && left?.retainTxids === right?.retainTxids;
 }
+function liveOptionsMismatch(dbName, current, next) {
+	if (current.workerMode !== next.workerMode) return `database ${dbName} is already open with workerMode=${current.workerMode}`;
+	if (current.cachePages !== next.cachePages) return `database ${dbName} is already open in this tab with cachePages=${current.cachePages}; requested cachePages=${next.cachePages}`;
+	if (next.changeFeed !== null && !sameChangeFeed(current.changeFeed, next.changeFeed)) return `database ${dbName} is already open in this tab with a different changeFeed policy`;
+	return null;
+}
 function assertCompatibleOptions(dbName, current, next) {
-	if (current.workerMode !== next.workerMode) throw new InvalidOpenOptionsError(`database ${dbName} is already open with workerMode=${current.workerMode}`);
-	if (current.cachePages !== next.cachePages) throw new InvalidOpenOptionsError(`database ${dbName} is already open in this tab with cachePages=${current.cachePages}; requested cachePages=${next.cachePages}`);
-	if (next.changeFeed !== null && !sameChangeFeed(current.changeFeed, next.changeFeed)) throw new InvalidOpenOptionsError(`database ${dbName} is already open in this tab with a different changeFeed policy`);
+	const mismatch = liveOptionsMismatch(dbName, current, next);
+	if (mismatch !== null) throw new InvalidOpenOptionsError(mismatch);
 }
 function emitListeners(listeners) {
 	for (const listener of Array.from(listeners)) listener();
@@ -597,6 +810,45 @@ function hasKeyPrefix(key, prefix) {
 	for (let index = 0; index < prefix.byteLength; index += 1) if (key[index] !== prefix[index]) return false;
 	return true;
 }
+function matchesPrefix(change, prefix) {
+	return change.kind === "clear" || change.kind === "drop" || hasKeyPrefix(change.key, prefix);
+}
+function includesStoreLevelChange(changes) {
+	for (let index = 0; index < changes.length; index += 1) {
+		const kind = changes[index].kind;
+		if (kind === "clear" || kind === "drop") return true;
+	}
+	return false;
+}
+function prefixBytesOverlap(left, right) {
+	const limit = Math.min(left.byteLength, right.byteLength);
+	for (let index = 0; index < limit; index += 1) if (left[index] !== right[index]) return false;
+	return true;
+}
+function sharedChanges(changes, prefix) {
+	if (prefix === null) return changes;
+	let selected = null;
+	for (let index = 0; index < changes.length; index += 1) {
+		const change = changes[index];
+		if (matchesPrefix(change, prefix)) {
+			if (selected !== null) selected.push(change);
+			continue;
+		}
+		if (selected === null) selected = changes.slice(0, index);
+	}
+	if (selected === null) return changes.length === 0 ? null : changes;
+	return selected.length === 0 ? null : selected;
+}
+function viewsIntersect(leftPrefix, rightPrefix, hasStoreLevel) {
+	if (leftPrefix === null || rightPrefix === null) return true;
+	if (prefixBytesOverlap(leftPrefix, rightPrefix)) return true;
+	return hasStoreLevel();
+}
+function laterViewIntersects(deliveries, index, hasStoreLevel) {
+	const prefix = deliveries[index].entry.keyPrefix;
+	for (let later = index + 1; later < deliveries.length; later += 1) if (viewsIntersect(prefix, deliveries[later].entry.keyPrefix, hasStoreLevel)) return true;
+	return false;
+}
 function normalizeSubscriptionSpec(arg1, arg2, arg3) {
 	if (typeof arg1 === "function") {
 		if (arg2 !== void 0 || arg3 !== void 0) throw new TypeError("subscribe(callback) accepts exactly one callback argument");
@@ -673,23 +925,39 @@ var SubscriptionHub = class {
 	#handleMessage(payload) {
 		if (!isCommitAppliedEvent(payload) || payload.dbName !== this.#dbName || this.#entries.size === 0) return;
 		const entries = Array.from(this.#entries);
-		for (const storeEvent of payload.stores) for (const entry of entries) {
-			if (!entry.active) continue;
-			if (entry.store !== null && entry.store !== storeEvent.store) continue;
-			let changes;
-			const keyPrefix = entry.keyPrefix;
-			if (keyPrefix === null) changes = cloneChanges(storeEvent.changes);
-			else {
-				changes = cloneChanges(storeEvent.changes.filter((change) => change.kind === "clear" || change.kind === "drop" || hasKeyPrefix(change.key, keyPrefix)));
-				if (changes.length === 0) continue;
-			}
-			try {
-				entry.callback(storeEvent.store, changes, payload.txid);
-			} catch (error) {
-				queueMicrotask(() => {
-					throw error;
+		for (const storeEvent of payload.stores) {
+			const deliveries = [];
+			for (const entry of entries) {
+				if (!entry.active) continue;
+				if (entry.store !== null && entry.store !== storeEvent.store) continue;
+				const changes = sharedChanges(storeEvent.changes, entry.keyPrefix);
+				if (changes === null) continue;
+				deliveries.push({
+					entry,
+					changes
 				});
 			}
+			if (deliveries.length > 1) {
+				let storeLevel;
+				const hasStoreLevel = () => {
+					if (storeLevel === void 0) storeLevel = includesStoreLevelChange(storeEvent.changes);
+					return storeLevel;
+				};
+				for (let index = 0; index < deliveries.length; index += 1) {
+					if (!laterViewIntersects(deliveries, index, hasStoreLevel)) continue;
+					deliveries[index].changes = cloneChanges(deliveries[index].changes);
+				}
+			}
+			for (const delivery of deliveries) {
+				if (!delivery.entry.active) continue;
+				try {
+					delivery.entry.callback(storeEvent.store, delivery.changes, payload.txid);
+				} catch (error) {
+					queueMicrotask(() => {
+						throw error;
+					});
+				}
+			}
 		}
 	}
 };
@@ -2200,6 +2468,9 @@ function compareBytes(left, right) {
 var INDEX_SCAN_PAGE_ROWS = 256;
 var SCAN_PAGE_ROWS = 256;
 var SCAN_PAGE_BYTES = 8389662;
+/** Reused when a put has no ttl, or a scan range is omitted. Do not mutate. */
+var EMPTY_RANGE = Object.freeze({});
+var EMPTY_PUT_OPTIONS = Object.freeze({});
 async function callProxy(fn) {
 	try {
 		return await fn();
@@ -2239,12 +2510,12 @@ var TransactionImpl = class {
 		assertPublicStoreName(store);
 		return callProxy(() => this.#entry.proxy.has(this.#txId, store, key));
 	}
-	async put(store, key, value, options = {}) {
+	async put(store, key, value, options) {
 		this.#ensureOpen();
 		assertPublicStoreName(store);
 		return callProxy(() => this.#entry.proxy.put(this.#txId, store, key, value, normalizePutOptions(options)));
 	}
-	async putMany(store, entries, options = {}) {
+	async putMany(store, entries, options) {
 		this.#ensureOpen();
 		assertPublicStoreName(store);
 		return callProxy(() => this.#entry.proxy.putMany(this.#txId, store, entries, normalizePutOptions(options)));
@@ -2264,10 +2535,12 @@ var TransactionImpl = class {
 		assertPublicStoreName(store);
 		return callProxy(() => this.#entry.proxy.applyBatch(this.#txId, store, ops));
 	}
-	async scan(store, range = {}) {
+	async scan(store, range) {
 		this.#ensureOpen();
 		assertPublicStoreName(store);
-		return callProxy(() => this.#entry.proxy.scan(this.#txId, store, range));
+		const bounds = range ?? EMPTY_RANGE;
+		assertValidScanRange(bounds);
+		return callProxy(() => this.#entry.proxy.scan(this.#txId, store, bounds));
 	}
 	async scanPage(store, range = {}, options = {}) {
 		this.#ensureOpen();
@@ -2300,19 +2573,31 @@ var TransactionImpl = class {
 		assertPublicStoreName(store);
 		return callProxy(() => this.#entry.proxy.getByIndex(this.#txId, store, indexName, key));
 	}
-	async *scanByIndex(store, indexName, range = {}, options = {}) {
+	async *scanByIndex(store, indexName, range = EMPTY_RANGE, options = {}) {
 		this.#ensureOpen();
 		assertPublicStoreName(store);
 		const { maxRows: pageRows, maxBytes } = normalizeScanPageOptions(options);
+		const bounds = range;
+		assertValidScanRange(bounds);
 		let remaining = range.limit ?? Number.POSITIVE_INFINITY;
 		let cursor = null;
+		const proxy = this.#entry.proxy;
+		const txId = this.#txId;
 		while (remaining > 0) {
 			this.#ensureOpen();
 			const pageLimit = Math.min(remaining, pageRows, INDEX_SCAN_PAGE_ROWS);
-			const resumeAfter = cursor;
-			const page = await callProxy(() => this.#entry.proxy.scanByIndexPage(this.#txId, store, indexName, range, resumeAfter, pageLimit, maxBytes));
-			for (const row of page.rows) yield [row.key, row.value];
-			remaining -= page.rows.length;
+			let page;
+			try {
+				page = await proxy.scanByIndexPage(txId, store, indexName, bounds, cursor, pageLimit, maxBytes);
+			} catch (error) {
+				throw normalizeError(error);
+			}
+			const rows = page.rows;
+			for (let index = 0; index < rows.length; index += 1) {
+				const row = rows[index];
+				yield [row.key, row.value];
+			}
+			remaining -= rows.length;
 			if (page.cursor === null) return;
 			cursor = page.cursor;
 		}
@@ -2490,7 +2775,7 @@ var DBImpl = class {
 		assertPublicStoreName(store);
 		return this.#autocommit("readonly", "has", [store, key]);
 	}
-	async put(store, key, value, options = {}) {
+	async put(store, key, value, options) {
 		assertPublicStoreName(store);
 		await this.#autocommit("readwrite", "put", [
 			store,
@@ -2503,9 +2788,9 @@ var DBImpl = class {
 		assertPublicStoreName(store);
 		return this.#autocommit("readwrite", "delete", [store, key]);
 	}
-	async scan(store, range = {}) {
+	async scan(store, range) {
 		assertPublicStoreName(store);
-		return this.#autocommit("readonly", "scan", [store, range]);
+		return this.#autocommit("readonly", "scan", [store, range ?? EMPTY_RANGE]);
 	}
 	async scanPage(store, range = {}, options = {}) {
 		this.#ensureOpen();
@@ -2695,10 +2980,10 @@ var MigrationTransactionImpl = class {
 	async has(store, key) {
 		return this.#inner.has(store, key);
 	}
-	async put(store, key, value, options = {}) {
+	async put(store, key, value, options) {
 		await this.#inner.put(store, key, value, options);
 	}
-	async putMany(store, entries, options = {}) {
+	async putMany(store, entries, options) {
 		await this.#inner.putMany(store, entries, options);
 	}
 	async delete(store, key) {
@@ -2710,7 +2995,7 @@ var MigrationTransactionImpl = class {
 	async applyBatch(store, ops) {
 		await this.#inner.applyBatch(store, ops);
 	}
-	async scan(store, range = {}) {
+	async scan(store, range) {
 		return this.#inner.scan(store, range);
 	}
 	scanPage(store, range = {}, options = {}) {
@@ -2788,13 +3073,13 @@ var MigrationDbImpl = class {
 	async has(store, key) {
 		return this.#transaction.has(store, key);
 	}
-	async put(store, key, value, options = {}) {
+	async put(store, key, value, options) {
 		await this.#transaction.put(store, key, value, options);
 	}
 	async delete(store, key) {
 		return this.#transaction.delete(store, key);
 	}
-	async scan(store, range = {}) {
+	async scan(store, range) {
 		return this.#transaction.scan(store, range);
 	}
 	scanPage(store, range = {}, options = {}) {
@@ -2929,9 +3214,12 @@ function normalizeSchemaVersion(value) {
 	return normalizeOptionalNonNegativeSafeInteger(value, "version must be a non-negative safe integer", invalidOpenOptionsError);
 }
 function normalizePutOptions(options) {
-	const { ttl } = normalizeOptionsObject(options, "put options must be an object");
-	const normalizedTtl = normalizeOptionalNonNegativeSafeInteger(ttl, "ttl must be a non-negative safe integer");
-	return normalizedTtl === void 0 ? {} : { ttl: normalizedTtl };
+	if (options === void 0) return EMPTY_PUT_OPTIONS;
+	if (options === null || typeof options !== "object" || Array.isArray(options)) throw new TypeError("put options must be an object");
+	const ttl = options.ttl;
+	if (ttl === void 0) return EMPTY_PUT_OPTIONS;
+	if (typeof ttl !== "number" || !Number.isSafeInteger(ttl) || ttl < 0) throw new TypeError("ttl must be a non-negative safe integer");
+	return { ttl };
 }
 function normalizeCompressionOptions(options, message, allowSnappy) {
 	const { compression } = normalizeOptionsObject(options, message);
@@ -3424,6 +3712,6 @@ async function unsafeDebugCrashNodeWorker(name, options) {
 	});
 }
 //#endregion
-export { ChangeFeedCompactedError, ConstraintError, CorruptionError, DatabaseBusyError, DatabaseClosedError, INDEX_METADATA_STORE, IndexNotFoundError, InjectedFailureError, InternalError, InvalidOpenOptionsError, InvalidRangeError, KeyTooLargeError, MoyoDbError, ReadonlyTransactionError, RecordIndex, RecordStore, RecoveryRequiredError, ReservedStoreNameError, SerializationError, SqlSchemaError, SqlSyntaxError, SqlTypeError, StorageError, StoreExistsError, StoreNameTooLongError, StoreNotFoundError, TransactionClosedError, TransactionConflictError, UniqueIndexConstraintError, UnsupportedPlatformError, ValueTooLargeError, VersionError, WriteTransactionAlreadyOpenError, assertPublicStoreName, cloneNormalizedIndexDefinitions, compareNormalizedIndexDefinitions, compoundKey, compoundKeyCodec, compoundKeyRange, createIndexKeyExtractor, createRecordStore, createSqlClient, decodeIndexEntryKey, decodeIndexMetadataValue, decodeIndexedDocument, deleteNodeDB, encodeCompoundKeyParts, encodeIndexEntryKey, encodeIndexMetadataKey, encodeIndexMetadataValue, encodeIndexScalar, extractLogicalIndexKey, extractLogicalIndexKeyFromDocument, findIndexDefinition, indexDefinitionIdentity, indexKey, indexKeyExactRange, indexRangeToPhysicalRange, indexesForStore, isInternalStoreName, jsonDecode, jsonEncode, jsonRecordCodec, keyCodecs, normalizeError, normalizeIndexDefinitions, openNodeDB, openRecordStore, prefixRange, prefixSuccessor, scalarKeyCodec, serializeNormalizedIndexDefinitions, splitCompoundKey, toPublicIndexDefinitions, u64Key, unsafeDebugCrashNodeWorker, utf8Decode, utf8Encode, withRecordTransaction };
+export { ChangeFeedCompactedError, ConstraintError, CorruptionError, DatabaseBusyError, DatabaseClosedError, INDEX_METADATA_STORE, IndexNotFoundError, InjectedFailureError, InternalError, InvalidOpenOptionsError, InvalidRangeError, KeyTooLargeError, MAX_ENGINE_SCAN_LIMIT, MoyoDbError, ReadonlyTransactionError, RecordIndex, RecordStore, RecoveryRequiredError, ReservedStoreNameError, SerializationError, SqlSchemaError, SqlSyntaxError, SqlTypeError, StorageError, StoreExistsError, StoreNameTooLongError, StoreNotFoundError, TransactionClosedError, TransactionConflictError, UniqueIndexConstraintError, UnsupportedPlatformError, ValueTooLargeError, VersionError, WriteTransactionAlreadyOpenError, assertPublicStoreName, assertValidScanRange, cloneNormalizedIndexDefinitions, compareNormalizedIndexDefinitions, compoundKey, compoundKeyCodec, compoundKeyRange, createIndexKeyExtractor, createRecordStore, createSqlClient, decodeIndexEntryKey, decodeIndexMetadataValue, decodeIndexedDocument, deleteNodeDB, encodeCompoundKeyParts, encodeIndexEntryKey, encodeIndexMetadataKey, encodeIndexMetadataValue, encodeIndexScalar, extractLogicalIndexKey, extractLogicalIndexKeyFromDocument, findIndexDefinition, indexDefinitionIdentity, indexKey, indexKeyExactRange, indexRangeToPhysicalRange, indexesForStore, isInternalStoreName, jsonDecode, jsonEncode, jsonRecordCodec, keyCodecs, normalizeError, normalizeIndexDefinitions, openNodeDB, openRecordStore, prefixRange, prefixSuccessor, scalarKeyCodec, serializeNormalizedIndexDefinitions, splitCompoundKey, toPublicIndexDefinitions, u64Key, unsafeDebugCrashNodeWorker, utf8Decode, utf8Encode, withRecordTransaction };
 
 //# sourceMappingURL=node.js.map