@ohos-ports/lmdb 2.5.3 → 2.8.5-beta.0

package/dist/index.cjs

@@ -6,7 +6,6 @@ var module$1 = require('module');
 var pathModule = require('path');
 var url = require('url');
 var loadNAPI = require('node-gyp-build-optional-packages');
-var v8 = require('v8');
 var events = require('events');
 var os$1 = require('os');
 var fs$1 = require('fs');
@@ -39,14 +38,12 @@ var loadNAPI__default = /*#__PURE__*/_interopDefaultLegacy(loadNAPI);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$1);
 var orderedBinary__namespace = /*#__PURE__*/_interopNamespace(orderedBinary$1);
 
-let Env, Txn, Dbi, Compression, Cursor, getAddress; exports.clearKeptObjects = void 0; let setGlobalBuffer, arch, fs, os, tmpdir, lmdbError, path, EventEmitter, orderedBinary, MsgpackrEncoder, WeakLRUCache, getByBinary, detachBuffer, write, position, iterate, prefetch, resetTxn, getCurrentValue, getCurrentShared, getStringByBinary, getSharedByBinary, compress;
-
+let Env, Txn, Dbi, Compression, Cursor, getAddress, getBufferAddress; exports.clearKeptObjects = void 0; let globalBuffer, setGlobalBuffer, arch, fs, os, tmpdir, lmdbError, path, EventEmitter, orderedBinary, MsgpackrEncoder, WeakLRUCache, getByBinary, startRead, setReadCallback, write, position, iterate, prefetch, resetTxn, getCurrentValue, getStringByBinary, getSharedBuffer, compress;
 path = pathModule__default["default"];
