@harperfast/rocksdb-js 2.4.1 → 2.6.0

package/dist/index.d.mts

@@ -1,104 +1,121 @@
 import { ExtendedIterable } from "@harperfast/extended-iterable";
-
 //#region src/backup.d.ts
 /**
-* Options for creating a backup via `db.backup()`.
-*
-* Backups are whole-database: every column family, the manifest, and (unless
-* `backupLogFiles` is disabled) the write-ahead log are captured. A backup is
-* not scoped to an individual `Store`.
-*/
+ * Options for creating a backup via `db.backup()`.
+ *
+ * Backups are whole-database: every column family, the manifest, and (unless
+ * `backupLogFiles` is disabled) the write-ahead log are captured. A backup is
+ * not scoped to an individual `Store`.
+ */
 interface BackupOptions {
   /**
-  * Include write-ahead log files in the backup. Defaults to `true`.
-  */
+   * Include write-ahead log files in the backup. Defaults to `true`.
+   */
   backupLogFiles?: boolean;
   /**
-  * Flush the memtable before backing up. Defaults to `true` when the database
-  * was opened with `disableWAL` (otherwise unflushed data would be lost from
-  * the backup), and `false` otherwise.
-  */
+   * Preflight the destination volume and reject the backup when it lacks room.
+   * Defaults to `true`. The rejection is an I/O error whose message reports the
+   * available and required bytes (it is not distinguishable by an `err.code`).
+   *
+   * The required size is estimated conservatively as a *full* copy of the
+   * database's live files, plus the transaction-log snapshot when
+   * `transactionLogs` is enabled (a backup only ever copies files, so this can
+   * never under-estimate the bytes written). For incremental backups to a
+   * right-sized volume this may over-reject — set `false` to skip the check in
+   * that case. The check also self-disables when free space is unknowable (e.g.
+   * some network filesystems report 0), so it never blocks a backup on an
+   * untrustworthy number.
+   *
+   * Only applies to directory-target backups; the streaming backup path is
+   * unaffected.
+   */
+  checkDiskSpace?: boolean;
+  /**
+   * Flush the memtable before backing up. Defaults to `true` when the database
+   * was opened with `disableWAL` (otherwise unflushed data would be lost from
+   * the backup), and `false` otherwise.
+   */
   flushBeforeBackup?: boolean;
   /**
-  * Number of background threads used to copy files. Defaults to `1`.
-  */
+   * Number of background threads used to copy files. Defaults to `1`.
+   */
   maxBackgroundOperations?: number;
   /**
-  * Arbitrary application metadata stored with the backup and returned by
-  * `backups.list()`.
-  */
+   * Arbitrary application metadata stored with the backup and returned by
+   * `backups.list()`.
+   */
   metadata?: string;
   /**
-  * Distinguish shared files by checksum to avoid collisions across databases.
-  * Defaults to `true`. Only relevant when `shareTableFiles` is enabled.
-  */
+   * Distinguish shared files by checksum to avoid collisions across databases.
+   * Defaults to `true`. Only relevant when `shareTableFiles` is enabled.
+   */
   shareFilesWithChecksum?: boolean;
   /**
-  * Share table/blob files between backups in the same directory to enable
-  * incremental backups. Defaults to `true`.
-  */
+   * Share table/blob files between backups in the same directory to enable
+   * incremental backups. Defaults to `true`.
+   */
   shareTableFiles?: boolean;
   /**
-  * `fsync` backup files — including the transaction log snapshot when
-  * `transactionLogs` is enabled — for crash consistency. Defaults to `true`.
-  */
+   * `fsync` backup files — including the transaction log snapshot when
+   * `transactionLogs` is enabled — for crash consistency. Defaults to `true`.
+   */
   sync?: boolean;
   /**
-  * Snapshot the transaction log store into
-  * `<backupDir>/transaction_logs/<backupId>/`. Defaults to `false`. This is an
-  * all-or-nothing snapshot per backup (not incremental); `backups.delete()` and
-  * `backups.purge()` remove the corresponding log snapshots, and
-  * `backups.restore()` restores them into the database directory.
-  *
-  * The snapshot is staged and atomically renamed into place after every file
-  * is copied (and fsynced, per `sync`), so a crash mid-backup can never leave
-  * a partial snapshot: a backup id either has its complete log snapshot or
-  * none at all.
-  *
-  * The log snapshot is captured just after the RocksDB engine snapshot, so it
-  * may include entries committed between the two — the restored logs can run
-  * slightly ahead of the restored key-value data, never behind it. That bias
-  * is safe for redo-style logs that are replayed against the restored data.
-  */
+   * Snapshot the transaction log store into
+   * `<backupDir>/transaction_logs/<backupId>/`. Defaults to `false`. This is an
+   * all-or-nothing snapshot per backup (not incremental); `backups.delete()` and
+   * `backups.purge()` remove the corresponding log snapshots, and
+   * `backups.restore()` restores them into the database directory.
+   *
+   * The snapshot is staged and atomically renamed into place after every file
+   * is copied (and fsynced, per `sync`), so a crash mid-backup can never leave
+   * a partial snapshot: a backup id either has its complete log snapshot or
+   * none at all.
+   *
+   * The log snapshot is captured just after the RocksDB engine snapshot, so it
+   * may include entries committed between the two — the restored logs can run
+   * slightly ahead of the restored key-value data, never behind it. That bias
+   * is safe for redo-style logs that are replayed against the restored data.
+   */
   transactionLogs?: boolean;
 }
 /**
-* The level of incremental restore to perform.
-*
-* - `purgeAllFiles` (default): purge the destination directory and restore all
-*   files from the backup. Destructive but always correct.
-* - `keepLatestDbSessionIdFiles`: efficiently restore a healthy database,
-*   reusing existing files that match the backup.
-* - `verifyChecksum`: reuse existing destination files whose checksums match the
-*   backup, replacing only mismatched/corrupt files.
-*/
+ * The level of incremental restore to perform.
+ *
+ * - `purgeAllFiles` (default): purge the destination directory and restore all
+ *   files from the backup. Destructive but always correct.
+ * - `keepLatestDbSessionIdFiles`: efficiently restore a healthy database,
+ *   reusing existing files that match the backup.
+ * - `verifyChecksum`: reuse existing destination files whose checksums match the
+ *   backup, replacing only mismatched/corrupt files.
+ */
 type RestoreMode = "purgeAllFiles" | "keepLatestDbSessionIdFiles" | "verifyChecksum";
 /**
-* Options for restoring a backup via `backups.restore()`.
-*/
+ * Options for restoring a backup via `backups.restore()`.
+ */
 interface RestoreOptions {
   /**
-  * The backup id to restore. Defaults to the latest non-corrupt backup.
-  */
+   * The backup id to restore. Defaults to the latest non-corrupt backup.
+   */
   backupId?: number;
   /**
-  * Directory to restore write-ahead log files into. Defaults to the database
-  * directory.
-  */
+   * Directory to restore write-ahead log files into. Defaults to the database
+   * directory.
+   */
   walDir?: string;
   /**
-  * Keep existing log files in `walDir` rather than overwriting them. Defaults
-  * to `false`.
-  */
+   * Keep existing log files in `walDir` rather than overwriting them. Defaults
+   * to `false`.
+   */
   keepLogFiles?: boolean;
   /**
-  * The restore strategy. Defaults to `purgeAllFiles`, which is destructive.
-  */
+   * The restore strategy. Defaults to `purgeAllFiles`, which is destructive.
+   */
   mode?: RestoreMode;
 }
 /**
-* Information about a single backup, as returned by `backups.list()`.
-*/
+ * Information about a single backup, as returned by `backups.list()`.
+ */
 interface BackupInfo {
   /** The backup id (monotonically increasing integer). */
   backupId: number;
@@ -112,45 +129,64 @@ interface BackupInfo {
   appMetadata: string;
 }
 /**
-* Backup management operations that act on a backup directory and do not
-* require an open database. To create a backup, use the `db.backup()` instance
-* method instead (it needs a live database for a consistent snapshot).
-*
-* @example
-* ```typescript
-* import { backups } from '@harperfast/rocksdb-js';
-*
-* const id = await db.backup('/path/to/backups');
-* db.close();
-* await backups.restore('/path/to/backups', '/path/to/restored-db');
-* ```
-*/
+ * Backup management operations that act on a backup directory and do not
+ * require an open database. To create a backup, use the `db.backup()` instance
+ * method instead (it needs a live database for a consistent snapshot).
+ *
+ * @example
+ * ```typescript
+ * import { backups } from '@harperfast/rocksdb-js';
+ *
+ * const id = await db.backup('/path/to/backups');
+ * db.close();
+ * await backups.restore('/path/to/backups', '/path/to/restored-db');
+ * ```
+ */
 declare 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.
-  */
+   * 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.
+   */
   restore(backupDir: string, dbDir: string, options?: RestoreOptions): Promise<void>;
   /**
-  * Lists the non-corrupt backups in a backup directory, ordered by id.
-  */
+   * Lists the non-corrupt backups in a backup directory, ordered by id.
+   */
   list(backupDir: string): Promise<BackupInfo[]>;
   /**
-  * Deletes a specific backup. Shared files are reference-counted and only
-  * removed once no remaining backup references them.
-  */
+   * Deletes a specific backup. Shared files are reference-counted and only
+   * removed once no remaining backup references them.
+   */
   delete(backupDir: string, backupId: number): Promise<void>;
   /**
-  * Deletes all but the newest `keepCount` backups.
-  */
+   * Deletes all but the newest `keepCount` backups.
+   */
   purge(backupDir: string, keepCount: number): Promise<void>;
   /**
-  * Verifies a backup's file sizes, and optionally their checksums (which
-  * requires reading all backed-up data).
-  */
+   * Verifies a backup's file sizes, and optionally their checksums (which
+   * requires reading all backed-up data).
+   *
+   * 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.
+   */
   verify(backupDir: string, backupId: number, options?: {
     verifyWithChecksum?: boolean;
+    verifyTransactionLogs?: boolean;
   }): Promise<void>;
 };
 //#endregion
