@harperfast/rocksdb-js 2.6.1 → 2.7.1

package/dist/index.d.cts

@@ -255,6 +255,18 @@ type StoreRemoveOptions = DBITransactional | unknown;
 type CompactOptions = {
   start?: Key;
   end?: Key;
+  /**
+   * Compact the bottommost level as well, rewriting every file in range.
+   *
+   * RocksDB skips the bottommost level by default when no compaction filter is installed, and
+   * that is where most of the data sits — so an ordinary `compact()` leaves it untouched. Since a
+   * changed `compression` algorithm only governs newly written files, rewriting that level is the
+   * only way to re-encode data that already exists.
+   *
+   * This rewrites the whole range regardless of whether RocksDB considers it worth doing, so it
+   * is as expensive as the data is large. Defaults to `false`.
+   */
+  bottommost?: boolean;
 };
 /**
  * A RocksDB block/blob compression algorithm. Which algorithms are actually
@@ -281,6 +293,23 @@ type CompressionInfo = {
   algorithm: CompressionAlgorithm;
   level?: number;
 };
+/**
+ * The informational-log settings currently in effect for a database, as
+ * returned by the `logOptions` getter. These are database-wide (`DBOptions`)
+ * settings, not per-column-family.
+ */
+type LogOptions = {
+  /**
+   * Per-file size cap (bytes) for informational log files (`LOG` /
+   * `LOG.old.*`).
+   */
+  maxLogFileSize: number;
+  /**
+   * Verbosity of informational logging: `0` (debug), `1` (info), `2` (warn),
+   * `3` (error), `4` (fatal), or `5` (header-only).
+   */
+  infoLogLevel: number;
+};
 /**
  * Options for the `Store` class.
  */
@@ -302,6 +331,27 @@ interface StoreOptions extends Omit<NativeDatabaseOptions, "compression" | "comp
    * @default 'lz4'
    */
   compression?: CompressionOption;
+  /**
+   * Apply `compression` to every column family in the database, not only the one being opened.
+   *
+   * RocksDB opens all of a database's column families in a single native call, and by default
+   * each of the ones you did not name keeps its persisted algorithm. That is right when codecs
+   * are chosen per table, but it leaves a caller that wants one codec for the whole database
+   * unable to say so: those families are already open at their old algorithm before it gets a
+   * chance to ask, and a column family's compression cannot be changed while it is open.
+   *
+   * Setting this applies the requested algorithm to all of them instead — including families
+   * that were persisted with a different one, which is the point when adopting a codec on a
+   * database that predates it.
+   *
+   * Only meaningful with an explicit `compression` (it throws otherwise), and only on the open
+   * that actually creates the database handle; later opens of the same path reuse that handle
+   * and cannot revisit the decision. As always, the algorithm governs newly written files —
+   * existing SST/blob files keep theirs until rewritten (see `compact({ bottommost: true })`).
+   *
+   * @default false
+   */
+  compressionForAllColumnFamilies?: boolean;
   decoder?: Encoder | null;
   encoder?: Encoder | null;
   encoding?: Encoding;