-let dirName = (typeof __dirname == 'string' ? __dirname : // for bun, which doesn't have fileURLToPath
-	pathModule.dirname(url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || new URL('index.cjs', document.baseURI).href))))).replace(/dist$/, ''); // for node, which doesn't have __dirname in ESM
+let dirName = pathModule.dirname(url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index.cjs', document.baseURI).href)))).replace(/dist$/, '');
 let nativeAddon = loadNAPI__default["default"](dirName);
 
-if (process.isBun) {
+if (process.isBun && false) {
 	const { linkSymbols, FFIType } = require('bun:ffi');
 	let lmdbLib = linkSymbols({
 		getByBinary: {
@@ -87,19 +84,24 @@ function setNativeFunctions(externals) {
 	Dbi = externals.Dbi;
 	Compression = externals.Compression;
 	getAddress = externals.getAddress;
+	getBufferAddress = externals.getBufferAddress;
 	externals.createBufferForAddress;
 	exports.clearKeptObjects = externals.clearKeptObjects || function() {};
 	getByBinary = externals.getByBinary;
-	detachBuffer  = externals.detachBuffer;
+	externals.detachBuffer;
+	startRead = externals.startRead;
+	setReadCallback = externals.setReadCallback;
 	setGlobalBuffer = externals.setGlobalBuffer;
+	globalBuffer = externals.globalBuffer;
+	getSharedBuffer = externals.getSharedBuffer;
 	prefetch = externals.prefetch;
 	iterate = externals.iterate;
 	position = externals.position;
 	resetTxn = externals.resetTxn;
 	getCurrentValue = externals.getCurrentValue;
-	getCurrentShared = externals.getCurrentShared;
+	externals.getCurrentShared;
 	getStringByBinary = externals.getStringByBinary;
-	getSharedByBinary = externals.getSharedByBinary;
+	externals.getSharedByBinary;
 	write = externals.write;
 	compress = externals.compress;
 	Cursor = externals.Cursor;
@@ -119,36 +121,38 @@ function setExternals(externals) {
 	externals.onExit;
 }
 
-function when(promise, callback, errback) {
-  if (promise && promise.then) {
-    return errback ?
-      promise.then(callback, errback) :
-      promise.then(callback);
-  }
-  return callback(promise);
+function when(promise, callback, errback) {
+  if (promise && promise.then) {
+    return errback ?
+      promise.then(callback, errback) :
+      promise.then(callback);
+  }
+  return callback(promise);
 }
 
 var backpressureArray;
 
 const WAITING_OPERATION = 0x2000000;
-const BACKPRESSURE_THRESHOLD = 100000;
+const BACKPRESSURE_THRESHOLD = 300000;
 const TXN_DELIMITER = 0x8000000;
 const TXN_COMMITTED = 0x10000000;
 const TXN_FLUSHED = 0x20000000;
 const TXN_FAILED = 0x40000000;
 const FAILED_CONDITION = 0x4000000;
-const REUSE_BUFFER_MODE = 512;
+const REUSE_BUFFER_MODE$1 = 512;
 const RESET_BUFFER_MODE = 1024;
 const NO_RESOLVE = 16;
 const HAS_TXN = 8;
+const CONDITIONAL_VERSION_LESS_THAN = 0x800;
+const CONDITIONAL_ALLOW_NOTFOUND = 0x800;
 
 const SYNC_PROMISE_SUCCESS = Promise.resolve(true);
 const SYNC_PROMISE_FAIL = Promise.resolve(false);
 SYNC_PROMISE_SUCCESS.isSync = true;
 SYNC_PROMISE_FAIL.isSync = true;
 const PROMISE_SUCCESS = Promise.resolve(true);
-const ABORT = {};
-const IF_EXISTS = 3.542694326329068e-103;
+const ABORT = 4.452694326329068e-106; // random/unguessable numbers, which work across module/versions and native
+const IF_EXISTS$1 = 3.542694326329068e-103;
 const CALLBACK_THREW = {};
 const LocalSharedArrayBuffer = typeof Deno != 'undefined' ? ArrayBuffer : SharedArrayBuffer; // Deno can't handle SharedArrayBuffer as an FFI argument due to https://github.com/denoland/deno/issues/12678
 const ByteArray = typeof Buffer != 'undefined' ? function(buffer) { return Buffer.from(buffer) } : Uint8Array;
@@ -159,18 +163,23 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 	eventTurnBatching, txnStartThreshold, batchStartThreshold, overlappingSync, commitDelay, separateFlushed, maxFlushDelay }) {
 	//  stands for write instructions
 	var dynamicBytes;
-	function allocateInstructionBuffer() {
+	function allocateInstructionBuffer(lastPosition) {
 		// Must use a shared buffer on older node in order to use Atomics, and it is also more correct since we are 
 		// indeed accessing and modifying it from another thread (in C). However, Deno can't handle it for
 		// FFI so aliased above
 		let buffer = new LocalSharedArrayBuffer(WRITE_BUFFER_SIZE);
+		let lastBytes = dynamicBytes;
 		dynamicBytes = new ByteArray(buffer);
 		let uint32 = dynamicBytes.uint32 = new Uint32Array(buffer, 0, WRITE_BUFFER_SIZE >> 2);
-		uint32[0] = 0;
+		uint32[2] = 0;
 		dynamicBytes.float64 = new Float64Array(buffer, 0, WRITE_BUFFER_SIZE >> 3);
-		buffer.address = getAddress(dynamicBytes);
+		buffer.address = getBufferAddress(dynamicBytes);
 		uint32.address = buffer.address + uint32.byteOffset;
-		dynamicBytes.position = 0;
+		dynamicBytes.position = 1; // we start at position 1 to save space for writing the txn id before the txn delimiter
+		if (lastPosition) {
+			lastBytes.float64[lastPosition + 1] = dynamicBytes.uint32.address + (dynamicBytes.position << 3);
+			lastBytes.uint32[lastPosition << 1] = 3; // pointer instruction
+		}
 		return dynamicBytes;
 	}
 	var newBufferThreshold = (WRITE_BUFFER_SIZE - maxKeySize - 64) >> 3; // need to reserve more room if we do inline values
@@ -180,7 +189,7 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 	var committed;
 	var abortedNonChildTransactionWarn;
 	var nextTxnCallbacks = [];
-	var commitPromise, flushPromise, flushResolvers = [];
+	var commitPromise, flushPromise, flushResolvers = [], batchFlushResolvers = [];
 	commitDelay = commitDelay || 0;
 	eventTurnBatching = eventTurnBatching === false ? false : true;
 	var enqueuedCommit;
@@ -189,23 +198,25 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 	var enqueuedEventTurnBatch;
 	var batchDepth = 0;
 	var lastWritePromise;
-	var writeBatchStart, outstandingBatchCount, lastSyncTxnFlush, lastFlushTimeout, lastFlushCallback;
+	var writeBatchStart, outstandingBatchCount, lastSyncTxnFlush;
+	var hasUnresolvedTxns;
 	txnStartThreshold = txnStartThreshold || 5;
 	batchStartThreshold = batchStartThreshold || 1000;
 	maxFlushDelay = maxFlushDelay || 500;
 
 	allocateInstructionBuffer();
-	dynamicBytes.uint32[0] = TXN_DELIMITER | TXN_COMMITTED | TXN_FLUSHED;
-	var txnResolution, lastQueuedResolution, nextResolution = {
-		uint32: dynamicBytes.uint32, flagPosition: 0, flag: 0, valueBuffer: null, next: null, meta: null };
+	dynamicBytes.uint32[2] = TXN_DELIMITER | TXN_COMMITTED | TXN_FLUSHED;
+	var txnResolution, nextResolution = {
+		uint32: dynamicBytes.uint32, flagPosition: 2, flag: 0, valueBuffer: null, next: null, meta: null };
 	var uncommittedResolution = {
-		uint32: null, flagPosition: 0, flag: 0, valueBuffer: null, next: nextResolution, meta: null };
+		uint32: null, flagPosition: 2, flag: 0, valueBuffer: null, next: nextResolution, meta: null };
 	var unwrittenResolution = nextResolution;
 	var lastPromisedResolution = uncommittedResolution;
+	var lastQueuedResolution = uncommittedResolution;
 	function writeInstructions(flags, store, key, value, version, ifVersion) {
 		let writeStatus;
 		let targetBytes, position, encoder;
-		let valueBuffer, valueSize, valueBufferStart;
+		let valueSize, valueBuffer, valueBufferStart;
 		if (flags & 2) {
 			// encode first in case we have to write a shared structure
 			encoder = store.encoder;
@@ -213,7 +224,7 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 				valueBuffer = value['\x10binary-data\x02'];
 			else if (encoder) {
 				if (encoder.copyBuffers) // use this as indicator for support buffer reuse for now
-					valueBuffer = encoder.encode(value, REUSE_BUFFER_MODE | (writeTxn ? RESET_BUFFER_MODE : 0)); // in addition, if we are writing sync, after using, we can immediately reset the encoder's position to reuse that space, which can improve performance
+					valueBuffer = encoder.encode(value, REUSE_BUFFER_MODE$1 | (writeTxn ? RESET_BUFFER_MODE : 0)); // in addition, if we are writing sync, after using, we can immediately reset the encoder's position to reuse that space, which can improve performance
 				else { // various other encoders, including JSON.stringify, that might serialize to a string
 					valueBuffer = encoder.encode(value);
 					if (typeof valueBuffer == 'string')
@@ -242,7 +253,11 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 				enqueuedEventTurnBatch = queueTask(() => {
 					try {
 						for (let i = 0, l = beforeCommitCallbacks.length; i < l; i++) {
-							beforeCommitCallbacks[i]();
+							try {
+								beforeCommitCallbacks[i]();
+							} catch(error) {
+								console.error('In beforecommit callback', error);
+							}
 						}
 					} catch(error) {
 						console.error(error);
@@ -276,7 +291,7 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 			try {
 				endPosition = store.writeKey(key, targetBytes, keyStartPosition);
 				if (!(keyStartPosition < endPosition) && (flags & 0xf) != 12)
-					throw new Error('Invalid key or zero length key is not allowed in LMDB')
+					throw new Error('Invalid key or zero length key is not allowed in LMDB ' + key)
 			} catch(error) {
 				targetBytes.fill(0, keyStartPosition);
 				if (error.name == 'RangeError')
@@ -295,14 +310,14 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 				if (valueBufferStart > -1) { // if we have buffers with start/end position
 					// record pointer to value buffer
 					float64[position] = (valueBuffer.address ||
-						(valueBuffer.address = getAddress(valueBuffer))) + valueBufferStart;
+						(valueBuffer.address = getAddress(valueBuffer.buffer))) + valueBufferStart;
 					mustCompress = valueBuffer[valueBufferStart] >= 250; // this is the compression indicator, so we must compress
 				} else {
 					let valueArrayBuffer = valueBuffer.buffer;
 					// record pointer to value buffer
 					let address = (valueArrayBuffer.address ||
 						(valueBuffer.length === 0 ? 0 : // externally allocated buffers of zero-length with the same non-null-pointer can crash node, #161
-						(valueArrayBuffer.address = (getAddress(valueBuffer) - valueBuffer.byteOffset))))
+						valueArrayBuffer.address = getAddress(valueArrayBuffer)))
 							+ valueBuffer.byteOffset;
 					if (address <= 0 && valueBuffer.length > 0)
 						console.error('Supplied buffer had an invalid address', address);
@@ -347,12 +362,8 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 		// uint32[position << 1] = 0 // clear out the next slot
 		let nextUint32;
 		if (position > newBufferThreshold) {
-			// make new buffer and make pointer to it
-			let lastPosition = position;
-			targetBytes = allocateInstructionBuffer();
+			targetBytes = allocateInstructionBuffer(position);
 			position = targetBytes.position;
-			float64[lastPosition + 1] = targetBytes.uint32.address + position;
-			uint32[lastPosition << 1] = 3; // pointer instruction
 			nextUint32 = targetBytes.uint32;
 		} else
 			nextUint32 = uint32;
@@ -366,6 +377,8 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 			next: null,
 			meta: null,
 		};
+		lastQueuedResolution = resolution;
+
 		let writtenBatchDepth = batchDepth;
 
 		return (callback) => {
@@ -393,13 +406,25 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 			if (writeStatus & TXN_DELIMITER) {
 				commitPromise = null; // TODO: Don't reset these if this comes from the batch start operation on an event turn batch
 				flushPromise = null;
+				flushResolvers = [];
 				queueCommitResolution(resolution);
 				if (!startAddress) {
 					startAddress = uint32.address + (flagPosition << 2);
 				}
 			}
-			if (!flushPromise && overlappingSync)
-				flushPromise = new Promise(resolve => flushResolvers.push(resolve));
+			if (!writtenBatchDepth && batchFlushResolvers.length > 0) {
+				flushResolvers.push(...batchFlushResolvers);
+				batchFlushResolvers = [];
+			}
+			if (!flushPromise && overlappingSync) {
+				flushPromise = new Promise(resolve => {
+					if (writtenBatchDepth) {
+						batchFlushResolvers.push(resolve);
+					} else {
+						flushResolvers.push(resolve);
+					}
+				});
+			}
 			if (writeStatus & WAITING_OPERATION) { // write thread is waiting
 				write(env.address, 0);
 			}
@@ -428,11 +453,10 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 				};
 			}
 			resolution.valueBuffer = valueBuffer;
-			lastQueuedResolution = resolution;
 
 			if (callback) {
-				if (callback === IF_EXISTS)
-					ifVersion = IF_EXISTS;
+				if (callback === IF_EXISTS$1)
+					ifVersion = IF_EXISTS$1;
 				else {
 					let meta = resolution.meta || (resolution.meta = {});
 					meta.reject = callback;
@@ -471,15 +495,13 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 			return lastWritePromise;
 		};
 	}
-	let committedFlushResolvers, lastSync = Promise.resolve();
+	Promise.resolve();
 	function startWriting() {
 		if (enqueuedCommit) {
 			clearImmediate(enqueuedCommit);
 			enqueuedCommit = null;
 		}
 		let resolvers = flushResolvers;
-		flushResolvers = [];
-		let start = Date.now();
 		env.startWriting(startAddress, (status) => {
 			if (dynamicBytes.uint32[dynamicBytes.position << 1] & TXN_DELIMITER)
 				queueCommitResolution(nextResolution);
@@ -487,52 +509,30 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 			resolveWrites(true);
 			switch (status) {
 				case 0:
-					if (resolvers.length > 0) {
-						let delay = Date.now() - start;
-						scheduleFlush(resolvers, Math.min((flushPromise && flushPromise.hasCallbacks ? delay >> 1 : delay) + 1, maxFlushDelay));
+					for (let resolver of resolvers) {
+						resolver();
 					}
+					break;
 				case 1:
-				break;
+					break;
 				case 2:
+					hasUnresolvedTxns = false;
 					executeTxnCallbacks();
-				break;
+					return hasUnresolvedTxns;
 				default:
-				console.error(status);
-				if (commitRejectPromise) {
-					commitRejectPromise.reject(status);
-					commitRejectPromise = null;
-				}
+					try {
+						lmdbError(status);
+					} catch(error) {
+						console.error(error);
+						if (commitRejectPromise) {
+							commitRejectPromise.reject(error);
+							commitRejectPromise = null;
+						}
+					}
 			}
 		});
 		startAddress = 0;
 	}
-	function scheduleFlush(resolvers, delay) {
-		if (committedFlushResolvers)
-			committedFlushResolvers.push(...resolvers);
-		else {
-			committedFlushResolvers = resolvers;
-			lastFlushTimeout = setTimeout(lastFlushCallback = () => {
-				lastFlushTimeout = null;
-				lastSync.then(() => {
-					let resolvers = committedFlushResolvers || [];
-					committedFlushResolvers = null;
-					lastSync = new Promise((resolve) => {
-						env.sync(() => {
-							for (let i = 0; i < resolvers.length; i++)
-								resolvers[i]();
-							resolve();
-						});
-					});
-				});
-			}, delay || 0);
-		}
-	}
-	function expediteFlush() {
-		if (lastFlushTimeout) {
-			clearTimeout(lastFlushTimeout);
-			lastFlushCallback();
-		}
-	}
 
 	function queueCommitResolution(resolution) {
 		if (!(resolution.flag & HAS_TXN)) {
@@ -557,7 +557,7 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 			}
 			outstandingWriteCount--;
 			if (unwrittenResolution.flag !== HAS_TXN) {
-				if (unwrittenResolution.flag === NO_RESOLVE && !unwrittenResolution.store) {
+				if (unwrittenResolution.flag === NO_RESOLVE && !unwrittenResolution.meta) {
 					// in this case we can completely remove from the linked list, clearing more memory
 					lastPromisedResolution.next = unwrittenResolution = unwrittenResolution.next;
 					continue;
@@ -579,7 +579,7 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 	}
 
 	function resolveCommit(async) {
-		afterCommit();
+		afterCommit(txnResolution.uint32[txnResolution.flagPosition - 1]);
 		if (async)
 			resetReadTxn();
 		else
@@ -625,35 +625,38 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 		} else // otherwise the transaction could end at any time and we need to know the
 			// deterministically if it is ending, so we can reset the commit promise
 			// so we use the slower atomic operation
-			return Atomics.or(uint32, flagPosition, newStatus);
+			try {
+				return Atomics.or(uint32, flagPosition, newStatus);
+			} catch(error) {
+			console.error(error);
+			return;
+			}
 	}
-	function afterCommit() {
+	function afterCommit(txnId) {
 		for (let i = 0, l = afterCommitCallbacks.length; i < l; i++) {
-			afterCommitCallbacks[i]({ next: uncommittedResolution, last: unwrittenResolution});
+			try {
+				afterCommitCallbacks[i]({next: uncommittedResolution, last: txnResolution, txnId});
+			} catch(error) {
+				console.error('In aftercommit callback', error);
+			}
 		}
 	}
 	async function executeTxnCallbacks() {
 		env.writeTxn = writeTxn = { write: true };
-		//this.emit('begin-transaction');
-		let promises;
-		let txnCallbacks;
-		for (let i = 0, l = nextTxnCallbacks.length; i < l; i++) {
-			txnCallbacks = nextTxnCallbacks[i];
-			for (let i = 0, l = txnCallbacks.length; i < l; i++) {
-				let userTxnCallback = txnCallbacks[i];
+		nextTxnCallbacks.isExecuting = true;
+		for (let i = 0; i < nextTxnCallbacks.length; i++) {
+			let txnCallbacks = nextTxnCallbacks[i];
+			for (let j = 0, l = txnCallbacks.length; j < l; j++) {
+				let userTxnCallback = txnCallbacks[j];
 				let asChild = userTxnCallback.asChild;
 				if (asChild) {
-					if (promises) {
-						// must complete any outstanding transactions before proceeding
-						await Promise.all(promises);
-						promises = null;
-					}
 					env.beginTxn(1); // abortable
 					let parentTxn = writeTxn;
 					env.writeTxn = writeTxn = { write: true };
 					try {
 						let result = userTxnCallback.callback();
 						if (result && result.then) {
+							hasUnresolvedTxns = true;
 							await result;
 						}
 						if (result === ABORT)
@@ -661,33 +664,32 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 						else
 							env.commitTxn();
 						clearWriteTxn(parentTxn);
-						txnCallbacks[i] = result;
+						txnCallbacks[j] = result;
 					} catch(error) {
 						clearWriteTxn(parentTxn);
 						env.abortTxn();
-						txnError(error, i);
+						txnError(error, txnCallbacks, j);
 					}
 				} else {
 					try {
 						let result = userTxnCallback();
-						txnCallbacks[i] = result;
+						txnCallbacks[j] = result;
 						if (result && result.then) {
-							if (!promises)
-								promises = [];
-							promises.push(result.catch(() => {}));
+							hasUnresolvedTxns = true;
+							await result;
 						}
 					} catch(error) {
-						txnError(error, i);
+						txnError(error, txnCallbacks, j);
 					}
 				}
 			}
 		}
 		nextTxnCallbacks = [];
-		if (promises) { // finish any outstanding commit functions
-			await Promise.all(promises);
-		}
 		clearWriteTxn(null);
-		function txnError(error, i) {
+		if (hasUnresolvedTxns) {
+			env.resumeWriting();
+		}
+		function txnError(error, txnCallbacks, i) {
 			(txnCallbacks.errors || (txnCallbacks.errors = []))[i] = error;
 			txnCallbacks[i] = CALLBACK_THREW;
 		}
@@ -699,18 +701,23 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 		if (writeStatus & WAITING_OPERATION) {
 			write(env.address, 0);
 		}
+		if (dynamicBytes.position > newBufferThreshold) {
+			allocateInstructionBuffer(dynamicBytes.position);
+			nextResolution.flagPosition = dynamicBytes.position << 1;
+			nextResolution.uint32 = dynamicBytes.uint32;
+		}
 	}
 	function clearWriteTxn(parentTxn) {
 		// TODO: We might actually want to track cursors in a write txn and manually
 		// close them.
-		if (writeTxn.cursorCount > 0)
+		if (writeTxn && writeTxn.refCount > 0)
 			writeTxn.isDone = true;
 		env.writeTxn = writeTxn = parentTxn || null;
 	}
 	Object.assign(LMDBStore.prototype, {
 		put(key, value, versionOrOptions, ifVersion) {
 			let callback, flags = 15, type = typeof versionOrOptions;
-			if (type == 'object') {
+			if (type == 'object' && versionOrOptions) {
 				if (versionOrOptions.noOverwrite)
 					flags |= 0x10;
 				if (versionOrOptions.noDupData)
@@ -718,7 +725,7 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 				if (versionOrOptions.append)
 					flags |= 0x20000;
 				if (versionOrOptions.ifVersion != undefined)
-					ifVersion = versionsOrOptions.ifVersion;
+					ifVersion = versionOrOptions.ifVersion;
 				versionOrOptions = versionOrOptions.version;
 				if (typeof ifVersion == 'function')
 					callback = ifVersion;
@@ -733,7 +740,7 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 			if (ifVersionOrValue !== undefined) {
 				if (typeof ifVersionOrValue == 'function')
 					callback = ifVersionOrValue;
-				else if (ifVersionOrValue === IF_EXISTS && !callback)
+				else if (ifVersionOrValue === IF_EXISTS$1 && !callback)
 					// we have a handler for IF_EXISTS in the callback handler for remove
 					callback = ifVersionOrValue;
 				else if (this.useVersions)
@@ -751,11 +758,10 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 		ifNoExists(key, callback) {
 			return this.ifVersion(key, null, callback);
 		},
-
-		ifVersion(key, version, callback) {
+		ifVersion(key, version, callback, options) {
 			if (!callback) {
 				return new Batch((operations, callback) => {
-					let promise = this.ifVersion(key, version, operations);
+					let promise = this.ifVersion(key, version, operations, options);
 					if (callback)
 						promise.then(callback);
 					return promise;
@@ -768,7 +774,12 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 				}
 				return SYNC_PROMISE_FAIL;
 			}
-			let finishStartWrite = writeInstructions(key === undefined || version === undefined ? 1 : 4, this, key, undefined, undefined, version);
+			let flags = key === undefined || version === undefined ? 1 : 4;
+			if (options?.ifLessThan)
+				flags |= CONDITIONAL_VERSION_LESS_THAN;
+			if (options?.allowNotFound)
+				flags |= CONDITIONAL_ALLOW_NOTFOUND;
+			let finishStartWrite = writeInstructions(flags, this, key, undefined, undefined, version);
 			let promise;
 			batchDepth += 2;
 			if (batchDepth > 2)
@@ -805,7 +816,7 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 			return this.ifVersion(undefined, undefined, callbackOrOperations);
 		},
 		drop(callback) {
-			return writeInstructions(1024 + 12, this, undefined, undefined, undefined, undefined)(callback);
+			return writeInstructions(1024 + 12, this, Buffer.from([]), undefined, undefined, undefined)(callback);
 		},
 		clearAsync(callback) {
 			if (this.encoder) {
@@ -814,7 +825,7 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 				else if (this.encoder.structures)
 					this.encoder.structures = [];
 			}
-			return writeInstructions(12, this, undefined, undefined, undefined, undefined)(callback);
+			return writeInstructions(12, this, Buffer.from([]), undefined, undefined, undefined)(callback);
 		},
 		_triggerError() {
 			finishBatch();
@@ -822,20 +833,20 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 
 		putSync(key, value, versionOrOptions, ifVersion) {
 			if (writeTxn)
-				return this.put(key, value, versionOrOptions, ifVersion);
+				return this.put(key, value, versionOrOptions, ifVersion) === SYNC_PROMISE_SUCCESS;
 			else
 				return this.transactionSync(() =>
-					this.put(key, value, versionOrOptions, ifVersion) == SYNC_PROMISE_SUCCESS, overlappingSync? 0x10002 : 2); // non-abortable, async flush
+					this.put(key, value, versionOrOptions, ifVersion) === SYNC_PROMISE_SUCCESS, overlappingSync? 0x10002 : 2); // non-abortable, async flush
 		},
 		removeSync(key, ifVersionOrValue) {
 			if (writeTxn)
-				return this.remove(key, ifVersionOrValue);
+				return this.remove(key, ifVersionOrValue) === SYNC_PROMISE_SUCCESS;
 			else
 				return this.transactionSync(() =>
-					this.remove(key, ifVersionOrValue) == SYNC_PROMISE_SUCCESS, overlappingSync? 0x10002 : 2); // non-abortable, async flush
+					this.remove(key, ifVersionOrValue) === SYNC_PROMISE_SUCCESS, overlappingSync? 0x10002 : 2); // non-abortable, async flush
 		},
 		transaction(callback) {
-			if (writeTxn) {
+			if (writeTxn && !nextTxnCallbacks.isExecuting) {
 				// already nested in a transaction, just execute and return
 				return callback();
 			}
@@ -846,11 +857,13 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 				throw new Error('Child transactions are not supported in writemap mode');
 			if (writeTxn) {
 				let parentTxn = writeTxn;
-				env.writeTxn = writeTxn = { write: true };
+				let thisTxn = env.writeTxn = writeTxn = { write: true };
 				env.beginTxn(1); // abortable
-				let callbackDone;
+				let callbackDone, finishTxn;
 				try {
-					return when(callback(), (result) => {
+					return writeTxn.childResults = when(callback(), finishTxn = (result) => {
+						if (writeTxn !== thisTxn) // need to wait for child txn to finish asynchronously
+							return writeTxn.childResults.then(() => finishTxn(result));
 						callbackDone = true;
 						if (result === ABORT)
 							env.abortTxn();
@@ -875,14 +888,23 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 		transactionAsync(callback, asChild) {
 			let txnIndex;
 			let txnCallbacks;
-			if (!nextResolution.callbacks) {
+			if (lastQueuedResolution.callbacks) {
+				txnCallbacks = lastQueuedResolution.callbacks;
+				txnIndex = txnCallbacks.push(asChild ? { callback, asChild } : callback) - 1;
+			} else if (nextTxnCallbacks.isExecuting) {
 				txnCallbacks = [asChild ? { callback, asChild } : callback];
-				nextResolution.callbacks = txnCallbacks;
-				txnCallbacks.results = writeInstructions(8 | (this.strictAsyncOrder ? 0x100000 : 0), this)();
+				txnCallbacks.results = commitPromise;
+				nextTxnCallbacks.push(txnCallbacks);
 				txnIndex = 0;
 			} else {
-				txnCallbacks = lastQueuedResolution.callbacks;
-				txnIndex = txnCallbacks.push(asChild ? { callback, asChild } : callback) - 1;
+				if (writeTxn)
+					throw new Error('Can not enqueue transaction during write txn');
+				let finishWrite = writeInstructions(8 | (this.strictAsyncOrder ? 0x100000 : 0), this);
+				txnCallbacks = [asChild ? { callback, asChild } : callback];
+				lastQueuedResolution.callbacks = txnCallbacks;
+				lastQueuedResolution.id = Math.random();
+				txnCallbacks.results = finishWrite();
+				txnIndex = 0;
 			}
 			return txnCallbacks.results.then((results) => {
 				let result = txnCallbacks[txnIndex];
@@ -893,7 +915,7 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 		},
 		transactionSync(callback, flags) {
 			if (writeTxn) {
-				if (!useWritemap && !this.isCaching) // can't use child transactions in write maps or caching stores
+				if (!useWritemap && (flags == undefined || (flags & 1))) // can't use child transactions in write maps
 					// already nested in a transaction, execute as child transaction (if possible) and return
 					return this.childTransaction(callback);
 				let result = callback(); // else just run in current transaction
@@ -903,13 +925,17 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 				}
 				return result;
 			}
-			let callbackDone;
+			let callbackDone, finishTxn;
+			this.transactions++;
+			if (!env.address)
+				throw new Error('The database has been closed and you can not transact on it');
+			env.beginTxn(flags == undefined ? 3 : flags);
+			let thisTxn = writeTxn = env.writeTxn = { write: true };
 			try {
-				this.transactions++;
-				env.beginTxn(flags == undefined ? 3 : flags);
-				writeTxn = env.writeTxn = { write: true };
 				this.emit('begin-transaction');
-				return when(callback(), (result) => {
+				return writeTxn.childResults = when(callback(), finishTxn = (result) => {
+					if (writeTxn !== thisTxn) // need to wait for child txn to finish asynchronously
+						return writeTxn.childResults.then(() => finishTxn(result));
 					try {
 						callbackDone = true;
 						if (result === ABORT)
@@ -917,8 +943,6 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 						else {
 							env.commitTxn();
 							resetReadTxn();
-							if ((flags & 0x10000) && overlappingSync) // if it is no-sync in overlapping-sync mode, need to schedule flush for it to be marked as persisted
-								lastSyncTxnFlush = new Promise(resolve => scheduleFlush([resolve]));
 						}
 						return result;
 					} finally {
@@ -963,11 +987,9 @@ function addWriteMethods(LMDBStore, { env, fixedBuffer, resetReadTxn, useWritema
 			let finalPromise = flushPromise || commitPromise || lastWritePromise;
 			if (flushPromise)
 				flushPromise.hasCallbacks = true;
-			if (lastFlushTimeout)
-				expediteFlush();
 			let finalSyncPromise = lastSyncTxnFlush;
 			if (finalPromise && resolvedPromise != finalPromise ||
-					finalSyncPromise && resolvedSyncPromise != finalSyncPromise) {
+					finalSyncPromise ) {
 				return Promise.all([finalPromise, finalSyncPromise]).then(() => this._endWrites(finalPromise, finalSyncPromise), () => this._endWrites(finalPromise, finalSyncPromise));
 			}
 			Object.defineProperty(env, 'sync', { value: null });
@@ -1008,160 +1030,11 @@ function asBinary(buffer) {
 	};
 }
 
-let getLastVersion$1;
-const mapGet = Map.prototype.get;
-const CachingStore = (Store, env) => {
-	let childTxnChanges;
-	return class extends Store {
-	constructor(dbName, options) {
-		super(dbName, options);
-		if (!env.cacheCommitter) {
-			env.cacheCommitter = true;
-			this.on('aftercommit', ({ next, last }) => {
-				do {
-					let meta = next.meta;
-					let store = meta && meta.store;
-					if (store) {
-						if (next.flag & FAILED_CONDITION)
-							store.cache.delete(meta.key); // just delete it from the map
-						else {
-							let expirationPriority = meta.valueSize >> 10;
-							let cache = store.cache;
-							let entry = mapGet.call(cache, meta.key);
-							if (entry)
-								cache.used(entry, expirationPriority + 4); // this will enter it into the LRFU (with a little lower priority than a read)
-						}
-					}
-				} while (next != last && (next = next.next))
-			});
-		}
-		this.db.cachingDb = this;
-		if (options.cache.clearKeptInterval)
-			options.cache.clearKeptObjects = exports.clearKeptObjects;
-		this.cache = new WeakLRUCache(options.cache);
-	}
-	get isCaching() {
-		return true
-	}
-	get(id, cacheMode) {
-		let value = this.cache.getValue(id);
-		if (value !== undefined)
-			return value;
-		value = super.get(id);
-		if (value && typeof value === 'object' && !cacheMode && typeof id !== 'object') {
-			let entry = this.cache.setValue(id, value, this.lastSize >> 10);
-			if (this.useVersions) {
-				entry.version = getLastVersion$1();
-			}
-		}
-		return value;
-	}
-	getEntry(id, cacheMode) {
-		let entry = this.cache.get(id);
-		if (entry)
-			return entry;
-		let value = super.get(id);
-		if (value === undefined)
-			return;
-		if (value && typeof value === 'object' && !cacheMode && typeof id !== 'object') {
-			entry = this.cache.setValue(id, value, this.lastSize >> 10);
-		} else {
-			entry = { value };
-		}
-		if (this.useVersions) {
-			entry.version = getLastVersion$1();
-		}
-		return entry;
-	}
-	putEntry(id, entry, ifVersion) {
-		let result = super.put(id, entry.value, entry.version, ifVersion);
-		if (typeof id === 'object')
-			return result;
-		if (result && result.then)
-			this.cache.setManually(id, entry); // set manually so we can keep it pinned in memory until it is committed
-		else // sync operation, immediately add to cache
-			this.cache.set(id, entry);
-	}
-	put(id, value, version, ifVersion) {
-		let result = super.put(id, value, version, ifVersion);
-		if (typeof id !== 'object') {
-			if (value && value['\x10binary-data\x02']) {
-				// don't cache binary data, since it will be decoded on get
-				this.cache.delete(id);
-				return result;
-			}	
-			// sync operation, immediately add to cache, otherwise keep it pinned in memory until it is committed
-			let entry = this.cache.setValue(id, value, !result || result.isSync ? 0 : -1);
-			if (childTxnChanges)
-				childTxnChanges.add(id);
-			if (version !== undefined)
-				entry.version = typeof version === 'object' ? version.version : version;
-		}
-		return result;
-	}
-	putSync(id, value, version, ifVersion) {
-		if (id !== 'object') {
-			// sync operation, immediately add to cache, otherwise keep it pinned in memory until it is committed
-			if (value && typeof value === 'object') {
-				let entry = this.cache.setValue(id, value);
-				if (childTxnChanges)
-					childTxnChanges.add(id);
-				if (version !== undefined) {
-					entry.version = typeof version === 'object' ? version.version : version;
-				}
-			} else // it is possible that  a value used to exist here
-				this.cache.delete(id);
-		}
-		return super.putSync(id, value, version, ifVersion);
-	}
-	remove(id, ifVersion) {
-		this.cache.delete(id);
-		return super.remove(id, ifVersion);
-	}
-	removeSync(id, ifVersion) {
-		this.cache.delete(id);
-		return super.removeSync(id, ifVersion);
-	}
-	clearAsync(callback) {
-		this.cache.clear();
-		return super.clearAsync(callback);
-	}
-	clearSync() {
-		this.cache.clear();
-		super.clearSync();
-	}
-	childTransaction(callback) {
-		return super.childTransaction(() => {
-			let cache = this.cache;
-			let previousChanges = childTxnChanges;
-			try {
-				childTxnChanges = new Set();
-				return when(callback(), (result) => {
-					if (result === ABORT)
-						return abort();
-					childTxnChanges = previousChanges;
-					return result;
-				}, abort);
-			} catch(error) {
-				abort(error);
-			}
-			function abort(error) {
-				// if the transaction was aborted, remove all affected entries from cache
-				for (let id of childTxnChanges)
-					cache.delete(id);
-				childTxnChanges = previousChanges;
-				if (error)
-					throw error;
-			}
-		});
-	}
-	};
-};
-function setGetLastVersion(get) {
-	getLastVersion$1 = get;
-}
-
 const SKIP = {};
+const DONE = {
+	value: null,
+	done: true,
+};
 if (!Symbol.asyncIterator) {
 	Symbol.asyncIterator = Symbol.for('Symbol.asyncIterator');
 }
@@ -1174,9 +1047,10 @@ class RangeIterable {
 	}
 	map(func) {
 		let source = this;
-		let result = new RangeIterable();
-		result.iterate = (async) => {
+		let iterable = new RangeIterable();
+		iterable.iterate = (async) => {
 			let iterator = source[Symbol.iterator](async);
+			let i = 0;
 			return {
 				next(resolvedResult) {
 					let result;
@@ -1193,31 +1067,38 @@ class RangeIterable {
 						}
 						if (iteratorResult.done === true) {
 							this.done = true;
+							if (iterable.onDone) iterable.onDone();
 							return iteratorResult;
 						}
-						result = func(iteratorResult.value);
+						result = func(iteratorResult.value, i++);
 						if (result && result.then) {
 							return result.then(result =>
-								result == SKIP ?
+								result === SKIP ?
 									this.next() :
 									{
 										value: result
 									});
 						}
-					} while(result == SKIP)
+					} while(result === SKIP);
+					if (result === DONE) {
+						if (iterable.onDone) iterable.onDone();
+						return result;
+					}
 					return {
 						value: result
 					};
 				},
 				return() {
+					if (iterable.onDone) iterable.onDone();
 					return iterator.return();
 				},
 				throw() {
+					if (iterable.onDone) iterable.onDone();
 					return iterator.throw();
 				}
 			};
 		};
-		return result;
+		return iterable;
 	}
 	[Symbol.asyncIterator]() {
 		return this.iterator = this.iterate();
@@ -1226,7 +1107,12 @@ class RangeIterable {
 		return this.iterator = this.iterate();
 	}
 	filter(func) {
-		return this.map(element => func(element) ? element : SKIP);
+		return this.map(element => {
+			let result = func(element);
+			// handle promise
+			if (result?.then) return result.then((result) => result ? element : SKIP);
+			else return result ? element : SKIP;
+		});
 	}
 
 	forEach(callback) {
@@ -1241,27 +1127,103 @@ class RangeIterable {
 		concatIterable.iterate = (async) => {
 			let iterator = this.iterator = this.iterate();
 			let isFirst = true;
-			let concatIterator = {
+			function iteratorDone(result) {
+				if (isFirst) {
+					isFirst = false;
+					iterator = secondIterable[Symbol.iterator](async);
+					result = iterator.next();
+					if (concatIterable.onDone) {
+						if (result.then)
+							result.then((result) => {
+								if (result.done()) concatIterable.onDone();
+							});
+						else if (result.done) concatIterable.onDone();
+					}
+				} else {
+					if (concatIterable.onDone) concatIterable.onDone();
+				}
+				return result;
+			}
+			return {
 				next() {
 					let result = iterator.next();
-					if (isFirst && result.done) {
-						isFirst = false;
-						iterator = secondIterable[Symbol.iterator](async);
-						return iterator.next();
-					}
+					if (result.then)
+						return result.then((result) => {
+							if (result.done) return iteratorDone(result);
+							return result;
+						});
+					if (result.done) return iteratorDone(result);
 					return result;
 				},
 				return() {
+					if (concatIterable.onDone) concatIterable.onDone();
 					return iterator.return();
 				},
 				throw() {
+					if (concatIterable.onDone) concatIterable.onDone();
 					return iterator.throw();
 				}
 			};
-			return concatIterator;
 		};
 		return concatIterable;
 	}
+
+	flatMap(callback) {
+		let mappedIterable = new RangeIterable();
+		mappedIterable.iterate = (async) => {
+			let iterator = this.iterator = this.iterate(async);
+			let currentSubIterator;
+			return {
+				next() {
+					do {
+						if (currentSubIterator) {
+							let result = currentSubIterator.next();
+							if (!result.done) {
+								return result;
+							}
+						}
+						let result = iterator.next();
+						if (result.done) {
+							if (mappedIterable.onDone) mappedIterable.onDone();
+							return result;
+						}
+						let value = callback(result.value);
+						if (Array.isArray(value) || value instanceof RangeIterable)
+							currentSubIterator = value[Symbol.iterator]();
+						else {
+							currentSubIterator = null;
+							return { value };
+						}
+					} while(true);
+				},
+				return() {
+					if (mappedIterable.onDone) mappedIterable.onDone();
+					if (currentSubIterator)
+						currentSubIterator.return();
+					return iterator.return();
+				},
+				throw() {
+					if (mappedIterable.onDone) mappedIterable.onDone();
+					if (currentSubIterator)
+						currentSubIterator.throw();
+					return iterator.throw();
+				}
+			};
+		};
+		return mappedIterable;
+	}
+
+	slice(start, end) {
+		return this.map((element, i) => {
+			if (i < start)
+				return SKIP;
+			if (i >= end) {
+				DONE.value = element;
+				return DONE;
+			}
+			return element;
+		});
+	}
 	next() {
 		if (!this.iterator)
 			this.iterator = this.iterate();
@@ -1271,7 +1233,7 @@ class RangeIterable {
 		if (this.asArray && this.asArray.forEach) {
 			return this.asArray;
 		}
-		throw new Error('Can not serialize async iteratables without first calling resolveJSON');
+		throw new Error('Can not serialize async iterables without first calling resolveJSON');
 		//return Array.from(this)
 	}
 	get asArray() {
@@ -1281,6 +1243,7 @@ class RangeIterable {
 			let iterator = this.iterate();
 			let array = [];
 			let iterable = this;
+			Object.defineProperty(array, 'iterable', { value: iterable });
 			function next(result) {
 				while (result.done !== true) {
 					if (result.then) {
@@ -1290,7 +1253,6 @@ class RangeIterable {
 					}
 					result = iterator.next();
 				}
-				array.iterable = iterable;
 				resolve(iterable._asArray = array);
 			}
 			next(iterator.next());
@@ -1302,146 +1264,173 @@ class RangeIterable {
 		return this.asArray;
 	}
 }
+RangeIterable.prototype.DONE = DONE;
+
+const REUSE_BUFFER_MODE = 512;
+const writeUint32Key = (key, target, start) => {
+	(target.dataView || (target.dataView = new DataView(target.buffer, 0, target.length))).setUint32(start, key, true);
+	return start + 4;
+};
+const readUint32Key = (target, start) => {
+	return (target.dataView || (target.dataView = new DataView(target.buffer, 0, target.length))).getUint32(start, true);
+};
+const writeBufferKey = (key, target, start) => {
+	target.set(key, start);
+	return key.length + start;
+};
+const Uint8ArraySlice$1 = Uint8Array.prototype.slice;
+const readBufferKey = (target, start, end) => {
+	return Uint8ArraySlice$1.call(target, start, end);
+};
+
+let lastEncodedValue, bytes;
+function applyKeyHandling(store) {
+ 	if (store.encoding == 'ordered-binary') {
+		store.encoder = store.decoder = {
+			writeKey: orderedBinary.writeKey,
+			readKey: orderedBinary.readKey,
+		};
+	}
+	if (store.encoder && store.encoder.writeKey && !store.encoder.encode) {
+		store.encoder.encode = function(value, mode) {
+			if (typeof value !== 'object' && value && value === lastEncodedValue) ; else {
+				lastEncodedValue = value;
+				bytes = saveKey(value, this.writeKey, false, store.maxKeySize);
+			}
+			if (bytes.end > 0 && !(REUSE_BUFFER_MODE & mode)) {
+				return bytes.subarray(bytes.start, bytes.end);
+			}
+			return bytes;
+		};
+		store.encoder.copyBuffers = true; // just an indicator for the buffer reuse in write.js
+	}
+	if (store.decoder && store.decoder.readKey && !store.decoder.decode) {
+		store.decoder.decode = function(buffer) { return this.readKey(buffer, 0, buffer.length); };
+		store.decoderCopies = true;
+	}
+	if (store.keyIsUint32 || store.keyEncoding == 'uint32') {
+		store.writeKey = writeUint32Key;
+		store.readKey = readUint32Key;
+	} else if (store.keyIsBuffer || store.keyEncoding == 'binary') {
+		store.writeKey = writeBufferKey;
+		store.readKey = readBufferKey;
+	} else if (store.keyEncoder) {
+		store.writeKey = store.keyEncoder.writeKey;
+		store.readKey = store.keyEncoder.readKey;
+	} else {
+		store.writeKey = orderedBinary.writeKey;
+		store.readKey = orderedBinary.readKey;
+	}
+}
 
-const writeUint32Key = (key, target, start) => {
-	(target.dataView || (target.dataView = new DataView(target.buffer, 0, target.length))).setUint32(start, key, true);
-	return start + 4;
-};
-const readUint32Key = (target, start) => {
-	return (target.dataView || (target.dataView = new DataView(target.buffer, 0, target.length))).getUint32(start, true);
-};
-const writeBufferKey = (key, target, start) => {
-	target.set(key, start);
-	return key.length + start;
-};
-const Uint8ArraySlice$1 = Uint8Array.prototype.slice;
-const readBufferKey = (target, start, end) => {
-	return Uint8ArraySlice$1.call(target, start, end);
-};
-
-function applyKeyHandling(store) {
- 	if (store.encoding == 'ordered-binary') {
-		store.encoder = store.decoder = {
-			writeKey: orderedBinary.writeKey,
-			readKey: orderedBinary.readKey,
-		};
-	}
-	if (store.encoder && store.encoder.writeKey && !store.encoder.encode) {
-		store.encoder.encode = function(value) {
-			return saveKey(value, this.writeKey, false, store.maxKeySize);
-		};
-	}
-	if (store.decoder && store.decoder.readKey && !store.decoder.decode) {
-		store.decoder.decode = function(buffer) { return this.readKey(buffer, 0, buffer.length); };
-		store.decoderCopies = true;
-	}
-	if (store.keyIsUint32 || store.keyEncoding == 'uint32') {
-		store.writeKey = writeUint32Key;
-		store.readKey = readUint32Key;
-	} else if (store.keyIsBuffer || store.keyEncoding == 'binary') {
-		store.writeKey = writeBufferKey;
-		store.readKey = readBufferKey;
-	} else if (store.keyEncoder) {
-		store.writeKey = store.keyEncoder.writeKey;
-		store.readKey = store.keyEncoder.readKey;
-	} else {
-		store.writeKey = orderedBinary.writeKey;
-		store.readKey = orderedBinary.readKey;
-	}
-}
-
-let saveBuffer, saveDataView = { setFloat64() {}, setUint32() {} }, saveDataAddress;
-let savePosition = 8000;
-let DYNAMIC_KEY_BUFFER_SIZE = 8192;
-function allocateSaveBuffer() {
-	saveBuffer = typeof Buffer != 'undefined' ? Buffer.alloc(DYNAMIC_KEY_BUFFER_SIZE) : new Uint8Array(DYNAMIC_KEY_BUFFER_SIZE);
-	saveBuffer.buffer.address = getAddress(saveBuffer);
-	saveDataAddress = saveBuffer.buffer.address;
-	// TODO: Conditionally only do this for key sequences?
-	saveDataView.setUint32(savePosition, 0xffffffff);
-	saveDataView.setFloat64(savePosition + 4, saveDataAddress, true); // save a pointer from the old buffer to the new address for the sake of the prefetch sequences
-	saveBuffer.dataView = saveDataView = new DataView(saveBuffer.buffer, saveBuffer.byteOffset, saveBuffer.byteLength);
-	savePosition = 0;
-}
-function saveKey(key, writeKey, saveTo, maxKeySize) {
-	if (savePosition > 7800) {
-		allocateSaveBuffer();
-	}
-	let start = savePosition;
-	try {
-		savePosition = key === undefined ? start + 4 :
-			writeKey(key, saveBuffer, start + 4);
-	} catch (error) {
-		saveBuffer.fill(0, start + 4); // restore zeros
-		if (error.name == 'RangeError') {
-			if (8180 - start < maxKeySize) {
-				allocateSaveBuffer(); // try again:
-				return saveKey(key, writeKey, saveTo, maxKeySize);
-			}
-			throw new Error('Key was too large, max key size is ' + maxKeySize);
-		} else
-			throw error;
-	}
-	let length = savePosition - start - 4;
-	if (length > maxKeySize) {
-		throw new Error('Key of size ' + length + ' was too large, max key size is ' + maxKeySize);
-	}
-	if (savePosition >= 8160) { // need to reserve enough room at the end for pointers
-		savePosition = start; // reset position
-		allocateSaveBuffer(); // try again:
-		return saveKey(key, writeKey, saveTo, maxKeySize);
-	}
-	if (saveTo) {
-		saveDataView.setUint32(start, length, true); // save the length
-		saveTo.saveBuffer = saveBuffer;
-		savePosition = (savePosition + 12) & 0xfffffc;
-		return start + saveDataAddress;
-	} else {
-		saveBuffer.start = start + 4;
-		saveBuffer.end = savePosition;
-		savePosition = (savePosition + 7) & 0xfffff8; // full 64-bit word alignment since these are usually copied
-		return saveBuffer;
-	}
+let saveBuffer, saveDataView = { setFloat64() {}, setUint32() {} }, saveDataAddress;
+let savePosition$1 = 8000;
+let DYNAMIC_KEY_BUFFER_SIZE$1 = 8192;
+function allocateSaveBuffer() {
+	saveBuffer = typeof Buffer != 'undefined' ? Buffer.alloc(DYNAMIC_KEY_BUFFER_SIZE$1) : new Uint8Array(DYNAMIC_KEY_BUFFER_SIZE$1);
+	saveBuffer.buffer.address = getAddress(saveBuffer.buffer);
+	saveDataAddress = saveBuffer.buffer.address;
+	// TODO: Conditionally only do this for key sequences?
+	saveDataView.setUint32(savePosition$1, 0xffffffff);
+	saveDataView.setFloat64(savePosition$1 + 4, saveDataAddress, true); // save a pointer from the old buffer to the new address for the sake of the prefetch sequences
+	saveDataView = saveBuffer.dataView || (saveBuffer.dataView = new DataView(saveBuffer.buffer, saveBuffer.byteOffset, saveBuffer.byteLength));
+	savePosition$1 = 0;
+}
+function saveKey(key, writeKey, saveTo, maxKeySize, flags) {
+	if (savePosition$1 > 7800) {
+		allocateSaveBuffer();
+	}
+	let start = savePosition$1;
+	try {
+		savePosition$1 = key === undefined ? start + 4 :
+			writeKey(key, saveBuffer, start + 4);
+	} catch (error) {
+		saveBuffer.fill(0, start + 4); // restore zeros
+		if (error.name == 'RangeError') {
+			if (8180 - start < maxKeySize) {
+				allocateSaveBuffer(); // try again:
+				return saveKey(key, writeKey, saveTo, maxKeySize);
+			}
+			throw new Error('Key was too large, max key size is ' + maxKeySize);
+		} else
+			throw error;
+	}
+	let length = savePosition$1 - start - 4;
+	if (length > maxKeySize) {
+		throw new Error('Key of size ' + length + ' was too large, max key size is ' + maxKeySize);
+	}
+	if (savePosition$1 >= 8160) { // need to reserve enough room at the end for pointers
+		savePosition$1 = start; // reset position
+		allocateSaveBuffer(); // try again:
+		return saveKey(key, writeKey, saveTo, maxKeySize);
+	}
+	if (saveTo) {
+		saveDataView.setUint32(start, flags ? length | flags : length, true); // save the length
+		saveTo.saveBuffer = saveBuffer;
+		savePosition$1 = (savePosition$1 + 12) & 0xfffffc;
+		return start + saveDataAddress;
+	} else {
+		saveBuffer.start = start + 4;
+		saveBuffer.end = savePosition$1;
+		savePosition$1 = (savePosition$1 + 7) & 0xfffff8; // full 64-bit word alignment since these are usually copied
+		return saveBuffer;
+	}
 }
 
+const IF_EXISTS = 3.542694326329068e-103;
 const ITERATOR_DONE = { done: true, value: undefined };
 const Uint8ArraySlice = Uint8Array.prototype.slice;
-const Uint8A = typeof Buffer != 'undefined' ? Buffer.allocUnsafeSlow : Uint8Array;
-let getValueBytes = makeReusableBuffer(0);
+let getValueBytes = globalBuffer;
+if (!getValueBytes.maxLength) {
+	getValueBytes.maxLength = getValueBytes.length;
+	getValueBytes.isGlobal = true;
+	Object.defineProperty(getValueBytes, 'length', { value: getValueBytes.length, writable: true, configurable: true });
+}
 const START_ADDRESS_POSITION = 4064;
 const NEW_BUFFER_THRESHOLD = 0x8000;
+const SOURCE_SYMBOL = Symbol.for('source');
+const UNMODIFIED = {};
+let mmaps = [];
 
 function addReadMethods(LMDBStore, {
-	maxKeySize, env, keyBytes, keyBytesView, getLastVersion
+	maxKeySize, env, keyBytes, keyBytesView, getLastVersion, getLastTxnId
 }) {
 	let readTxn, readTxnRenewed, asSafeBuffer = false;
 	let renewId = 1;
+	let outstandingReads = 0;
 	Object.assign(LMDBStore.prototype, {
-		getString(id) {
-			(env.writeTxn || (readTxnRenewed ? readTxn : renewReadTxn(this)));
-			let string = getStringByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0));
+		getString(id, options) {
+			let txn = env.writeTxn || (options && options.transaction) || (readTxnRenewed ? readTxn : renewReadTxn(this));
+			let string = getStringByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0), txn.address || 0);
 			if (typeof string === 'number') { // indicates the buffer wasn't large enough
 				this._allocateGetBuffer(string);
 				// and then try again
-				string = getStringByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0));
+				string = getStringByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0), txn.address || 0);
 			}
 			if (string)
 				this.lastSize = string.length;
 			return string;
 		},
-		getBinaryFast(id) {
-			(env.writeTxn || (readTxnRenewed ? readTxn : renewReadTxn(this)));
-			let rc = this.lastSize = getByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0));
+		getBinaryFast(id, options) {
+			let rc;
+			let txn = env.writeTxn || (options && options.transaction) || (readTxnRenewed ? readTxn : renewReadTxn(this));
+			rc = this.lastSize = getByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0), (options && options.ifNotTxnId) || 0, txn.address || 0);
 			if (rc < 0) {
 				if (rc == -30798) // MDB_NOTFOUND
 					return; // undefined
+				if (rc == -30004) // txn id matched
+					return UNMODIFIED;
 				if (rc == -30781 /*MDB_BAD_VALSIZE*/ && this.writeKey(id, keyBytes, 0) == 0)
 					throw new Error(id === undefined ?
 					'A key is required for get, but is undefined' :
 					'Zero length key is not allowed in LMDB');
 				if (rc == -30000) // int32 overflow, read uint32
 					rc = this.lastSize = keyBytesView.getUint32(0, true);
-				else
+				else if (rc == -30001) {// shared buffer
+					this.lastSize = keyBytesView.getUint32(0, true);
+					let bufferId = keyBytesView.getUint32(4, true);
+					return getMMapBuffer(bufferId, this.lastSize);
+				} else
 					throw lmdbError(rc);
 			}
 			let compression = this.compression;
@@ -1449,13 +1438,89 @@ function addReadMethods(LMDBStore, {
 			if (rc > bytes.maxLength) {
 				// this means the target buffer wasn't big enough, so the get failed to copy all the data from the database, need to either grow or use special buffer
 				return this._returnLargeBuffer(
-					() => getByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0)),
-					() => getSharedByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0)));
+					() => getByBinary(this.dbAddress, this.writeKey(id, keyBytes, 0), 0, txn.address || 0));
 			}
 			bytes.length = this.lastSize;
 			return bytes;
 		},
-		_returnLargeBuffer(getFast, getShared) {
+		getBFAsync(id, options, callback) {
+			let txn = env.writeTxn || (options && options.transaction) || (readTxnRenewed ? readTxn : renewReadTxn(this));
+			txn.refCount = (txn.refCount || 0) + 1;
+			outstandingReads++;
+			let address = recordReadInstruction(txn.address, this.db.dbi, id, this.writeKey, maxKeySize, ( rc, bufferId, offset, size ) => {
+				if (rc && rc !== 1)
+					callback(lmdbError(rc));
+				outstandingReads--;
+				let buffer = mmaps[bufferId];
+				if (!buffer) {
+					buffer = mmaps[bufferId] = getSharedBuffer(bufferId, env.address);
+				}
+				//console.log({bufferId, offset, size})
+				if (buffer.isSharedMap) {
+					// using LMDB shared memory
+					// TODO: We may want explicit support for clearing aborting the transaction on the next event turn,
+					// but for now we are relying on the GC to cleanup transaction for larger blocks of memory
+					let bytes = new Uint8Array(buffer, offset, size);
+					bytes.txn = txn;
+					callback(bytes, 0, size);
+				} else {
+					// using copied memory
+					txn.done(); // decrement and possibly abort
+					callback(buffer, offset, size);
+				}
+			});
+			if (address) {
+				startRead(address, () => {
+					resolveReads();
+				});
+			}
+		},
+		getAsync(id, options, callback) {
+			let promise;
+			if (!callback)
+				promise = new Promise(resolve => callback = resolve);
+			this.getBFAsync(id, options, (buffer, offset, size) => {
+				if (this.useVersions) {
+					// TODO: And get the version
+					offset += 8;
+					size -= 8;
+				}
+				let bytes = new Uint8Array(buffer, offset, size);
+				let value;
+				if (this.decoder) {
+					// the decoder potentially uses the data from the buffer in the future and needs a stable buffer
+					value = bytes && this.decoder.decode(bytes);
+				} else if (this.encoding == 'binary') {
+					value = bytes;
+				} else {
+					value = Buffer.prototype.utf8Slice.call(bytes, 0, size);
+					if (this.encoding == 'json' && value)
+						value = JSON.parse(value);
+				}
+				callback(value);
+			});
+			return promise;
+		},
+		retain(data, options) {
+			if (!data)
+				return
+			let source = data[SOURCE_SYMBOL];
+			let buffer = source ? source.bytes : data;
+			if (!buffer.isGlobal && !env.writeTxn) {
+				let txn = options?.transaction || (readTxnRenewed ? readTxn : renewReadTxn(this));
+				buffer.txn = txn;
+				txn.refCount = (txn.refCount || 0) + 1;
+				return data;
+			} else {
+				buffer = Uint8ArraySlice.call(buffer, 0, this.lastSize);
+				if (source) {
+					source.bytes = buffer;
+					return data;
+				} else
+					return buffer;
+			}
+		},
+		_returnLargeBuffer(getFast) {
 			let bytes;
 			let compression = this.compression;
 			if (asSafeBuffer && this.lastSize > NEW_BUFFER_THRESHOLD) {
@@ -1467,7 +1532,7 @@ function addReadMethods(LMDBStore, {
 						let dictionary = compression.dictionary || [];
 						let dictLength = (dictionary.length >> 3) << 3;// make sure it is word-aligned
 						bytes = makeReusableBuffer(this.lastSize);
-						compression.setBuffer(bytes, this.lastSize, dictionary, dictLength);
+						compression.setBuffer(bytes.buffer, bytes.byteOffset, this.lastSize, dictionary, dictLength);
 						compression.getValueBytes = bytes;
 					} else {
 						bytesToRestore = getValueBytes;
@@ -1477,7 +1542,7 @@ function addReadMethods(LMDBStore, {
 				} finally {
 					if (compression) {
 						let dictLength = (compression.dictionary.length >> 3) << 3;
-						compression.setBuffer(bytesToRestore, bytesToRestore.maxLength, compression.dictionary, dictLength);
+						compression.setBuffer(bytesToRestore.buffer, bytesToRestore.byteOffset, bytesToRestore.maxLength, compression.dictionary, dictLength);
 						compression.getValueBytes = bytesToRestore;
 					} else {
 						setGlobalBuffer(bytesToRestore);
@@ -1486,12 +1551,6 @@ function addReadMethods(LMDBStore, {
 				}
 				return bytes;
 			}
-			if (this.lastSize > NEW_BUFFER_THRESHOLD && !compression) {
-				// for large binary objects, cheaper to make a buffer that directly points at the shared LMDB memory to avoid copying a large amount of memory, but only for large data since there is significant overhead to instantiating the buffer
-				if (globalThis.__lmdb_last_shared__ && detachBuffer) // we have to detach the last one, or else could crash due to two buffers pointing at same location
-					detachBuffer(globalThis.__lmdb_last_shared__.buffer);
-				return globalThis.__lmdb_last_shared__ = getShared();
-			}
 			// grow our shared/static buffer to accomodate the size of the data
 			bytes = this._allocateGetBuffer(this.lastSize);
 			// and try again
@@ -1503,13 +1562,13 @@ function addReadMethods(LMDBStore, {
 			let newLength = Math.min(Math.max(lastSize * 2, 0x1000), 0xfffffff8);
 			let bytes;
 			if (this.compression) {
-				let dictionary = this.compression.dictionary || new Uint8A(0);
+				let dictionary = this.compression.dictionary || Buffer.allocUnsafeSlow(0);
 				let dictLength = (dictionary.length >> 3) << 3;// make sure it is word-aligned
-				bytes = new Uint8A(newLength + dictLength);
+				bytes = Buffer.allocUnsafeSlow(newLength + dictLength);
 				bytes.set(dictionary); // copy dictionary into start
 				// the section after the dictionary is the target area for get values
 				bytes = bytes.subarray(dictLength);
-				this.compression.setBuffer(bytes, newLength, dictionary, dictLength);
+				this.compression.setBuffer(bytes.buffer, bytes.byteOffset, newLength, dictionary, dictLength);
 				bytes.maxLength = newLength;
 				Object.defineProperty(bytes, 'length', { value: newLength, writable: true, configurable: true });
 				this.compression.getValueBytes = bytes;
@@ -1517,41 +1576,51 @@ function addReadMethods(LMDBStore, {
 				bytes = makeReusableBuffer(newLength);
 				setGlobalBuffer(getValueBytes = bytes);
 			}
-			bytes.isShared = true;
+			bytes.isGlobal = true;
 			return bytes;
 		},
-		getBinary(id) {
+		getBinary(id, options) {
 			try {
 				asSafeBuffer = true;
-				let fastBuffer = this.getBinaryFast(id);
-				return fastBuffer && (fastBuffer.isShared ? Uint8ArraySlice.call(fastBuffer, 0, this.lastSize) : fastBuffer);
+				let fastBuffer = this.getBinaryFast(id, options);
+				return fastBuffer && (fastBuffer.isGlobal ? Uint8ArraySlice.call(fastBuffer, 0, this.lastSize) : fastBuffer);
 			} finally {
 				asSafeBuffer = false;
 			}
 		},
-		get(id) {
+		getSharedBinary(id, options) {
+			let fastBuffer = this.getBinaryFast(id, options);
+			if (fastBuffer) {
+				if (fastBuffer.isGlobal || writeTxn)
+					return Uint8ArraySlice.call(fastBuffer, 0, this.lastSize)
+				fastBuffer.txn = (options && options.transaction);
+				options.transaction.refCount = (options.transaction.refCount || 0) + 1;
+				return fastBuffer;
+			}
+		},
+		get(id, options) {
 			if (this.decoderCopies) {
 				// the decoder copies any data, so we can use the fast binary retrieval that overwrites the same buffer space
-				let bytes = this.getBinaryFast(id);
-				return bytes && this.decoder.decode(bytes);
+				let bytes = this.getBinaryFast(id, options);
+				return bytes && (bytes == UNMODIFIED ? UNMODIFIED : this.decoder.decode(bytes, options));
 			}
 			if (this.encoding == 'binary')
-				return this.getBinary(id);
+				return this.getBinary(id, options);
 			if (this.decoder) {
 				// the decoder potentially uses the data from the buffer in the future and needs a stable buffer
-				let bytes = this.getBinary(id);
-				return bytes && this.decoder.decode(bytes);
+				let bytes = this.getBinary(id, options);
+				return bytes && (bytes == UNMODIFIED ? UNMODIFIED : this.decoder.decode(bytes));
 			}
 
-			let result = this.getString(id);
+			let result = this.getString(id, options);
 			if (result) {
 				if (this.encoding == 'json')
 					return JSON.parse(result);
 			}
 			return result;
 		},
-		getEntry(id) {
-			let value = this.get(id);
+		getEntry(id, options) {
+			let value = this.get(id, options);
 			if (value !== undefined) {
 				if (this.useVersions)
 					return {
@@ -1570,8 +1639,11 @@ function addReadMethods(LMDBStore, {
 			resetReadTxn();
 		},
 		_commitReadTxn() {
-			if (readTxn)
+			if (readTxn) {
+				readTxn.isCommitted = true;
 				readTxn.commit();
+			}
+			lastReadTxnRef = null;
 			readTxnRenewed = null;
 			readTxn = null;
 		},
@@ -1580,15 +1652,12 @@ function addReadMethods(LMDBStore, {
 				renewReadTxn(this);
 		},
 		doesExist(key, versionOrValue) {
-			if (!env.writeTxn)
-				readTxnRenewed ? readTxn : renewReadTxn(this);
 			if (versionOrValue == null) {
 				// undefined means the entry exists, null is used specifically to check for the entry *not* existing
 				return (this.getBinaryFast(key) === undefined) == (versionOrValue === null);
 			}
 			else if (this.useVersions) {
-				this.getBinaryFast(key);
-				return this.getBinaryFast(key) !== undefined && getLastVersion() === versionOrValue;
+				return this.getBinaryFast(key) !== undefined && (versionOrValue === IF_EXISTS || getLastVersion() === versionOrValue);
 			}
 			else {
 				if (versionOrValue && versionOrValue['\x10binary-data\x02'])
@@ -1654,28 +1723,39 @@ function addReadMethods(LMDBStore, {
 				let cursor, cursorRenewId, cursorAddress;
 				let txn;
 				let flags = (includeValues ? 0x100 : 0) | (reverse ? 0x400 : 0) |
-					(valuesForKey ? 0x800 : 0) | (options.exactMatch ? 0x4000 : 0);
+					(valuesForKey ? 0x800 : 0) | (options.exactMatch ? 0x4000 : 0) |
+					(options.inclusiveEnd ? 0x8000 : 0) |
+					(options.exclusiveStart ? 0x10000 : 0);
 				let store = this;
 				function resetCursor() {
 					try {
 						if (cursor)
 							finishCursor();
-						let writeTxn = env.writeTxn;
-						if (writeTxn)
-							snapshot = false;
-						txn = writeTxn || (readTxnRenewed ? readTxn : renewReadTxn(store));
-						cursor = !writeTxn && db.availableCursor;
+						let txnAddress;
+						txn = options.transaction;
+						if (txn) {
+							if (txn.isDone) throw new Error('Can not iterate on range with transaction that is already' +
+								' done');
+							txnAddress = txn.address;
+							cursor = null;
+						} else {
+							let writeTxn = env.writeTxn;
+							if (writeTxn)
+								snapshot = false;
+							txn = env.writeTxn || options.transaction || (readTxnRenewed ? readTxn : renewReadTxn(store));
+							cursor = !writeTxn && db.availableCursor;
+						}
 						if (cursor) {
 							db.availableCursor = null;
 							flags |= 0x2000;
 						} else {
-							cursor = new Cursor(db);
+							cursor = new Cursor(db, txnAddress || 0);
 						}
 						cursorAddress = cursor.address;
-						txn.cursorCount = (txn.cursorCount || 0) + 1; // track transaction so we always use the same one
+						txn.refCount = (txn.refCount || 0) + 1; // track transaction so we always use the same one
 						if (snapshot === false) {
 							cursorRenewId = renewId; // use shared read transaction
-							txn.renewingCursorCount = (txn.renewingCursorCount || 0) + 1; // need to know how many are renewing cursors
+							txn.renewingRefCount = (txn.renewingRefCount || 0) + 1; // need to know how many are renewing cursors
 						}
 					} catch(error) {
 						if (cursor) {
@@ -1696,6 +1776,9 @@ function addReadMethods(LMDBStore, {
 					return count;
 				}
 				function position$1(offset) {
+					if (!env.address) {
+						throw new Error('Can not iterate on a closed database');
+					}
 					let keySize = currentKey === undefined ? 0 : store.writeKey(currentKey, keyBytes, 0);
 					let endAddress;
 					if (valuesForKey) {
@@ -1723,9 +1806,11 @@ function addReadMethods(LMDBStore, {
 				function finishCursor() {
 					if (txn.isDone)
 						return;
+					if (iterable.onDone)
+						iterable.onDone();
 					if (cursorRenewId)
-						txn.renewingCursorCount--;
-					if (--txn.cursorCount <= 0 && txn.onlyCursor) {
+						txn.renewingRefCount--;
+					if (--txn.refCount <= 0 && txn.notCurrent) {
 						cursor.close();
 						txn.abort(); // this is no longer main read txn, abort it now that we are done
 						txn.isDone = true;
@@ -1752,7 +1837,7 @@ function addReadMethods(LMDBStore, {
 						if (keySize <= 0 ||
 								(count++ >= limit)) {
 							if (count < 0)
-								lmdbError(count);				
+								lmdbError(count);
 							finishCursor();
 							return ITERATOR_DONE;
 						}
@@ -1767,24 +1852,27 @@ function addReadMethods(LMDBStore, {
 						if (includeValues) {
 							let value;
 							lastSize = keyBytesView.getUint32(0, true);
-							let bytes = compression ? compression.getValueBytes : getValueBytes;
-							if (lastSize > bytes.maxLength) {
-								store.lastSize = lastSize;
-								asSafeBuffer = store.encoding == 'binary';
-								try {
-									bytes = store._returnLargeBuffer(
-										() => getCurrentValue(cursorAddress),
-										() => getCurrentShared(cursorAddress)
-									);
-								} finally {
-									asSafeBuffer = false;
-								}
-							} else
-								bytes.length = lastSize;
+							let bufferId = keyBytesView.getUint32(4, true);
+							let bytes;
+							if (bufferId) {
+								bytes = getMMapBuffer(bufferId, lastSize);
+							} else {
+								bytes = compression ? compression.getValueBytes : getValueBytes;
+								if (lastSize > bytes.maxLength) {
+									store.lastSize = lastSize;
+									asSafeBuffer = store.encoding == 'binary';
+									try {
+										bytes = store._returnLargeBuffer(() => getCurrentValue(cursorAddress));
+									} finally {
+										asSafeBuffer = false;
+									}
+								} else
+									bytes.length = lastSize;
+							}
 							if (store.decoder) {
 								value = store.decoder.decode(bytes, lastSize);
 							} else if (store.encoding == 'binary')
-								value = bytes.isShared ? Uint8ArraySlice.call(bytes, 0, lastSize) : bytes;
+								value = bytes.isGlobal ? Uint8ArraySlice.call(bytes, 0, lastSize) : bytes;
 							else {
 								value = bytes.toString('utf8', 0, lastSize);
 								if (store.encoding == 'json' && value)
@@ -1850,8 +1938,8 @@ function addReadMethods(LMDBStore, {
 			});
 			return promise;
 		},
-		getSharedBufferForGet(id) {
-			let txn = (env.writeTxn || (readTxnRenewed ? readTxn : renewReadTxn(this)));
+		getSharedBufferForGet(id, options) {
+			let txn = env.writeTxn || (options && options.transaction) || (readTxnRenewed ? readTxn : renewReadTxn(this));
 			this.lastSize = this.keyIsCompatibility ? txn.getBinaryShared(id) : this.db.get(this.writeKey(id, keyBytes, 0));
 			if (this.lastSize === -30798) { // not found code
 				return; //undefined
@@ -1873,7 +1961,13 @@ function addReadMethods(LMDBStore, {
 			let bufferHolder = {};
 			let lastBuffer;
 			for (let key of keys) {
-				let position = saveKey(key, this.writeKey, bufferHolder, maxKeySize);
+				let position;
+				if (key && key.key !== undefined && key.value !== undefined) {
+					position = saveKey(key.value, this.writeKey, bufferHolder, maxKeySize, 0x80000000);
+					saveKey(key.key, this.writeKey, bufferHolder, maxKeySize);
+				} else {
+					position = saveKey(key, this.writeKey, bufferHolder, maxKeySize);
+				}
 				if (!startPosition)
 					startPosition = position;
 				if (bufferHolder.saveBuffer != lastBuffer) {
@@ -1883,7 +1977,9 @@ function addReadMethods(LMDBStore, {
 				}
 			}
 			saveKey(undefined, this.writeKey, bufferHolder, maxKeySize);
+			outstandingReads++;
 			prefetch(this.dbAddress, startPosition, (error) => {
+				outstandingReads--;
 				if (error)
 					console.error('Error with prefetch', buffers, bufferHolder); // partly exists to keep the buffers pinned in memory
 				else
@@ -1892,27 +1988,44 @@ function addReadMethods(LMDBStore, {
 			if (!callback)
 				return new Promise(resolve => callback = resolve);
 		},
+		useReadTransaction() {
+			let txn = readTxnRenewed ? readTxn : renewReadTxn(this);
+			if (!txn.use) {
+				throw new Error('Can not use read transaction from a closed database');
+			}
+			txn.use();
+			return txn;
+		},
 		close(callback) {
 			this.status = 'closing';
+			let txnPromise;
 			if (this.isRoot) {
-				if (readTxn) {
-					try {
-						readTxn.abort();
-					} catch(error) {}
-				}
-				readTxn = {
-					renew() {
+				// if it is root, we need to abort and/or wait for transactions to finish
+				if (readTxn) readTxn.abort();
+				else readTxn = {};
+				readTxn.isDone = true;
+				Object.defineProperty(readTxn,'renew', {
+					value: () => {
 						throw new Error('Can not read from a closed database');
-					}
-				};
+					}, configurable: true
+				});
+				Object.defineProperty(readTxn,'use', {
+					value: () => {
+						throw new Error('Can not read from a closed database');
+					}, configurable: true
+				});
 				readTxnRenewed = null;
+				txnPromise = this._endWrites && this._endWrites();
 			}
-			let txnPromise = this._endWrites();
 			const doClose = () => {
-				this.db.close();
 				if (this.isRoot) {
+					if (outstandingReads > 0) {
+						return new Promise(resolve => setTimeout(() => resolve(doClose()), 1));
+					}
+					env.address = 0;
 					env.close();
-				}
+				} else
+					this.db.close();
 				this.status = 'closed';
 				if (callback)
 					callback();
@@ -1925,18 +2038,40 @@ function addReadMethods(LMDBStore, {
 			}
 		},
 		getStats() {
-			readTxnRenewed ? readTxn : renewReadTxn(this);
-			return this.db.stat();
-		}
+			env.writeTxn || (readTxnRenewed ? readTxn : renewReadTxn(this));
+			let dbStats = this.db.stat();
+			dbStats.root = env.stat();
+			Object.assign(dbStats, env.info());
+			dbStats.free = env.freeStat();
+			return dbStats;
+		},
 	});
 	let get = LMDBStore.prototype.get;
+	let lastReadTxnRef;
+	function getMMapBuffer(bufferId, size) {
+		let buffer = mmaps[bufferId];
+		if (!buffer) {
+			buffer = mmaps[bufferId] = getSharedBuffer(bufferId, env.address);
+		}
+		let offset = keyBytesView.getUint32(8, true);
+		return new Uint8Array(buffer, offset, size);
+	}
 	function renewReadTxn(store) {
+		if (!env.address) {
+			throw new Error('Can not renew a transaction from a closed database');
+		}
 		if (!readTxn) {
 			let retries = 0;
 			let waitArray;
 			do {
 				try {
-					readTxn = new Txn(env, 0x20000);
+					let lastReadTxn = lastReadTxnRef && lastReadTxnRef.deref();
+					readTxn = new Txn(env, 0x20000, lastReadTxn && !lastReadTxn.isDone && lastReadTxn);
+					if (readTxn.address == 0) {
+						readTxn = lastReadTxn;
+						if (readTxn.notCurrent)
+							readTxn.notCurrent = false;
+					}
 					break;
 				} catch (error) {
 					if (error.message.includes('temporarily')) {
@@ -1954,15 +2089,20 @@ function addReadMethods(LMDBStore, {
 		store.emit('begin-transaction');
 		return readTxn;
 	}
-	function resetReadTxn(hardReset) {
+	function resetReadTxn() {
 		renewId++;
 		if (readTxnRenewed) {
 			readTxnRenewed = null;
-			if (readTxn.cursorCount - (readTxn.renewingCursorCount || 0) > 0) {
-				readTxn.onlyCursor = true;
+			if (readTxn.refCount - (readTxn.renewingRefCount || 0) > 0) {
+				readTxn.notCurrent = true;
+				lastReadTxnRef = new WeakRef(readTxn);
 				readTxn = null;
-			} else
+			} else if (readTxn.address && !readTxn.isDone) {
 				resetTxn(readTxn.address);
+			} else {
+				console.warn('Attempt to reset an invalid read txn', readTxn);
+				throw new Error('Attempt to reset an invalid read txn');
+			}
 		}
 	}
 }
@@ -1973,12 +2113,296 @@ function makeReusableBuffer(size) {
 	return bytes;
 }
 
+Txn.prototype.done = function() {
+	this.refCount--;
+	if (this.refCount === 0 && this.notCurrent) {
+		this.abort();
+		this.isDone = true;
+	}
+};
+Txn.prototype.use = function() {
+	this.refCount = (this.refCount || 0) + 1;
+};
+
+
+let readInstructions, readCallbacks = new Map(), uint32Instructions, instructionsDataView = { setFloat64() {}, setUint32() {} }, instructionsAddress;
+let savePosition = 8000;
+let DYNAMIC_KEY_BUFFER_SIZE = 8192;
+function allocateInstructionsBuffer() {
+	readInstructions = typeof Buffer != 'undefined' ? Buffer.alloc(DYNAMIC_KEY_BUFFER_SIZE) : new Uint8Array(DYNAMIC_KEY_BUFFER_SIZE);
+	uint32Instructions = new Int32Array(readInstructions.buffer, 0, readInstructions.buffer.byteLength >> 2);
+	uint32Instructions[2] = 0xf0000000; // indicates a new read task must be started
+	instructionsAddress = readInstructions.buffer.address = getAddress(readInstructions.buffer);
+	readInstructions.dataView = instructionsDataView = new DataView(readInstructions.buffer, readInstructions.byteOffset, readInstructions.byteLength);
+	savePosition = 0;
+}
+function recordReadInstruction(txnAddress, dbi, key, writeKey, maxKeySize, callback) {
+	if (savePosition > 7800) {
+		allocateInstructionsBuffer();
+	}
+	let start = savePosition;
+	let keyPosition = savePosition + 16;
+	try {
+		savePosition = key === undefined ? keyPosition :
+			writeKey(key, readInstructions, keyPosition);
+	} catch (error) {
+		if (error.name == 'RangeError') {
+			if (8180 - start < maxKeySize) {
+				allocateInstructionsBuffer(); // try again:
+				return recordReadInstruction(txnAddress, dbi, key, writeKey, maxKeySize, callback);
+			}
+			throw new Error('Key was too large, max key size is ' + maxKeySize);
+		} else
+			throw error;
+	}
+	let length = savePosition - keyPosition;
+	if (length > maxKeySize) {
+		savePosition = start;
+		throw new Error('Key of size ' + length + ' was too large, max key size is ' + maxKeySize);
+	}
+	uint32Instructions[(start >> 2) + 3] = length; // save the length
+	uint32Instructions[(start >> 2) + 2] = dbi;
+	savePosition = (savePosition + 12) & 0xfffffc;
+	instructionsDataView.setFloat64(start, txnAddress, true);
+	let callbackId = addReadCallback(() => {
+		let position = start >> 2;
+		let rc = thisInstructions[position];
+		callback(rc, thisInstructions[position + 1], thisInstructions[position + 2], thisInstructions[position + 3]);
+	});
+	let thisInstructions = uint32Instructions;
+	//if (start === 0)
+		return startRead(instructionsAddress + start, callbackId, {}, 'read');
+	//else
+		//nextRead(start);
+}
+let nextCallbackId = 0;
+let addReadCallback = globalThis.__lmdb_read_callback;
+if (!addReadCallback) {
+	addReadCallback = globalThis.__lmdb_read_callback = function(callback) {
+		let callbackId = nextCallbackId++;
+		readCallbacks.set(callbackId, callback);
+		return callbackId;
+	};
+	setReadCallback(function(callbackId) {
+		readCallbacks.get(callbackId)();
+		readCallbacks.delete(callbackId);
+	});
+}
+
+let getLastVersion$1, getLastTxnId$1;
+const mapGet = Map.prototype.get;
+const CachingStore = (Store, env) => {
+	let childTxnChanges;
+	return class LMDBStore extends Store {
+	constructor(dbName, options) {
+		super(dbName, options);
+		if (!env.cacheCommitter) {
+			env.cacheCommitter = true;
+			this.on('aftercommit', ({ next, last, txnId }) => {
+				do {
+					let meta = next.meta;
+					let store = meta && meta.store;
+					if (store) {
+						if (next.flag & FAILED_CONDITION)
+							store.cache.delete(meta.key); // just delete it from the map
+						else {
+							let expirationPriority = meta.valueSize >> 10;
+							let cache = store.cache;
+							let entry = mapGet.call(cache, meta.key);
+							if (entry) {
+								entry.txnId = txnId;
+								cache.used(entry, expirationPriority + 4); // this will enter it into the LRFU (with a little lower priority than a read)
+							}
+						}
+					}
+				} while (next != last && (next = next.next))
+			});
+		}
+		this.db.cachingDb = this;
+		if (options.cache.clearKeptInterval)
+			options.cache.clearKeptObjects = exports.clearKeptObjects;
+		this.cache = new WeakLRUCache(options.cache);
+		if (options.cache.validated)
+			this.cache.validated = true;
+	}
+	get isCaching() {
+		return true
+	}
+	get(id, options) {
+		let value;
+		if (this.cache.validated) {
+			let entry = this.cache.get(id);
+			if (entry) {
+				let cachedValue = entry.value;
+				if (entry.txnId != null) {
+					value = super.get(id, { ifNotTxnId: entry.txnId, transaction: options && options.transaction });
+					if (value === UNMODIFIED)
+						return cachedValue;
+				} else // with no txn id we do not validate; this is the state of a cached value after a write before it transacts
+					return cachedValue;
+			} else
+				value = super.get(id, options);
+		} else if (options && options.transaction) {
+			return super.get(id, options);
+		} else {
+			value = this.cache.getValue(id);
+			if (value !== undefined) {
+				return value;
+			}
+			value = super.get(id);
+		}
+		if (value && typeof value === 'object' && !options && typeof id !== 'object') {
+			let entry = this.cache.setValue(id, value, this.lastSize >> 10);
+			if (this.useVersions) {
+				entry.version = getLastVersion$1();
+			}
+			if (this.cache.validated)
+				entry.txnId = getLastTxnId$1();
+		}
+		return value;
+	}
+	getEntry(id, options) {
+		let entry, value;
+		if (this.cache.validated) {
+			entry = this.cache.get(id);
+			if (entry) {
+				if (entry.txnId != null) {
+					value = super.get(id, { ifNotTxnId: entry.txnId, transaction: options && options.transaction });
+					if (value === UNMODIFIED)
+						return entry;
+				} else // with no txn id we do not validate; this is the state of a cached value after a write before it transacts
+					return entry;
+			} else
+				value = super.get(id, options);
+		} else if (options && options.transaction) {
+			return super.getEntry(id, options);
+		} else {
+			entry = this.cache.get(id);
+			if (entry !== undefined) {
+				return entry;
+			}
+			value = super.get(id);
+		}
+		if (value === undefined)
+			return;
+		if (value && typeof value === 'object' && !options && typeof id !== 'object') {
+			entry = this.cache.setValue(id, value, this.lastSize >> 10);
+		} else
+			entry = { value };
+		if (this.useVersions)
+			entry.version = getLastVersion$1();
+		if (this.cache.validated)
+			entry.txnId = getLastTxnId$1();
+		return entry;
+	}
+	putEntry(id, entry, ifVersion) {
+		let result = super.put(id, entry.value, entry.version, ifVersion);
+		if (typeof id === 'object')
+			return result;
+		if (result && result.then)
+			this.cache.setManually(id, entry); // set manually so we can keep it pinned in memory until it is committed
+		else // sync operation, immediately add to cache
+			this.cache.set(id, entry);
+	}
+	put(id, value, version, ifVersion) {
+		let result = super.put(id, value, version, ifVersion);
+		if (typeof id !== 'object') {
+			if (value && value['\x10binary-data\x02']) {
+				// don't cache binary data, since it will be decoded on get
+				this.cache.delete(id);
+				return result;
+			}	
+			// sync operation, immediately add to cache, otherwise keep it pinned in memory until it is committed
+			let entry = this.cache.setValue(id, value, !result || result.isSync ? 0 : -1);
+			if (childTxnChanges)
+				childTxnChanges.add(id);
+			if (version !== undefined)
+				entry.version = typeof version === 'object' ? version.version : version;
+		}
+		return result;
+	}
+	putSync(id, value, version, ifVersion) {
+		if (id !== 'object') {
+			// sync operation, immediately add to cache, otherwise keep it pinned in memory until it is committed
+			if (value && typeof value === 'object') {
+				let entry = this.cache.setValue(id, value);
+				if (childTxnChanges)
+					childTxnChanges.add(id);
+				if (version !== undefined) {
+					entry.version = typeof version === 'object' ? version.version : version;
+				}
+			} else // it is possible that  a value used to exist here
+				this.cache.delete(id);
+		}
+		return super.putSync(id, value, version, ifVersion);
+	}
+	remove(id, ifVersion) {
+		this.cache.delete(id);
+		return super.remove(id, ifVersion);
+	}
+	removeSync(id, ifVersion) {
+		this.cache.delete(id);
+		return super.removeSync(id, ifVersion);
+	}
+	clearAsync(callback) {
+		this.cache.clear();
+		return super.clearAsync(callback);
+	}
+	clearSync() {
+		this.cache.clear();
+		super.clearSync();
+	}
+	childTransaction(callback) {
+		return super.childTransaction(() => {
+			let cache = this.cache;
+			let previousChanges = childTxnChanges;
+			try {
+				childTxnChanges = new Set();
+				return when(callback(), (result) => {
+					if (result === ABORT)
+						return abort();
+					childTxnChanges = previousChanges;
+					return result;
+				}, abort);
+			} catch(error) {
+				abort(error);
+			}
+			function abort(error) {
+				// if the transaction was aborted, remove all affected entries from cache
+				for (let id of childTxnChanges)
+					cache.delete(id);
+				childTxnChanges = previousChanges;
+				if (error)
+					throw error;
+				else
+					return ABORT;
+			}
+		});
+	}
+	doesExist(key, versionOrValue) {
+		let entry = this.cache.get(key);
+		if (entry) {
+			if (versionOrValue == null) {
+				return versionOrValue !== null;
+			} else if (this.useVersions) {
+				return versionOrValue === IF_EXISTS$1 || entry.version === versionOrValue;
+			}
+		}
+		return super.doesExist(key, versionOrValue);
+	}
+	};
+};
+function setGetLastVersion(get, getTxnId) {
+	getLastVersion$1 = get;
+	getLastTxnId$1 = getTxnId;
+}
+
 let moduleRequire = typeof require == 'function' && require;
 function setRequire(require) {
 	moduleRequire = require;
 }
 
-setGetLastVersion(getLastVersion);
+setGetLastVersion(getLastVersion, getLastTxnId);
 let keyBytes, keyBytesView;
 const { onExit, getEnvsPointer, setEnvsPointer, getEnvFlags, setJSFlags } = nativeAddon;
 if (globalThis.__lmdb_envs__)
@@ -1989,12 +2413,29 @@ else
 // this is hard coded as an upper limit because it is important assumption of the fixed buffers in writing instructions
 // this corresponds to the max key size for 8KB pages
 const MAX_KEY_SIZE = 4026;
+// this is used as the key size by default because default page size is OS page size, which is usually
+// 4KB (but is 16KB on M-series MacOS), and this keeps a consistent max key size when no page size specified.
+const DEFAULT_MAX_KEY_SIZE = 1978;
 const DEFAULT_COMMIT_DELAY = 0;
 
 const allDbs = new Map();
 let defaultCompression;
 let hasRegisteredOnExit;
 function open(path$1, options) {
+	if (nativeAddon.open) {
+		if (nativeAddon.open !== open) {
+			// this is the case when lmdb-js has been opened in both ESM and CJS mode, which means that there are two
+			// separate JS modules, but they are both using the same native module.
+			getLastVersion = nativeAddon.getLastVersion;
+			getLastTxnId = nativeAddon.getLastTxnId;
+			setGetLastVersion(getLastVersion, getLastTxnId);
+			return nativeAddon.open(path$1, options);
+		}
+	} else {
+		nativeAddon.open = open;
+		nativeAddon.getLastVersion = getLastVersion;
+		nativeAddon.getLastTxnId = getLastTxnId;
+	}
 	if (!keyBytes) // TODO: Consolidate get buffer and key buffer (don't think we need both)
 		allocateFixedBuffer();
 	if (typeof path$1 == 'object' && !options) {
@@ -2002,8 +2443,9 @@ function open(path$1, options) {
 		path$1 = options.path;
 	}
 	options = options || {};
+	let noFSAccess = options.noFSAccess; // this can only be configured on open, can't let users change it
 	let userOptions = options;
-	if (!path$1) {
+	if (path$1 == null) {
 		options = Object.assign({
 			deleteOnClose: true,
 			noSync: true,
@@ -2014,17 +2456,16 @@ function open(path$1, options) {
 	let extension = path.extname(path$1);
 	let name = path.basename(path$1, extension);
 	let is32Bit = arch().endsWith('32');
-	let remapChunks = options.remapChunks || (options.mapSize ?
+	let remapChunks = options.remapChunks || options.encryptionKey || (options.mapSize ?
 		(is32Bit && options.mapSize > 0x100000000) : // larger than fits in address space, must use dynamic maps
 		is32Bit); // without a known map size, we default to being able to handle large data correctly/well*/
+	let userMapSize = options.mapSize;
 	options = Object.assign({
-		path: path$1,
 		noSubdir: Boolean(extension),
 		isRoot: true,
 		maxDbs: 12,
 		remapChunks,
 		keyBytes,
-		pageSize: 4096,
 		overlappingSync: (options.noSync || options.readOnly) ? false : (os != 'win32'),
 		// default map size limit of 4 exabytes when using remapChunks, since it is not preallocated and we can
 		// make it super huge.
@@ -2032,9 +2473,18 @@ function open(path$1, options) {
 			0x20000, // Otherwise we start small with 128KB
 		safeRestore: process.env.LMDB_RESTORE == 'safe',
 	}, options);
+	options.path = path$1;
 	if (options.asyncTransactionOrder == 'strict') {
 		options.strictAsyncOrder = true;
 	}
+	if (nativeAddon.version.major + nativeAddon.version.minor / 100 + nativeAddon.version.patch / 10000 < 0.0980) {
+		options.overlappingSync = false; // not support on older versions
+		options.trackMetrics = false;
+		options.usePreviousSnapshot = false;
+		options.safeRestore = false;
+		options.remapChunks = false;
+		if (!userMapSize) options.mapSize = 0x40000000; // 1 GB
+	}
 
 	if (!exists(options.noSubdir ? path.dirname(path$1) : path$1))
 		fs.mkdirSync(options.noSubdir ? path.dirname(path$1) : path$1, { recursive: true }
@@ -2047,7 +2497,7 @@ function open(path$1, options) {
 			return defaultCompression;
 		compressionOptions = Object.assign({
 			threshold: 1000,
-			dictionary: fs.readFileSync(new URL('./dict/dict.txt', (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || new URL('index.cjs', document.baseURI).href)).replace(/dist[\\\/]index.cjs$/, ''))),
+			dictionary: fs.readFileSync(new URL('./dict/dict.txt', (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index.cjs', document.baseURI).href)).replace(/dist[\\\/]index.cjs$/, ''))),
 			getValueBytes: makeReusableBuffer(0),
 		}, compressionOptions);
 		let compression = Object.assign(new Compression(compressionOptions), compressionOptions);
@@ -2070,17 +2520,20 @@ function open(path$1, options) {
 		(options.noMemInit ? 0x1000000 : 0) |
 		(options.usePreviousSnapshot ? 0x2000000 : 0) |
 		(options.remapChunks ? 0x4000000 : 0) |
-		(options.safeRestore ? 0x8000000 : 0);
+		(options.safeRestore ? 0x800 : 0) |
+		(options.trackMetrics ? 0x400 : 0);
 
 	let env = new Env();
 	let jsFlags = (options.overlappingSync ? 0x1000 : 0) |
 		(options.separateFlushed ? 1 : 0) |
 		(options.deleteOnClose ? 2 : 0);
 	let rc = env.open(options, flags, jsFlags);
+	env.path = path$1;
    if (rc)
 		lmdbError(rc);
+	delete options.keyBytes; // no longer needed, don't copy to stores
 	let maxKeySize = env.getMaxKeySize();
-	maxKeySize = Math.min(maxKeySize, MAX_KEY_SIZE);
+	maxKeySize = Math.min(maxKeySize, options.pageSize ? MAX_KEY_SIZE : DEFAULT_MAX_KEY_SIZE);
 	flags = getEnvFlags(env.address); // re-retrieve them, they are not necessarily the same if we are connecting to an existing env
 	if (flags & 0x1000) {
 		if (userOptions.noSync) {
@@ -2134,14 +2587,14 @@ function open(path$1, options) {
 				(dbOptions.integerDup ? 0x20 : 0) |
 				(dbOptions.reverseDup ? 0x40 : 0) |
 				(!options.readOnly && dbOptions.create !== false ? 0x40000 : 0) |
-				(dbOptions.useVersions ? 0x1000 : 0);
+				(dbOptions.useVersions ? 0x100 : 0);
 			let keyType = (dbOptions.keyIsUint32 || dbOptions.keyEncoding == 'uint32') ? 2 : keyIsBuffer ? 3 : 0;
 			if (keyType == 2)
 				flags |= 0x08; // integer key
 
 			if (options.readOnly) {
 				// in read-only mode we use a read-only txn to open the database
-				// TODO: LMDB is actually not entire thread-safe when it comes to opening databases with
+				// TODO: LMDB is actually not entirely thread-safe when it comes to opening databases with
 				// read-only transactions since there is a race condition on setting the update dbis that
 				// occurs outside the lock
 				// make sure we are using a fresh read txn, so we don't want to share with a cursor txn
@@ -2186,7 +2639,7 @@ function open(path$1, options) {
 			}
 			if (Encoder) {
 				this.encoder = new Encoder(Object.assign(
-					assignConstrainedProperties(['copyBuffers', 'getStructures', 'saveStructures', 'useFloat32', 'useRecords', 'structuredClone', 'variableMapSize', 'useTimestamp32', 'largeBigIntToFloat', 'encodeUndefinedAsNil', 'int64AsNumber', 'onInvalidDate', 'mapsAsObjects', 'useTag259ForMaps', 'pack', 'maxSharedStructures', 'shouldShareStructure'],
+					assignConstrainedProperties(['copyBuffers', 'getStructures', 'saveStructures', 'useFloat32', 'useRecords', 'structuredClone', 'variableMapSize', 'useTimestamp32', 'largeBigIntToFloat', 'encodeUndefinedAsNil', 'int64AsNumber', 'onInvalidDate', 'mapsAsObjects', 'useTag259ForMaps', 'pack', 'maxSharedStructures', 'shouldShareStructure', 'randomAccessStructure', 'freezeData'],
 					this.sharedStructuresKey ? this.setupSharedStructures() : {
 						copyBuffers: true, // need to copy any embedded buffers that are found since we use unsafe buffers
 					}, options, dbOptions), this.encoder));
@@ -2230,8 +2683,11 @@ function open(path$1, options) {
 				callback(null, db);
 			return db;
 		}
-		backup(path) {
-			return new Promise((resolve, reject) => env.copy(path, false, (error) => {
+		backup(path$1, compact) {
+			if (noFSAccess)
+				return;
+			fs.mkdirSync(path.dirname(path$1), { recursive: true });
+			return new Promise((resolve, reject) => env.copy(path$1, false, (error) => {
 				if (error) {
 					reject(error);
 				} else {
@@ -2343,11 +2799,14 @@ function openAsClass(path, options) {
 function getLastVersion() {
 	return keyBytesView.getFloat64(16, true);
 }
-
 function setLastVersion(version) {
 	return keyBytesView.setFloat64(16, version, true);
 }
 
+function getLastTxnId() {
+	return keyBytesView.getUint32(32, true);
+}
+
 const KEY_BUFFER_SIZE = 4096;
 function allocateFixedBuffer() {
 	keyBytes = typeof Buffer != 'undefined' ? Buffer.allocUnsafeSlow(KEY_BUFFER_SIZE) : new Uint8Array(KEY_BUFFER_SIZE);
@@ -2355,7 +2814,7 @@ function allocateFixedBuffer() {
 	keyBytesView = keyBytes.dataView || (keyBytes.dataView = new DataView(keyBytes.buffer, 0, KEY_BUFFER_SIZE)); // max key size is actually 4026
 	keyBytes.uint32 = new Uint32Array(keyBuffer, 0, KEY_BUFFER_SIZE >> 2);
 	keyBytes.float64 = new Float64Array(keyBuffer, 0, KEY_BUFFER_SIZE >> 3);
-	keyBytes.uint32.address = keyBytes.address = keyBuffer.address = getAddress(keyBytes);
+	keyBytes.uint32.address = keyBytes.address = keyBuffer.address = getAddress(keyBuffer);
 }
 
 function exists(path) {
@@ -2379,72 +2838,76 @@ function assignConstrainedProperties(allowedProperties, target) {
 	return target;
 }
 
-function levelup(store) {
-	return Object.assign(Object.create(store), {
-		get(key, options, callback) {
-			let result = store.get(key);
-			if (typeof options == 'function')
-				callback = options;
-			if (callback) {
-				if (result === undefined)
-					callback(new NotFoundError());
-				else
-					callback(null, result);
-			} else {
-				if (result === undefined)
-					return Promise.reject(new NotFoundError());
-				else
-					return Promise.resolve(result);
-			}
-		},
-	});
-}
-class NotFoundError extends Error {
-	constructor(message) {
-		super(message);
-		this.name = 'NotFoundError';
-		this.notFound = true;
-	}
+function levelup(store) {
+	return Object.assign(Object.create(store), {
+		get(key, options, callback) {
+			let result = store.get(key);
+			if (typeof options == 'function')
+				callback = options;
+			if (callback) {
+				if (result === undefined)
+					callback(new NotFoundError());
+				else
+					callback(null, result);
+			} else {
+				if (result === undefined)
+					return Promise.reject(new NotFoundError());
+				else
+					return Promise.resolve(result);
+			}
+		},
+	});
+}
+class NotFoundError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = 'NotFoundError';
+		this.notFound = true;
+	}
 }
 
-orderedBinary__namespace.enableNullTermination();
-setExternals({
-	arch: os$1.arch, fs: fs__default["default"], tmpdir: os$1.tmpdir, MsgpackrEncoder: msgpackr.Encoder, WeakLRUCache: weakLruCache.WeakLRUCache, orderedBinary: orderedBinary__namespace,
-	EventEmitter: events.EventEmitter, os: os$1.platform(), onExit(callback) {
-		if (process.getMaxListeners() < process.listenerCount('exit') + 8)
-			process.setMaxListeners(process.listenerCount('exit') + 8);
-		process.on('exit', callback);
-	},
-});
-let { noop } = nativeAddon;
-const TransactionFlags = {
-	ABORTABLE: 1,
-	SYNCHRONOUS_COMMIT: 2,
-	NO_SYNC_FLUSH: 0x10000,
-};
-var index = {
-	open, openAsClass, getLastVersion, compareKey: orderedBinary$1.compareKeys, keyValueToBuffer: orderedBinary$1.toBufferKey, bufferToKeyValue: orderedBinary$1.fromBufferKey, ABORT, IF_EXISTS, asBinary, levelup, TransactionFlags
+orderedBinary__namespace.enableNullTermination();
+setExternals({
+	arch: os$1.arch, fs: fs__default["default"], tmpdir: os$1.tmpdir, MsgpackrEncoder: msgpackr.Encoder, WeakLRUCache: weakLruCache.WeakLRUCache, orderedBinary: orderedBinary__namespace,
+	EventEmitter: events.EventEmitter, os: os$1.platform(), onExit(callback) {
+		if (process.getMaxListeners() < process.listenerCount('exit') + 8)
+			process.setMaxListeners(process.listenerCount('exit') + 8);
+		process.on('exit', callback);
+	},
+});
+let { noop } = nativeAddon;
+const TransactionFlags = {
+	ABORTABLE: 1,
+	SYNCHRONOUS_COMMIT: 2,
+	NO_SYNC_FLUSH: 0x10000,
+};
+var index = {
+	open, openAsClass, getLastVersion, compareKey: orderedBinary$1.compareKeys, keyValueToBuffer: orderedBinary$1.toBufferKey, bufferToKeyValue: orderedBinary$1.fromBufferKey, ABORT, IF_EXISTS: IF_EXISTS$1, asBinary, levelup, TransactionFlags
 };
 
-setRequire(module$1.createRequire((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || new URL('index.cjs', document.baseURI).href))));
+let require$1 = module$1.createRequire((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index.cjs', document.baseURI).href)));
+setRequire(require$1);
 exports.v8AccelerationEnabled = false;
 
 let versions = process.versions;
-let [ majorVersion, minorVersion ] = versions.node.split('.');
-
-if (versions.v8 && +majorVersion == nativeAddon.version.nodeCompiledVersion) {
-	let v8Funcs = {};
-	let fastApiCalls = (majorVersion == 17 || majorVersion == 18 || majorVersion == 16 && minorVersion > 6) && !process.env.DISABLE_TURBO_CALLS;
-	if (fastApiCalls)
-		v8.setFlagsFromString('--turbo-fast-api-calls');
-	nativeAddon.enableDirectV8(v8Funcs, fastApiCalls);
-	Object.assign(nativeAddon, v8Funcs);
-	exports.v8AccelerationEnabled = true;
-} else if (majorVersion == 14) {
-	// node v14 only has ABI compatibility with node v16 for zero-arg clearKeptObjects
-	let v8Funcs = {};
-	nativeAddon.enableDirectV8(v8Funcs, false);
-	nativeAddon.clearKeptObjects = v8Funcs.clearKeptObjects;
+if (!versions.deno && !process.isBun) {
+	let [ majorVersion, minorVersion ] = versions.node.split('.');
+	if (versions.v8 && +majorVersion == nativeAddon.version.nodeCompiledVersion) {
+		let v8Funcs = {};
+		let fastApiCalls = (majorVersion == 17 || majorVersion == 18 || majorVersion == 16 && minorVersion > 8) && !process.env.DISABLE_TURBO_CALLS;
+		if (fastApiCalls) {
+			require$1('v8').setFlagsFromString('--turbo-fast-api-calls');
+		}
+		nativeAddon.enableDirectV8(v8Funcs, fastApiCalls);
+		Object.assign(nativeAddon, v8Funcs);
+		exports.v8AccelerationEnabled = true;
+	} else if (majorVersion == 14) {
+		// node v14 only has ABI compatibility with node v16 for zero-arg clearKeptObjects
+		let v8Funcs = {};
+		nativeAddon.enableDirectV8(v8Funcs, false);
+		nativeAddon.clearKeptObjects = v8Funcs.clearKeptObjects;
+	}
+	nativeAddon.enableThreadSafeCalls();
 }
 setNativeFunctions(nativeAddon);
 
@@ -2465,13 +2928,16 @@ Object.defineProperty(exports, 'keyValueToBuffer', {
 	get: function () { return orderedBinary$1.toBufferKey; }
 });
 exports.ABORT = ABORT;
-exports.IF_EXISTS = IF_EXISTS;
+exports.IF_EXISTS = IF_EXISTS$1;
+exports.SKIP = SKIP;
 exports.TransactionFlags = TransactionFlags;
 exports.allDbs = allDbs;
 exports.asBinary = asBinary;
 exports["default"] = index;
+exports.getLastTxnId = getLastTxnId;
 exports.getLastVersion = getLastVersion;
 exports.levelup = levelup;
+exports.nativeAddon = nativeAddon;
 exports.noop = noop;
 exports.open = open;
 exports.openAsClass = openAsClass;