@harperfast/rocksdb-js 2.4.1 → 2.6.0

package/dist/index.cjs

@@ -87,6 +87,15 @@ const removeGlobalListener = binding.removeListener;
 const globalListenerCount = binding.listenerCount;
 const globalNotify = binding.notify;
 const constants = binding.constants;
+/**
+* The friendly names of every compression algorithm compiled into the loaded
+* RocksDB native binding, e.g. `['none', 'snappy', 'lz4', 'zstd']`. The set is
+* fixed for a given binary (it depends on which compression libraries RocksDB
+* was linked against), so this is a static list. `'none'` (no compression) is
+* always present. Use it to validate a `compression` option or to pick an
+* algorithm that is actually available at runtime.
+*/
+const supportedCompression = Object.freeze(binding.supportedCompression);
 const NativeDatabase = binding.Database;
 const NativeIterator = binding.Iterator;
 const NativeTransaction = binding.Transaction;
@@ -115,13 +124,21 @@ const coolTransactionLogs = binding.coolTransactionLogs;
 */
 const transactionLogMapCount = binding.transactionLogMapCount;
 /**
+* Test-only: force the next `count` transaction commits to fail with TryAgain (rolled back, so
+* no data is committed), reproducing a stranded-snapshot conflict deterministically. Pass 0 to
+* disarm. Used by the ERR_TRY_AGAIN retry regression test.
+*/
+const forceTryAgainForTesting = binding.forceTryAgainForTesting;
+/**
 * Creates a native file lock using the specified file path (`flock` on POSIX,
-* `LockFileEx` on Windows). Returns an opaque non-zero token to pass to
-* `fileLockRelease`, or `0` if another holder — in any process, container, or
-* worker thread — currently has it. Throws if `file` is missing or on a hard
-* error. The OS handle is owned entirely in native code (no fd crosses into
-* JS), and the kernel releases the lock when the handle closes, including on
-* process death.
+* `LockFileEx` on Windows), creating the file and any missing parent
+* directories. Exclusive by default; pass `shared` for a shared (reader) lock
+* that coexists with other shared holders but conflicts with an exclusive
+* holder in either direction. Returns an opaque non-zero token to pass to
+* `fileLockRelease`, or `0` if a conflicting holder — in any process,
+* container, or worker thread — currently has it. Throws on a hard error. The
+* OS handle is owned entirely in native code (no fd crosses into JS), and the
+* kernel releases the lock when the handle closes, including on process death.
 */
 const tryFileLock = binding.tryFileLock;
 /**
@@ -134,9 +151,51 @@ const nativeBackupList = binding.backupList;
 const nativeBackupDelete = binding.backupDelete;
 const nativeBackupPurge = binding.backupPurge;
 const nativeBackupVerify = binding.backupVerify;
+const nativeValidateTransactionLog = binding.validateTransactionLog;
 const stats = binding.stats;
 const version = binding.version;
 
+//#endregion
+//#region src/validate-transaction-log.ts
+/**
+* Validates a transaction log store directory: every `<sequence>.txnlog` file
+* is checked for a valid header (token, version) and intact v1 entry framing
+* (using the same scan as open-time crash recovery), file-name and sequence
+* continuity are checked, and the `txn.state` side file (when present) is
+* checked for shape and a plausible flushed position. The result reports
+* per-file entry counts, errors, and warnings; it does not throw when the
+* store is invalid — check `result.valid`.
+*
+* Runs entirely in native code on a worker thread and does not require (or
+* open) a database, so it works on the store of a closed database and on the
+* per-backup snapshots under `<backupDir>/transaction_logs/<backupId>/` alike.
+*
+* Validating a store that is being actively appended to can spuriously report
+* a torn tail for the current log file — the tail of an in-flight append is
+* indistinguishable from a crash artifact.
+*
+* Rejects if `path` does not exist or is not a directory (a bad argument, as
+* opposed to an invalid store).
+*
+* @param path The store directory, e.g. `<dbDir>/transaction_logs/<name>`.
+* @param options Validation options.
+*
+* @example
+* ```typescript
+* import { validateTransactionLogStore } from '@harperfast/rocksdb-js';
+*
+* const result = await validateTransactionLogStore('/path/to/db/transaction_logs/mylog');
+* if (!result.valid) {
+*   for (const file of result.files) {
+*     console.error(file.file, file.errors);
+*   }
+* }
+* ```
+*/
+function validateTransactionLogStore(path, options) {
+	return new Promise((resolve, reject) => nativeValidateTransactionLog(resolve, reject, path, options?.strict ?? false));
+}
+
 //#endregion
 //#region src/backup.ts
 /** Subdirectory (under a backup directory) holding per-backup transaction log snapshots. */