@@ -190,14 +226,14 @@ interface DBIteratorValue<T> {
   value: T;
 }
 /**
-* Wraps the `NativeIterator` C++ binding, decoding keys and values from the
-* shared key/value buffers (fast path) or from per-iteration buffers (slow
-* fallback path used for oversized data or stable-buffer decoders).
-*
-* The native `next()` returns a primitive signal (and writes lengths to the
-* shared `ITERATOR_STATE` buffer) instead of constructing a JS result object,
-* so this class is responsible for building the `IteratorResult`.
-*/
+ * Wraps the `NativeIterator` C++ binding, decoding keys and values from the
+ * shared key/value buffers (fast path) or from per-iteration buffers (slow
+ * fallback path used for oversized data or stable-buffer decoders).
+ *
+ * The native `next()` returns a primitive signal (and writes lengths to the
+ * shared `ITERATOR_STATE` buffer) instead of constructing a JS result object,
+ * so this class is responsible for building the `IteratorResult`.
+ */
 declare class DBIterator<T> implements Iterator<DBIteratorValue<T>> {
   #private;
   iterator: InstanceType<typeof NativeIteratorCls>;
@@ -221,9 +257,51 @@ type CompactOptions = {
   end?: Key;
 };
 /**
-* Options for the `Store` class.
-*/
-interface StoreOptions extends Omit<NativeDatabaseOptions, "mode" | "transactionLogRetentionMs"> {
+ * A RocksDB block/blob compression algorithm. Which algorithms are actually
+ * available depends on the libraries the native binding was compiled with —
+ * check `supportedCompression` at runtime. `'none'` disables compression and
+ * is always available.
+ */
+type CompressionAlgorithm = "none" | "snappy" | "zlib" | "bzip2" | "lz4" | "lz4hc" | "xpress" | "zstd";
+/**
+ * The `compression` open option: either an algorithm name, or an object with
+ * an algorithm and an optional level (forwarded to RocksDB's
+ * `compression_opts.level`; meaning is algorithm-specific).
+ */
+type CompressionOption = CompressionAlgorithm | {
+  algorithm: CompressionAlgorithm;
+  level?: number;
+};
+/**
+ * The compression currently in effect for a column family, as returned by the
+ * `compression` getter. `level` is present only when a non-default compression
+ * level is configured.
+ */
+type CompressionInfo = {
+  algorithm: CompressionAlgorithm;
+  level?: number;
+};
+/**
+ * Options for the `Store` class.
+ */
+interface StoreOptions extends Omit<NativeDatabaseOptions, "compression" | "compressionLevel" | "mode" | "transactionLogRetentionMs"> {
+  /**
+   * The block/blob compression algorithm for this column family. Accepts an
+   * algorithm name (`'lz4'`, `'zstd'`, `'none'`, ...) or an object with an
+   * `algorithm` and optional `level`. Applies to both SST blocks and blob
+   * files (large values). Which algorithms are available depends on the native
+   * build — see `supportedCompression`.
+   *
+   * When omitted, defaults to `lz4` if the build supports it, otherwise
+   * RocksDB's own default (Snappy when linked, else no compression).
+   * Compression is a dynamically-changeable option: reopening with a
+   * different algorithm governs subsequently written files; existing files
+   * keep their compression until rewritten by compaction. Use the
+   * `compression` getter to read the value currently in effect.
+   *
+   * @default 'lz4'
+   */
+  compression?: CompressionOption;
   decoder?: Encoder | null;
   encoder?: Encoder | null;
   encoding?: Encoding;
@@ -236,266 +314,293 @@ interface StoreOptions extends Omit<NativeDatabaseOptions, "mode" | "transaction
   maxKeySize?: number;
   pessimistic?: boolean;
   /**
-  * If `true`, the encoder will use a random access structure.
-  */
+   * If `true`, the encoder will use a random access structure.
+   */
   randomAccessStructure?: boolean;
   /**
-  * When `true`, the database is opened in read-only mode. Write operations
-  * will throw an error with code `ERR_DATABASE_READONLY`.
-  */
+   * When `true`, the database is opened in read-only mode. Write operations
+   * will throw an error with code `ERR_DATABASE_READONLY`.
+   */
   readOnly?: boolean;
   sharedStructuresKey?: symbol;
   /**
-  * A string containing the amount of time or the number of milliseconds to
-  * retain transaction logs before purging.
-  *
-  * @default '3d' (3 days)
-  */
+   * A string containing the amount of time or the number of milliseconds to
+   * retain transaction logs before purging.
+   *
+   * @default '3d' (3 days)
+   */
   transactionLogRetention?: number | string;
 }
 /**
-* Options for the `getUserSharedBuffer()` method.
-*/
+ * Options for the `getUserSharedBuffer()` method.
+ */
 type UserSharedBufferOptions = {
   callback?: UserSharedBufferCallback;
 };
 /**
-* The return type of `getUserSharedBuffer()`.
-*/
+ * The return type of `getUserSharedBuffer()`.
+ */
 type ArrayBufferWithNotify = ArrayBuffer & {
   cancel: () => void;
   notify: () => void;
 };
 /**
-* 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 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.
+ *
+ * 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.)
+ */
 declare class Store {
+  #private;
   /**
-  * The database instance.
-  */
+   * The database instance.
+   */
   db: NativeDatabase;
   /**
-  * The decoder instance. This is commonly the same as the `encoder`
-  * instance.
-  */
+   * The decoder instance. This is commonly the same as the `encoder`
+   * instance.
+   */
   decoder: Encoder | null;
   /**
-  * Whether the decoder copies the buffer when encoding values.
-  */
+   * Whether the decoder copies the buffer when encoding values.
+   */
   decoderCopies: boolean;
   /**
-  * Whether to disable the write ahead log.
-  */
+   * The compression algorithm (or `{ algorithm, level }`) requested for this
+   * store's column family. Normalized and applied when the database opens.
+   */
+  compression?: CompressionOption;
+  /**
+   * Whether to disable the write ahead log.
+   */
   disableWAL: boolean;
   /**
-  * Whether to enable RocksDB statistics.
-  */
+   * Whether to enable RocksDB statistics.
+   */
   enableStats: boolean;
   /**
-  * Reusable buffer for encoding values using `writeKey()` when the custom
-  * encoder does not provide a `encode()` method.
-  */
+   * Reusable buffer for encoding values using `writeKey()` when the custom
+   * encoder does not provide a `encode()` method.
+   */
   encodeBuffer: BufferWithDataView;
   /**
-  * The encoder instance.
-  */
+   * The encoder instance.
+   */
   encoder: Encoder | null;
   /**
-  * The encoding used to encode values. Defaults to `'msgpack'` in
-  * `RocksDatabase.open()`.
-  */
+   * The encoding used to encode values. Defaults to `'msgpack'` in
+   * `RocksDatabase.open()`.
+   */
   encoding: Encoding | null;
   /**
-  * Encoder specific option used to signal that the data should be frozen.
-  */
+   * Encoder specific option used to signal that the data should be frozen.
+   */
   freezeData: boolean;
   /**
-  * Reusable buffer for encoding keys.
-  */
+   * Reusable buffer for encoding keys.
+   */
   keyBuffer: BufferWithDataView;
   /**
-  * The key encoding to use for keys. Defaults to `'ordered-binary'`.
-  */
+   * The key encoding to use for keys. Defaults to `'ordered-binary'`.
+   */
   keyEncoding: KeyEncoding;
   /**
-  * The maximum key size.
-  */
+   * The maximum key size.
+   */
   maxKeySize: number;
   /**
-  * 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.
-  */
+   * 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?: number;
+  /**
+   * 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.
+   */
   maxWriteBufferNumber?: number;
   /**
-  * The bytes of recent memtable history to retain in memory for transaction
-  * conflict checking. `-1` derives the value from
-  * `maxWriteBufferNumber * writeBufferSize`.
-  */
+   * The bytes of recent memtable history to retain in memory for transaction
+   * conflict checking. `-1` derives the value from
+   * `maxWriteBufferNumber * writeBufferSize`.
+   */
   maxWriteBufferSizeToMaintain?: number;
   /**
-  * The total memtable budget in bytes across all column families. When the
-  * sum of memtables reaches this size, RocksDB flushes the largest one. `0`
-  * disables the global trigger so per-CF `writeBufferSize` drives flushing.
-  */
+   * The total memtable budget in bytes across all column families. When the
+   * sum of memtables reaches this size, RocksDB flushes the largest one. `0`
+   * disables the global trigger so per-CF `writeBufferSize` drives flushing.
+   */
   dbWriteBufferSize?: number;
   /**
-  * The name of the store (e.g. the column family). Defaults to `'default'`.
-  */
+   * The name of the store (e.g. the column family). Defaults to `'default'`.
+   */
   name: string;
   /**
-  * Whether to disable the block cache.
-  */
+   * Whether to disable the block cache.
+   */
   noBlockCache?: boolean;
   /**
-  * The number of threads to use for parallel operations. This is a RocksDB
-  * option. When undefined, the native layer picks
-  * `max(1, hardware_concurrency() / 2)`.
-  */
+   * The number of threads to use for parallel operations. This is a RocksDB
+   * option. When undefined, the native layer picks
+   * `max(1, hardware_concurrency() / 2)`.
+   */
   parallelismThreads?: number;
   /**
-  * The path to the database.
-  */
+   * The path to the database.
+   */
   path: string;
   /**
-  * 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.
-  */
+   * 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: boolean;
   /**
-  * Whether the database is open in readonly mode. When `true`, write
-  * operations will throw an error with code `ERR_DATABASE_READONLY`.
-  */
+   * Whether the database is open in readonly mode. When `true`, write
+   * operations will throw an error with code `ERR_DATABASE_READONLY`.
+   */
   readOnly: boolean;
   /**
-  * Encoder specific flag used to signal that the encoder should use a random
-  * access structure.
-  */
+   * Encoder specific flag used to signal that the encoder should use a random
+   * access structure.
+   */
   randomAccessStructure: boolean;
   /**
-  * The function used to encode keys.
-  */
+   * The function used to encode keys.
+   */
   readKey: ReadKeyFunction<Key>;
   /**
-  * The key used to store shared structures.
-  */
+   * The key used to store shared structures.
+   */
   sharedStructuresKey?: symbol;
   /**
-  * The level of statistics to capture.
-  */
+   * The level of statistics to capture.
+   */
   statsLevel?: (typeof stats.StatsLevel)[keyof typeof stats.StatsLevel];
   /**
-  * 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.
-  */
+   * 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?: number;
   /**
-  * The maximum size of a transaction log before it is rotated to the next
-  * sequence number.
-  */
+   * The maximum size of a transaction log before it is rotated to the next
+   * sequence number.
+   */
   transactionLogMaxSize?: number;
   /**
-  * A string containing the amount of time or the number of milliseconds to
-  * retain transaction logs before purging.
-  *
-  * @default '3d' (3 days)
-  */
+   * A string containing the amount of time or the number of milliseconds to
+   * retain transaction logs before purging.
+   *
+   * @default '3d' (3 days)
+   */
   transactionLogRetention?: number | string;
   /**
-  * The path to the transaction logs directory.
-  */
+   * The path to the transaction logs directory.
+   */
   transactionLogsPath?: string;
   /**
-  * Whether this store's column family participates in the VerificationTable.
-  */
+   * Whether this store's column family participates in the VerificationTable.
+   */
   verificationTable?: boolean;
   /**
-  * The per-column-family memtable size in bytes at which the memtable is
-  * sealed and flushed.
-  */
+   * The per-column-family memtable size in bytes at which the memtable is
+   * sealed and flushed.
+   */
   writeBufferSize?: number;
   /**
-  * The function used to encode keys using the shared `keyBuffer`.
-  */
+   * The function used to encode keys using the shared `keyBuffer`.
+   */
   writeKey: WriteKeyFunction;
   /**
-  * Initializes the store with a new `NativeDatabase` instance.
-  *
-  * @param path - The path to the database.
-  * @param options - The options for the store.
-  */
+   * Initializes the store with a new `NativeDatabase` instance.
+   *
+   * @param path - The path to the database.
+   * @param options - The options for the store.
+   */
   constructor(path: string, options?: StoreOptions);
   /**
-  * Closes the database.
-  */
+   * Closes the database.
+   */
   close(): void;
   /**
-  * Compacts the entire key range of the database asynchronously.
-  * This triggers manual compaction which removes tombstones and reclaims space.
-  *
-  * @example
-  * ```typescript
-  * const db = RocksDatabase.open('/path/to/database');
-  * await db.compact();
-  * ```
-  */
+   * 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(): void;
+  /**
+   * Compacts the entire key range of the database asynchronously.
+   * This triggers manual compaction which removes tombstones and reclaims space.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/database');
+   * await db.compact();
+   * ```
+   */
   compact(options?: CompactOptions): Promise<void>;
   /**
-  * Creates a backup of the entire database (all column families) into the
-  * given directory and resolves with the new backup id. Parent directories
-  * are created as needed. See `backups` for restore and management.
-  *
-  * @example
-  * ```typescript
-  * const id = await db.backup('/path/to/backups');
-  * ```
-  */
+   * Creates a backup of the entire database (all column families) into the
+   * given directory and resolves with the new backup id. Parent directories
+   * are created as needed. See `backups` for restore and management.
+   *
+   * @example
+   * ```typescript
+   * const id = await db.backup('/path/to/backups');
+   * ```
+   */
   backup(backupDir: string, options?: BackupOptions): Promise<number>;
   backup(stream: WritableStream<Uint8Array>, options?: BackupStreamOptions): Promise<void>;
   /**
-  * Compacts the entire key range of the database synchronously.
-  * This triggers manual compaction which removes tombstones and reclaims space.
-  *
-  * @example
-  * ```typescript
-  * const db = RocksDatabase.open('/path/to/database');
-  * db.compactSync();
-  * ```
-  */
+   * Compacts the entire key range of the database synchronously.
+   * This triggers manual compaction which removes tombstones and reclaims space.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/database');
+   * db.compactSync();
+   * ```
+   */
   compactSync(options?: CompactOptions): void;
   /**
-  * Decodes a key from the database.
-  *
-  * @param key - The key to decode.
-  * @returns The decoded key.
-  */
+   * Decodes a key from the database.
+   *
+   * @param key - The key to decode.
+   * @returns The decoded key.
+   */
   decodeKey(key: Buffer): Key;
   /**
-  * Decodes a value from the database.
-  *
-  * @param value - The value to decode.
-  * @returns The decoded value.
-  */
+   * Decodes a value from the database.
+   *
+   * @param value - The value to decode.
+   * @returns The decoded value.
+   */
   decodeValue(value: BufferWithDataView): any;
   /**
-  * Encodes a key for the database.
-  *
-  * @param key - The key to encode.
-  * @returns The encoded key.
-  */
+   * Encodes a key for the database.
+   *
+   * @param key - The key to encode.
+   * @returns The encoded key.
+   */
   encodeKey(key: Key): BufferWithDataView;
   /**
-  * Encodes a value for the database.
-  *
-  * @param value - The value to encode.
-  * @returns The encoded value.
-  */
+   * Encodes a value for the database.
+   *
+   * @param value - The value to encode.
+   * @returns The encoded value.
+   */
   encodeValue(value: any): BufferWithDataView | Uint8Array;
   get(context: StoreContext, key: Key, alwaysCreateNewBuffer?: boolean, options?: StoreGetOptions): any | undefined;
   getCount(context: StoreContext, options?: StoreRangeOptions): number;
@@ -504,118 +609,118 @@ declare class Store {
   getRange(context: StoreContext, options?: StoreIteratorOptions): ExtendedIterable<DBIteratorValue<any>>;
   getSync(context: StoreContext, key: Key, alwaysCreateNewBuffer?: boolean, options?: StoreGetOptions): any | undefined;
   /**
-  * Checks if the data method options object contains a transaction ID and
-  * returns it.
-  */
+   * Checks if the data method options object contains a transaction ID and
+   * returns it.
+   */
   getTxnId(options?: DBITransactional | unknown): number | undefined;
   /**
-  * 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`.
-  */
+   * 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: Key, defaultBuffer: ArrayBuffer, options?: UserSharedBufferOptions): ArrayBufferWithNotify;
   /**
-  * Checks if a lock exists.
-  * @param key The lock key.
-  * @returns `true` if the lock exists, `false` otherwise
-  */
+   * Checks if a lock exists.
+   * @param key The lock key.
+   * @returns `true` if the lock exists, `false` otherwise
+   */
   hasLock(key: Key): boolean;
   /**
-  * Checks if the database is open.
-  *
-  * @returns `true` if the database is open, `false` otherwise.
-  */
+   * Checks if the database is open.
+   *
+   * @returns `true` if the database is open, `false` otherwise.
+   */
   isOpen(): boolean;
   /**
-  * Lists all transaction log names.
-  *
-  * @returns an array of transaction log names.
-  */
+   * Lists all transaction log names.
+   *
+   * @returns an array of transaction log names.
+   */
   listLogs(): string[];
   /**
-  * Opens the database. This must be called before any database operations
-  * are performed.
-  */
+   * Opens the database. This must be called before any database operations
+   * are performed.
+   */
   open(): boolean;
   putSync(context: StoreContext, key: Key, value: any, options?: StorePutOptions): void;
   removeSync(context: StoreContext, key: Key, options?: StoreRemoveOptions): void;
   /**
-  * 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.
-  */
+   * 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: Key, onUnlocked?: () => void): boolean;
   /**
-  * Releases the lock on the given key and calls any queued `onUnlocked`
-  * callback handlers.
-  *
-  * @param key - The key to unlock.
-  */
+   * Releases the lock on the given key and calls any queued `onUnlocked`
+   * callback handlers.
+   *
+   * @param key - The key to unlock.
+   */
   unlock(key: Key): void;
   /**
-  * 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.
-  */
+   * 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: StoreContext, name: string | number): TransactionLog;
   /**
-  * Checks the process-global verification table for a fresh version match
-  * on `key`. Returns `true` when the table currently records `version` for
-  * this database+column-family. Provides a fast cache-freshness check
-  * before falling back to a full read.
-  */
+   * Checks the process-global verification table for a fresh version match
+   * on `key`. Returns `true` when the table currently records `version` for
+   * this database+column-family. Provides a fast cache-freshness check
+   * before falling back to a full read.
+   */
   verifyVersion(key: Key, version: number): boolean;
   /**
-  * Seeds the verification-table slot for `key` with `version`. Has no
-  * effect if the slot is currently lock-tagged or the table is disabled.
-  * Useful after a full read where the caller already knows the version.
-  */
+   * Seeds the verification-table slot for `key` with `version`. Has no
+   * effect if the slot is currently lock-tagged or the table is disabled.
+   * Useful after a full read where the caller already knows the version.
+   */
   populateVersion(key: Key, version: number): void;
   /**
-  * 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.
-  */
+   * 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: Key, callback: () => void | Promise<void>): Promise<void>;
 }
 interface GetOptions {
   /**
-  * When set, the native layer checks the verification table before reading.
-  * If the slot holds this version, returns `FRESH_VERSION_FLAG` immediately
-  * (the cached value is still valid). After a DB read, also seeds the slot
-  * with the version extracted from the value.
-  */
+   * When set, the native layer checks the verification table before reading.
+   * If the slot holds this version, returns `FRESH_VERSION_FLAG` immediately
+   * (the cached value is still valid). After a DB read, also seeds the slot
+   * with the version extracted from the value.
+   */
   expectedVersion?: number;
   /**
-  * When `true`, after a DB read the native layer automatically seeds the
-  * verification-table slot with the version extracted from the value.
-  * Eliminates the need for a separate `populateVersion` call on cold reads.
-  *
-  * @default false
-  */
+   * When `true`, after a DB read the native layer automatically seeds the
+   * verification-table slot with the version extracted from the value.
+   * Eliminates the need for a separate `populateVersion` call on cold reads.
+   *
+   * @default false
+   */
   populateVersion?: boolean;
   /**
-  * Whether to skip decoding the value.
-  *
-  * @default false
-  */
+   * Whether to skip decoding the value.
+   *
+   * @default false
+   */
   skipDecode?: boolean;
 }
 interface PutOptions {
@@ -627,55 +732,55 @@ interface PutOptions {
 //#endregion
 //#region src/transaction.d.ts
 /**
-* Sentinel value returned by `commit()` when `coordinatedRetry: true` and the
-* transaction encountered an IsBusy conflict. The native layer parks on VT
-* slots and resolves only after the conflicting transaction releases its write
-* intent, so callers should retry immediately without any backoff delay.
-*/
+ * Sentinel value returned by `commit()` when `coordinatedRetry: true` and the
+ * transaction encountered an IsBusy conflict. The native layer parks on VT
+ * slots and resolves only after the conflicting transaction releases its write
+ * intent, so callers should retry immediately without any backoff delay.
+ */
 declare const RETRY_NOW: number;
 /**
-* Provides transaction level operations to a transaction callback.
-*/
+ * Provides transaction level operations to a transaction callback.
+ */
 declare class Transaction extends DBI {
   #private;
   /**
-  * Create a new transaction.
-  *
-  * @param store - The base store interface for this transaction.
-  * @param options - The options for the transaction.
-  */
+   * Create a new transaction.
+   *
+   * @param store - The base store interface for this transaction.
+   * @param options - The options for the transaction.
+   */
   constructor(store: Store, options?: NativeTransactionOptions);
   /**
-  * Abort the transaction.
-  */
+   * Abort the transaction.
+   */
   abort(): void;
   /**
-  * Commit the transaction.
-  *
-  * Returns `RETRY_NOW` when `coordinatedRetry: true` and an IsBusy conflict
-  * was detected. The caller should retry the transaction body immediately.
-  */
+   * Commit the transaction.
+   *
+   * Returns `RETRY_NOW` when `coordinatedRetry: true` and an IsBusy conflict
+   * was detected. The caller should retry the transaction body immediately.
+   */
   commit(): Promise<typeof RETRY_NOW | void>;
   /**
-  * Commit the transaction synchronously.
-  */
+   * Commit the transaction synchronously.
+   */
   commitSync(): void;
   /**
-  * Returns the transaction start timestamp in seconds. Defaults to the time at which
-  * the transaction was created.
-  *
-  * @returns The transaction start timestamp in seconds.
-  */
+   * 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(): number;
   /**
-  * Get the transaction id.
-  */
+   * Get the transaction id.
+   */
   get id(): number;
   /**
-  * Set the transaction start timestamp in seconds.
-  *
-  * @param timestamp - The timestamp to set in seconds.
-  */
+   * Set the transaction start timestamp in seconds.
+   *
+   * @param timestamp - The timestamp to set in seconds.
+   */
   setTimestamp(timestamp?: number): void;
 }
 //#endregion
@@ -685,317 +790,317 @@ type MaybePromise<T> = T | Promise<T>;
 //#region src/dbi.d.ts
 interface RocksDBOptions {
   /**
-  * When `true`, RocksDB will do some enhancements for prefetching the data.
-  * Defaults to `true`. Note that RocksDB defaults this to `false`.
-  */
+   * When `true`, RocksDB will do some enhancements for prefetching the data.
+   * Defaults to `true`. Note that RocksDB defaults this to `false`.
+   */
   adaptiveReadahead?: boolean;
   /**
-  * When `true`, RocksDB will prefetch some data async and apply it if reads
-  * are sequential and its internal automatic prefetching. Defaults to
-  * `true`. Note that RocksDB defaults this to `false`.
-  */
+   * When `true`, RocksDB will prefetch some data async and apply it if reads
+   * are sequential and its internal automatic prefetching. Defaults to
+   * `true`. Note that RocksDB defaults this to `false`.
+   */
   asyncIO?: boolean;
   /**
-  * When `true`, RocksDB will auto-tune the readahead size during scans
-  * internally based on the block cache data when block caching is enabled,
-  * an end key (e.g. upper bound) is set, and prefix is the same as the start
-  * key. Defaults to `true`.
-  */
+   * When `true`, RocksDB will auto-tune the readahead size during scans
+   * internally based on the block cache data when block caching is enabled,
+   * an end key (e.g. upper bound) is set, and prefix is the same as the start
+   * key. Defaults to `true`.
+   */
   autoReadaheadSize?: boolean;
   /**
-  * When `true`, after the iterator is closed, a background job is scheduled
-  * to flush the job queue and delete obsolete files. Defaults to `true`.
-  * Note that RocksDB defaults this to `false`.
-  */
+   * When `true`, after the iterator is closed, a background job is scheduled
+   * to flush the job queue and delete obsolete files. Defaults to `true`.
+   * Note that RocksDB defaults this to `false`.
+   */
   backgroundPurgeOnIteratorCleanup?: boolean;
   /**
-  * When `true`, the iterator will fill the block cache. Filling the block
-  * cache is not desirable for bulk scans and could impact eviction order.
-  * Defaults to `false`. Note that RocksDB defaults this to `true`.
-  */
+   * When `true`, the iterator will fill the block cache. Filling the block
+   * cache is not desirable for bulk scans and could impact eviction order.
+   * Defaults to `false`. Note that RocksDB defaults this to `true`.
+   */
   fillCache?: boolean;
   /**
-  * The RocksDB readahead size. RocksDB does auto-readahead for iterators
-  * when there is more than two reads for a table file. The readahead
-  * starts at 8KB and doubles on every additional read up to 256KB. This
-  * option can help if most of the range scans are large and if a larger
-  * readahead than that enabled by auto-readahead is needed. Using a large
-  * readahead size (> 2MB) can typically improve the performance of forward
-  * iteration on spinning disks. Defaults to `0`.
-  */
+   * The RocksDB readahead size. RocksDB does auto-readahead for iterators
+   * when there is more than two reads for a table file. The readahead
+   * starts at 8KB and doubles on every additional read up to 256KB. This
+   * option can help if most of the range scans are large and if a larger
+   * readahead than that enabled by auto-readahead is needed. Using a large
+   * readahead size (> 2MB) can typically improve the performance of forward
+   * iteration on spinning disks. Defaults to `0`.
+   */
   readaheadSize?: number;
   /**
-  * When `true`, creates a "tailing iterator" which is a special iterator
-  * that has a view of the complete database including newly added data and
-  * is optimized for sequential reads. This will return records that were
-  * inserted into the database after the creation of the iterator. Defaults
-  * to `false`.
-  */
+   * When `true`, creates a "tailing iterator" which is a special iterator
+   * that has a view of the complete database including newly added data and
+   * is optimized for sequential reads. This will return records that were
+   * inserted into the database after the creation of the iterator. Defaults
+   * to `false`.
+   */
   tailing?: boolean;
 }
 interface RangeOptions extends RocksDBOptions {
   /**
-  * The range end key, otherwise known as the "upper bound". Defaults to
-  * the last key in the database.
-  */
+   * The range end key, otherwise known as the "upper bound". Defaults to
+   * the last key in the database.
+   */
   end?: Key | Uint8Array;
   /**
-  * When `true`, the iterator will exclude the first key if it matches the start key.
-  * Defaults to `false`.
-  */
+   * When `true`, the iterator will exclude the first key if it matches the start key.
+   * Defaults to `false`.
+   */
   exclusiveStart?: boolean;
   /**
-  * When `true`, the iterator will include the last key if it matches the end
-  * key. Defaults to `false`.
-  */
+   * When `true`, the iterator will include the last key if it matches the end
+   * key. Defaults to `false`.
+   */
   inclusiveEnd?: boolean;
   /**
-  * The range start key, otherwise known as the "lower bound". Defaults to
-  * the first key in the database.
-  */
+   * The range start key, otherwise known as the "lower bound". Defaults to
+   * the first key in the database.
+   */
   start?: Key | Uint8Array;
 }
 interface IteratorOptions extends RangeOptions {
   /**
-  * The maximum number of entries to yield. When set, iteration stops after
-  * `limit` entries regardless of the range bounds. Values <= 0 yield nothing.
-  * Unset means no limit.
-  */
+   * The maximum number of entries to yield. When set, iteration stops after
+   * `limit` entries regardless of the range bounds. Values <= 0 yield nothing.
+   * Unset means no limit.
+   */
   limit?: number;
   /**
-  * A specific key to match which may result in zero, one, or many values.
-  */
+   * A specific key to match which may result in zero, one, or many values.
+   */
   key?: Key;
   /**
-  * When `true`, only returns the number of values for the given query.
-  */
+   * When `true`, only returns the number of values for the given query.
+   */
   onlyCount?: boolean;
   /**
-  * When `true`, the iterator will iterate in reverse order. Defaults to
-  * `false`.
-  */
+   * When `true`, the iterator will iterate in reverse order. Defaults to
+   * `false`.
+   */
   reverse?: boolean;
   /**
-  * When `true`, decodes and returns the value. When `false`, the value is
-  * omitted. Defaults to `true`.
-  */
+   * When `true`, decodes and returns the value. When `false`, the value is
+   * omitted. Defaults to `true`.
+   */
   values?: boolean;
   /**
-  * When `true`, the iterator will only return the values.
-  */
+   * When `true`, the iterator will only return the values.
+   */
   valuesOnly?: boolean;
 }
 interface DBITransactional {
   transaction?: Transaction;
 }
 /**
-* 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.
-*/
+ * 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.
+ */
 declare class DBI<T extends DBITransactional | unknown = unknown> {
   /**
-  * The RocksDB context for `get()`, `put()`, and `remove()`.
-  */
+   * The RocksDB context for `get()`, `put()`, and `remove()`.
+   */
   _context: StoreContext;
   /**
-  * The database store instance. The store instance is tied to the database
-  * instance and shared with transaction instances.
-  */
+   * The database store instance. The store instance is tied to the database
+   * instance and shared with transaction instances.
+   */
   store: Store;
   /**
-  * Initializes the DBI context.
-  *
-  * @param store - The store instance.
-  * @param transaction - The transaction instance.
-  */
+   * Initializes the DBI context.
+   *
+   * @param store - The store instance.
+   * @param transaction - The transaction instance.
+   */
   constructor(store: Store, transaction?: NativeTransaction);
   /**
-  * Adds a listener for the given key.
-  *
-  * @param event - The event name to add the listener for.
-  * @param callback - The callback to add.
-  */
+   * 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: string, callback: (...args: any[]) => void): this;
   /**
-  * Retrieves the value for the given key, then returns the decoded value.
-  */
+   * Retrieves the value for the given key, then returns the decoded value.
+   */
   get(key: Key, options?: GetOptions & T): MaybePromise<any | undefined>;
   /**
-  * Retrieves the binary data for the given key. This is just like `get()`,
-  * but bypasses the decoder.
-  *
-  * Note: Used by HDBreplication.
-  */
+   * Retrieves the binary data for the given key. This is just like `get()`,
+   * but bypasses the decoder.
+   *
+   * Note: Used by HDBreplication.
+   */
   getBinary(key: Key, options?: GetOptions & T): MaybePromise<Buffer | number | undefined>;
   /**
-  * Synchronously retrieves the binary data for the given key.
-  */
+   * Synchronously retrieves the binary data for the given key.
+   */
   getBinarySync(key: Key, options?: GetOptions & T): Buffer | number | undefined;
   /**
-  * 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).
-  */
+   * 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: Key, options?: GetOptions & T): MaybePromise<Buffer | number | undefined>;
   /**
-  * 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).
-  */
+   * 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: Key, options?: GetOptions & T): Buffer | number | undefined;
   /**
-  * Retrieves all keys within a range.
-  */
+   * Retrieves all keys within a range.
+   */
   getKeys(options?: IteratorOptions & T): any | undefined;
   /**
-  * 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' });
-  * ```
-  */
+   * 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?: RangeOptions & T): number;
   /**
-  * 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 });
-  * }
-  * ```
-  */
+   * 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?: IteratorOptions & T): any | undefined;
   /**
-  * Synchronously retrieves the value for the given key, then returns the
-  * decoded value.
-  */
+   * Synchronously retrieves the value for the given key, then returns the
+   * decoded value.
+   */
   getSync(key: Key, options?: GetOptions & T): any | undefined;
   /**
-  * 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.
-  */
+   * 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: string | BufferWithDataView): number;
   /**
-  * 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.
-  */
+   * 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: string, ...args: any[]): boolean;
   /**
-  * Alias for `removeListener()`.
-  *
-  * @param event - The event name to remove the listener for.
-  * @param callback - The callback to remove.
-  */
+   * Alias for `removeListener()`.
+   *
+   * @param event - The event name to remove the listener for.
+   * @param callback - The callback to remove.
+   */
   off(event: string, callback: (...args: any[]) => void): this;
   /**
-  * Alias for `addListener()`.
-  *
-  * @param event - The event name to add the listener for.
-  * @param callback - The callback to add.
-  */
+   * Alias for `addListener()`.
+   *
+   * @param event - The event name to add the listener for.
+   * @param callback - The callback to add.
+   */
   on(event: string, callback: (...args: any[]) => void): 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.
