@harperfast/rocksdb-js 2.5.0 → 2.6.1

package/dist/index.d.cts

@@ -256,10 +256,52 @@ type CompactOptions = {
   start?: Key;
   end?: Key;
 };
+/**
+ * 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, "mode" | "transactionLogRetentionMs"> {
+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;
@@ -307,9 +349,14 @@ type ArrayBufferWithNotify = ArrayBuffer & {
  * single database instance can be shared between the main `RocksDatabase`
  * instance and the `Transaction` instance.
  *
- * This store should not be shared between `RocksDatabase` instances.
+ * A store is bound to a single `RocksDatabase` instance and must not be shared
+ * between `RocksDatabase` instances. Each `RocksDatabase` claims its store on
+ * construction (see `claim()`); passing a store that another `RocksDatabase`
+ * already owns throws. (Sharing with the owning database's `Transaction`
+ * instances is expected and allowed.)
  */
 declare class Store {
+  #private;
   /**
    * The database instance.
    */
@@ -323,6 +370,11 @@ declare class Store {
    * Whether the decoder copies the buffer when encoding values.
    */
   decoderCopies: boolean;
+  /**
+   * 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.
    */
@@ -481,6 +533,13 @@ declare class Store {
    * Closes the database.
    */
   close(): void;
+  /**
+   * 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.
@@ -1684,6 +1743,18 @@ 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;
@@ -1752,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;
@@ -1868,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;
@@ -2108,6 +2192,20 @@ declare class RocksDatabase extends DBI<DBITransactional> {
    * Returns the list of column families in the RocksDB database.
    */
   get columns(): string[];
+  /**
+   * 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.
    *
@@ -2496,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 TransactionLogFileValidation, type TransactionLogPosition, type TransactionLogStats, type TransactionLogStoreValidation, type ValidateTransactionLogStoreOptions, backups, constants, coolTransactionLogs, currentThreadId, fileLockRelease, parseTransactionLog, registryStatus, shutdown, stats, 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 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

@@ -256,10 +256,52 @@ type CompactOptions = {
   start?: Key;
   end?: Key;
 };
+/**
+ * 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, "mode" | "transactionLogRetentionMs"> {
+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;
@@ -307,9 +349,14 @@ type ArrayBufferWithNotify = ArrayBuffer & {
  * single database instance can be shared between the main `RocksDatabase`
  * instance and the `Transaction` instance.
  *
- * This store should not be shared between `RocksDatabase` instances.
+ * A store is bound to a single `RocksDatabase` instance and must not be shared
+ * between `RocksDatabase` instances. Each `RocksDatabase` claims its store on
+ * construction (see `claim()`); passing a store that another `RocksDatabase`
+ * already owns throws. (Sharing with the owning database's `Transaction`
+ * instances is expected and allowed.)
  */
 declare class Store {
+  #private;
   /**
    * The database instance.
    */
@@ -323,6 +370,11 @@ declare class Store {
    * Whether the decoder copies the buffer when encoding values.
    */
   decoderCopies: boolean;
+  /**
+   * 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.
    */
@@ -481,6 +533,13 @@ declare class Store {
    * Closes the database.
    */
   close(): void;
+  /**
+   * 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.
@@ -1684,6 +1743,18 @@ 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;
@@ -1752,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;
@@ -1868,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;
@@ -2108,6 +2192,20 @@ declare class RocksDatabase extends DBI<DBITransactional> {
    * Returns the list of column families in the RocksDB database.
    */
   get columns(): string[];
+  /**
+   * 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.
    *
@@ -2496,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 TransactionLogFileValidation, type TransactionLogPosition, type TransactionLogStats, type TransactionLogStoreValidation, type ValidateTransactionLogStoreOptions, backups, constants, coolTransactionLogs, currentThreadId, fileLockRelease, parseTransactionLog, registryStatus, shutdown, stats, 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 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

@@ -62,6 +62,15 @@ const removeGlobalListener = binding.removeListener;
 const globalListenerCount = binding.listenerCount;
 const globalNotify = binding.notify;
 const constants = binding.constants;
+/**
+* The friendly names of every compression algorithm compiled into the loaded
+* RocksDB native binding, e.g. `['none', 'snappy', 'lz4', 'zstd']`. The set is
+* fixed for a given binary (it depends on which compression libraries RocksDB
+* was linked against), so this is a static list. `'none'` (no compression) is
+* always present. Use it to validate a `compression` option or to pick an
+* algorithm that is actually available at runtime.
+*/
+const supportedCompression = Object.freeze(binding.supportedCompression);
 const NativeDatabase = binding.Database;
 const NativeIterator = binding.Iterator;
 const NativeTransaction = binding.Transaction;
@@ -1203,13 +1212,55 @@ const ITERATOR_STATE = new Uint32Array(ITERATOR_STATE_BUFFER.buffer, ITERATOR_ST
 const MAX_KEY_SIZE = 1024 * 1024;
 const SAVE_BUFFER_SIZE = 8192;
 /**
+* Normalizes the public `compression` option into the primitive fields the
+* native layer expects. When `option` is omitted, or is an object without an
+* `algorithm`, returns an empty object and lets the native layer apply the
+* default (LZ4 when the build supports it, else RocksDB's own default).
+* Throws a `TypeError` for a malformed option and an
+* `Error` for an algorithm that isn't supported by this build.
+*/
+function normalizeCompression(option) {
+	if (option === void 0 || option === null) return {};
+	let algorithm;
+	let level;
+	if (typeof option === "string") algorithm = option;
+	else if (typeof option === "object" && !Array.isArray(option)) {
+		if (option.algorithm === void 0 || option.algorithm === null) {
+			if (option.level !== void 0 && option.level !== null) throw new TypeError("Compression level cannot be specified without an algorithm");
+			return {};
+		}
+		algorithm = option.algorithm;
+		if (option.level !== void 0 && option.level !== null) {
+			const raw = option.level;
+			const coerced = typeof raw === "number" ? raw : typeof raw === "string" && raw.trim() !== "" ? Number(raw) : NaN;
+			if (!Number.isInteger(coerced) || coerced < -2147483648 || coerced > 2147483647) throw new TypeError(`compression level must be a 32-bit integer, got ${JSON.stringify(option.level)}`);
+			level = coerced;
+		}
+	} else throw new TypeError("compression must be an algorithm name or an { algorithm, level } object");
+	if (!supportedCompression.includes(algorithm)) throw new Error(`Unsupported compression algorithm "${algorithm}". This build supports: ${supportedCompression.join(", ")}`);
+	return {
+		compression: algorithm,
+		compressionLevel: level
+	};
+}
+/**
 * A store wraps the `NativeDatabase` binding and database settings so that a
 * single database instance can be shared between the main `RocksDatabase`
 * instance and the `Transaction` instance.
 *
-* This store should not be shared between `RocksDatabase` instances.
+* A store is bound to a single `RocksDatabase` instance and must not be shared
+* between `RocksDatabase` instances. Each `RocksDatabase` claims its store on
+* construction (see `claim()`); passing a store that another `RocksDatabase`
+* already owns throws. (Sharing with the owning database's `Transaction`
+* instances is expected and allowed.)
 */
 var Store = class {
+	/**
+	* Whether a `RocksDatabase` has claimed this store. Durable across
+	* close/reopen (unlike the handle's open state), so a store reused after its
+	* owner temporarily closed is still recognized as in-use. See `claim()`.
+	*/
+	#claimed = false;
 	/**
 	* The database instance.
 	*/
@@ -1224,6 +1275,11 @@ var Store = class {
 	*/
 	decoderCopies = false;
 	/**
+	* The compression algorithm (or `{ algorithm, level }`) requested for this
+	* store's column family. Normalized and applied when the database opens.
+	*/
+	compression;
+	/**
 	* Whether to disable the write ahead log.
 	*/
 	disableWAL;
@@ -1381,6 +1437,7 @@ var Store = class {
 		if (options !== void 0 && options !== null && typeof options !== "object") throw new TypeError("Database options must be an object");
 		const { keyEncoding, readKey, writeKey } = initKeyEncoder(options?.keyEncoding, options?.keyEncoder);
 		this.db = new NativeDatabase();
+		this.compression = options?.compression;
 		this.dbWriteBufferSize = options?.dbWriteBufferSize;
 		this.decoder = options?.decoder ?? null;
 		this.disableWAL = options?.disableWAL ?? false;
@@ -1420,6 +1477,16 @@ var Store = class {
 		this.db.close();
 	}
 	/**
+	* Claims this store for a `RocksDatabase`. A store is bound to a single
+	* database instance, so claiming a store that another `RocksDatabase` has
+	* already claimed throws. The claim is durable across close/reopen, so a
+	* store reused after its owner temporarily closed still throws.
+	*/
+	claim() {
+		if (this.#claimed) throw new Error("Store is already in use by another RocksDatabase instance");
+		this.#claimed = true;
+	}
+	/**
 	* Compacts the entire key range of the database asynchronously.
 	* This triggers manual compaction which removes tombstones and reclaims space.
 	*
@@ -1681,7 +1748,10 @@ var Store = class {
 	*/
 	open() {
 		if (this.db.opened) return true;
+		const { compression, compressionLevel } = normalizeCompression(this.compression);
 		this.db.open(this.path, {
+			compression,
+			compressionLevel,
 			dbWriteBufferSize: this.dbWriteBufferSize,
 			disableWAL: this.disableWAL,
 			enableStats: this.enableStats,
@@ -1983,9 +2053,12 @@ var RocksDatabase = class RocksDatabase extends DBI {
 	*/
 	#name;
 	constructor(pathOrStore, options) {
-		if (typeof pathOrStore === "string") super(new Store(pathOrStore, options));
-		else if (pathOrStore instanceof Store) super(pathOrStore);
+		let store;
+		if (typeof pathOrStore === "string") store = new Store(pathOrStore, options);
+		else if (pathOrStore instanceof Store) store = pathOrStore;
 		else throw new TypeError("Invalid database path or store");
+		store.claim();
+		super(store);
 		this.#name = options?.name ?? "default";
 	}
 	/**
@@ -2099,6 +2172,22 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		return this.store.db.columns;
 	}
 	/**
+	* The compression currently in effect for this database's column family, read
+	* live from RocksDB, as `{ algorithm, level? }`. `algorithm` is a friendly
+	* name (e.g. `'lz4'`, `'zstd'`, `'none'`); `level` is present only when a
+	* non-default compression level is set. The database must be open. Defaults to
+	* LZ4 when the native build supports it.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/db', { compression: { algorithm: 'zstd', level: 3 } });
+	* db.compression; // { algorithm: 'zstd', level: 3 }
+	* ```
+	*/
+	get compression() {
+		return this.store.db.getCompression();
+	}
+	/**
 	* Set global database settings.
 	*
 	* @param options - The options for the database.
@@ -2928,9 +3017,9 @@ function loadLastPosition(transactionLog, readUncommitted) {
 //#region src/index.ts
 const versions = {
 	rocksdb: version,
-	"rocksdb-js": "2.5.0"
+	"rocksdb-js": "2.6.1"
 };
 
 //#endregion
-export { DBI, DBIterator, RocksDatabase, Store, Transaction, TransactionLog, backups, constants, coolTransactionLogs, currentThreadId, fileLockRelease, parseTransactionLog, registryStatus, shutdown, stats, tryFileLock, validateTransactionLogStore, versions };
+export { DBI, DBIterator, RocksDatabase, Store, Transaction, TransactionLog, backups, constants, coolTransactionLogs, currentThreadId, fileLockRelease, parseTransactionLog, registryStatus, shutdown, stats, supportedCompression, tryFileLock, validateTransactionLogStore, versions };
 //# sourceMappingURL=index.mjs.map