@harperfast/rocksdb-js 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1767 @@
+import { createRequire } from "node:module";
+import { execSync } from "node:child_process";
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Encoder } from "msgpackr";
+import * as orderedBinary from "ordered-binary";
+import { ExtendedIterable } from "@harperfast/extended-iterable";
+
+//#region src/load-binding.ts
+const nativeExtRE = /\.node$/;
+/**
+* Locates the native binding in the `build` directory, then the `prebuilds`
+* directory.
+*
+* @returns The path to the native binding.
+*/
+function locateBinding() {
+	const baseDir = dirname(dirname(fileURLToPath(import.meta.url)));
+	for (const type of ["Release", "Debug"]) try {
+		const dir = join(baseDir, "build", type);
+		const files = readdirSync(dir);
+		for (const file of files) if (nativeExtRE.test(file)) return resolve(dir, file);
+	} catch {}
+	let runtime = "";
+	if (process.platform === "linux") {
+		let isMusl = false;
+		try {
+			isMusl = readFileSync("/usr/bin/ldd", "utf8").includes("musl");
+		} catch {
+			if (typeof process.report?.getReport === "function") {
+				process.report.excludeEnv = true;
+				const report = process.report.getReport();
+				isMusl = (!report?.header || !report.header.glibcVersionRuntime) && Array.isArray(report?.sharedObjects) && report.sharedObjects.some((obj) => obj.includes("libc.musl-") || obj.includes("ld-musl-"));
+			}
+			isMusl = isMusl || execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+		}
+		runtime = isMusl ? "-musl" : "-glibc";
+	}
+	/* v8 ignore next 10 -- @preserve */
+	try {
+		const path = join(baseDir, "node_modules", "@harperfast", `rocksdb-js-${process.platform}-${process.arch}${runtime}`, "rocksdb-js.node");
+		if (existsSync(path)) return resolve(path);
+	} catch {}
+	throw new Error("Unable to locate rocksdb-js native binding");
+}
+const binding = createRequire(import.meta.url)(locateBinding());
+const config = binding.config;
+const constants = binding.constants;
+const NativeDatabase = binding.Database;
+const NativeIterator = binding.Iterator;
+const NativeTransaction = binding.Transaction;
+const TransactionLog = binding.TransactionLog;
+const version = binding.version;
+const shutdown = binding.shutdown;
+
+//#endregion
+//#region src/util.ts
+/**
+* Parses a duration string into milliseconds.
+*
+* @param duration - The duration string to parse.
+* @returns The duration in milliseconds.
+*
+* @example
+* ```typescript
+* parseDuration('1s'); // 1000
+* parseDuration('1m'); // 60000
+* parseDuration('1h'); // 3600000
+* parseDuration('1d'); // 86400000
+* parseDuration('1ms'); // 1
+* parseDuration('1s 1ms'); // 1001
+* parseDuration('1m 1s'); // 61000
+* parseDuration('foo'); // throws error
+*
+* parseDuration(1000); // 1000
+* parseDuration(60000); // 60000
+* parseDuration(3600000); // 3600000
+* parseDuration(86400000); // 86400000
+* parseDuration(NaN); // throws error
+* ```
+*/
+function parseDuration(duration) {
+	if (typeof duration === "number") {
+		if (isNaN(duration) || !isFinite(duration)) throw new Error(`Invalid duration: ${duration}`);
+		return duration;
+	}
+	let result = 0;
+	for (const part of duration.split(" ")) {
+		const m = part.match(/^(\d+)\s*(ms|s|m|h|d)?$/);
+		if (!m) throw new Error(`Invalid duration: ${duration}`);
+		const [, value, unit] = m;
+		let num = parseInt(value, 10);
+		switch (unit) {
+			case "s":
+				num *= 1e3;
+				break;
+			case "m":
+				num *= 1e3 * 60;
+				break;
+			case "h":
+				num *= 1e3 * 60 * 60;
+				break;
+			case "d":
+				num *= 1e3 * 60 * 60 * 24;
+				break;
+		}
+		result += num;
+	}
+	return result;
+}
+/**
+* Helper function handling `MaybePromise` results.
+*
+* If the result originates from a function that could throw an error, wrap it
+* in a function so this function can catch any errors and use a unified error
+* handling mechanism.
+*/
+function when(subject, callback, errback) {
+	try {
+		let result;
+		if (typeof subject === "function") result = subject();
+		else result = subject;
+		if (result instanceof Promise) return result.then(callback, errback);
+		return callback ? callback(result) : result;
+	} catch (error) {
+		return errback ? errback(error) : Promise.reject(error);
+	}
+}
+
+//#endregion
+//#region src/dbi.ts
+/**
+* The base class for all database operations. This base class is shared by
+* `RocksDatabase` and `Transaction`.
+*
+* This class is not meant to be used directly.
+*/
+var DBI = class DBI {
+	/**
+	* The RocksDB context for `get()`, `put()`, and `remove()`.
+	*/
+	#context;
+	/**
+	* The database store instance. The store instance is tied to the database
+	* instance and shared with transaction instances.
+	*/
+	store;
+	/**
+	* Initializes the DBI context.
+	*
+	* @param store - The store instance.
+	* @param transaction - The transaction instance.
+	*/
+	constructor(store, transaction) {
+		if (new.target === DBI) throw new Error("DBI is an abstract class and cannot be instantiated directly");
+		this.store = store;
+		this.#context = transaction || store.db;
+	}
+	/**
+	* Adds a listener for the given key.
+	*
+	* @param event - The event name to add the listener for.
+	* @param callback - The callback to add.
+	*/
+	addListener(event, callback) {
+		this.store.db.addListener(event, callback);
+		return this;
+	}
+	/**
+	* Retrieves the value for the given key, then returns the decoded value.
+	*/
+	get(key, options) {
+		if (this.store.decoderCopies) return when(() => this.getBinaryFast(key, options), (result) => {
+			if (result === void 0) return;
+			if (options?.skipDecode) return result;
+			return this.store.decodeValue(result);
+		});
+		return when(() => this.getBinary(key, options), (result) => result === void 0 ? void 0 : this.store.encoding === "binary" || !this.store.decoder || options?.skipDecode ? result : this.store.decodeValue(result));
+	}
+	/**
+	* Retrieves the binary data for the given key. This is just like `get()`,
+	* but bypasses the decoder.
+	*
+	* Note: Used by HDBreplication.
+	*/
+	getBinary(key, options) {
+		if (!this.store.isOpen()) return Promise.reject(/* @__PURE__ */ new Error("Database not open"));
+		return this.store.get(this.#context, key, true, this.store.getTxnId(options));
+	}
+	/**
+	* Synchronously retrieves the binary data for the given key.
+	*/
+	getBinarySync(key, options) {
+		if (!this.store.isOpen()) throw new Error("Database not open");
+		return this.store.getSync(this.#context, key, true, options);
+	}
+	/**
+	* Retrieves the binary data for the given key using a preallocated,
+	* reusable buffer. Data in the buffer is only valid until the next get
+	* operation (including cursor operations).
+	*
+	* Note: The reusable buffer slightly differs from a typical buffer:
+	* - `.length` is set to the size of the value
+	* - `.byteLength` is set to the size of the full allocated memory area for
+	*   the buffer (usually much larger).
+	*/
+	getBinaryFast(key, options) {
+		if (!this.store.isOpen()) return Promise.reject(/* @__PURE__ */ new Error("Database not open"));
+		return this.store.get(this.#context, key, false, this.store.getTxnId(options));
+	}
+	/**
+	* Synchronously retrieves the binary data for the given key using a
+	* preallocated, reusable buffer. Data in the buffer is only valid until the
+	* next get operation (including cursor operations).
+	*/
+	getBinaryFastSync(key, options) {
+		if (!this.store.isOpen()) throw new Error("Database not open");
+		return this.store.getSync(this.#context, key, false, options);
+	}
+	/**
+	* Retrieves all keys within a range.
+	*/
+	getKeys(options) {
+		return this.store.getRange(this.#context, {
+			...options,
+			values: false
+		}).map((item) => item.key);
+	}
+	/**
+	* Retrieves the number of keys within a range.
+	*
+	* @param options - The range options.
+	* @returns The number of keys within the range.
+	*
+	* @example
+	* ```typescript
+	* const total = db.getKeysCount();
+	* const range = db.getKeysCount({ start: 'a', end: 'z' });
+	* ```
+	*/
+	getKeysCount(options) {
+		return this.store.getCount(this.#context, options);
+	}
+	/**
+	* Retrieves a range of keys and their values.
+	*
+	* @param options - The iterator options.
+	* @returns A range iterable.
+	*
+	* @example
+	* ```typescript
+	* for (const { key, value } of db.getRange()) {
+	*   console.log({ key, value });
+	* }
+	*
+	* for (const { key, value } of db.getRange({ start: 'a', end: 'z' })) {
+	*   console.log({ key, value });
+	* }
+	* ```
+	*/
+	getRange(options) {
+		return this.store.getRange(this.#context, options);
+	}
+	/**
+	* Synchronously retrieves the value for the given key, then returns the
+	* decoded value.
+	*/
+	getSync(key, options) {
+		if (this.store.decoderCopies) {
+			const bytes = this.getBinaryFastSync(key, options);
+			return bytes === void 0 ? void 0 : this.store.decodeValue(bytes);
+		}
+		if (this.store.encoding === "binary") return this.getBinarySync(key, options);
+		if (this.store.decoder) {
+			const result = this.getBinarySync(key, options);
+			return result ? this.store.decodeValue(result) : void 0;
+		}
+		if (!this.store.isOpen()) throw new Error("Database not open");
+		return this.store.decodeValue(this.store.getSync(this.#context, key, true, options));
+	}
+	/**
+	* Gets the number of listeners for the given key.
+	*
+	* @param event - The event name to get the listeners for.
+	* @returns The number of listeners for the given key.
+	*/
+	listeners(event) {
+		return this.store.db.listeners(event);
+	}
+	/**
+	* Notifies an event for the given key.
+	*
+	* @param event - The event name to emit the event for.
+	* @param args - The arguments to emit.
+	* @returns `true` if there were listeners, `false` otherwise.
+	*/
+	notify(event, ...args) {
+		return this.store.db.notify(event, args);
+	}
+	/**
+	* Alias for `removeListener()`.
+	*
+	* @param event - The event name to remove the listener for.
+	* @param callback - The callback to remove.
+	*/
+	off(event, callback) {
+		this.store.db.removeListener(event, callback);
+		return this;
+	}
+	/**
+	* Alias for `addListener()`.
+	*
+	* @param event - The event name to add the listener for.
+	* @param callback - The callback to add.
+	*/
+	on(event, callback) {
+		this.store.db.addListener(event, callback);
+		return this;
+	}
+	/**
+	* Adds a one-time listener, then automatically removes it.
+	*
+	* @param event - The event name to add the listener for.
+	* @param callback - The callback to add.
+	*/
+	once(event, callback) {
+		const wrapper = (...args) => {
+			this.removeListener(event, wrapper);
+			callback(...args);
+		};
+		this.store.db.addListener(event, wrapper);
+		return this;
+	}
+	/**
+	* Stores a value for the given key.
+	*
+	* @param key - The key to store the value for.
+	* @param value - The value to store.
+	* @param options - The put options.
+	* @returns The key and value.
+	*
+	* @example
+	* ```typescript
+	* await db.put('a', 'b');
+	* ```
+	*/
+	async put(key, value, options) {
+		return this.store.putSync(this.#context, key, value, options);
+	}
+	/**
+	* Synchronously stores a value for the given key.
+	*
+	* @param key - The key to store the value for.
+	* @param value - The value to store.
+	* @param options - The put options.
+	* @returns The key and value.
+	*
+	* @example
+	* ```typescript
+	* db.putSync('a', 'b');
+	* ```
+	*/
+	putSync(key, value, options) {
+		return this.store.putSync(this.#context, key, value, options);
+	}
+	/**
+	* Removes a value for the given key. If the key does not exist, it will
+	* not error.
+	*
+	* @param key - The key to remove the value for.
+	* @param options - The remove options.
+	* @returns The key and value.
+	*
+	* @example
+	* ```typescript
+	* await db.remove('a');
+	* ```
+	*/
+	async remove(key, options) {
+		return this.store.removeSync(this.#context, key, options);
+	}
+	/**
+	* Removes a value for the given key. If the key does not exist, it will
+	* not error.
+	*
+	* @param key - The key to remove the value for.
+	* @param options - The remove options.
+	* @returns The key and value.
+	*
+	* @example
+	* ```typescript
+	* db.removeSync('a');
+	* ```
+	*/
+	removeSync(key, options) {
+		return this.store.removeSync(this.#context, key, options);
+	}
+	/**
+	* Removes an event listener. You must specify the exact same callback that was
+	* used in `addListener()`.
+	*
+	* @param event - The event name to remove the listener for.
+	* @param callback - The callback to remove.
+	*/
+	removeListener(event, callback) {
+		return this.store.db.removeListener(event, callback);
+	}
+	/**
+	* Get or create a transaction log instance.
+	*
+	* @param name - The name of the transaction log.
+	* @returns The transaction log.
+	*/
+	useLog(name) {
+		return this.store.useLog(this.#context, name);
+	}
+};
+
+//#endregion
+//#region src/dbi-iterator.ts
+/**
+* Wraps an iterator, namely the `NativeIterator` class, and decodes the key
+* and value.
+*/
+var DBIterator = class {
+	iterator;
+	store;
+	#includeValues;
+	constructor(iterator, store, options) {
+		this.iterator = iterator;
+		this.store = store;
+		this.#includeValues = options?.values ?? true;
+	}
+	[Symbol.iterator]() {
+		return this;
+	}
+	next(...[_value]) {
+		const result = this.iterator.next();
+		if (result.done) return result;
+		const value = {};
+		value.key = this.store.decodeKey(result.value.key);
+		if (this.#includeValues) value.value = this.store.decodeValue(result.value.value);
+		return {
+			done: false,
+			value
+		};
+	}
+	return(value) {
+		if (this.iterator.return) return this.iterator.return(value);
+		return {
+			done: true,
+			value
+		};
+	}
+	throw(err) {
+		if (this.iterator.throw) return this.iterator.throw(err);
+		throw err;
+	}
+};
+
+//#endregion
+//#region src/encoding.ts
+/**
+* Initializes the key encoder functions.
+*
+* @param keyEncoding - The key encoding to use.
+* @param keyEncoder - The key encoder to use.
+* @returns The key encoder.
+*/
+function initKeyEncoder(requestedKeyEncoding, keyEncoder) {
+	const keyEncoding = requestedKeyEncoding ?? "ordered-binary";
+	if (keyEncoder) {
+		const { readKey, writeKey } = keyEncoder;
+		if (!readKey || !writeKey) throw new Error("Custom key encoder must provide both readKey and writeKey");
+		return {
+			keyEncoding,
+			readKey,
+			writeKey
+		};
+	}
+	if (keyEncoding === "binary") return {
+		keyEncoding,
+		readKey(source, start, end) {
+			return Uint8Array.prototype.slice.call(source, start, end);
+		},
+		writeKey(key, target, start) {
+			const keyBuffer = key instanceof Buffer ? key : Buffer.from(String(key));
+			target.set(keyBuffer, start);
+			return keyBuffer.length + start;
+		}
+	};
+	if (keyEncoding === "uint32") return {
+		keyEncoding,
+		readKey(source, start, _end) {
+			if (!source.dataView) source.dataView = new DataView(source.buffer);
+			return source.dataView.getUint32(start, true);
+		},
+		writeKey(key, target, start) {
+			const keyNumber = Number(key);
+			if (isNaN(keyNumber)) throw new TypeError("Key is not a number");
+			target.dataView.setUint32(start, keyNumber, true);
+			return start + 4;
+		}
+	};
+	if (keyEncoding === "ordered-binary") return {
+		keyEncoding,
+		readKey: orderedBinary.readKey,
+		writeKey: orderedBinary.writeKey
+	};
+	throw new Error(`Invalid key encoding: ${keyEncoding}`);
+}
+/**
+* Creates a fixed-size buffer with a data view, start, and end properties.
+*
+* Note: It uses `Buffer.allocUnsafe()` because it's the fastest by using
+* Node.js's preallocated memory pool, though the memory is not zeroed out.
+*
+* @param size - The size of the buffer.
+* @returns The buffer with a data view.
+*/
+function createFixedBuffer(size) {
+	const buffer = Buffer.allocUnsafeSlow(size);
+	buffer.dataView = new DataView(buffer.buffer);
+	buffer.start = 0;
+	buffer.end = 0;
+	return buffer;
+}
+
+//#endregion
+//#region src/store.ts
+const { ONLY_IF_IN_MEMORY_CACHE_FLAG, NOT_IN_MEMORY_CACHE_FLAG, ALWAYS_CREATE_NEW_BUFFER_FLAG } = constants;
+const KEY_BUFFER_SIZE = 4096;
+const KEY_BUFFER = createFixedBuffer(KEY_BUFFER_SIZE);
+const VALUE_BUFFER = createFixedBuffer(64 * 1024);
+const MAX_KEY_SIZE = 1024 * 1024;
+const RESET_BUFFER_MODE = 1024;
+const REUSE_BUFFER_MODE = 512;
+const SAVE_BUFFER_SIZE = 8192;
+/**
+* A store wraps the `NativeDatabase` binding and database settings so that a
+* single database instance can be shared between the main `RocksDatabase`
+* instance and the `Transaction` instance.
+*
+* This store should not be shared between `RocksDatabase` instances.
+*/
+var Store = class {
+	/**
+	* The database instance.
+	*/
+	db;
+	/**
+	* The decoder instance. This is commonly the same as the `encoder`
+	* instance.
+	*/
+	decoder;
+	/**
+	* Whether the decoder copies the buffer when encoding values.
+	*/
+	decoderCopies = false;
+	/**
+	* Whether to disable the write ahead log.
+	*/
+	disableWAL;
+	/**
+	* Reusable buffer for encoding values using `writeKey()` when the custom
+	* encoder does not provide a `encode()` method.
+	*/
+	encodeBuffer;
+	/**
+	* The encoder instance.
+	*/
+	encoder;
+	/**
+	* The encoding used to encode values. Defaults to `'msgpack'` in
+	* `RocksDatabase.open()`.
+	*/
+	encoding;
+	/**
+	* Encoder specific option used to signal that the data should be frozen.
+	*/
+	freezeData;
+	/**
+	* Reusable buffer for encoding keys.
+	*/
+	keyBuffer;
+	/**
+	* The key encoding to use for keys. Defaults to `'ordered-binary'`.
+	*/
+	keyEncoding;
+	/**
+	* The maximum key size.
+	*/
+	maxKeySize;
+	/**
+	* The name of the store (e.g. the column family). Defaults to `'default'`.
+	*/
+	name;
+	/**
+	* Whether to disable the block cache.
+	*/
+	noBlockCache;
+	/**
+	* The number of threads to use for parallel operations. This is a RocksDB
+	* option.
+	*/
+	parallelismThreads;
+	/**
+	* The path to the database.
+	*/
+	path;
+	/**
+	* Whether to use pessimistic locking for transactions. When `true`,
+	* transactions will fail as soon as a conflict is detected. When `false`,
+	* transactions will only fail when `commit()` is called.
+	*/
+	pessimistic;
+	/**
+	* Encoder specific flag used to signal that the encoder should use a random
+	* access structure.
+	*/
+	randomAccessStructure;
+	/**
+	* The function used to encode keys.
+	*/
+	readKey;
+	/**
+	* The key used to store shared structures.
+	*/
+	sharedStructuresKey;
+	/**
+	* The threshold for the transaction log file's last modified time to be
+	* older than the retention period before it is rotated to the next sequence
+	* number. A threshold of 0 means ignore age check.
+	*/
+	transactionLogMaxAgeThreshold;
+	/**
+	* The maximum size of a transaction log before it is rotated to the next
+	* sequence number.
+	*/
+	transactionLogMaxSize;
+	/**
+	* A string containing the amount of time or the number of milliseconds to
+	* retain transaction logs before purging.
+	*
+	* @default '3d' (3 days)
+	*/
+	transactionLogRetention;
+	/**
+	* The path to the transaction logs directory.
+	*/
+	transactionLogsPath;
+	/**
+	* The function used to encode keys using the shared `keyBuffer`.
+	*/
+	writeKey;
+	/**
+	* Initializes the store with a new `NativeDatabase` instance.
+	*
+	* @param path - The path to the database.
+	* @param options - The options for the store.
+	*/
+	constructor(path, options) {
+		if (!path || typeof path !== "string") throw new TypeError("Invalid database path");
+		if (options !== void 0 && options !== null && typeof options !== "object") throw new TypeError("Database options must be an object");
+		const { keyEncoding, readKey, writeKey } = initKeyEncoder(options?.keyEncoding, options?.keyEncoder);
+		this.db = new NativeDatabase();
+		this.decoder = options?.decoder ?? null;
+		this.disableWAL = options?.disableWAL ?? false;
+		this.encodeBuffer = createFixedBuffer(SAVE_BUFFER_SIZE);
+		this.encoder = options?.encoder ?? null;
+		this.encoding = options?.encoding ?? null;
+		this.freezeData = options?.freezeData ?? false;
+		this.keyBuffer = KEY_BUFFER;
+		this.keyEncoding = keyEncoding;
+		this.maxKeySize = options?.maxKeySize ?? MAX_KEY_SIZE;
+		this.name = options?.name ?? "default";
+		this.noBlockCache = options?.noBlockCache;
+		this.parallelismThreads = options?.parallelismThreads ?? 1;
+		this.path = path;
+		this.pessimistic = options?.pessimistic ?? false;
+		this.randomAccessStructure = options?.randomAccessStructure ?? false;
+		this.readKey = readKey;
+		this.sharedStructuresKey = options?.sharedStructuresKey;
+		this.transactionLogMaxAgeThreshold = options?.transactionLogMaxAgeThreshold;
+		this.transactionLogMaxSize = options?.transactionLogMaxSize;
+		this.transactionLogRetention = options?.transactionLogRetention;
+		this.transactionLogsPath = options?.transactionLogsPath;
+		this.writeKey = writeKey;
+	}
+	/**
+	* Closes the database.
+	*/
+	close() {
+		this.db.close();
+	}
+	/**
+	* Decodes a key from the database.
+	*
+	* @param key - The key to decode.
+	* @returns The decoded key.
+	*/
+	decodeKey(key) {
+		return this.readKey(key, 0, key.length);
+	}
+	/**
+	* Decodes a value from the database.
+	*
+	* @param value - The value to decode.
+	* @returns The decoded value.
+	*/
+	decodeValue(value) {
+		if (value?.length > 0 && typeof this.decoder?.decode === "function") return this.decoder.decode(value, { end: value.end });
+		return value;
+	}
+	/**
+	* Encodes a key for the database.
+	*
+	* @param key - The key to encode.
+	* @returns The encoded key.
+	*/
+	encodeKey(key) {
+		if (key === void 0) throw new Error("Key is required");
+		const bytesWritten = this.writeKey(key, this.keyBuffer, 0);
+		if (bytesWritten === 0) throw new Error("Zero length key is not allowed");
+		this.keyBuffer.end = bytesWritten;
+		return this.keyBuffer;
+	}
+	/**
+	* Encodes a value for the database.
+	*
+	* @param value - The value to encode.
+	* @returns The encoded value.
+	*/
+	encodeValue(value) {
+		if (value && value["binary-data"]) return value["binary-data"];
+		if (typeof this.encoder?.encode === "function") {
+			if (this.encoder.copyBuffers) return this.encoder.encode(value, REUSE_BUFFER_MODE | RESET_BUFFER_MODE);
+			const valueBuffer = this.encoder.encode(value);
+			if (typeof valueBuffer === "string") return Buffer.from(valueBuffer);
+			return valueBuffer;
+		}
+		if (typeof value === "string") return Buffer.from(value);
+		if (value instanceof Uint8Array) return value;
+		throw new Error(`Invalid value put in database (${typeof value}), consider using an encoder`);
+	}
+	get(context, key, alwaysCreateNewBuffer = false, txnId) {
+		const keyParam = getKeyParam(this.encodeKey(key));
+		let flags = 0;
+		if (alwaysCreateNewBuffer) flags |= ALWAYS_CREATE_NEW_BUFFER_FLAG;
+		const result = context.getSync(keyParam, flags | ONLY_IF_IN_MEMORY_CACHE_FLAG, txnId);
+		if (typeof result === "number") {
+			if (result === NOT_IN_MEMORY_CACHE_FLAG) return new Promise((resolve, reject) => {
+				context.get(keyParam, resolve, reject, txnId);
+			});
+			VALUE_BUFFER.end = result;
+			return VALUE_BUFFER;
+		}
+		return result;
+	}
+	getCount(context, options) {
+		options = { ...options };
+		if (options?.start !== void 0) {
+			const start = this.encodeKey(options.start);
+			options.start = Buffer.from(start.subarray(start.start, start.end));
+		}
+		if (options?.end !== void 0) {
+			const end = this.encodeKey(options.end);
+			options.end = Buffer.from(end.subarray(end.start, end.end));
+		}
+		return context.getCount(options, this.getTxnId(options));
+	}
+	getRange(context, options) {
+		if (!this.db.opened) throw new Error("Database not open");
+		options = { ...options };
+		const unencodedStartKey = options.key ?? options.start;
+		if (unencodedStartKey !== void 0) {
+			const start = this.encodeKey(unencodedStartKey);
+			options.start = Buffer.from(start.subarray(start.start, start.end));
+		}
+		if (options.key !== void 0) {
+			options.end = options.start;
+			options.inclusiveEnd = true;
+		} else if (options.end !== void 0) {
+			const end = this.encodeKey(options.end);
+			options.end = Buffer.from(end.subarray(end.start, end.end));
+		}
+		if (options.reverse) {
+			const start = options.start;
+			options.start = options.end;
+			options.end = start;
+			options.exclusiveStart = options.exclusiveStart ?? true;
+			options.inclusiveEnd = options.inclusiveEnd ?? true;
+		}
+		return new ExtendedIterable(new DBIterator(new NativeIterator(context, options), this, options));
+	}
+	getSync(context, key, alwaysCreateNewBuffer = false, options) {
+		const keyParam = getKeyParam(this.encodeKey(key));
+		let flags = 0;
+		if (alwaysCreateNewBuffer) flags |= ALWAYS_CREATE_NEW_BUFFER_FLAG;
+		const result = context.getSync(keyParam, flags, this.getTxnId(options));
+		if (typeof result === "number") {
+			VALUE_BUFFER.end = result;
+			return VALUE_BUFFER;
+		}
+		return result;
+	}
+	/**
+	* Checks if the data method options object contains a transaction ID and
+	* returns it.
+	*/
+	getTxnId(options) {
+		let txnId;
+		if (options?.transaction) {
+			txnId = options.transaction.id;
+			if (txnId === void 0) throw new TypeError("Invalid transaction");
+		}
+		return txnId;
+	}
+	/**
+	* Gets or creates a buffer that can be shared across worker threads.
+	*
+	* @param key - The key to get or create the buffer for.
+	* @param defaultBuffer - The default buffer to copy and use if the buffer
+	* does not exist.
+	* @param [options] - The options for the buffer.
+	* @param [options.callback] - A optional callback is called when `notify()`
+	* on the returned buffer is called.
+	* @returns An `ArrayBuffer` that is internally backed by a rocksdb-js
+	* managed buffer. The buffer also has `notify()` and `cancel()` methods
+	* that can be used to notify the specified `options.callback`.
+	*/
+	getUserSharedBuffer(key, defaultBuffer, options) {
+		const encodedKey = this.encodeKey(key);
+		if (options !== void 0 && typeof options !== "object") throw new TypeError("Options must be an object");
+		const buffer = this.db.getUserSharedBuffer(encodedKey, defaultBuffer, options?.callback);
+		buffer.notify = (...args) => {
+			return this.db.notify(this.encodeKey(key), args);
+		};
+		buffer.cancel = () => {
+			if (options?.callback) this.db.removeListener(this.encodeKey(key), options.callback);
+		};
+		return buffer;
+	}
+	/**
+	* Checks if a lock exists.
+	* @param key The lock key.
+	* @returns `true` if the lock exists, `false` otherwise
+	*/
+	hasLock(key) {
+		return this.db.hasLock(this.encodeKey(key));
+	}
+	/**
+	* Checks if the database is open.
+	*
+	* @returns `true` if the database is open, `false` otherwise.
+	*/
+	isOpen() {
+		return this.db.opened;
+	}
+	/**
+	* Lists all transaction log names.
+	*
+	* @returns an array of transaction log names.
+	*/
+	listLogs() {
+		return this.db.listLogs();
+	}
+	/**
+	* Opens the database. This must be called before any database operations
+	* are performed.
+	*/
+	open() {
+		if (this.db.opened) return true;
+		this.db.open(this.path, {
+			disableWAL: this.disableWAL,
+			mode: this.pessimistic ? "pessimistic" : "optimistic",
+			name: this.name,
+			noBlockCache: this.noBlockCache,
+			parallelismThreads: this.parallelismThreads,
+			transactionLogMaxAgeThreshold: this.transactionLogMaxAgeThreshold,
+			transactionLogMaxSize: this.transactionLogMaxSize,
+			transactionLogRetentionMs: this.transactionLogRetention ? parseDuration(this.transactionLogRetention) : void 0,
+			transactionLogsPath: this.transactionLogsPath
+		});
+		return false;
+	}
+	putSync(context, key, value, options) {
+		if (!this.db.opened) throw new Error("Database not open");
+		const valueBuffer = this.encodeValue(value);
+		context.putSync(this.encodeKey(key), valueBuffer, this.getTxnId(options));
+	}
+	removeSync(context, key, options) {
+		if (!this.db.opened) throw new Error("Database not open");
+		context.removeSync(this.encodeKey(key), this.getTxnId(options));
+	}
+	/**
+	* Attempts to acquire a lock for a given key. If the lock is available,
+	* the function returns `true` and the optional callback is never called.
+	* If the lock is not available, the function returns `false` and the
+	* callback is queued until the lock is released.
+	*
+	* @param key - The key to lock.
+	* @param onUnlocked - A callback to call when the lock is released.
+	* @returns `true` if the lock was acquired, `false` otherwise.
+	*/
+	tryLock(key, onUnlocked) {
+		if (onUnlocked !== void 0 && typeof onUnlocked !== "function") throw new TypeError("Callback must be a function");
+		return this.db.tryLock(this.encodeKey(key), onUnlocked);
+	}
+	/**
+	* Releases the lock on the given key and calls any queued `onUnlocked`
+	* callback handlers.
+	*
+	* @param key - The key to unlock.
+	*/
+	unlock(key) {
+		return this.db.unlock(this.encodeKey(key));
+	}
+	/**
+	* Gets or creates a transaction log instance.
+	*
+	* @param context - The context to use for the transaction log.
+	* @param name - The name of the transaction log.
+	* @returns The transaction log.
+	*/
+	useLog(context, name) {
+		if (typeof name !== "string" && typeof name !== "number") throw new TypeError("Log name must be a string or number");
+		return context.useLog(String(name));
+	}
+	/**
+	* Acquires a lock on the given key and calls the callback.
+	*
+	* @param key - The key to lock.
+	* @param callback - The callback to call when the lock is acquired.
+	* @returns A promise that resolves when the lock is acquired.
+	*/
+	withLock(key, callback) {
+		if (typeof callback !== "function") return Promise.reject(/* @__PURE__ */ new TypeError("Callback must be a function"));
+		return this.db.withLock(this.encodeKey(key), callback);
+	}
+};
+/**
+* Ensure that they key has been copied into our shared buffer, and return the ending position
+* @param keyBuffer
+*/
+function getKeyParam(keyBuffer) {
+	if (keyBuffer.buffer === KEY_BUFFER.buffer) {
+		if (keyBuffer.end >= 0) return keyBuffer.end;
+		if (keyBuffer.byteOffset === 0) return keyBuffer.byteLength;
+	}
+	if (keyBuffer.length > KEY_BUFFER.length) return keyBuffer;
+	KEY_BUFFER.set(keyBuffer);
+	return keyBuffer.length;
+}
+
+//#endregion
+//#region src/transaction.ts
+/**
+* Provides transaction level operations to a transaction callback.
+*/
+var Transaction = class extends DBI {
+	#txn;
+	/**
+	* Create a new transaction.
+	*
+	* @param store - The base store interface for this transaction.
+	* @param options - The options for the transaction.
+	*/
+	constructor(store, options) {
+		const txn = new NativeTransaction(store.db, options);
+		super(store, txn);
+		this.#txn = txn;
+	}
+	/**
+	* Abort the transaction.
+	*/
+	abort() {
+		this.#txn.abort();
+	}
+	/**
+	* Commit the transaction.
+	*/
+	async commit() {
+		try {
+			await new Promise((resolve, reject) => {
+				this.notify("beforecommit");
+				this.#txn.commit(resolve, reject);
+			});
+		} finally {
+			this.notify("aftercommit", {
+				next: null,
+				last: null,
+				txnId: this.#txn.id
+			});
+		}
+	}
+	/**
+	* Commit the transaction synchronously.
+	*/
+	commitSync() {
+		try {
+			this.notify("beforecommit");
+			this.#txn.commitSync();
+		} finally {
+			this.notify("aftercommit", {
+				next: null,
+				last: null,
+				txnId: this.#txn.id
+			});
+		}
+	}
+	/**
+	* Returns the transaction start timestamp in seconds. Defaults to the time at which
+	* the transaction was created.
+	*
+	* @returns The transaction start timestamp in seconds.
+	*/
+	getTimestamp() {
+		return this.#txn.getTimestamp();
+	}
+	/**
+	* Get the transaction id.
+	*/
+	get id() {
+		return this.#txn.id;
+	}
+	/**
+	* Set the transaction start timestamp in seconds.
+	*
+	* @param timestamp - The timestamp to set in seconds.
+	*/
+	setTimestamp(timestamp) {
+		this.#txn.setTimestamp(timestamp);
+	}
+};
+
+//#endregion
+//#region src/database.ts
+/**
+* The main class for interacting with a RocksDB database.
+*
+* Before using this class, you must open the database first.
+*
+* @example
+* ```typescript
+* const db = RocksDatabase.open('/path/to/database');
+* await db.put('key', 'value');
+* const value = await db.get('key');
+* db.close();
+* ```
+*/
+var RocksDatabase = class RocksDatabase extends DBI {
+	constructor(pathOrStore, options) {
+		if (typeof pathOrStore === "string") super(new Store(pathOrStore, options));
+		else if (pathOrStore instanceof Store) super(pathOrStore);
+		else throw new TypeError("Invalid database path or store");
+	}
+	/**
+	* Removes all data from the database asynchronously.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* await db.clear();
+	* ```
+	*/
+	clear() {
+		if (!this.store.db.opened) return Promise.reject(/* @__PURE__ */ new Error("Database not open"));
+		if (this.store.encoder?.structures !== void 0) this.store.encoder.structures = [];
+		return new Promise((resolve, reject) => {
+			this.store.db.clear(resolve, reject);
+		});
+	}
+	/**
+	* Removes all entries from the database synchronously.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* db.clearSync();
+	* ```
+	*/
+	clearSync() {
+		if (!this.store.db.opened) throw new Error("Database not open");
+		if (this.store.encoder?.structures !== void 0) this.store.encoder.structures = [];
+		return this.store.db.clearSync();
+	}
+	/**
+	* Closes the database.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* db.close();
+	* ```
+	*/
+	close() {
+		this.store.close();
+	}
+	/**
+	* Set global database settings.
+	*
+	* @param options - The options for the database.
+	*
+	* @example
+	* ```typescript
+	* RocksDatabase.config({ blockCacheSize: 1024 * 1024 });
+	* ```
+	*/
+	static config(options) {
+		config(options);
+	}
+	async drop() {
+		if (!this.store.db.opened) return Promise.reject(/* @__PURE__ */ new Error("Database not open"));
+		return new Promise((resolve, reject) => {
+			this.store.db.drop(resolve, reject);
+		});
+	}
+	dropSync() {
+		if (!this.store.db.opened) throw new Error("Database not open");
+		return this.store.db.dropSync();
+	}
+	get encoder() {
+		return this.store.encoder;
+	}
+	/**
+	* Returns the current timestamp as a monotonically increasing timestamp in
+	* milliseconds represented as a decimal number.
+	*
+	* @returns The current monotonic timestamp in milliseconds.
+	*/
+	getMonotonicTimestamp() {
+		return this.store.db.getMonotonicTimestamp();
+	}
+	/**
+	* Returns a number representing a unix timestamp of the oldest unreleased
+	* snapshot.
+	*
+	* @returns The oldest snapshot timestamp.
+	*/
+	getOldestSnapshotTimestamp() {
+		return this.store.db.getOldestSnapshotTimestamp();
+	}
+	/**
+	* Gets a RocksDB database property as a string.
+	*
+	* @param propertyName - The name of the property to retrieve (e.g., 'rocksdb.levelstats').
+	* @returns The property value as a string.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* const levelStats = db.getDBProperty('rocksdb.levelstats');
+	* const stats = db.getDBProperty('rocksdb.stats');
+	* ```
+	*/
+	getDBProperty(propertyName) {
+		return this.store.db.getDBProperty(propertyName);
+	}
+	/**
+	* Gets a RocksDB database property as an integer.
+	*
+	* @param propertyName - The name of the property to retrieve (e.g., 'rocksdb.num-blob-files').
+	* @returns The property value as a number.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* const blobFiles = db.getDBIntProperty('rocksdb.num-blob-files');
+	* const numKeys = db.getDBIntProperty('rocksdb.estimate-num-keys');
+	* ```
+	*/
+	getDBIntProperty(propertyName) {
+		return this.store.db.getDBIntProperty(propertyName);
+	}
+	/**
+	* Flushes the underlying database by performing a commit or clearing any buffered operations.
+	*
+	* @return {void} Does not return a value.
+	*/
+	flush() {
+		return new Promise((resolve, reject) => this.store.db.flush(resolve, reject));
+	}
+	/**
+	* Synchronously flushes the underlying database by performing a commit or clearing any buffered operations.
+	*
+	* @return {void} Does not return a value.
+	*/
+	flushSync() {
+		return this.store.db.flushSync();
+	}
+	getStats() {
+		return {
+			free: {},
+			root: {}
+		};
+	}
+	/**
+	* Gets or creates a buffer that can be shared across worker threads.
+	*
+	* @param key - The key to get or create the buffer for.
+	* @param defaultBuffer - The default buffer to copy and use if the buffer
+	* does not exist.
+	* @param [options] - The options for the buffer.
+	* @param [options.callback] - A optional callback that receives
+	* key-specific events.
+	* @returns An `ArrayBuffer` that is internally backed by a shared block of
+	* memory. The buffer also has `notify()` and `cancel()` methods that can be
+	* used to notify the specified `options.callback`.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* const buffer = db.getUserSharedBuffer('foo', new ArrayBuffer(10));
+	*/
+	getUserSharedBuffer(key, defaultBuffer, options) {
+		return this.store.getUserSharedBuffer(key, defaultBuffer, options);
+	}
+	/**
+	* Returns whether the database has a lock for the given key.
+	*
+	* @param key - The key to check.
+	* @returns `true` if the database has a lock for the given key, `false`
+	* otherwise.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* db.hasLock('foo'); // false
+	* db.tryLock('foo', () => {});
+	* db.hasLock('foo'); // true
+	* ```
+	*/
+	hasLock(key) {
+		return this.store.hasLock(key);
+	}
+	async ifNoExists(_key) {}
+	/**
+	* Returns whether the database is open.
+	*
+	* @returns `true` if the database is open, `false` otherwise.
+	*/
+	isOpen() {
+		return this.store.isOpen();
+	}
+	/**
+	* Lists all transaction log names.
+	*
+	* @returns an array of transaction log names.
+	*/
+	listLogs() {
+		return this.store.listLogs();
+	}
+	/**
+	* Sugar method for opening a database.
+	*
+	* @param pathOrStore - The filesystem path to the database or a custom store.
+	* @param options - The options for the database.
+	* @returns A new RocksDatabase instance.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* ```
+	*/
+	static open(pathOrStore, options) {
+		return new RocksDatabase(pathOrStore, options).open();
+	}
+	/**
+	* Opens the database. This function returns immediately if the database is
+	* already open.
+	*
+	* @returns A new RocksDatabase instance.
+	*
+	* @example
+	* ```typescript
+	* const db = new RocksDatabase('/path/to/database');
+	* db.open();
+	* ```
+	*/
+	open() {
+		const { store } = this;
+		if (store.open()) return this;
+		store.db.setDefaultValueBuffer(VALUE_BUFFER);
+		store.db.setDefaultKeyBuffer(KEY_BUFFER);
+		/**
+		* The encoder initialization precedence is:
+		* 1. encoder.Encoder
+		* 2. encoder.encode()
+		* 3. encoding === `msgpack`
+		* 4. encoding === `ordered-binary`
+		* 5. encoder.writeKey()
+		*/
+		let EncoderClass = store.encoder?.Encoder;
+		if (store.encoding === false) {
+			store.encoder = null;
+			EncoderClass = void 0;
+		} else if (typeof EncoderClass === "function") store.encoder = null;
+		else if (typeof store.encoder?.encode !== "function" && (!store.encoding || store.encoding === "msgpack")) {
+			store.encoding = "msgpack";
+			EncoderClass = Encoder;
+		}
+		if (EncoderClass) {
+			const opts = {
+				copyBuffers: true,
+				freezeData: store.freezeData,
+				randomAccessStructure: store.randomAccessStructure
+			};
+			const { sharedStructuresKey } = store;
+			if (sharedStructuresKey) {
+				opts.getStructures = () => {
+					const buffer = this.getBinarySync(sharedStructuresKey);
+					return buffer && store.decoder?.decode ? store.decoder.decode(buffer) : void 0;
+				};
+				opts.saveStructures = (structures, isCompatible) => {
+					return this.transactionSync((txn) => {
+						const existingStructuresBuffer = this.getBinarySync(sharedStructuresKey);
+						const existingStructures = existingStructuresBuffer && store.decoder?.decode ? store.decoder.decode(existingStructuresBuffer) : void 0;
+						if (typeof isCompatible == "function") {
+							if (!isCompatible(existingStructures)) return false;
+						} else if (existingStructures && existingStructures.length !== isCompatible) return false;
+						txn.putSync(sharedStructuresKey, structures);
+					});
+				};
+			}
+			store.encoder = new EncoderClass({
+				...opts,
+				...store.encoder
+			});
+			store.decoder = store.encoder;
+		} else if (typeof store.encoder?.encode === "function") {
+			if (!store.decoder) store.decoder = store.encoder;
+		} else if (store.encoding === "ordered-binary") {
+			store.encoder = {
+				readKey: orderedBinary.readKey,
+				writeKey: orderedBinary.writeKey
+			};
+			store.decoder = store.encoder;
+		}
+		if (typeof store.encoder?.writeKey === "function" && !store.encoder?.encode) {
+			store.encoder = {
+				...store.encoder,
+				encode: (value, _mode) => {
+					const bytesWritten = store.writeKey(value, store.encodeBuffer, 0);
+					return store.encodeBuffer.subarray(0, bytesWritten);
+				}
+			};
+			store.encoder.copyBuffers = true;
+		}
+		if (store.decoder && store.decoder.needsStableBuffer !== true) store.decoderCopies = true;
+		if (store.decoder?.readKey && !store.decoder.decode) {
+			store.decoder.decode = (buffer) => {
+				if (store.decoder?.readKey) return store.decoder.readKey(buffer, 0, buffer.end);
+				return buffer;
+			};
+			store.decoderCopies = true;
+		}
+		return this;
+	}
+	/**
+	* Returns the path to the database.
+	*/
+	get path() {
+		return this.store.path;
+	}
+	/**
+	* Purges transaction logs.
+	*/
+	purgeLogs(options) {
+		return this.store.db.purgeLogs(options);
+	}
+	/**
+	* Executes all operations in the callback as a single transaction.
+	*
+	* @param callback - A async function that receives the transaction as an argument.
+	* @returns A promise that resolves the `callback` return value.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* await db.transaction(async (txn) => {
+	*   await txn.put('key', 'value');
+	* });
+	* ```
+	*/
+	async transaction(callback, options) {
+		if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+		const txn = new Transaction(this.store, options);
+		let result;
+		try {
+			this.notify("begin-transaction");
+			result = await callback(txn);
+		} catch (err) {
+			try {
+				txn.abort();
+			} catch (err) {
+				if (err instanceof Error && "code" in err && err.code === "ERR_ALREADY_ABORTED") return;
+			}
+			throw err;
+		}
+		try {
+			await txn.commit();
+			return result;
+		} catch (err) {
+			if (err instanceof Error && "code" in err && err.code === "ERR_ALREADY_ABORTED") return;
+			throw err;
+		}
+	}
+	/**
+	* Executes all operations in the callback as a single transaction.
+	*
+	* @param callback - A function that receives the transaction as an
+	* argument. If the callback return promise-like value, it is awaited
+	* before committing the transaction. Otherwise, the callback is treated as
+	* synchronous.
+	* @returns The `callback` return value.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* await db.transaction(async (txn) => {
+	*   await txn.put('key', 'value');
+	* });
+	* ```
+	*/
+	transactionSync(callback, options) {
+		if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+		const txn = new Transaction(this.store, options);
+		let result;
+		try {
+			this.notify("begin-transaction");
+			result = callback(txn);
+		} catch (err) {
+			try {
+				txn.abort();
+			} catch (err) {
+				if (err instanceof Error && "code" in err && err.code === "ERR_ALREADY_ABORTED") return;
+			}
+			throw err;
+		}
+		if (result && typeof result === "object" && "then" in result && typeof result.then === "function") return result.then((value) => {
+			try {
+				txn.commitSync();
+				return value;
+			} catch (err) {
+				if (err instanceof Error && "code" in err && err.code === "ERR_ALREADY_ABORTED") return;
+				throw err;
+			}
+		});
+		try {
+			txn.commitSync();
+			return result;
+		} catch (err) {
+			if (err instanceof Error && "code" in err && err.code === "ERR_ALREADY_ABORTED") return;
+			try {
+				txn.abort();
+			} catch {}
+			throw err;
+		}
+	}
+	/**
+	* Attempts to acquire a lock for a given key. If the lock is available,
+	* the function returns `true` and the optional callback is never called.
+	* If the lock is not available, the function returns `false` and the
+	* callback is queued until the lock is released.
+	*
+	* @param key - The key to lock.
+	* @param onUnlocked - A callback to call when the lock is released.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* db.tryLock('foo', () => {
+	*   console.log('lock acquired');
+	* });
+	* ```
+	* @returns `true` if the lock was acquired, `false` otherwise.
+	*/
+	tryLock(key, onUnlocked) {
+		return this.store.tryLock(key, onUnlocked);
+	}
+	/**
+	* Releases the lock on the given key and calls any queued `onUnlocked`
+	* callback handlers.
+	*
+	* @param key - The key to unlock.
+	* @returns `true` if the lock was released or `false` if the lock did not
+	* exist.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* db.tryLock('foo', () => {});
+	* db.unlock('foo'); // returns `true`
+	* db.unlock('foo'); // already unlocked, returns `false`
+	* ```
+	*/
+	unlock(key) {
+		return this.store.unlock(key);
+	}
+	/**
+	* Excecutes a function using a thread-safe lock to ensure mutual
+	* exclusion.
+	*
+	* @param callback - A callback to call when the lock is acquired.
+	* @returns A promise that resolves when the lock is acquired.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* await db.withLock(async (waited) => {
+	*   console.log('lock acquired', waited);
+	* });
+	* ```
+	*/
+	withLock(key, callback) {
+		return this.store.withLock(key, callback);
+	}
+};
+
+//#endregion
+//#region src/parse-transaction-log.ts
+const { TRANSACTION_LOG_TOKEN } = constants;
+/**
+* Loads an entire transaction log file into memory.
+* @param path - The path to the transaction log file.
+* @returns The transaction log.
+*/
+function parseTransactionLog(path) {
+	let stats;
+	try {
+		stats = statSync(path);
+	} catch (error) {
+		if (error.code === "ENOENT") throw new Error("Transaction log file does not exist");
+		throw error;
+	}
+	let { size } = stats;
+	if (size === 0) throw new Error("Transaction log file is too small");
+	const fileHandle = openSync(path, "r");
+	let fileOffset = 0;
+	const read = (numBytes) => {
+		const buffer = Buffer.allocUnsafe(numBytes);
+		const bytesRead = readSync(fileHandle, buffer, 0, numBytes, fileOffset);
+		fileOffset += bytesRead;
+		if (bytesRead !== numBytes) throw new Error(`Expected to read ${numBytes} bytes but only read ${bytesRead}, file offset: ${fileOffset}, file size: ${size}, file path: ${path}, buffer: ${buffer.toString("hex")}`);
+		return buffer;
+	};
+	try {
+		if (read(4).readUInt32BE(0) !== TRANSACTION_LOG_TOKEN) throw new Error("Invalid token");
+		const version = read(1).readUInt8(0);
+		if (version !== 1) throw new Error(`Unsupported transaction log file version: ${version}`);
+		const timestamp = read(8).readDoubleBE(0);
+		const entries = [];
+		while (fileOffset < size) {
+			const timestamp = read(8).readDoubleBE(0);
+			if (timestamp === 0) {
+				size = fileOffset - 8;
+				break;
+			}
+			const length = read(4).readUInt32BE(0);
+			const flags = read(1).readUInt8(0);
+			const data = read(length);
+			entries.push({
+				timestamp,
+				length,
+				flags,
+				data
+			});
+		}
+		return {
+			entries,
+			timestamp,
+			size,
+			version
+		};
+	} catch (error) {
+		if (error instanceof Error) error.message = `Invalid transaction log file: ${error.message}`;
+		throw error;
+	} finally {
+		closeSync(fileHandle);
+	}
+}
+
+//#endregion
+//#region src/transaction-log-reader.ts
+const FLOAT_TO_UINT32 = new Float64Array(1);
+const UINT32_FROM_FLOAT = new Uint32Array(FLOAT_TO_UINT32.buffer);
+const { TRANSACTION_LOG_FILE_HEADER_SIZE, TRANSACTION_LOG_ENTRY_HEADER_SIZE } = constants;
+/**
+* Returns an iterable for transaction entries within the specified range of timestamps
+* This iterable can be iterated over multiple times, and subsequent iterations will continue
+* from where the last iteration left off, allowing for iteration through the log file
+* to resume after more transactions have been committed.
+* @param start
+* @param end
+* @param exactStart - if this is true, the function will try to find the transaction that
+* exactly matches the start timestamp, and then return all subsequent transactions in the log
+* regardless of whether their timestamp is before or after the start
+*/
+Object.defineProperty(TransactionLog.prototype, "query", { value({ start, end, exactStart, startFromLastFlushed, readUncommitted, exclusiveStart } = {}) {
+	if (!this._lastCommittedPosition) {
+		const lastCommittedPosition = this._getLastCommittedPosition();
+		this._lastCommittedPosition = new Float64Array(lastCommittedPosition.buffer);
+		this._logBuffers = /* @__PURE__ */ new Map();
+	}
+	end ??= Number.MAX_VALUE;
+	const transactionLog = this;
+	let { logId: latestLogId, size } = loadLastPosition(this, !!readUncommitted);
+	let logId = latestLogId;
+	let position = 0;
+	let dataView;
+	let logBuffer = this._currentLogBuffer;
+	let foundExactStart = false;
+	if (start === void 0 && !startFromLastFlushed) {
+		position = size;
+		start = 0;
+	} else {
+		if (startFromLastFlushed) {
+			FLOAT_TO_UINT32[0] = this._getLastFlushed();
+			if (FLOAT_TO_UINT32[0] === 0) FLOAT_TO_UINT32[0] = this._findPosition(0);
+			start ??= 0;
+		} else FLOAT_TO_UINT32[0] = this._findPosition(start);
+		logId = UINT32_FROM_FLOAT[1];
+		position = UINT32_FROM_FLOAT[0];
+	}
+	if (logBuffer === void 0 || logBuffer.logId !== logId) {
+		logBuffer = getLogMemoryMap(this, logId);
+		if (logBuffer && latestLogId === logId && !readUncommitted) this._currentLogBuffer = logBuffer;
+		if (logBuffer === void 0) {
+			logBuffer = Buffer.alloc(0);
+			logBuffer.logId = 0;
+			logBuffer.size = 0;
+			logBuffer.dataView = new DataView(logBuffer.buffer);
+		}
+	}
+	dataView = logBuffer.dataView;
+	if (latestLogId !== logId) {
+		size = logBuffer.size;
+		if (size === void 0) size = logBuffer.size = this.getLogFileSize(logId);
+	}
+	return {
+		[Symbol.iterator]() {
+			return this;
+		},
+		next() {
+			let timestamp;
+			if (position >= size) {
+				const { logId: latestLogId, size: latestSize } = loadLastPosition(transactionLog, !!readUncommitted);
+				size = latestSize;
+				if (latestLogId > logBuffer.logId) {
+					size = logBuffer.size ?? (logBuffer.size = transactionLog.getLogFileSize(logBuffer.logId));
+					if (position >= size) {
+						const nextLogBuffer = getLogMemoryMap(transactionLog, logBuffer.logId + 1);
+						dataView = nextLogBuffer.dataView;
+						logBuffer = nextLogBuffer;
+						if (latestLogId > logBuffer.logId) size = logBuffer.size ?? (logBuffer.size = transactionLog.getLogFileSize(logBuffer.logId));
+						else size = latestSize;
+						position = TRANSACTION_LOG_FILE_HEADER_SIZE;
+					}
+				}
+			}
+			while (position < size) {
+				do
+					try {
+						timestamp = dataView.getFloat64(position);
+					} catch (error) {
+						error.message += ` at position ${position} of log ${logBuffer.logId} (size=${size}, log buffer length=${logBuffer.length})`;
+						throw error;
+					}
+				while (timestamp < 1 && ++position < size);
+				if (!timestamp) return {
+					done: true,
+					value: void 0
+				};
+				const length = dataView.getUint32(position + 8);
+				position += TRANSACTION_LOG_ENTRY_HEADER_SIZE;
+				let matchesRange;
+				if (foundExactStart) matchesRange = (!exclusiveStart || timestamp !== start) && timestamp < end;
+				else if (exactStart) if (timestamp === start) {
+					matchesRange = !exclusiveStart;
+					foundExactStart = true;
+				} else matchesRange = false;
+				else matchesRange = (exclusiveStart ? timestamp > start : timestamp >= start) && timestamp < end;
+				const entryStart = position;
+				position += length;
+				if (matchesRange) return {
+					done: false,
+					value: {
+						timestamp,
+						endTxn: Boolean(logBuffer[entryStart - 1] & 1),
+						data: logBuffer.subarray(entryStart, position)
+					}
+				};
+				if (position >= size) {
+					const { logId: latestLogId, size: latestSize } = loadLastPosition(transactionLog, !!readUncommitted);
+					size = latestSize;
+					if (latestLogId > logBuffer.logId) {
+						logBuffer = getLogMemoryMap(transactionLog, logBuffer.logId + 1);
+						dataView = logBuffer.dataView;
+						size = logBuffer.size;
+						if (size == void 0) {
+							size = transactionLog.getLogFileSize(logBuffer.logId);
+							if (!readUncommitted) logBuffer.size = size;
+						}
+						position = TRANSACTION_LOG_FILE_HEADER_SIZE;
+					}
+				}
+			}
+			return {
+				done: true,
+				value: void 0
+			};
+		}
+	};
+} });
+function getLogMemoryMap(transactionLog, logId) {
+	if (logId <= 0) return;
+	let logBuffer = transactionLog._logBuffers.get(logId)?.deref();
+	if (logBuffer) return logBuffer;
+	try {
+		logBuffer = transactionLog._getMemoryMapOfFile(logId);
+	} catch (error) {
+		error.message += ` (log file ID: ${logId})`;
+		throw error;
+	}
+	if (!logBuffer) return;
+	logBuffer.logId = logId;
+	logBuffer.dataView = new DataView(logBuffer.buffer);
+	transactionLog._logBuffers.set(logId, new WeakRef(logBuffer));
+	let maxMisses = 3;
+	for (const [logId, reference] of transactionLog._logBuffers) if (reference.deref() === void 0) transactionLog._logBuffers.delete(logId);
+	else if (--maxMisses === 0) break;
+	return logBuffer;
+}
+function loadLastPosition(transactionLog, readUncommitted) {
+	FLOAT_TO_UINT32[0] = transactionLog._lastCommittedPosition[0];
+	let logId = UINT32_FROM_FLOAT[1];
+	let size = 0;
+	if (readUncommitted) {
+		let nextSize = 0;
+		let nextLogId = logId || 1;
+		while (true) {
+			nextSize = transactionLog.getLogFileSize(nextLogId);
+			if (nextSize === 0) break;
+			else {
+				size = nextSize;
+				logId = nextLogId++;
+			}
+		}
+	} else size = UINT32_FROM_FLOAT[0];
+	return {
+		logId,
+		size
+	};
+}
+
+//#endregion
+//#region src/index.ts
+const versions = {
+	rocksdb: version,
+	"rocksdb-js": "0.1.0"
+};
+
+//#endregion
+export { DBIterator, RocksDatabase, Store, Transaction, TransactionLog, constants, parseTransactionLog, shutdown, versions };
+//# sourceMappingURL=index.mjs.map