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

package/index.js

@@ -1,37 +1,38 @@
-import { EventEmitter } from 'events';
-import { setExternals, setNativeFunctions, Dbi } from './native.js';
-import { arch, tmpdir, platform } from 'os';
-import fs from 'fs';
-import { Encoder as MsgpackrEncoder } from 'msgpackr';
-import { WeakLRUCache } from 'weak-lru-cache';
-import * as orderedBinary from 'ordered-binary';
-
-
-orderedBinary.enableNullTermination();
-setExternals({
-	arch, fs, tmpdir, MsgpackrEncoder, WeakLRUCache, orderedBinary,
-	EventEmitter, os: platform(), onExit(callback) {
-		if (process.getMaxListeners() < process.listenerCount('exit') + 8)
-			process.setMaxListeners(process.listenerCount('exit') + 8);
-		process.on('exit', callback);
-	},
-});
-export { toBufferKey as keyValueToBuffer, compareKeys, compareKeys as compareKey, fromBufferKey as bufferToKeyValue } from 'ordered-binary';
-export { ABORT, IF_EXISTS, asBinary } from './write.js';
-import { ABORT, IF_EXISTS, asBinary } from './write.js';
-export { levelup } from './level.js';
-import { levelup } from './level.js';
-export { clearKeptObjects } from './native.js';
-import { nativeAddon } from './native.js';
-export let { noop } = nativeAddon;
-export { open, openAsClass, getLastVersion, allDbs } from './open.js';
-import { toBufferKey as keyValueToBuffer, compareKeys as compareKey, fromBufferKey as bufferToKeyValue } from 'ordered-binary';
-import { open, openAsClass, getLastVersion } from './open.js';
-export const TransactionFlags = {
-	ABORTABLE: 1,
-	SYNCHRONOUS_COMMIT: 2,
-	NO_SYNC_FLUSH: 0x10000,
-};
-export default {
-	open, openAsClass, getLastVersion, compareKey, keyValueToBuffer, bufferToKeyValue, ABORT, IF_EXISTS, asBinary, levelup, TransactionFlags
-};
+import { EventEmitter } from 'events';
+import { setExternals, setNativeFunctions, Dbi } from './native.js';
+import { arch, tmpdir, platform } from 'os';
+import fs from 'fs';
+import { Encoder as MsgpackrEncoder } from 'msgpackr';
+import { WeakLRUCache } from 'weak-lru-cache';
+import * as orderedBinary from 'ordered-binary';
+
+
+orderedBinary.enableNullTermination();
+setExternals({
+	arch, fs, tmpdir, MsgpackrEncoder, WeakLRUCache, orderedBinary,
+	EventEmitter, os: platform(), onExit(callback) {
+		if (process.getMaxListeners() < process.listenerCount('exit') + 8)
+			process.setMaxListeners(process.listenerCount('exit') + 8);
+		process.on('exit', callback);
+	},
+});
+export { toBufferKey as keyValueToBuffer, compareKeys, compareKeys as compareKey, fromBufferKey as bufferToKeyValue } from 'ordered-binary';
+export { ABORT, IF_EXISTS, asBinary } from './write.js';
+import { ABORT, IF_EXISTS, asBinary } from './write.js';
+export { levelup } from './level.js';
+export { SKIP } from './util/RangeIterable.js';
+import { levelup } from './level.js';
+export { clearKeptObjects } from './native.js';
+import { nativeAddon } from './native.js';
+export let { noop } = nativeAddon;
+export { open, openAsClass, getLastVersion, allDbs, getLastTxnId } from './open.js';
+import { toBufferKey as keyValueToBuffer, compareKeys as compareKey, fromBufferKey as bufferToKeyValue } from 'ordered-binary';
+import { open, openAsClass, getLastVersion } from './open.js';
+export const TransactionFlags = {
+	ABORTABLE: 1,
+	SYNCHRONOUS_COMMIT: 2,
+	NO_SYNC_FLUSH: 0x10000,
+};
+export default {
+	open, openAsClass, getLastVersion, compareKey, keyValueToBuffer, bufferToKeyValue, ABORT, IF_EXISTS, asBinary, levelup, TransactionFlags
+};

package/keys.js