-  */
+   * 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: string, callback: (...args: any[]) => void): 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');
-  * ```
-  */
+   * 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');
+   * ```
+   */
   put(key: Key, value: any, options?: PutOptions & T): Promise<void>;
   /**
-  * 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');
-  * ```
-  */
+   * 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: Key, value: any, options?: PutOptions & T): void;
   /**
-  * 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');
-  * ```
-  */
+   * 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');
+   * ```
+   */
   remove(key: Key, options?: T): Promise<void>;
   /**
-  * 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');
-  * ```
-  */
+   * 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: Key, options?: T): void;
   /**
-  * 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.
-  */
+   * 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: string, callback: (value?: any) => void): boolean;
   /**
-  * Get or create a transaction log instance.
-  *
-  * @param name - The name of the transaction log.
-  * @returns The transaction log.
-  */
+   * Get or create a transaction log instance.
+   *
+   * @param name - The name of the transaction log.
+   * @returns The transaction log.
+   */
   useLog(name: string | number): TransactionLog;
 }
 //#endregion
@@ -1049,6 +1154,8 @@ type StatsBasics = {
   "txnlog.transactionsWritten": number;
   "txnlog.bytesWritten": number;
   "txnlog.replayGapBytes": number;
+  "commitPipeline.logQueueDepth": number;
+  "commitPipeline.commitQueueDepth": number;
 };
 type StatsCuratedExtras = {
   "rocksdb.block.cache.hit": number;
@@ -1367,24 +1474,132 @@ interface GetStatsMethod {
   getStats(all: true): StatsAll;
 }
 //#endregion
+//#region src/validate-transaction-log.d.ts
+/**
+ * The validation result for a single transaction log file within a store, as
+ * returned by {@link validateTransactionLogStore}.
+ */
+interface TransactionLogFileValidation {
+  /** File name relative to the store directory, e.g. `"3.txnlog"`. */
+  file: string;
+  /** Sequence number parsed from the file name. */
+  sequence: number;
+  /** On-disk file size in bytes. */
+  size: number;
+  /** Number of well-formed entry frames. */
+  entries: number;
+  /** End offset of the validly framed data (header + well-formed entries). */
+  validBytes: number;
+  /** `true` when `errors` is empty. */
+  valid: boolean;
+  /**
+   * Conditions that make the file invalid: a bad/missing header, an
+   * unsupported version, or a mid-file framing break. With `strict`, a torn
+   * tail is also reported here.
+   */
+  errors: string[];
+  /**
+   * Conditions that do not invalidate the file: a torn tail (recoverable —
+   * open-time recovery truncates it without losing committed entries) and
+   * per-entry anomalies such as suspicious timestamps or undefined flag bits.
+   */
+  warnings: string[];
+}
+/**
+ * The result of validating a transaction log store directory, as returned by
+ * {@link validateTransactionLogStore}.
+ */
+interface TransactionLogStoreValidation {
+  /** The validated store directory. */
+  path: string;
+  /**
+   * `true` when there are no store-level errors and every log file is valid.
+   */
+  valid: boolean;
+  /** Per-file validation results, ordered by sequence number. */
+  files: TransactionLogFileValidation[];
+  /**
+   * Store-level errors: malformed file names, an unreadable file, or a
+   * corrupt `txn.state`.
+   */
+  errors: string[];
+  /**
+   * Store-level warnings: sequence gaps, unexpected directory entries, or an
+   * implausible `txn.state` flushed position.
+   */
+  warnings: string[];
+}
+/**
+ * Options for {@link validateTransactionLogStore}.
+ */
+interface ValidateTransactionLogStoreOptions {
+  /**
+   * Report conditions that indicate an incomplete snapshot — a torn tail, a
+   * sequence gap, or a `txn.state` flushed position beyond the newest log
+   * file or beyond its file's actual size — as errors instead of warnings. A
+   * torn tail on a live store is a normal crash artifact that open-time
+   * recovery truncates, but a backup snapshot captures every surviving file
+   * on committed entry boundaries and must be clean end to end —
+   * `backups.verify()` validates snapshots with `strict: true`. Defaults to
+   * `false`.
+   */
+  strict?: boolean;
+}
+/**
+ * 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);
+ *   }
+ * }
+ * ```
+ */
+declare function validateTransactionLogStore(path: string, options?: ValidateTransactionLogStoreOptions): Promise<TransactionLogStoreValidation>;
+//#endregion
 //#region src/load-binding.d.ts
 type NativeTransactionOptions = {
   /**
-  * Whether to disable snapshots.
-  *
-  * @default false
-  */
+   * Whether to disable snapshots.
+   *
+   * @default false
+   */
   disableSnapshot?: boolean;
   /**
-  * When `true`, an `IsBusy` conflict at commit time is resolved with the
-  * `RETRY_NOW` sentinel value instead of being rejected. The native layer
-  * may park on a VT slot before resolving, so the JS retry fires only after
-  * the conflicting transaction has committed and released its write intent.
-  *
-  * Use together with `verificationTable: true` on the database.
-  *
-  * @default false
-  */
+   * When `true`, an `IsBusy` conflict at commit time is resolved with the
+   * `RETRY_NOW` sentinel value instead of being rejected. The native layer
+   * may park on a VT slot before resolving, so the JS retry fires only after
+   * the conflicting transaction has committed and released its write intent.
+   *
+   * Use together with `verificationTable: true` on the database.
+   *
+   * @default false
+   */
   coordinatedRetry?: boolean;
 };
 type NativeTransaction = {
@@ -1421,23 +1636,23 @@ type TransactionEntry = {
   endTxn: boolean;
 };
 /**
-* A position within a transaction log, identifying a log file by its sequence
-* number and a byte `offset` within that file.
-*/
+ * A position within a transaction log, identifying a log file by its sequence
+ * number and a byte `offset` within that file.
+ */
 type TransactionLogPosition = {
   sequence: number;
   offset: number;
 };
 /**
-* A detailed statistics snapshot for a single transaction log store, returned
-* by {@link TransactionLog.getStats}. All sizes are in bytes; timestamps are
-* milliseconds since the Unix epoch.
-*
-* Memory note: `memory.mappedBytes` is virtual address space — the active write
-* file is mapped at the full configured `maxFileSize` on POSIX, so it does not
-* reflect resident memory. `memory.overlayBytes` (POSIX only; 0 on Windows) is
-* the file-backed portion and is the closer proxy for real consumption.
-*/
+ * A detailed statistics snapshot for a single transaction log store, returned
+ * by {@link TransactionLog.getStats}. All sizes are in bytes; timestamps are
+ * milliseconds since the Unix epoch.
+ *
+ * Memory note: `memory.mappedBytes` is virtual address space — the active write
+ * file is mapped at the full configured `maxFileSize` on POSIX, so it does not
+ * reflect resident memory. `memory.overlayBytes` (POSIX only; 0 on Windows) is
+ * the file-backed portion and is the closer proxy for real consumption.
+ */
 type TransactionLogStats = {
   name: string;
   path: string;
@@ -1497,10 +1712,10 @@ type TransactionLog = {
   _logBuffers: Map<number, WeakRef<LogBuffer>>;
 };
 /**
-* Shape of options that can be passed to the native iterator constructor for
-* the rare case of advanced RocksDB ReadOptions overrides. Common iterator
-* options are passed via the bitmask `flags` argument instead.
-*/
+ * Shape of options that can be passed to the native iterator constructor for
+ * the rare case of advanced RocksDB ReadOptions overrides. Common iterator
+ * options are passed via the bitmask `flags` argument instead.
+ */
 type NativeIteratorAdvancedOptions = {
   adaptiveReadahead?: boolean;
   asyncIO?: boolean;
@@ -1511,11 +1726,11 @@ type NativeIteratorAdvancedOptions = {
   tailing?: boolean;
 };
 /**
-* The result of a single native iterator step. A number value matches one of
-* the `ITERATOR_RESULT_*` constants. The slow-path object is returned when
-* the data does not fit in the shared key/value buffers, or when the decoder
-* needs a stable value buffer.
-*/
+ * The result of a single native iterator step. A number value matches one of
+ * the `ITERATOR_RESULT_*` constants. The slow-path object is returned when
+ * the data does not fit in the shared key/value buffers, or when the decoder
+ * needs a stable value buffer.
+ */
 type NativeIteratorResult = number | {
   key: Buffer;
   value?: Buffer;
@@ -1528,9 +1743,22 @@ declare class NativeIteratorCls {
 }
 type NativeDatabaseMode = "optimistic" | "pessimistic";
 type NativeDatabaseOptions = {
+  /**
+   * The friendly name of a compression algorithm compiled into this RocksDB
+   * build (see `supportedCompression`), e.g. `'lz4'`, `'zstd'`, `'none'`. The
+   * higher-level `StoreOptions.compression` (which also accepts an object with
+   * a level) is normalized down to this string plus `compressionLevel`.
+   */
+  compression?: string;
+  /**
+   * Compression level forwarded to RocksDB's `compression_opts.level`. Meaning
+   * is algorithm-specific; omit to use the algorithm's default.
+   */
+  compressionLevel?: number;
   dbWriteBufferSize?: number;
   disableWAL?: boolean;
   enableStats?: boolean;
+  maxOpenFiles?: number;
   maxWriteBufferNumber?: number;
   maxWriteBufferSizeToMaintain?: number;
   mode?: NativeDatabaseMode;
@@ -1544,11 +1772,11 @@ type NativeDatabaseOptions = {
   transactionLogRetentionMs?: number;
   transactionLogsPath?: string;
   /**
-  * When true, transaction writes to this column family invalidate the
-  * VerificationTable slot for each written key at write time (not at
-  * commit time). Enable only for column families whose records are
-  * cached (e.g. the primary CF of a table). Default: false.
-  */
+   * When true, transaction writes to this column family invalidate the
+   * VerificationTable slot for each written key at write time (not at
+   * commit time). Enable only for column families whose records are
+   * cached (e.g. the primary CF of a table). Default: false.
+   */
   verificationTable?: boolean;
   writeBufferSize?: number;
 };
@@ -1559,16 +1787,16 @@ type PurgeLogsOptions = {
   before?: number;
   destroy?: boolean;
   /**
-  * When `true`, count the entries in each purged log file (extra work) and
-  * return `PurgedLog[]` instead of the default `string[]` of file paths.
-  */
+   * When `true`, count the entries in each purged log file (extra work) and
+   * return `PurgedLog[]` instead of the default `string[]` of file paths.
+   */
   includeEntryCounts?: boolean;
   name?: string;
 };
 /**
-* A purged transaction log file and the number of entries it held, returned by
-* `purgeLogs()` when `includeEntryCounts` is `true`.
-*/
+ * A purged transaction log file and the number of entries it held, returned by
+ * `purgeLogs()` when `includeEntryCounts` is `true`.
+ */
 type PurgedLog = {
   path: string;
   entries: number;
@@ -1595,6 +1823,10 @@ type NativeDatabase = {
   flushSync(): void;
   notify(event: string | BufferWithDataView, args?: any[]): boolean;
   get(keyLengthOrKeyBuffer: number | Buffer, resolve: ResolveCallback<Buffer | number>, reject: RejectCallback, txnId?: number, expectedVersion?: number): number;
+  getCompression(): {
+    algorithm: string;
+    level?: number;
+  };
   getCount(options?: RangeOptions, txnId?: number): number;
   getDBIntProperty(propertyName: string): number | undefined;
   getDBProperty(propertyName: string): string | undefined;
@@ -1633,47 +1865,47 @@ type NativeDatabase = {
 type RocksDatabaseConfig = {
   blockCacheSize?: number;
   /**
-  * Number of slots in the process-global verification table. Each slot is
-  * 8 bytes; the default of 128K slots is 1 MB. Set to 0 to disable.
-  *
-  * Must be configured before the first database is opened. Once the table
-  * is materialized, attempts to change this value will throw.
-  */
+   * Number of slots in the process-global verification table. Each slot is
+   * 8 bytes; the default of 128K slots is 1 MB. Set to 0 to disable.
+   *
+   * Must be configured before the first database is opened. Once the table
+   * is materialized, attempts to change this value will throw.
+   */
   verificationTableEntries?: number;
   compactOnClose?: boolean;
   /**
-  * Total memtable memory limit (bytes) shared across every database opened
-  * in this process. When set, RocksDB uses a single `WriteBufferManager` so
-  * write buffers are bounded process-wide rather than per database. 0 (the
-  * default) disables the manager.
-  *
-  * Can be updated at runtime; the new size takes effect on the existing
-  * manager via `SetBufferSize`.
-  */
+   * Total memtable memory limit (bytes) shared across every database opened
+   * in this process. When set, RocksDB uses a single `WriteBufferManager` so
+   * write buffers are bounded process-wide rather than per database. 0 (the
+   * default) disables the manager.
+   *
+   * Can be updated at runtime; the new size takes effect on the existing
+   * manager via `SetBufferSize`.
+   */
   writeBufferManagerSize?: number;
   /**
-  * When `true`, memtable memory is "charged" against the shared block cache
-  * so the block cache and write buffers draw from a single pool. During
-  * write bursts the cache shrinks to make room for memtables; once
-  * memtables flush, the cache can grow back into the reclaimed space.
-  *
-  * Has no effect when the block cache is disabled (size 0) or
-  * `writeBufferManagerSize` is 0. Must be set on the same `config()` call
-  * that first enables the manager — changing it after the manager has been
-  * created has no effect on the running instance.
-  *
-  * @default false
-  */
+   * When `true`, memtable memory is "charged" against the shared block cache
+   * so the block cache and write buffers draw from a single pool. During
+   * write bursts the cache shrinks to make room for memtables; once
+   * memtables flush, the cache can grow back into the reclaimed space.
+   *
+   * Has no effect when the block cache is disabled (size 0) or
+   * `writeBufferManagerSize` is 0. Must be set on the same `config()` call
+   * that first enables the manager — changing it after the manager has been
+   * created has no effect on the running instance.
+   *
+   * @default false
+   */
   writeBufferManagerCostToCache?: boolean;
   /**
-  * When `true`, writes are stalled once the manager's `buffer_size` is
-  * exceeded, providing a hard cap on memtable memory. When `false`,
-  * memtables are allowed to grow past the limit and flushes are simply
-  * scheduled more aggressively. Off by default to favor write throughput
-  * over hard memory bounding.
-  *
-  * @default false
-  */
+   * When `true`, writes are stalled once the manager's `buffer_size` is
+   * exceeded, providing a hard cap on memtable memory. When `false`,
+   * memtables are allowed to grow past the limit and flushes are simply
+   * scheduled more aggressively. Off by default to favor write throughput
+   * over hard memory bounding.
+   *
+   * @default false
+   */
   writeBufferManagerAllowStall?: boolean;
 };
 type RegistryStatusDB = {
@@ -1694,10 +1926,10 @@ declare const constants: {
   POPULATE_VERSION_FLAG: number;
   FRESH_VERSION_FLAG: number;
   /**
-  * Sentinel value resolved (not rejected) by `commit()` when
-  * `coordinatedRetry: true` and the transaction encountered an IsBusy
-  * conflict. JS should retry the transaction body immediately.
-  */
+   * Sentinel value resolved (not rejected) by `commit()` when
+   * `coordinatedRetry: true` and the transaction encountered an IsBusy
+   * conflict. JS should retry the transaction body immediately.
+   */
   RETRY_NOW_VALUE: number;
   TRANSACTION_LOG_TOKEN: number;
   TRANSACTION_LOG_ENTRY_HEADER_SIZE: number;
@@ -1711,6 +1943,15 @@ declare const constants: {
   ITERATOR_RESULT_DONE: number;
   ITERATOR_RESULT_FAST: number;
 };
+/**
+ * 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.
+ */
+declare const supportedCompression: readonly string[];
 declare const NativeDatabase: NativeDatabase;
 declare const NativeTransaction: NativeTransaction;
 declare const TransactionLog: TransactionLog;
@@ -1718,36 +1959,38 @@ declare const registryStatus: () => RegistryStatus;
 declare const shutdown: () => void;
 declare const currentThreadId: () => number;
 /**
-* Advises the kernel that the file-backed pages of every mapped transaction log
-* are cold (Linux MADV_COLD), so they are reclaimed first under memory pressure
-* without being freed — useful during replication catch-up, where a full read of
-* the logs would otherwise inflate the container's reclaimable cache toward its
-* cgroup limit. No-op on kernels < 5.4, macOS, and Windows.
-*
-* The transaction log registry is a process-global singleton shared across all
-* worker threads, so a single call cools every worker's maps. Call it on an
-* interval from one thread (e.g. an `unref()`ed timer on the main thread).
-*
-* @returns the number of maps cooled and total file-backed bytes advised.
-*/
+ * Advises the kernel that the file-backed pages of every mapped transaction log
+ * are cold (Linux MADV_COLD), so they are reclaimed first under memory pressure
+ * without being freed — useful during replication catch-up, where a full read of
+ * the logs would otherwise inflate the container's reclaimable cache toward its
+ * cgroup limit. No-op on kernels < 5.4, macOS, and Windows.
+ *
+ * The transaction log registry is a process-global singleton shared across all
+ * worker threads, so a single call cools every worker's maps. Call it on an
+ * interval from one thread (e.g. an `unref()`ed timer on the main thread).
+ *
+ * @returns the number of maps cooled and total file-backed bytes advised.
+ */
 declare const coolTransactionLogs: () => {
   maps: number;
   bytes: number;
 };
 /**
-* 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.
-*/
-declare const tryFileLock: (file: string) => number;
+ * Creates a native file lock using the specified file path (`flock` on POSIX,
+ * `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.
+ */
+declare const tryFileLock: (file: string, shared?: boolean) => number;
 /**
-* Releases a file lock acquired via `tryFileLock`. A no-op for
-* token `0` or an unknown token.
-*/
+ * Releases a file lock acquired via `tryFileLock`. A no-op for
+ * token `0` or an unknown token.
+ */
 declare const fileLockRelease: (token: number) => void;
 declare const stats: {
   StatsLevel: {
@@ -1763,32 +2006,32 @@ declare const stats: {
 //#endregion
 //#region src/backup-stream.d.ts
 /**
-* Options for streaming a backup via `db.backup(stream)`.
-*/
+ * Options for streaming a backup via `db.backup(stream)`.
+ */
 interface BackupStreamOptions {
   /**
-  * Flush the memtable before streaming. Defaults to `true` when the database
-  * was opened with `disableWAL` (otherwise unflushed data would be missing
-  * from the stream), and `false` otherwise — matching `db.backup(dir)`.
-  */
+   * Flush the memtable before streaming. Defaults to `true` when the database
+   * was opened with `disableWAL` (otherwise unflushed data would be missing
+   * from the stream), and `false` otherwise — matching `db.backup(dir)`.
+   */
   flushBeforeBackup?: boolean;
   /**
-  * Gzip-compress the archive before writing it to the stream, producing a
-  * `.tar.gz` stream instead of a plain `.tar`. Defaults to `false`.
-  *
-  * Compression runs in the runtime's `CompressionStream`, downstream of the tar
-  * encoder, so end-to-end backpressure is preserved. RocksDB SST files are
-  * usually already block-compressed, so the additional savings vary with the
-  * data and the configured compression.
-  */
+   * Gzip-compress the archive before writing it to the stream, producing a
+   * `.tar.gz` stream instead of a plain `.tar`. Defaults to `false`.
+   *
+   * Compression runs in the runtime's `CompressionStream`, downstream of the tar
+   * encoder, so end-to-end backpressure is preserved. RocksDB SST files are
+   * usually already block-compressed, so the additional savings vary with the
+   * data and the configured compression.
+   */
   gzip?: boolean;
   /**
-  * Also stream the transaction log store as `transaction_logs/<store>/…`
-  * entries (each `*.txnlog` and `txn.state` file) after the database files.
-  * Defaults to `false`. Extraction reconstructs them next to the database, and
-  * their mtimes are preserved so the store's age-based rotation/retention stays
-  * correct.
-  */
+   * Also stream the transaction log store as `transaction_logs/<store>/…`
+   * entries (each `*.txnlog` and `txn.state` file) after the database files.
+   * Defaults to `false`. Extraction reconstructs them next to the database, and
+   * their mtimes are preserved so the store's age-based rotation/retention stays
+   * correct.
+   */
   transactionLogs?: boolean;
 }
 //#endregion
@@ -1796,418 +2039,432 @@ interface BackupStreamOptions {
 type TransactionCallback<T> = (txn: Transaction, attempt: number) => T | PromiseLike<T>;
 interface RocksDatabaseOptions extends StoreOptions {
   /**
-  * The column family name.
-  *
-  * @default 'default'
-  */
+   * The column family name.
+   *
+   * @default 'default'
+   */
   name?: string;
 }
 interface TransactionOptions extends NativeTransactionOptions {
   /**
-  * The maximum number of times to retry the transaction.
-  *
-  * @default 3
-  */
+   * The maximum number of times to retry the transaction.
+   *
+   * @default 3
+   */
   maxRetries?: number;
   /**
-  * Whether to retry the transaction if it fails with `IsBusy`.
-  *
-  * @default `true` when the transaction is bound to a transaction log, otherwise `false`
-  */
+   * Whether to retry the transaction if it fails with `IsBusy`.
+   *
+   * @default `true` when the transaction is bound to a transaction log, otherwise `false`
+   */
   retryOnBusy?: boolean;
 }
 type RocksDBStat = StatsValue;
 type RocksDBStats = StatsDefault | StatsAll;
 /**
-* 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();
-* ```
-*/
+ * 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();
+ * ```
+ */
 declare class RocksDatabase extends DBI<DBITransactional> {
   #private;
   constructor(pathOrStore: string | Store, options?: RocksDatabaseOptions);
   /**
-  * Removes all data from the database asynchronously.
-  *
-  * @example
-  * ```typescript
-  * const db = RocksDatabase.open('/path/to/database');
-  * await db.clear();
-  * ```
-  */
+   * Removes all data from the database asynchronously.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/database');
+   * await db.clear();
+   * ```
+   */
   clear(): Promise<void>;
   /**
-  * Removes all entries from the database synchronously.
-  *
-  * @example
-  * ```typescript
-  * const db = RocksDatabase.open('/path/to/database');
-  * db.clearSync();
-  * ```
-  */
+   * Removes all entries from the database synchronously.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/database');
+   * db.clearSync();
+   * ```
+   */
   clearSync(): void;
   /**
-  * Closes the database.
-  *
-  * @example
-  * ```typescript
-  * const db = RocksDatabase.open('/path/to/database');
-  * db.close();
-  * ```
-  */
+   * Closes the database.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/database');
+   * db.close();
+   * ```
+   */
   close(): void;
   /**
-  * Compacts the entire key range of the database asynchronously.
-  * This triggers manual compaction which removes tombstones and reclaims space.
-  *
-  * @example
-  * ```typescript
-  * const db = RocksDatabase.open('/path/to/database');
-  * await db.compact();
-  * ```
-  */
+   * Compacts the entire key range of the database asynchronously.
+   * This triggers manual compaction which removes tombstones and reclaims space.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/database');
+   * await db.compact();
+   * ```
+   */
   compact(options?: CompactOptions): Promise<void>;
   /**
-  * Creates a backup of the entire database (all column families) into the
-  * given directory, creating parent directories as needed, and resolves with
-  * the new backup id. Use the `backups` namespace to restore, list, delete,
-  * purge, or verify backups.
-  *
-  * When the database was opened with `disableWAL`, the memtable is flushed
-  * before the backup by default so unflushed data is not lost.
-  *
-  * @example
-  * ```typescript
-  * import { backups } from '@harperfast/rocksdb-js';
-  *
-  * const db = RocksDatabase.open('/path/to/database');
-  * const id = await db.backup('/path/to/backups');
-  * ```
-  */
+   * Creates a backup of the entire database (all column families) into the
+   * given directory, creating parent directories as needed, and resolves with
+   * the new backup id. Use the `backups` namespace to restore, list, delete,
+   * purge, or verify backups.
+   *
+   * When the database was opened with `disableWAL`, the memtable is flushed
+   * before the backup by default so unflushed data is not lost.
+   *
+   * @example
+   * ```typescript
+   * import { backups } from '@harperfast/rocksdb-js';
+   *
+   * const db = RocksDatabase.open('/path/to/database');
+   * const id = await db.backup('/path/to/backups');
+   * ```
+   */
   backup(backupDir: string, options?: BackupOptions): Promise<number>;
   /**
-  * Streams a consistent snapshot of the entire database to a `WritableStream`
-  * as a tar archive, with no intermediate copy written to disk. Resolves once
-  * the stream has been fully written and closed.
-  *
-  * Backpressure is honored end to end, so a slow consumer (e.g. a network or
-  * S3 upload) paces the backup rather than buffering it in memory. The archive
-  * unpacks with any tar tool into a directory that opens as a RocksDB database.
-  *
-  * @example
-  * ```typescript
-  * const file = await fetch(uploadUrl, { method: 'PUT', body: stream });
-  * await db.backup(stream); // `stream` is the request's WritableStream
-  * ```
-  */
+   * Streams a consistent snapshot of the entire database to a `WritableStream`
+   * as a tar archive, with no intermediate copy written to disk. Resolves once
+   * the stream has been fully written and closed.
+   *
+   * Backpressure is honored end to end, so a slow consumer (e.g. a network or
+   * S3 upload) paces the backup rather than buffering it in memory. The archive
+   * unpacks with any tar tool into a directory that opens as a RocksDB database.
+   *
+   * @example
+   * ```typescript
+   * const file = await fetch(uploadUrl, { method: 'PUT', body: stream });
+   * await db.backup(stream); // `stream` is the request's WritableStream
+   * ```
+   */
   backup(stream: WritableStream<Uint8Array>, options?: BackupStreamOptions): Promise<void>;
   /**
-  * Creates a hardlinked, point-in-time, fully independent copy of the entire
-  * database (all column families) at `targetPath` and resolves once written.
-  *
-  * Unlike a backup, a checkpoint is a normal, writable sibling database: open
-  * it with {@link RocksDatabase.open} and it diverges independently from the
-  * source. SST and blob files are hardlinked when `targetPath` is on the same
-  * filesystem as the database and copied otherwise (other files such as the
-  * MANIFEST are always copied), so the operation is near-instant on the same
-  * filesystem. The memtable is flushed so the checkpoint includes the latest
-  * writes even when the WAL is disabled.
-  *
-  * Parent directories are created as needed. `targetPath` itself must not
-  * already exist (RocksDB creates the checkpoint directory) and rejects with
-  * `Create checkpoint failed: target path exists` if it does. The caller is
-  * responsible for eventual cleanup of the directory.
-  *
-  * @example
-  * ```typescript
-  * const db = RocksDatabase.open('/path/to/database');
-  * await db.createCheckpoint('/path/to/checkpoint');
-  * const branch = RocksDatabase.open('/path/to/checkpoint');
-  * ```
-  */
+   * Creates a hardlinked, point-in-time, fully independent copy of the entire
+   * database (all column families) at `targetPath` and resolves once written.
+   *
+   * Unlike a backup, a checkpoint is a normal, writable sibling database: open
+   * it with {@link RocksDatabase.open} and it diverges independently from the
+   * source. SST and blob files are hardlinked when `targetPath` is on the same
+   * filesystem as the database and copied otherwise (other files such as the
+   * MANIFEST are always copied), so the operation is near-instant on the same
+   * filesystem. The memtable is flushed so the checkpoint includes the latest
+   * writes even when the WAL is disabled.
+   *
+   * Parent directories are created as needed. `targetPath` itself must not
+   * already exist (RocksDB creates the checkpoint directory) and rejects with
+   * `Create checkpoint failed: target path exists` if it does. The caller is
+   * responsible for eventual cleanup of the directory.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/database');
+   * await db.createCheckpoint('/path/to/checkpoint');
+   * const branch = RocksDatabase.open('/path/to/checkpoint');
+   * ```
+   */
   createCheckpoint(targetPath: string): Promise<void>;
   /**
-  * Compacts the entire key range of the database synchronously.
-  * This triggers manual compaction which removes tombstones and reclaims space.
-  *
-  * @example
-  * ```typescript
-  * const db = RocksDatabase.open('/path/to/database');
-  * db.compactSync();
-  * ```
-  */
+   * Compacts the entire key range of the database synchronously.
+   * This triggers manual compaction which removes tombstones and reclaims space.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/database');
+   * db.compactSync();
+   * ```
+   */
   compactSync(options?: CompactOptions): void;
   /**
-  * Returns the list of column families in the RocksDB database.
-  */
+   * Returns the list of column families in the RocksDB database.
+   */
   get columns(): string[];
   /**
-  * Set global database settings.
-  *
-  * @param options - The options for the database.
-  *
-  * @example
-  * ```typescript
-  * RocksDatabase.config({ blockCacheSize: 1024 * 1024 });
-  * ```
-  */
+   * 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(): CompressionInfo;
+  /**
+   * Set global database settings.
+   *
+   * @param options - The options for the database.
+   *
+   * @example
+   * ```typescript
+   * RocksDatabase.config({ blockCacheSize: 1024 * 1024 });
+   * ```
+   */
   static config(options: RocksDatabaseConfig): void;
   /**
-  * Registers a process-wide event listener. Internal events emitted by the
-  * native binding use namespaced keys (e.g. `'transactionLog:warning'`).
-  *
-  * Listeners are not tied to any specific database — they fire for every
-  * matching event emitted in this process.
-  *
-  * @example
-  * ```typescript
-  * RocksDatabase.on('transactionLog:warning', (warning) => {
-  *   console.warn(warning);
-  * });
-  * ```
-  */
+   * Registers a process-wide event listener. Internal events emitted by the
+   * native binding use namespaced keys (e.g. `'transactionLog:warning'`).
+   *
+   * Listeners are not tied to any specific database — they fire for every
+   * matching event emitted in this process.
+   *
+   * @example
+   * ```typescript
+   * RocksDatabase.on('transactionLog:warning', (warning) => {
+   *   console.warn(warning);
+   * });
+   * ```
+   */
   static on(event: string, callback: (...args: any[]) => void): void;
   /**
-  * Alias for {@link RocksDatabase.on}, mirroring the Node `EventEmitter` API.
-  */
+   * Alias for {@link RocksDatabase.on}, mirroring the Node `EventEmitter` API.
+   */
   static addListener(event: string, callback: (...args: any[]) => void): void;
   /**
-  * Removes a previously-registered process-wide event listener. The
-  * callback identity must match the one passed to {@link RocksDatabase.on}.
-  *
-  * @returns `true` if a matching listener was removed.
-  */
+   * Removes a previously-registered process-wide event listener. The
+   * callback identity must match the one passed to {@link RocksDatabase.on}.
+   *
+   * @returns `true` if a matching listener was removed.
+   */
   static off(event: string, callback: (...args: any[]) => void): boolean;
   /**
-  * Alias for {@link RocksDatabase.off}, mirroring the Node `EventEmitter` API.
-  */
+   * Alias for {@link RocksDatabase.off}, mirroring the Node `EventEmitter` API.
+   */
   static removeListener(event: string, callback: (...args: any[]) => void): boolean;
   /**
-  * Returns the number of process-wide listeners registered for the given event.
-  */
+   * Returns the number of process-wide listeners registered for the given event.
+   */
   static listenerCount(event: string): number;
   /**
-  * Emits a process-wide event. Mostly intended for tests and as a peer to
-  * {@link RocksDatabase.on} — native code should call `emitGlobalEvent` in
-  * `napi/global_events.h` directly rather than round-tripping through JS.
-  *
-  * @returns `true` if there was at least one listener.
-  */
+   * Emits a process-wide event. Mostly intended for tests and as a peer to
+   * {@link RocksDatabase.on} — native code should call `emitGlobalEvent` in
+   * `napi/global_events.h` directly rather than round-tripping through JS.
+   *
+   * @returns `true` if there was at least one listener.
+   */
   static notify(event: string, ...args: any[]): boolean;
   destroy(): void;
   drop(): Promise<void>;
   dropSync(): void;
   get encoder(): Encoder | null;
   /**
-  * Flushes the underlying database by performing a commit or clearing any buffered operations.
-  *
-  * @return {void} Does not return a value.
-  */
+   * Flushes the underlying database by performing a commit or clearing any buffered operations.
+   *
+   * @return {void} Does not return a value.
+   */
   flush(): Promise<void>;
   /**
-  * Synchronously flushes the underlying database by performing a commit or clearing any buffered operations.
-  *
-  * @return {void} Does not return a value.
-  */
+   * Synchronously flushes the underlying database by performing a commit or clearing any buffered operations.
+   *
+   * @return {void} Does not return a value.
+   */
   flushSync(): void;
   /**
-  * 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');
-  * ```
-  */
+   * 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: string): number | undefined;
   /**
-  * 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');
-  * ```
-  */
+   * 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: string): string | undefined;
   /**
-  * Retrieves the estimated number of keys in the database.
-  *
-  * @example
-  * ```typescript
-  * const db = RocksDatabase.open('/path/to/database');
-  * const estimated = db.getEstimatedKeyCount();
-  * console.log(estimated);
-  * ```
-  */
+   * Retrieves the estimated number of keys in the database.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/database');
+   * const estimated = db.getEstimatedKeyCount();
+   * console.log(estimated);
+   * ```
+   */
   getEstimatedKeyCount(): number;
   /**
-  * Returns the current timestamp as a monotonically increasing timestamp in
-  * milliseconds represented as a decimal number.
-  *
-  * @returns The current monotonic timestamp in milliseconds.
-  */
+   * Returns the current timestamp as a monotonically increasing timestamp in
+   * milliseconds represented as a decimal number.
+   *
+   * @returns The current monotonic timestamp in milliseconds.
+   */
   getMonotonicTimestamp(): number;
   /**
-  * Returns a number representing a unix timestamp of the oldest unreleased
-  * snapshot.
-  *
-  * @returns The oldest snapshot timestamp.
-  */
+   * Returns a number representing a unix timestamp of the oldest unreleased
+   * snapshot.
+   *
+   * @returns The oldest snapshot timestamp.
+   */
   getOldestSnapshotTimestamp(): number;
   /**
-  * Gets a RocksDB statistic.
-  *
-  * @param statName - The name of the statistic to retrieve.
-  * @returns The statistic value.
-  */
+   * Gets a RocksDB statistic.
+   *
+   * @param statName - The name of the statistic to retrieve.
+   * @returns The statistic value.
+   */
   getStat(statName: string): RocksDBStat;
   /**
-  * Gets the RocksDB statistics. The RocksDB ticker/histogram stats require
-  * statistics to be enabled, but the result always includes a summarized,
-  * aggregate set of `txnlog.*` keys (across all of this database's transaction
-  * logs), regardless of whether statistics are enabled. For detailed per-log
-  * statistics, including memory-map usage, use `log.getStats()` on the log
-  * returned by {@link RocksDatabase#useLog}.
-  *
-  * @example
-  * ```typescript
-  * const db = RocksDatabase.open('/path/to/database');
-  * const stats = db.getStats();
-  * stats['txnlog.totalSizeBytes']; // bytes across all transaction logs
-  * ```
-  */
+   * Gets the RocksDB statistics. The RocksDB ticker/histogram stats require
+   * statistics to be enabled, but the result always includes a summarized,
+   * aggregate set of `txnlog.*` keys (across all of this database's transaction
+   * logs), regardless of whether statistics are enabled. For detailed per-log
+   * statistics, including memory-map usage, use `log.getStats()` on the log
+   * returned by {@link RocksDatabase#useLog}.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/database');
+   * const stats = db.getStats();
+   * stats['txnlog.totalSizeBytes']; // bytes across all transaction logs
+   * ```
+   */
   getStats(all?: false): StatsDefault;
   getStats(all: true): StatsAll;
   /**
-  * 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));
-  */
+   * 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: Key, defaultBuffer: ArrayBuffer, options?: UserSharedBufferOptions): ArrayBufferWithNotify;
   /**
-  * 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
-  * ```
-  */
+   * 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: Key): boolean;
   ifNoExists(_key: Key): Promise<void>;
   /**
-  * Checks the process-global verification table for a fresh version match
-  * on `key`. Returns `true` when the table currently records `version`. Use
-  * this as a fast cache-freshness check before falling back to a full read:
-  *
-  * ```typescript
-  * if (db.verifyVersion(key, cachedEntry.version)) {
-  *   return cachedEntry.value;
-  * }
-  * const value = db.getSync(key);
-  * db.populateVersion(key, extractVersion(value));
-  * ```
-  */
+   * Checks the process-global verification table for a fresh version match
+   * on `key`. Returns `true` when the table currently records `version`. Use
+   * this as a fast cache-freshness check before falling back to a full read:
+   *
+   * ```typescript
+   * if (db.verifyVersion(key, cachedEntry.version)) {
+   *   return cachedEntry.value;
+   * }
+   * const value = db.getSync(key);
+   * db.populateVersion(key, extractVersion(value));
+   * ```
+   */
   verifyVersion(key: Key, version: number): boolean;
   /**
-  * Seeds the verification-table slot for `key` with `version`. Has no
-  * effect if the slot is currently lock-tagged or if the verification
-  * table is disabled.
-  */
+   * Seeds the verification-table slot for `key` with `version`. Has no
+   * effect if the slot is currently lock-tagged or if the verification
+   * table is disabled.
+   */
   populateVersion(key: Key, version: number): void;
   /**
-  * Returns whether the database is open.
-  *
-  * @returns `true` if the database is open, `false` otherwise.
-  */
+   * Returns whether the database is open.
+   *
+   * @returns `true` if the database is open, `false` otherwise.
+   */
   isOpen(): boolean;
   /**
-  * Lists all transaction log names.
-  *
-  * @returns an array of transaction log names.
-  */
+   * Lists all transaction log names.
+   *
+   * @returns an array of transaction log names.
+   */
   listLogs(): string[];
   /**
-  * The name of the database.
-  */
+   * The name of the database.
+   */
   get name(): string;
   /**
-  * Whether the database is open in readonly mode.
-  */
+   * Whether the database is open in readonly mode.
+   */
   get readOnly(): boolean;
   /**
-  * 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');
-  * ```
-  */
+   * 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: string | Store, options?: RocksDatabaseOptions): RocksDatabase;
   /**
-  * 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();
-  * ```
-  */
+   * 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(): RocksDatabase;
   /**
-  * Returns the path to the database.
-  */
+   * Returns the path to the database.
+   */
   get path(): string;
   /**
-  * Purges transaction logs.
-  *
-  * By default returns the paths of the deleted log files. Pass
-  * `includeEntryCounts: true` to instead return, for each deleted file, its
-  * path and the number of entries it held (`{ path, entries }`).
-  */
+   * Purges transaction logs.
+   *
+   * By default returns the paths of the deleted log files. Pass
+   * `includeEntryCounts: true` to instead return, for each deleted file, its
+   * path and the number of entries it held (`{ path, entries }`).
+   */
   purgeLogs(options: PurgeLogsOptions & {
     includeEntryCounts: true;
   }): PurgedLog[];
@@ -2216,93 +2473,93 @@ declare class RocksDatabase extends DBI<DBITransactional> {
   }): string[];
   purgeLogs(options?: PurgeLogsOptions): string[] | PurgedLog[];
   /**
-  * The status of the database.
-  */
+   * The status of the database.
+   */
   get status(): "open" | "closed";
   /**
-  * 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');
-  * });
-  * ```
-  */
+   * 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');
+   * });
+   * ```
+   */
   transaction<T>(callback: TransactionCallback<T>, options?: TransactionOptions): Promise<T | void>;
   /**
-  * 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');
-  * });
-  * ```
-  */
+   * 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<T>(callback: TransactionCallback<T>, options?: TransactionOptions): T | PromiseLike<T> | void;
   /**
-  * 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.
-  */
+   * 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: Key, onUnlocked?: () => void): boolean;
   /**
-  * 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`
-  * ```
-  */
+   * 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: Key): void;
   /**
-  * 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);
-  * });
-  * ```
-  */
+   * 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: Key, callback: () => void | Promise<void>): Promise<void> | undefined;
 }
 //#endregion