@@ -375,6 +425,11 @@ declare class Store {
    * store's column family. Normalized and applied when the database opens.
    */
   compression?: CompressionOption;
+  /**
+   * Whether `compression` applies to every column family in the database rather than just this
+   * store's. See `RocksDatabaseOptions.compressionForAllColumnFamilies`.
+   */
+  compressionForAllColumnFamilies: boolean;
   /**
    * Whether to disable the write ahead log.
    */
@@ -401,6 +456,11 @@ declare class Store {
    * Encoder specific option used to signal that the data should be frozen.
    */
   freezeData: boolean;
+  /**
+   * Verbosity of RocksDB's informational logging (`info_log_level`). Omit to
+   * leave RocksDB's own default.
+   */
+  infoLogLevel?: number;
   /**
    * Reusable buffer for encoding keys.
    */
@@ -413,6 +473,16 @@ declare class Store {
    * The maximum key size.
    */
   maxKeySize: number;
+  /**
+   * Per-file size cap (bytes) for informational log files (`LOG` /
+   * `LOG.old.*`). Bounds total informational-log footprint to roughly `5 *
+   * maxLogFileSize` (RocksDB retains up to 5 of these files). A value of `0`
+   * is RocksDB's "single unbounded log file" mode: it disables size-based
+   * rotation, so the log can grow without limit — set it only if you want that.
+   *
+   * @default 16777216 (16MB)
+   */
+  maxLogFileSize?: number;
   /**
    * The maximum number of table files RocksDB keeps open. `0` (the default)
    * derives a budget from the effective per-process open-file limit (an
@@ -432,13 +502,26 @@ declare class Store {
   /**
    * The bytes of recent memtable history to retain in memory for transaction
    * conflict checking. `-1` derives the value from
-   * `maxWriteBufferNumber * writeBufferSize`.
+   * `maxWriteBufferNumber * writeBufferSize`, except under a stalling
+   * `writeBufferManager`, where it derives `0`: retained history is charged to
+   * that manager and is only trimmable down to this target, so a target the
+   * budget cannot hold stalls writes permanently. Set a number to size it
+   * yourself against the budget and the column-family count.
    */
   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.
+   * sum of memtables reaches this size, RocksDB flushes the largest one.
+   * Defaults to `0`, which disables the global trigger so per-CF
+   * `writeBufferSize` drives flushing.
+   *
+   * Set this only if you know your column-family count: it is one budget split
+   * across all of them, so a value that suits a few families starves many. To
+   * bound total memtable memory instead, configure a WriteBufferManager.
+   *
+   * Database-wide, so it binds when the path is first opened in this process:
+   * a later open of the same path — including from another worker thread —
+   * keeps the first opener's value rather than overriding or rejecting it.
    */
   dbWriteBufferSize?: number;
   /**
@@ -750,6 +833,15 @@ declare class Transaction extends DBI {
    * @param options - The options for the transaction.
    */
   constructor(store: Store, options?: NativeTransactionOptions);
+  /**
+   * Release the staged writes' verification-table write intents without
+   * closing the transaction, barring any later commit or write. For a
+   * transaction kept open only for its outstanding read iterators after the
+   * writes were replayed onto another transaction: otherwise other writers'
+   * coordinated-retry commits park on those intents until it is aborted.
+   * Reads keep working, including read-your-own-writes.
+   */
+  abandonWrites(): void;
   /**
    * Abort the transaction.
    */
@@ -1605,6 +1697,7 @@ type NativeTransactionOptions = {
 type NativeTransaction = {
   id: number;
   new (context: NativeDatabase, options?: NativeTransactionOptions): NativeTransaction;
+  abandonWrites(): void;
   abort(): void;
   commit(resolve: (retrySignal?: number) => void, reject: (err: Error) => void): void;
   commitSync(): void;
@@ -1755,9 +1848,30 @@ type NativeDatabaseOptions = {
    * is algorithm-specific; omit to use the algorithm's default.
    */
   compressionLevel?: number;
+  /**
+   * Apply `compression` to every column family the underlying `DB::Open` opens, rather than
+   * only the one named by `name`. Requires an explicit `compression`.
+   */
+  compressionForAllColumnFamilies?: boolean;
   dbWriteBufferSize?: number;
   disableWAL?: boolean;
   enableStats?: boolean;
+  /**
+   * Verbosity of RocksDB's informational logging (`info_log_level`): `0`
+   * (debug), `1` (info), `2` (warn), `3` (error), `4` (fatal), or `5`
+   * (header-only). Omit to leave RocksDB's own default (`INFO_LEVEL` in a
+   * release build of the linked RocksDB library).
+   */
+  infoLogLevel?: number;
+  /**
+   * Per-file size cap (bytes) for informational log files (`LOG` /
+   * `LOG.old.*`, `max_log_file_size`). RocksDB retains up to 5 of these files
+   * (`keep_log_file_num`, not currently exposed as an option), so total
+   * informational-log footprint is bounded at roughly `5 * maxLogFileSize`.
+   *
+   * @default 16777216 (16MB)
+   */
+  maxLogFileSize?: number;
   maxOpenFiles?: number;
   maxWriteBufferNumber?: number;
   maxWriteBufferSizeToMaintain?: number;
@@ -1812,8 +1926,8 @@ type NativeDatabase = {
   clear(resolve: ResolveCallback<void>, reject: RejectCallback): void;
   clearSync(): void;
   close(): void;
-  compact(resolve: ResolveCallback<void>, reject: RejectCallback, start?: Key, end?: Key): void;
-  compactSync(start?: Key, end?: Key): void;
+  compact(resolve: ResolveCallback<void>, reject: RejectCallback, start?: Key, end?: Key, bottommost?: boolean): void;
+  compactSync(start?: Key, end?: Key, bottommost?: boolean): void;
   columns: string[];
   createCheckpoint(resolve: ResolveCallback<void>, reject: RejectCallback, targetPath: string): void;
   destroy(): void;
@@ -1830,6 +1944,10 @@ type NativeDatabase = {
   getCount(options?: RangeOptions, txnId?: number): number;
   getDBIntProperty(propertyName: string): number | undefined;
   getDBProperty(propertyName: string): string | undefined;
+  getLogOptions(): {
+    maxLogFileSize: number;
+    infoLogLevel: number;
+  };
   getMonotonicTimestamp(): number;
   getOldestSnapshotTimestamp(): number;
   getStat(statName: string): number | StatsHistogramData;
@@ -2206,6 +2324,22 @@ declare class RocksDatabase extends DBI<DBITransactional> {
    * ```
    */
   get compression(): CompressionInfo;
+  /**
+   * The informational-log settings currently in effect for this database,
+   * read live from RocksDB, as `{ maxLogFileSize, infoLogLevel }`. These are
+   * database-wide settings (not per-column-family): `maxLogFileSize` bounds
+   * each retained `LOG` / `LOG.old.*` file's size (defaults to 16MB, so with
+   * RocksDB's `keep_log_file_num = 5` the total footprint is bounded at
+   * roughly 80MB); `infoLogLevel` is the logging verbosity. The database must
+   * be open.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/db', { maxLogFileSize: 4 * 1024 * 1024 });
+   * db.logOptions; // { maxLogFileSize: 4194304, infoLogLevel: 1 }
+   * ```
+   */
+  get logOptions(): LogOptions;
   /**
    * Set global database settings.
    *
@@ -2594,5 +2728,5 @@ declare const versions: {
   "rocksdb-js": string;
 };
 //#endregion
-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 };
+export { type BackupInfo, type BackupOptions, type BackupStreamOptions, type CompressionAlgorithm, type CompressionInfo, type CompressionOption, DBI, DBIterator, type GetStatsMethod, type IteratorOptions, type Key, type LogOptions, 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.cts.map

package/dist/index.d.mts

@@ -255,6 +255,18 @@ type StoreRemoveOptions = DBITransactional | unknown;
 type CompactOptions = {
   start?: Key;
   end?: Key;
+  /**
+   * Compact the bottommost level as well, rewriting every file in range.
+   *
+   * RocksDB skips the bottommost level by default when no compaction filter is installed, and
+   * that is where most of the data sits — so an ordinary `compact()` leaves it untouched. Since a
+   * changed `compression` algorithm only governs newly written files, rewriting that level is the
+   * only way to re-encode data that already exists.
+   *
+   * This rewrites the whole range regardless of whether RocksDB considers it worth doing, so it
+   * is as expensive as the data is large. Defaults to `false`.
+   */
+  bottommost?: boolean;
 };
 /**
  * A RocksDB block/blob compression algorithm. Which algorithms are actually
@@ -281,6 +293,23 @@ type CompressionInfo = {
   algorithm: CompressionAlgorithm;
   level?: number;
 };
+/**
+ * The informational-log settings currently in effect for a database, as
+ * returned by the `logOptions` getter. These are database-wide (`DBOptions`)
+ * settings, not per-column-family.
+ */
+type LogOptions = {
+  /**
+   * Per-file size cap (bytes) for informational log files (`LOG` /
+   * `LOG.old.*`).
+   */
+  maxLogFileSize: number;
+  /**
+   * Verbosity of informational logging: `0` (debug), `1` (info), `2` (warn),
+   * `3` (error), `4` (fatal), or `5` (header-only).
+   */
+  infoLogLevel: number;
+};
 /**
  * Options for the `Store` class.
  */
@@ -302,6 +331,27 @@ interface StoreOptions extends Omit<NativeDatabaseOptions, "compression" | "comp
    * @default 'lz4'
    */
   compression?: CompressionOption;
+  /**
+   * Apply `compression` to every column family in the database, not only the one being opened.
+   *
+   * RocksDB opens all of a database's column families in a single native call, and by default
+   * each of the ones you did not name keeps its persisted algorithm. That is right when codecs
+   * are chosen per table, but it leaves a caller that wants one codec for the whole database
+   * unable to say so: those families are already open at their old algorithm before it gets a
+   * chance to ask, and a column family's compression cannot be changed while it is open.
+   *
+   * Setting this applies the requested algorithm to all of them instead — including families
+   * that were persisted with a different one, which is the point when adopting a codec on a
+   * database that predates it.
+   *
+   * Only meaningful with an explicit `compression` (it throws otherwise), and only on the open
+   * that actually creates the database handle; later opens of the same path reuse that handle
+   * and cannot revisit the decision. As always, the algorithm governs newly written files —
+   * existing SST/blob files keep theirs until rewritten (see `compact({ bottommost: true })`).
+   *
+   * @default false
+   */
+  compressionForAllColumnFamilies?: boolean;
   decoder?: Encoder | null;
   encoder?: Encoder | null;
   encoding?: Encoding;
@@ -375,6 +425,11 @@ declare class Store {
    * store's column family. Normalized and applied when the database opens.
    */
   compression?: CompressionOption;
+  /**
+   * Whether `compression` applies to every column family in the database rather than just this
+   * store's. See `RocksDatabaseOptions.compressionForAllColumnFamilies`.
+   */
+  compressionForAllColumnFamilies: boolean;
   /**
    * Whether to disable the write ahead log.
    */
@@ -401,6 +456,11 @@ declare class Store {
    * Encoder specific option used to signal that the data should be frozen.
    */
   freezeData: boolean;
+  /**
+   * Verbosity of RocksDB's informational logging (`info_log_level`). Omit to
+   * leave RocksDB's own default.
+   */
+  infoLogLevel?: number;
   /**
    * Reusable buffer for encoding keys.
    */
@@ -413,6 +473,16 @@ declare class Store {
    * The maximum key size.
    */
   maxKeySize: number;
+  /**
+   * Per-file size cap (bytes) for informational log files (`LOG` /
+   * `LOG.old.*`). Bounds total informational-log footprint to roughly `5 *
+   * maxLogFileSize` (RocksDB retains up to 5 of these files). A value of `0`
+   * is RocksDB's "single unbounded log file" mode: it disables size-based
+   * rotation, so the log can grow without limit — set it only if you want that.
+   *
+   * @default 16777216 (16MB)
+   */
+  maxLogFileSize?: number;
   /**
    * The maximum number of table files RocksDB keeps open. `0` (the default)
    * derives a budget from the effective per-process open-file limit (an
@@ -432,13 +502,26 @@ declare class Store {
   /**
    * The bytes of recent memtable history to retain in memory for transaction
    * conflict checking. `-1` derives the value from
-   * `maxWriteBufferNumber * writeBufferSize`.
+   * `maxWriteBufferNumber * writeBufferSize`, except under a stalling
+   * `writeBufferManager`, where it derives `0`: retained history is charged to
+   * that manager and is only trimmable down to this target, so a target the
+   * budget cannot hold stalls writes permanently. Set a number to size it
+   * yourself against the budget and the column-family count.
    */
   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.
+   * sum of memtables reaches this size, RocksDB flushes the largest one.
+   * Defaults to `0`, which disables the global trigger so per-CF
+   * `writeBufferSize` drives flushing.
+   *
+   * Set this only if you know your column-family count: it is one budget split
+   * across all of them, so a value that suits a few families starves many. To
+   * bound total memtable memory instead, configure a WriteBufferManager.
+   *
+   * Database-wide, so it binds when the path is first opened in this process:
+   * a later open of the same path — including from another worker thread —
+   * keeps the first opener's value rather than overriding or rejecting it.
    */
   dbWriteBufferSize?: number;
   /**
@@ -750,6 +833,15 @@ declare class Transaction extends DBI {
    * @param options - The options for the transaction.
    */
   constructor(store: Store, options?: NativeTransactionOptions);
+  /**
+   * Release the staged writes' verification-table write intents without
+   * closing the transaction, barring any later commit or write. For a
+   * transaction kept open only for its outstanding read iterators after the
+   * writes were replayed onto another transaction: otherwise other writers'
+   * coordinated-retry commits park on those intents until it is aborted.
+   * Reads keep working, including read-your-own-writes.
+   */
+  abandonWrites(): void;
   /**
    * Abort the transaction.
    */
@@ -1605,6 +1697,7 @@ type NativeTransactionOptions = {
 type NativeTransaction = {
   id: number;
   new (context: NativeDatabase, options?: NativeTransactionOptions): NativeTransaction;
+  abandonWrites(): void;
   abort(): void;
   commit(resolve: (retrySignal?: number) => void, reject: (err: Error) => void): void;
   commitSync(): void;
@@ -1755,9 +1848,30 @@ type NativeDatabaseOptions = {
    * is algorithm-specific; omit to use the algorithm's default.
    */
   compressionLevel?: number;
+  /**
+   * Apply `compression` to every column family the underlying `DB::Open` opens, rather than
+   * only the one named by `name`. Requires an explicit `compression`.
+   */
+  compressionForAllColumnFamilies?: boolean;
   dbWriteBufferSize?: number;
   disableWAL?: boolean;
   enableStats?: boolean;
+  /**
+   * Verbosity of RocksDB's informational logging (`info_log_level`): `0`
+   * (debug), `1` (info), `2` (warn), `3` (error), `4` (fatal), or `5`
+   * (header-only). Omit to leave RocksDB's own default (`INFO_LEVEL` in a
+   * release build of the linked RocksDB library).
+   */
+  infoLogLevel?: number;
+  /**
+   * Per-file size cap (bytes) for informational log files (`LOG` /
+   * `LOG.old.*`, `max_log_file_size`). RocksDB retains up to 5 of these files
+   * (`keep_log_file_num`, not currently exposed as an option), so total
+   * informational-log footprint is bounded at roughly `5 * maxLogFileSize`.
+   *
+   * @default 16777216 (16MB)
+   */
+  maxLogFileSize?: number;
   maxOpenFiles?: number;
   maxWriteBufferNumber?: number;
   maxWriteBufferSizeToMaintain?: number;
@@ -1812,8 +1926,8 @@ type NativeDatabase = {
   clear(resolve: ResolveCallback<void>, reject: RejectCallback): void;
   clearSync(): void;
   close(): void;
-  compact(resolve: ResolveCallback<void>, reject: RejectCallback, start?: Key, end?: Key): void;
-  compactSync(start?: Key, end?: Key): void;
+  compact(resolve: ResolveCallback<void>, reject: RejectCallback, start?: Key, end?: Key, bottommost?: boolean): void;
+  compactSync(start?: Key, end?: Key, bottommost?: boolean): void;
   columns: string[];
   createCheckpoint(resolve: ResolveCallback<void>, reject: RejectCallback, targetPath: string): void;
   destroy(): void;
@@ -1830,6 +1944,10 @@ type NativeDatabase = {
   getCount(options?: RangeOptions, txnId?: number): number;
   getDBIntProperty(propertyName: string): number | undefined;
   getDBProperty(propertyName: string): string | undefined;
+  getLogOptions(): {
+    maxLogFileSize: number;
+    infoLogLevel: number;
+  };
   getMonotonicTimestamp(): number;
   getOldestSnapshotTimestamp(): number;
   getStat(statName: string): number | StatsHistogramData;
@@ -2206,6 +2324,22 @@ declare class RocksDatabase extends DBI<DBITransactional> {
    * ```
    */
   get compression(): CompressionInfo;
+  /**
+   * The informational-log settings currently in effect for this database,
+   * read live from RocksDB, as `{ maxLogFileSize, infoLogLevel }`. These are
+   * database-wide settings (not per-column-family): `maxLogFileSize` bounds
+   * each retained `LOG` / `LOG.old.*` file's size (defaults to 16MB, so with
+   * RocksDB's `keep_log_file_num = 5` the total footprint is bounded at
+   * roughly 80MB); `infoLogLevel` is the logging verbosity. The database must
+   * be open.
+   *
+   * @example
+   * ```typescript
+   * const db = RocksDatabase.open('/path/to/db', { maxLogFileSize: 4 * 1024 * 1024 });
+   * db.logOptions; // { maxLogFileSize: 4194304, infoLogLevel: 1 }
+   * ```
+   */
+  get logOptions(): LogOptions;
   /**
    * Set global database settings.
    *
@@ -2594,5 +2728,5 @@ declare const versions: {
   "rocksdb-js": string;
 };
 //#endregion
-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 };
+export { type BackupInfo, type BackupOptions, type BackupStreamOptions, type CompressionAlgorithm, type CompressionInfo, type CompressionOption, DBI, DBIterator, type GetStatsMethod, type IteratorOptions, type Key, type LogOptions, 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

package/dist/index.mjs

@@ -1280,6 +1280,11 @@ var Store = class {
 	*/
 	compression;
 	/**
+	* Whether `compression` applies to every column family in the database rather than just this
+	* store's. See `RocksDatabaseOptions.compressionForAllColumnFamilies`.
+	*/
+	compressionForAllColumnFamilies = false;
+	/**
 	* Whether to disable the write ahead log.
 	*/
 	disableWAL;
@@ -1306,6 +1311,11 @@ var Store = class {
 	*/
 	freezeData;
 	/**
+	* Verbosity of RocksDB's informational logging (`info_log_level`). Omit to
+	* leave RocksDB's own default.
+	*/
+	infoLogLevel;
+	/**
 	* Reusable buffer for encoding keys.
 	*/
 	keyBuffer;
@@ -1318,6 +1328,16 @@ var Store = class {
 	*/
 	maxKeySize;
 	/**
+	* Per-file size cap (bytes) for informational log files (`LOG` /
+	* `LOG.old.*`). Bounds total informational-log footprint to roughly `5 *
+	* maxLogFileSize` (RocksDB retains up to 5 of these files). A value of `0`
+	* is RocksDB's "single unbounded log file" mode: it disables size-based
+	* rotation, so the log can grow without limit — set it only if you want that.
+	*
+	* @default 16777216 (16MB)
+	*/
+	maxLogFileSize;
+	/**
 	* 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
@@ -1336,13 +1356,26 @@ var Store = class {
 	/**
 	* The bytes of recent memtable history to retain in memory for transaction
 	* conflict checking. `-1` derives the value from
-	* `maxWriteBufferNumber * writeBufferSize`.
+	* `maxWriteBufferNumber * writeBufferSize`, except under a stalling
+	* `writeBufferManager`, where it derives `0`: retained history is charged to
+	* that manager and is only trimmable down to this target, so a target the
+	* budget cannot hold stalls writes permanently. Set a number to size it
+	* yourself against the budget and the column-family count.
 	*/
 	maxWriteBufferSizeToMaintain;
 	/**
 	* 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.
+	* sum of memtables reaches this size, RocksDB flushes the largest one.
+	* Defaults to `0`, which disables the global trigger so per-CF
+	* `writeBufferSize` drives flushing.
+	*
+	* Set this only if you know your column-family count: it is one budget split
+	* across all of them, so a value that suits a few families starves many. To
+	* bound total memtable memory instead, configure a WriteBufferManager.
+	*
+	* Database-wide, so it binds when the path is first opened in this process:
+	* a later open of the same path — including from another worker thread —
+	* keeps the first opener's value rather than overriding or rejecting it.
 	*/
 	dbWriteBufferSize;
 	/**
@@ -1438,6 +1471,7 @@ var Store = class {
 		const { keyEncoding, readKey, writeKey } = initKeyEncoder(options?.keyEncoding, options?.keyEncoder);
 		this.db = new NativeDatabase();
 		this.compression = options?.compression;
+		this.compressionForAllColumnFamilies = options?.compressionForAllColumnFamilies === true;
 		this.dbWriteBufferSize = options?.dbWriteBufferSize;
 		this.decoder = options?.decoder ?? null;
 		this.disableWAL = options?.disableWAL ?? false;
@@ -1446,9 +1480,11 @@ var Store = class {
 		this.encoder = options?.encoder ?? null;
 		this.encoding = options?.encoding ?? null;
 		this.freezeData = options?.freezeData ?? false;
+		this.infoLogLevel = options?.infoLogLevel;
 		this.keyBuffer = KEY_BUFFER;
 		this.keyEncoding = keyEncoding;
 		this.maxKeySize = options?.maxKeySize ?? MAX_KEY_SIZE;
+		this.maxLogFileSize = options?.maxLogFileSize;
 		this.maxOpenFiles = options?.maxOpenFiles;
 		this.maxWriteBufferNumber = options?.maxWriteBufferNumber;
 		this.maxWriteBufferSizeToMaintain = options?.maxWriteBufferSizeToMaintain;
@@ -1507,7 +1543,7 @@ var Store = class {
 			const end = this.encodeKey(options.end);
 			endBuffer = Buffer.from(end.subarray(end.start, end.end));
 		}
-		return new Promise((resolve, reject) => this.db.compact(resolve, reject, startBuffer, endBuffer));
+		return new Promise((resolve, reject) => this.db.compact(resolve, reject, startBuffer, endBuffer, options?.bottommost === true));
 	}
 	async backup(target, options) {
 		if (typeof target !== "string" && typeof target?.getWriter === "function") return backupToStream(this.db, target, options);
@@ -1535,7 +1571,7 @@ var Store = class {
 			const end = this.encodeKey(options.end);
 			endBuffer = Buffer.from(end.subarray(end.start, end.end));
 		}
-		this.db.compactSync(startBuffer, endBuffer);
+		this.db.compactSync(startBuffer, endBuffer, options?.bottommost === true);
 	}
 	/**
 	* Decodes a key from the database.
@@ -1752,9 +1788,12 @@ var Store = class {
 		this.db.open(this.path, {
 			compression,
 			compressionLevel,
+			compressionForAllColumnFamilies: this.compressionForAllColumnFamilies,
 			dbWriteBufferSize: this.dbWriteBufferSize,
 			disableWAL: this.disableWAL,
 			enableStats: this.enableStats,
+			infoLogLevel: this.infoLogLevel,
+			maxLogFileSize: this.maxLogFileSize,
 			maxOpenFiles: this.maxOpenFiles,
 			maxWriteBufferNumber: this.maxWriteBufferNumber,
 			maxWriteBufferSizeToMaintain: this.maxWriteBufferSizeToMaintain,
@@ -1934,7 +1973,7 @@ var Transaction = class extends DBI {
 		if (store.readOnly) {
 			super(store);
 			this.#txn = { id: 0 };
-			this.abort = this.commitSync = this.setTimestamp = () => {};
+			this.abandonWrites = this.abort = this.commitSync = this.setTimestamp = () => {};
 			this.commit = async () => {};
 			this.getTimestamp = () => 0;
 		} else {
@@ -1944,6 +1983,17 @@ var Transaction = class extends DBI {
 		}
 	}
 	/**
+	* Release the staged writes' verification-table write intents without
+	* closing the transaction, barring any later commit or write. For a
+	* transaction kept open only for its outstanding read iterators after the
+	* writes were replayed onto another transaction: otherwise other writers'
+	* coordinated-retry commits park on those intents until it is aborted.
+	* Reads keep working, including read-your-own-writes.
+	*/
+	abandonWrites() {
+		this.#txn.abandonWrites();
+	}
+	/**
 	* Abort the transaction.
 	*/
 	abort() {
@@ -2188,6 +2238,24 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		return this.store.db.getCompression();
 	}
 	/**
+	* The informational-log settings currently in effect for this database,
+	* read live from RocksDB, as `{ maxLogFileSize, infoLogLevel }`. These are
+	* database-wide settings (not per-column-family): `maxLogFileSize` bounds
+	* each retained `LOG` / `LOG.old.*` file's size (defaults to 16MB, so with
+	* RocksDB's `keep_log_file_num = 5` the total footprint is bounded at
+	* roughly 80MB); `infoLogLevel` is the logging verbosity. The database must
+	* be open.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/db', { maxLogFileSize: 4 * 1024 * 1024 });
+	* db.logOptions; // { maxLogFileSize: 4194304, infoLogLevel: 1 }
+	* ```
+	*/
+	get logOptions() {
+		return this.store.db.getLogOptions();
+	}
+	/**
 	* Set global database settings.
 	*
 	* @param options - The options for the database.
@@ -3017,7 +3085,7 @@ function loadLastPosition(transactionLog, readUncommitted) {
 //#region src/index.ts
 const versions = {
 	rocksdb: version,
-	"rocksdb-js": "2.6.1"
+	"rocksdb-js": "2.7.1"
 };
 
 //#endregion