@@ -1,102 +1,116 @@
-import { getAddress, orderedBinary } from './native.js';
-
-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 = Uint8Array.prototype.slice;
-const readBufferKey = (target, start, end) => {
-	return Uint8ArraySlice.call(target, start, end);
-};
-
-export 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;
-}
-export 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;
-	}
-}
+import { getAddress, orderedBinary } from './native.js';
+
+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 = Uint8Array.prototype.slice;
+const readBufferKey = (target, start, end) => {
+	return Uint8ArraySlice.call(target, start, end);
+};
+
+let lastEncodedValue, bytes;
+export 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) {
+				// reuse the last serialized bytes
+				// NOTE that it is very important that nothing else calls saveKey with saveTo: false
+			} 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;
+	}
+}
+
+let saveBuffer, uint32, 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);
+	uint32 = null;
+	saveBuffer.buffer.address = getAddress(saveBuffer.buffer);
+	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
+	saveDataView = saveBuffer.dataView || (saveBuffer.dataView = new DataView(saveBuffer.buffer, saveBuffer.byteOffset, saveBuffer.byteLength));
+	savePosition = 0;
+}
+export function saveKey(key, writeKey, saveTo, maxKeySize, flags) {
+	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, flags ? length | flags : 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;
+	}
+}

package/level.js

@@ -1,27 +1,27 @@
-export 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;
-	}
+export 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;
+	}
 }

package/native.js

@@ -1,14 +1,12 @@
 import { dirname, join, default as pathModule } from 'path';
 import { fileURLToPath } from 'url';
 import loadNAPI from 'node-gyp-build-optional-packages';
-export let Env, Txn, Dbi, Compression, Cursor, getAddress, createBufferForAddress, clearKeptObjects, setGlobalBuffer, arch, fs, os, onExit, tmpdir, lmdbError, path, EventEmitter, orderedBinary, MsgpackrEncoder, WeakLRUCache, setEnvMap, getEnvMap, getByBinary, detachBuffer, write, position, iterate, prefetch, resetTxn, getCurrentValue, getCurrentShared, getStringByBinary, getSharedByBinary, compress;
-
+export let Env, Txn, Dbi, Compression, Cursor, getAddress, getBufferAddress, createBufferForAddress, clearKeptObjects, globalBuffer, setGlobalBuffer, arch, fs, os, onExit, tmpdir, lmdbError, path, EventEmitter, orderedBinary, MsgpackrEncoder, WeakLRUCache, setEnvMap, getEnvMap, getByBinary, detachBuffer, startRead, setReadCallback, write, position, iterate, prefetch, resetTxn, getCurrentValue, getCurrentShared, getStringByBinary, getSharedByBinary, getSharedBuffer, compress;
 path = pathModule;
-let dirName = (typeof __dirname == 'string' ? __dirname : // for bun, which doesn't have fileURLToPath
-	dirname(fileURLToPath(import.meta.url))).replace(/dist$/, ''); // for node, which doesn't have __dirname in ESM
+let dirName = dirname(fileURLToPath(import.meta.url)).replace(/dist$/, '');
 export let nativeAddon = loadNAPI(dirName);
 