@@ -2323,10 +2580,10 @@ interface TransactionLog$1 {
   version: number;
 }
 /**
-* Loads an entire transaction log file into memory.
-* @param path - The path to the transaction log file.
-* @returns The transaction log.
-*/
+ * Loads an entire transaction log file into memory.
+ * @param path - The path to the transaction log file.
+ * @returns The transaction log.
+ */
 declare function parseTransactionLog(path: string, options?: {
   skipData?: boolean;
 }): TransactionLog$1;
@@ -2337,5 +2594,5 @@ declare const versions: {
   "rocksdb-js": string;
 };
 //#endregion
-export { type BackupInfo, type BackupOptions, type BackupStreamOptions, DBI, DBIterator, type GetStatsMethod, type IteratorOptions, type Key, type RestoreMode, type RestoreOptions, type RocksDBStat, type RocksDBStats, RocksDatabase, type RocksDatabaseOptions, type StatsAll, type StatsAllExtras, type StatsBasics, type StatsCurated, type StatsCuratedExtras, type StatsDefault, type StatsHistogramData, type StatsValue, Store, type StoreContext, type StoreGetOptions, type StoreIteratorOptions, type StorePutOptions, type StoreRangeOptions, type StoreRemoveOptions, Transaction, type TransactionEntry, TransactionLog, type TransactionLogPosition, type TransactionLogStats, backups, constants, coolTransactionLogs, currentThreadId, fileLockRelease, parseTransactionLog, registryStatus, shutdown, stats, tryFileLock, versions };
+export { type BackupInfo, type BackupOptions, type BackupStreamOptions, type CompressionAlgorithm, type CompressionInfo, type CompressionOption, DBI, DBIterator, type GetStatsMethod, type IteratorOptions, type Key, type RestoreMode, type RestoreOptions, type RocksDBStat, type RocksDBStats, RocksDatabase, type RocksDatabaseOptions, type StatsAll, type StatsAllExtras, type StatsBasics, type StatsCurated, type StatsCuratedExtras, type StatsDefault, type StatsHistogramData, type StatsValue, Store, type StoreContext, type StoreGetOptions, type StoreIteratorOptions, type StorePutOptions, type StoreRangeOptions, type StoreRemoveOptions, Transaction, type TransactionEntry, TransactionLog, type TransactionLogFileValidation, type TransactionLogPosition, type TransactionLogStats, type TransactionLogStoreValidation, type ValidateTransactionLogStoreOptions, backups, constants, coolTransactionLogs, currentThreadId, fileLockRelease, parseTransactionLog, registryStatus, shutdown, stats, supportedCompression, tryFileLock, validateTransactionLogStore, versions };
 //# sourceMappingURL=index.d.mts.map