@@ -152,17 +211,29 @@ async function exists(path) {
 }
 /**
 * Runs `fn` while holding a native file lock for `backupDir`, releasing it when
-* `fn` settles. Used by the writable-engine operations `backups.delete` and
-* `backups.purge`; backup creation (`Store.backup`) takes the same lock on the
-* same file natively inside `Database::Backup` (see `runCreateBackup` in
+* `fn` settles. The lock is exclusive by default — used by the writable-engine
+* operations `backups.delete` and `backups.purge`; backup creation
+* (`Store.backup`) takes the same exclusive lock on the same file natively
+* inside `Database::Backup` (see `runCreateBackup` in
 * `src/binding/database/backup.cpp`), where the backup directory is also
-* created. Throws immediately (without running `fn`) if another writer holds
-* the directory lock.
+* created. Throws immediately (without running `fn`) if the backup directory
+* is missing — `tryFileLock` creates missing parents, but `delete`/`purge`/
+* `restore` on a nonexistent directory is a caller error and must not conjure
+* an empty one — or if a conflicting holder has the directory lock.
 *
-* Read-only operations (`list`, `verify`, and a restore's source read) use
-* `BackupEngineReadOnly` and are not locked: concurrent readers are safe.
-* Running a reader concurrently with a `delete`/`purge` on the same directory is
-* a caller-managed hazard, matching RocksDB's one-writable-engine-per-dir model.
+* `backups.restore` holds the lock in `shared` mode for its source read:
+* shared holders coexist (concurrent restores are safe), but a writer's
+* exclusive acquisition rejects while a restore is in flight — and vice versa.
+* Without this, a `purge`/`delete` racing a restore can delete the very files
+* the restore is copying, after the restore's default `purgeAllFiles` mode has
+* already wiped the destination — failing the restore with no fallback. A
+* rejected writer, by contrast, just retries later.
+*
+* The remaining read-only operations (`list`, `verify`) use
+* `BackupEngineReadOnly` and are not locked: concurrent readers are safe, and
+* locking them would make cheap listings reject during a long backup. Running
+* them concurrently with a `delete`/`purge` on the same directory is a
+* caller-managed hazard, matching RocksDB's one-writable-engine-per-dir model.
 *
 * RocksDB only serializes work within a single `BackupEngine` instance and has
 * no lock on the backup directory itself. Two writable engines — in any
@@ -188,8 +259,9 @@ async function exists(path) {
 * The lock file is never deleted, only locked and unlocked; an unlocked, empty
 * `.backup.lock` at the directory root is the steady state.
 */