-if (process.isBun) {
+if (process.isBun && false) {
 	const { linkSymbols, FFIType } = require('bun:ffi');
 	let lmdbLib = linkSymbols({
 		getByBinary: {
@@ -49,11 +47,16 @@ export function setNativeFunctions(externals) {
 	Dbi = externals.Dbi;
 	Compression = externals.Compression;
 	getAddress = externals.getAddress;
+	getBufferAddress = externals.getBufferAddress;
 	createBufferForAddress = externals.createBufferForAddress;
 	clearKeptObjects = externals.clearKeptObjects || function() {};
 	getByBinary = externals.getByBinary;
 	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;

package/node-index.js

@@ -1,26 +1,30 @@
 import { createRequire } from 'module';
 import { setRequire } from './open.js';
 import { nativeAddon, setNativeFunctions } from './native.js';
-import { setFlagsFromString } from 'v8';
-setRequire(createRequire(import.meta.url));
+export { nativeAddon } from './native.js'
+let require = createRequire(import.meta.url);
+setRequire(require);
 export let 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)
-		setFlagsFromString('--turbo-fast-api-calls')
-	nativeAddon.enableDirectV8(v8Funcs, fastApiCalls);
-	Object.assign(nativeAddon, v8Funcs);
-	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('v8').setFlagsFromString('--turbo-fast-api-calls');
+		}
+		nativeAddon.enableDirectV8(v8Funcs, fastApiCalls);
+		Object.assign(nativeAddon, v8Funcs);
+		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);
 

package/open.js

@@ -1,4 +1,5 @@
-import { Compression, getAddress, arch, fs, path as pathModule, lmdbError, EventEmitter, MsgpackrEncoder, Env, Dbi, tmpdir, os, nativeAddon } from './native.js';
+import { Compression, getAddress, arch, fs, path as pathModule, lmdbError, EventEmitter, MsgpackrEncoder, Env,
+	Dbi, tmpdir, os, nativeAddon } from './native.js';
 import { CachingStore, setGetLastVersion } from './caching.js';
 import { addReadMethods, makeReusableBuffer } from './read.js';
 import { addWriteMethods } from './write.js';
@@ -8,7 +9,7 @@ export function setRequire(require) {
 	moduleRequire = require;
 }
 
-setGetLastVersion(getLastVersion);
+setGetLastVersion(getLastVersion, getLastTxnId);
 let keyBytes, keyBytesView;
 const buffers = [];
 const { onExit, getEnvsPointer, setEnvsPointer, getEnvFlags, setJSFlags } = nativeAddon;
@@ -20,6 +21,9 @@ 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;
 
 export const allDbs = new Map();
@@ -27,6 +31,20 @@ let defaultCompression;
 let lastSize;
 let hasRegisteredOnExit;
 export function open(path, 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, 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 == 'object' && !options) {
@@ -34,8 +52,9 @@ export function open(path, options) {
 		path = 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) {
+	if (path == null) {
 		options = Object.assign({
 			deleteOnClose: true,
 			noSync: true,
@@ -46,17 +65,16 @@ export function open(path, options) {
 	let extension = pathModule.extname(path);
 	let name = pathModule.basename(path, 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,
 		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.
@@ -64,9 +82,18 @@ export function open(path, options) {
 			0x20000, // Otherwise we start small with 128KB
 		safeRestore: process.env.LMDB_RESTORE == 'safe',
 	}, options);
+	options.path = path;
 	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 ? pathModule.dirname(path) : path))
 		fs.mkdirSync(options.noSubdir ? pathModule.dirname(path) : path, { recursive: true }
@@ -102,17 +129,20 @@ export function open(path, 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)
+		(options.deleteOnClose ? 2 : 0);
 	let rc = env.open(options, flags, jsFlags);
+	env.path = path;
    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) {
@@ -130,7 +160,6 @@ export function open(path, options) {
 	}
 
 	env.readerCheck(); // clear out any stale entries
-	let stores = [];
 	if ((options.overlappingSync || options.deleteOnClose) && !hasRegisteredOnExit && process.on) {
 		hasRegisteredOnExit = true;
 		process.on('exit', onExit);
@@ -167,14 +196,14 @@ export function open(path, 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
@@ -219,7 +248,7 @@ export function open(path, 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));
@@ -235,7 +264,6 @@ export function open(path, options) {
 			this.maxKeySize = maxKeySize;
 			applyKeyHandling(this);
 			allDbs.set(dbName ? name + '-' + dbName : name, this);
-			stores.push(this);
 		}
 		openDB(dbName, dbOptions) {
 			if (this.dupSort && this.name == null)
@@ -264,7 +292,10 @@ export function open(path, options) {
 				callback(null, db);
 			return db;
 		}
-		backup(path) {
+		backup(path, compact) {
+			if (noFSAccess)
+				return;
+			fs.mkdirSync(pathModule.dirname(path), { recursive: true });
 			return new Promise((resolve, reject) => env.copy(path, false, (error) => {
 				if (error) {
 					reject(error);
@@ -377,11 +408,14 @@ export function openAsClass(path, options) {
 export function getLastVersion() {
 	return keyBytesView.getFloat64(16, true);
 }
-
 export function setLastVersion(version) {
 	return keyBytesView.setFloat64(16, version, true);
 }
 
+export 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);
@@ -389,7 +423,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) {