-async function withBackupDirLock(backupDir, fn) {
-	const token = tryFileLock((0, node_path.join)(backupDir, ".backup.lock"));
+async function withBackupDirLock(backupDir, fn, options) {
+	if (!await exists(backupDir)) throw new Error(`Backup directory does not exist: ${backupDir}`);
+	const token = tryFileLock((0, node_path.join)(backupDir, ".backup.lock"), options?.shared === true);
 	if (token === 0) throw new Error(`Backup directory is locked: ${backupDir}`);
 	try {
 		return await fn();
@@ -198,6 +270,40 @@ async function withBackupDirLock(backupDir, fn) {
 	}
 }
 /**
+* Throws if `backupDir` resolves to the database directory itself or any path
+* beneath it. Backing up into the live database directory would write backup
+* files (the `.backup.lock`, `meta/`, `shared/`, `private/` subtrees) on top of
+* RocksDB's own files, and every subsequent backup would recursively capture
+* the prior ones. Both paths are resolved first so trailing slashes and
+* relative/absolute variants of the same location cannot slip past the check.
+*
+* Only the "backup dir at or under the database dir" direction is rejected —
+* the case the user hits by pointing a backup at `<db>` or `<db>/backups`. The
+* reverse (a database nested under the backup dir) is left to the caller: a
+* backup engine writes into named subtrees, not on top of arbitrary sibling
+* files, so it does not clobber the database in place.
+*
+* On case-insensitive filesystems `<db>` and `<db>/../DB/backup` are the same
+* directory on disk, but `relative()` compares case-sensitively and would call
+* the second one "outside". We case-fold both paths on the platforms whose
+* default filesystem is case-insensitive (macOS, Windows) so a casing
+* difference cannot slip a backup into the database directory. This is a
+* platform heuristic, not a per-volume probe (a case-sensitive macOS/Windows
+* volume exists), so it can over-reject a legitimately differently-cased
+* sibling there — the safe direction for a guard against clobbering the live
+* database.
+*/
+function assertBackupDirOutsideDatabase(dbPath, backupDir) {
+	let resolvedDb = (0, node_path.resolve)(dbPath);
+	let resolvedBackup = (0, node_path.resolve)(backupDir);
+	if (process.platform === "win32" || process.platform === "darwin") {
+		resolvedDb = resolvedDb.toLowerCase();
+		resolvedBackup = resolvedBackup.toLowerCase();
+	}
+	const rel = (0, node_path.relative)(resolvedDb, resolvedBackup);
+	if (!(rel === ".." || rel.startsWith(`..${node_path.sep}`) || (0, node_path.isAbsolute)(rel))) throw new Error(`Backup directory must not be inside the database directory: ${backupDir} is at or within ${dbPath}`);
+}
+/**
 * Removes `<backupDir>/transaction_logs/<id>` subtrees whose backup id no longer
 * corresponds to a surviving backup. Called after a `purge` (which holds the
 * backup-dir lock); a no-op when no transaction logs were backed up. Self-healing:
@@ -278,18 +384,32 @@ const backups = {
 	* Restores a database from a backup directory into a (closed) database
 	* directory. The default mode purges the destination directory, so it must
 	* not point at a live database.
+	*
+	* Holds the backup directory lock in shared mode for the duration: multiple
+	* restores can read concurrently, but a writer (`db.backup()`, `delete`,
+	* `purge`) rejects while a restore is in flight rather than deleting files
+	* out from under it — and a restore rejects while a writer holds the lock.
+	*
+	* The shared lock needs no write access to `backupDir`, so restoring from a
+	* read-only backup directory (immutable/WORM store, read-only-mounted volume)
+	* works: the lock is taken on an existing `.backup.lock` read-only, degrading
+	* to a no-op only when the media is read-only for every process (`EROFS`). A
+	* mere permission denial hard-fails instead — it doesn't prove a privileged
+	* writer isn't running.
 	*/
 	async restore(backupDir, dbDir, options) {
 		if ((0, node_path.resolve)(backupDir) === (0, node_path.resolve)(dbDir)) throw new Error("Backup directory and database directory must be different");
-		const walDir = options?.walDir ?? dbDir;
-		await (0, node_fs_promises.mkdir)(dbDir, { recursive: true });
-		if (walDir !== dbDir) await (0, node_fs_promises.mkdir)(walDir, { recursive: true });
-		await new Promise((resolve, reject) => nativeBackupRestore(resolve, reject, backupDir, dbDir, walDir, {
-			backupId: options?.backupId,
-			keepLogFiles: options?.keepLogFiles,
-			mode: options?.mode
-		}));
-		await restoreTransactionLogs(backupDir, dbDir, options?.backupId);
+		return withBackupDirLock(backupDir, async () => {
+			const walDir = options?.walDir ?? dbDir;
+			await (0, node_fs_promises.mkdir)(dbDir, { recursive: true });
+			if (walDir !== dbDir) await (0, node_fs_promises.mkdir)(walDir, { recursive: true });
+			await new Promise((resolve, reject) => nativeBackupRestore(resolve, reject, backupDir, dbDir, walDir, {
+				backupId: options?.backupId,
+				keepLogFiles: options?.keepLogFiles,
+				mode: options?.mode
+			}));
+			await restoreTransactionLogs(backupDir, dbDir, options?.backupId);
+		}, { shared: true });
 	},
 	/**
 	* Lists the non-corrupt backups in a backup directory, ordered by id.
@@ -326,9 +446,28 @@ const backups = {
 	/**
 	* Verifies a backup's file sizes, and optionally their checksums (which
 	* requires reading all backed-up data).
-	*/
-	verify(backupDir, backupId, options) {
-		return new Promise((resolve, reject) => nativeBackupVerify(resolve, reject, backupDir, backupId, options?.verifyWithChecksum ?? false));
+	*
+	* When the backup was created with `transactionLogs: true`, the backup's
+	* transaction log snapshot (`<backupDir>/transaction_logs/<backupId>/`) is
+	* also validated — every log file's header and entry framing must be intact
+	* (snapshots are copied on committed entry boundaries, so even a torn tail
+	* is a verification failure). Set `verifyTransactionLogs: false` to skip.
+	*/
+	async verify(backupDir, backupId, options) {
+		await new Promise((resolve, reject) => nativeBackupVerify(resolve, reject, backupDir, backupId, options?.verifyWithChecksum ?? false));
+		if (options?.verifyTransactionLogs === false) return;
+		const logsDir = (0, node_path.join)(backupDir, TRANSACTION_LOGS_DIRNAME, String(backupId));
+		if (!await exists(logsDir)) return;
+		const failures = [];
+		for (const entry of await (0, node_fs_promises.readdir)(logsDir, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			const result = await validateTransactionLogStore((0, node_path.join)(logsDir, entry.name), { strict: true });
+			if (!result.valid) {
+				const details = [...result.errors, ...result.files.flatMap((file) => file.errors.map((error) => `${file.file}: ${error}`))];
+				failures.push(`${entry.name}: ${details.join("; ")}`);
+			}
+		}
+		if (failures.length > 0) throw new Error(`Backup ${backupId} transaction log verification failed: ${failures.join("\n")}`);
 	}
 };
 
@@ -1098,13 +1237,50 @@ const ITERATOR_STATE = new Uint32Array(ITERATOR_STATE_BUFFER.buffer, ITERATOR_ST
 const MAX_KEY_SIZE = 1024 * 1024;
 const SAVE_BUFFER_SIZE = 8192;
 /**
+* Normalizes the public `compression` option into the primitive fields the
+* native layer expects. When `option` is omitted, returns an empty object and
+* lets the native layer apply the default (LZ4 when the build supports it, else
+* RocksDB's own default). Throws a `TypeError` for a malformed option and an
+* `Error` for an algorithm that isn't supported by this build.
+*/
+function normalizeCompression(option) {
+	if (option === void 0 || option === null) return {};
+	let algorithm;
+	let level;
+	if (typeof option === "string") algorithm = option;
+	else if (typeof option === "object" && option.algorithm !== void 0) {
+		algorithm = option.algorithm;
+		if (option.level !== void 0 && option.level !== null) {
+			const raw = option.level;
+			const coerced = typeof raw === "number" ? raw : typeof raw === "string" && raw.trim() !== "" ? Number(raw) : NaN;
+			if (!Number.isInteger(coerced) || coerced < -2147483648 || coerced > 2147483647) throw new TypeError(`compression level must be a 32-bit integer, got ${JSON.stringify(option.level)}`);
+			level = coerced;
+		}
+	} else throw new TypeError("compression must be an algorithm name or an { algorithm, level } object");
+	if (!supportedCompression.includes(algorithm)) throw new Error(`Unsupported compression algorithm "${algorithm}". This build supports: ${supportedCompression.join(", ")}`);
+	return {
+		compression: algorithm,
+		compressionLevel: level
+	};
+}
+/**
 * 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.
+* A store is bound to a single `RocksDatabase` instance and must not be shared
+* between `RocksDatabase` instances. Each `RocksDatabase` claims its store on
+* construction (see `claim()`); passing a store that another `RocksDatabase`
+* already owns throws. (Sharing with the owning database's `Transaction`
+* instances is expected and allowed.)
 */
 var Store = class {
+	/**
+	* Whether a `RocksDatabase` has claimed this store. Durable across
+	* close/reopen (unlike the handle's open state), so a store reused after its
+	* owner temporarily closed is still recognized as in-use. See `claim()`.
+	*/
+	#claimed = false;
 	/**
 	* The database instance.
 	*/
@@ -1119,6 +1295,11 @@ var Store = class {
 	*/
 	decoderCopies = false;
 	/**
+	* The compression algorithm (or `{ algorithm, level }`) requested for this
+	* store's column family. Normalized and applied when the database opens.
+	*/
+	compression;
+	/**
 	* Whether to disable the write ahead log.
 	*/
 	disableWAL;
@@ -1157,6 +1338,16 @@ var Store = class {
 	*/
 	maxKeySize;
 	/**
+	* The maximum number of table files RocksDB keeps open. `0` (the default)
+	* derives a budget from the effective per-process open-file limit (an
+	* eighth of the limit — several databases can share one process — clamped
+	* to `[1024, 262144]`); `-1` holds every table file open (the RocksDB
+	* default, which can exhaust the process file-descriptor limit when
+	* compaction falls behind under sustained ingest); a positive `int32` is
+	* an explicit cap.
+	*/
+	maxOpenFiles;
+	/**
 	* The maximum number of memtables that can be queued per column family
 	* before writes stall. Higher values absorb write bursts while flushes catch
 	* up, at the cost of memory.
@@ -1266,6 +1457,7 @@ var Store = class {
 		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.compression = options?.compression;
 		this.dbWriteBufferSize = options?.dbWriteBufferSize;
 		this.decoder = options?.decoder ?? null;
 		this.disableWAL = options?.disableWAL ?? false;
@@ -1277,6 +1469,7 @@ var Store = class {
 		this.keyBuffer = KEY_BUFFER;
 		this.keyEncoding = keyEncoding;
 		this.maxKeySize = options?.maxKeySize ?? MAX_KEY_SIZE;
+		this.maxOpenFiles = options?.maxOpenFiles;
 		this.maxWriteBufferNumber = options?.maxWriteBufferNumber;
 		this.maxWriteBufferSizeToMaintain = options?.maxWriteBufferSizeToMaintain;
 		this.name = options?.name ?? "default";
@@ -1304,6 +1497,16 @@ var Store = class {
 		this.db.close();
 	}
 	/**
+	* Claims this store for a `RocksDatabase`. A store is bound to a single
+	* database instance, so claiming a store that another `RocksDatabase` has
+	* already claimed throws. The claim is durable across close/reopen, so a
+	* store reused after its owner temporarily closed still throws.
+	*/
+	claim() {
+		if (this.#claimed) throw new Error("Store is already in use by another RocksDatabase instance");
+		this.#claimed = true;
+	}
+	/**
 	* Compacts the entire key range of the database asynchronously.
 	* This triggers manual compaction which removes tombstones and reclaims space.
 	*
@@ -1328,6 +1531,7 @@ var Store = class {
 	}
 	async backup(target, options) {
 		if (typeof target !== "string" && typeof target?.getWriter === "function") return backupToStream(this.db, target, options);
+		assertBackupDirOutsideDatabase(this.path, target);
 		return new Promise((resolve, reject) => this.db.backup(resolve, reject, target, options));
 	}
 	/**
@@ -1564,10 +1768,14 @@ var Store = class {
 	*/
 	open() {
 		if (this.db.opened) return true;
+		const { compression, compressionLevel } = normalizeCompression(this.compression);
 		this.db.open(this.path, {
+			compression,
+			compressionLevel,
 			dbWriteBufferSize: this.dbWriteBufferSize,
 			disableWAL: this.disableWAL,
 			enableStats: this.enableStats,
+			maxOpenFiles: this.maxOpenFiles,
 			maxWriteBufferNumber: this.maxWriteBufferNumber,
 			maxWriteBufferSizeToMaintain: this.maxWriteBufferSizeToMaintain,
 			mode: this.pessimistic ? "pessimistic" : "optimistic",
@@ -1686,8 +1894,18 @@ const RETRY_NOW = constants.RETRY_NOW_VALUE;
 var TransactionAlreadyAbortedError = class extends Error {
 	code = "ERR_ALREADY_ABORTED";
 };
-var TransactionIsBusyError = class extends Error {
-	code = "ERR_BUSY";
+/**
+* Base for commit conflicts the native layer has already recovered from by resetting the
+* transaction in place (fresh RocksDB snapshot; `committedPosition` preserved, so a staged
+* transaction-log batch stays write-once): the caller should re-run the transaction body
+* and retry the commit — the handling is identical for every subclass. `hasLog` reports
+* whether the transaction wrote to a transaction log (drives the default retry decision).
+*
+* {@link TransactionAbandonedError} shares this field shape but deliberately does NOT
+* extend this class — an abandoned transaction is not retryable, and retryability is the
+* boundary this hierarchy expresses.
+*/
+var TransactionRetryableError = class extends Error {
 	hasLog;
 	txn;
 	constructor(error, txn) {
@@ -1696,6 +1914,21 @@ var TransactionIsBusyError = class extends Error {
 		this.txn = txn;
 	}
 };
+/**
+* An optimistic commit detected a write conflict with a concurrently committed
+* transaction (RocksDB `Busy`).
+*/
+var TransactionIsBusyError = class extends TransactionRetryableError {
+	code = "ERR_BUSY";
+};
+/**
+* An optimistic commit could not be validated: the transaction's snapshot was stranded
+* outside the memtable window (its sequence history was flushed away — RocksDB
+* `TryAgain`), so the conflict check had nothing to validate against.
+*/
+var TransactionTryAgainError = class extends TransactionRetryableError {
+	code = "ERR_TRY_AGAIN";
+};
 var TransactionAbandonedError = class extends Error {
 	code = "ERR_TRANSACTION_ABANDONED";
 	hasLog;
@@ -1790,6 +2023,7 @@ var Transaction = class extends DBI {
 		if (err instanceof Error && "code" in err) {
 			if (err.code === "ERR_ALREADY_ABORTED") return new TransactionAlreadyAbortedError(err.message);
 			if (err.code === "ERR_BUSY") return new TransactionIsBusyError(err, this);
+			if (err.code === "ERR_TRY_AGAIN") return new TransactionTryAgainError(err, this);
 		}
 		return err;
 	}
@@ -1839,9 +2073,12 @@ var RocksDatabase = class RocksDatabase extends DBI {
 	*/
 	#name;
 	constructor(pathOrStore, options) {
-		if (typeof pathOrStore === "string") super(new Store(pathOrStore, options));
-		else if (pathOrStore instanceof Store) super(pathOrStore);
+		let store;
+		if (typeof pathOrStore === "string") store = new Store(pathOrStore, options);
+		else if (pathOrStore instanceof Store) store = pathOrStore;
 		else throw new TypeError("Invalid database path or store");
+		store.claim();
+		super(store);
 		this.#name = options?.name ?? "default";
 	}
 	/**
@@ -1955,6 +2192,22 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		return this.store.db.columns;
 	}
 	/**
+	* The compression currently in effect for this database's column family, read
+	* live from RocksDB, as `{ algorithm, level? }`. `algorithm` is a friendly
+	* name (e.g. `'lz4'`, `'zstd'`, `'none'`); `level` is present only when a
+	* non-default compression level is set. The database must be open. Defaults to
+	* LZ4 when the native build supports it.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/db', { compression: { algorithm: 'zstd', level: 3 } });
+	* db.compression; // { algorithm: 'zstd', level: 3 }
+	* ```
+	*/
+	get compression() {
+		return this.store.db.getCompression();
+	}
+	/**
 	* Set global database settings.
 	*
 	* @param options - The options for the database.
@@ -2370,7 +2623,7 @@ var RocksDatabase = class RocksDatabase extends DBI {
 				commitResult = await txn.commit();
 			} catch (commitErr) {
 				if (commitErr instanceof TransactionAlreadyAbortedError) return;
-				if (commitErr instanceof TransactionIsBusyError && (options?.retryOnBusy ?? commitErr.hasLog) && attempt < maxRetries) continue;
+				if (commitErr instanceof TransactionRetryableError && (options?.retryOnBusy ?? commitErr.hasLog) && attempt < maxRetries) continue;
 				this.#abandonTransaction(txn, commitErr);
 				return;
 			}
@@ -2402,7 +2655,7 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		if (typeof callback !== "function") throw new TypeError("Callback must be a function");
 		const maxRetries = options?.maxRetries ?? 3;
 		const isRetryable = (err, attempt) => {
-			return err instanceof TransactionIsBusyError && (options?.retryOnBusy ?? err.hasLog) && attempt <= maxRetries;
+			return err instanceof TransactionRetryableError && (options?.retryOnBusy ?? err.hasLog) && attempt <= maxRetries;
 		};
 		const runAttempt = (attempt) => {
 			const txn = new Transaction(this.store, options);
@@ -2598,7 +2851,7 @@ function parseTransactionLog(path, options = {}) {
 
 //#endregion
 //#region src/transaction-log-reader.ts
-const FLOAT_TO_UINT32 = new Float64Array(1);
+const FLOAT_TO_UINT32 = /* @__PURE__ */ 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;
 /**
@@ -2784,7 +3037,7 @@ function loadLastPosition(transactionLog, readUncommitted) {
 //#region src/index.ts
 const versions = {
 	rocksdb: version,
-	"rocksdb-js": "2.4.1"
+	"rocksdb-js": "2.6.0"
 };
 
 //#endregion
@@ -2803,6 +3056,8 @@ exports.parseTransactionLog = parseTransactionLog;
 exports.registryStatus = registryStatus;
 exports.shutdown = shutdown;
 exports.stats = stats;
+exports.supportedCompression = supportedCompression;
 exports.tryFileLock = tryFileLock;
+exports.validateTransactionLogStore = validateTransactionLogStore;
 exports.versions = versions;
 //# sourceMappingURL=index.cjs.map