@harperfast/rocksdb-js 2.7.1 → 2.9.0

package/dist/index.mjs

@@ -55,7 +55,37 @@ function locateBinding() {
 	throw new Error("Unable to locate rocksdb-js native binding");
 }
 const binding = req(locateBinding());
+/**
+* The native `BackgroundError` constructor (a real `Error` subclass). Exported
+* as both a value — for `err instanceof BackgroundError` — and, via declaration
+* merging with the interface above, a type. Instances are produced by the
+* `'error'` event and `db.getLastError()`; consumers rarely construct their own.
+* The `details` param is required and typed to the instance fields so a bare
+* `new BackgroundError()` (which would omit `severity` / `writesDisabled` / …)
+* is a type error.
+*/
+const BackgroundError = binding.BackgroundError;
 const config = binding.config;
+/**
+* Reads the live state of the process-wide `WriteBufferManager`: its budget,
+* charged memory, mutable share, stall state, and attached column-family
+* inventory. The manager is shared by every database and worker thread in the
+* process.
+*
+* A WriteBufferManager stall does not pass through RocksDB's `WriteController`,
+* so it is not reflected by `rocksdb.stall.micros`, `db.isWriteStalled()`, or
+* the `'writeStall'` event. Use `stallActive` to distinguish this condition from
+* an idle database.
+*
+* @example
+* ```typescript
+* const wbm = getWriteBufferManagerStats();
+* if (wbm.stallActive) {
+* 	log.warn(`writes stalled for ${wbm.stallActiveMs}ms`);
+* }
+* ```
+*/
+const getWriteBufferManagerStats = binding.getWriteBufferManagerStats;
 const FRESH_VERSION_FLAG$1 = binding.constants.FRESH_VERSION_FLAG;
 const addGlobalListener = binding.addListener;
 const removeGlobalListener = binding.removeListener;
@@ -104,6 +134,8 @@ const transactionLogMapCount = binding.transactionLogMapCount;
 * disarm. Used by the ERR_TRY_AGAIN retry regression test.
 */
 const forceTryAgainForTesting = binding.forceTryAgainForTesting;
+/** Delays one selected watchdog join in the concurrent-shutdown regression test. */
+const setWriteBufferManagerJoinDelayForTesting = binding.setWriteBufferManagerJoinDelayForTesting;
 /**
 * Creates a native file lock using the specified file path (`flock` on POSIX,
 * `LockFileEx` on Windows), creating the file and any missing parent
@@ -446,6 +478,150 @@ const backups = {
 	}
 };
 
+//#endregion
+//#region src/count-estimator.ts
+/**
+* Below this many traversed entries the observed density is too noisy to
+* calibrate with, so `estimate()` returns the raw statistical estimate.
+*/
+const CALIBRATION_MIN_TRAVERSED = 16;
+const CALIBRATION_MIN_CONFIDENCE = .8;
+/**
+* Bounds on how far the observed-vs-estimated ratio may scale the remainder;
+* the statistical estimate can be arbitrarily wrong at data-block granularity
+* and an unclamped ratio would let one bad sample dominate.
+*/
+const CALIBRATION_MAX = 8;
+/**
+* Progressively refines a range key-count estimate as an iterator traverses
+* the range. The estimate starts as the pure statistical estimate
+* (`estimateCount`) and converges toward the exact count: the traversed
+* portion is exact, and the statistical estimate of the untraversed remainder
+* is calibrated by the observed ratio of actual-to-estimated entries over the
+* portion already traversed.
+*
+* The estimator never touches the iterator itself — the caller reports
+* progress with `advance(lastKey, count)` whenever it wants a checkpoint
+* (e.g. once per page), then reads `estimate()`. The caller owns the
+* progress contract: cursors must move monotonically through the range and
+* each entry must be reported once (a re-reported page inflates the count
+* undetectably). When traversal completes, call `finish()` so `estimate()`
+* returns the exact total instead of adding a block-granular remainder.
+*
+* Each `estimate()` checkpoint queries RocksDB statistics for the two range
+* segments (cost scales with the SSTs overlapping them, not with key count);
+* results are memoized per checkpoint, so repeated reads between `advance()`
+* calls are free.
+*/
+var CountEstimator = class {
+	#store;
+	#start;
+	#end;
+	#exclusiveStart;
+	#inclusiveEnd;
+	#reverse;
+	#cursor;
+	#traversed = 0;
+	#finished = false;
+	#memoized;
+	constructor(store, options) {
+		this.#store = store;
+		this.#reverse = options?.reverse ?? false;
+		this.#start = this.#reverse ? options?.end : options?.start;
+		this.#end = this.#reverse ? options?.start : options?.end;
+		this.#exclusiveStart = options?.exclusiveStart ?? this.#reverse;
+		this.#inclusiveEnd = options?.inclusiveEnd ?? this.#reverse;
+	}
+	/**
+	* The number of entries reported traversed so far.
+	*/
+	get traversed() {
+		return this.#traversed;
+	}
+	/**
+	* Records that iteration has advanced through `count` more entries, ending
+	* at `lastKey`. Pass `count: 0` when an empty page has no last key.
+	*/
+	advance(lastKey, count = 1) {
+		if (lastKey === void 0) {
+			if (count !== 0) throw new Error("CountEstimator.advance requires lastKey when count is nonzero");
+			return;
+		}
+		this.#cursor = lastKey;
+		this.#traversed += count;
+		this.#memoized = void 0;
+	}
+	/**
+	* Marks traversal of the range as complete: `estimate()` becomes the exact
+	* traversed count.
+	*/
+	finish() {
+		this.#finished = true;
+	}
+	/**
+	* Estimates the total number of entries in the full range: the exact
+	* traversed count plus a calibrated statistical estimate of the remainder.
+	* `confidence` is the exactness-weighted blend of the traversed portion
+	* (exact) and the remainder's statistical confidence, so it approaches 1
+	* as the exact portion grows (though a checkpoint can decrease when
+	* calibration makes a large correction), and is exactly 1 after `finish()`.
+	*/
+	estimate() {
+		if (this.#finished) return {
+			count: this.#traversed,
+			confidence: 1
+		};
+		if (this.#memoized !== void 0) return { ...this.#memoized };
+		if (this.#cursor === void 0) {
+			this.#memoized = this.#store.estimateCount({
+				start: this.#start,
+				end: this.#end,
+				exclusiveStart: this.#exclusiveStart,
+				inclusiveEnd: this.#inclusiveEnd
+			});
+			return { ...this.#memoized };
+		}
+		const traversedRange = this.#reverse ? {
+			start: this.#cursor,
+			end: this.#end,
+			inclusiveEnd: this.#inclusiveEnd
+		} : {
+			start: this.#start,
+			exclusiveStart: this.#exclusiveStart,
+			end: this.#cursor,
+			inclusiveEnd: true
+		};
+		const remainingRange = this.#reverse ? {
+			start: this.#start,
+			exclusiveStart: this.#exclusiveStart,
+			end: this.#cursor
+		} : {
+			start: this.#cursor,
+			exclusiveStart: true,
+			end: this.#end,
+			inclusiveEnd: this.#inclusiveEnd
+		};
+		const remainingEstimate = this.#store.estimateCount(remainingRange);
+		let remaining = remainingEstimate.count;
+		let calibrationConfidence = 1;
+		if (this.#traversed >= CALIBRATION_MIN_TRAVERSED) {
+			const traversedEstimate = this.#store.estimateCount(traversedRange);
+			if (traversedEstimate.count >= CALIBRATION_MIN_TRAVERSED && traversedEstimate.confidence >= CALIBRATION_MIN_CONFIDENCE) {
+				const calibration = Math.min(CALIBRATION_MAX, Math.max(1 / CALIBRATION_MAX, this.#traversed / traversedEstimate.count));
+				remaining *= calibration;
+				calibrationConfidence = Math.min(calibration, 1 / calibration);
+			}
+		}
+		const count = Math.round(this.#traversed + remaining);
+		const confidence = count > 0 ? Math.min(.999, (this.#traversed + calibrationConfidence * remainingEstimate.confidence * remaining) / count) : Math.min(.999, calibrationConfidence * remainingEstimate.confidence);
+		this.#memoized = {
+			count,
+			confidence
+		};
+		return { ...this.#memoized };
+	}
+};
+
 //#endregion
 //#region src/util.ts
 /**
@@ -488,14 +664,12 @@ function parseDuration(duration) {
 				num *= 1e3;
 				break;
 			case "m":
-				num *= 1e3 * 60;
+				num *= 6e4;
 				break;
 			case "h":
-				num *= 1e3 * 60 * 60;
-				break;
-			case "d":
-				num *= 1e3 * 60 * 60 * 24;
+				num *= 36e5;
 				break;
+			case "d": num *= 864e5;
 		}
 		result += num;
 	}
@@ -1198,10 +1372,10 @@ function createFixedBuffer(size) {
 
 //#endregion
 //#region src/store.ts
-const { ONLY_IF_IN_MEMORY_CACHE_FLAG, NOT_IN_MEMORY_CACHE_FLAG, ALWAYS_CREATE_NEW_BUFFER_FLAG, FRESH_VERSION_FLAG, POPULATE_VERSION_FLAG, ITERATOR_REVERSE_FLAG, ITERATOR_INCLUSIVE_END_FLAG, ITERATOR_EXCLUSIVE_START_FLAG, ITERATOR_INCLUDE_VALUES_FLAG, ITERATOR_NEEDS_STABLE_VALUE_BUFFER_FLAG, ITERATOR_CONTEXT_IS_TRANSACTION_FLAG } = constants;
+const { ONLY_IF_IN_MEMORY_CACHE_FLAG, NOT_IN_MEMORY_CACHE_FLAG, ALWAYS_CREATE_NEW_BUFFER_FLAG, FRESH_VERSION_FLAG, POPULATE_VERSION_FLAG, ITERATOR_REVERSE_FLAG, ITERATOR_INCLUSIVE_END_FLAG, ITERATOR_EXCLUSIVE_START_FLAG, ITERATOR_INCLUDE_VALUES_FLAG, ITERATOR_NEEDS_STABLE_VALUE_BUFFER_FLAG, ITERATOR_CONTEXT_IS_TRANSACTION_FLAG, ITERATOR_HAS_TRANSACTION_ID_FLAG } = constants;
 const KEY_BUFFER_SIZE = 4096;
 const KEY_BUFFER = createFixedBuffer(KEY_BUFFER_SIZE);
-const VALUE_BUFFER = createFixedBuffer(64 * 1024);
+const VALUE_BUFFER = createFixedBuffer(65536);
 /**
 * Backing buffer for the shared iterator state. Layout (Uint32Array view):
 *   [0] = key length written into KEY_BUFFER by the most recent iterator step
@@ -1209,7 +1383,7 @@ const VALUE_BUFFER = createFixedBuffer(64 * 1024);
 */
 const ITERATOR_STATE_BUFFER = Buffer.allocUnsafeSlow(8);
 const ITERATOR_STATE = new Uint32Array(ITERATOR_STATE_BUFFER.buffer, ITERATOR_STATE_BUFFER.byteOffset, 2);
-const MAX_KEY_SIZE = 1024 * 1024;
+const MAX_KEY_SIZE = 1048576;
 const SAVE_BUFFER_SIZE = 8192;
 /**
 * Normalizes the public `compression` option into the primitive fields the
@@ -1244,6 +1418,15 @@ function normalizeCompression(option) {
 	};
 }
 /**
+* Whether `codec` is a pre-constructed encoder/decoder instance that `open()`
+* would reuse as-is (rather than instantiate fresh from an `Encoder` factory).
+* Such an instance carries per-column-family mutable state (its `name`, msgpack
+* `structures`), so it cannot be shared across column families.
+*/
+function sharesMutableCodec(codec) {
+	return codec != null && typeof codec === "object" && typeof codec.Encoder !== "function" && (typeof codec.encode === "function" || typeof codec.decode === "function");
+}
+/**
 * 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.
@@ -1262,6 +1445,13 @@ var Store = class {
 	*/
 	#claimed = false;
 	/**
+	* Shallow snapshot of the options this store was constructed with, used by
+	* `createColumnFamilyStore()` to derive sibling column-family stores. Snapshot
+	* (not the caller's object) so later mutations of the caller's options don't
+	* leak into derived views.
+	*/
+	#columnFamilyOptions;
+	/**
 	* The database instance.
 	*/
 	db;
@@ -1397,6 +1587,11 @@ var Store = class {
 	*/
 	path;
 	/**
+	* The open database's resolved filesystem identity, read once from
+	* `NativeDatabase.identityPath`. `undefined` until opened.
+	*/
+	identityPath;
+	/**
 	* 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.
@@ -1404,10 +1599,19 @@ var Store = class {
 	pessimistic;
 	/**
 	* Whether the database is open in readonly mode. When `true`, write
-	* operations will throw an error with code `ERR_DATABASE_READONLY`.
+	* operations will throw an error with code `ERR_DATABASE_READONLY`, except
+	* for `flush()`/`flushSync()`/`compact()`/`compactSync()`, which succeed as
+	* no-ops.
 	*/
 	readOnly;
 	/**
+	* The secondary instance's workspace directory when the database is opened
+	* as a secondary (see `RocksDatabaseOptions.secondaryPath`); `undefined`
+	* otherwise. A secondary is read-only, so `readOnly` is `true` whenever
+	* this is set.
+	*/
+	secondaryPath;
+	/**
 	* Encoder specific flag used to signal that the encoder should use a random
 	* access structure.
 	*/
@@ -1431,8 +1635,8 @@ var Store = class {
 	*/
 	transactionLogMaxAgeThreshold;
 	/**
-	* The maximum size of a transaction log before it is rotated to the next
-	* sequence number.
+	* The target maximum size of a transaction log before rotation. Transactions
+	* are never split across files, so one transaction may exceed this target.
 	*/
 	transactionLogMaxSize;
 	/**
@@ -1493,7 +1697,10 @@ var Store = class {
 		this.parallelismThreads = options?.parallelismThreads;
 		this.path = path;
 		this.pessimistic = options?.pessimistic ?? false;
-		this.readOnly = options?.readOnly ?? false;
+		const secondaryPath = options?.secondaryPath ?? void 0;
+		if (secondaryPath !== void 0 && options?.readOnly === false) throw new Error("A secondary open is read-only; secondaryPath cannot be combined with readOnly: false");
+		this.readOnly = options?.readOnly ?? secondaryPath !== void 0;
+		this.secondaryPath = secondaryPath;
 		this.randomAccessStructure = options?.randomAccessStructure ?? false;
 		this.readKey = readKey;
 		this.sharedStructuresKey = options?.sharedStructuresKey;
@@ -1505,6 +1712,36 @@ var Store = class {
 		this.verificationTable = options?.verificationTable;
 		this.writeBufferSize = options?.writeBufferSize;
 		this.writeKey = writeKey;
+		this.#columnFamilyOptions = options ? { ...options } : void 0;
+	}
+	/**
+	* Creates an independent `Store` for another column family of the same
+	* database, used by {@link RocksDatabase#use}. The returned store shares the
+	* underlying database but must have its own codec state: a mutable
+	* encoder/decoder instance cannot be shared across column families (opening a
+	* view mutates the encoder's `name`, and clearing a view resets its
+	* `structures`), so a pre-constructed instance is rejected here — supply an
+	* encoder factory (`{ Encoder }`) or a named `encoding` instead.
+	*
+	* Override this in a `Store` subclass whose constructor cannot be recreated
+	* from `(path, options)` (e.g. it takes injected dependencies) or that needs
+	* to control how a view's codec state is built.
+	*
+	* @param name - The column family name for the derived store.
+	* @param options - Options overriding this store's, for the derived store.
+	* @returns A new, independent `Store` bound to `name`.
+	*/
+	createColumnFamilyStore(name, options) {
+		const derived = {
+			...this.#columnFamilyOptions,
+			...options,
+			name
+		};
+		if (sharesMutableCodec(derived.encoder) || sharesMutableCodec(derived.decoder)) throw new Error("Cannot derive a column family view from a Store configured with a pre-constructed encoder/decoder instance — its mutable state would be shared across column families. Provide an encoder factory (`{ Encoder }`) or a named `encoding`, or override `Store#createColumnFamilyStore`.");
+		const StoreClass = this.constructor;
+		const store = new StoreClass(this.path, derived);
+		if (store.name !== name) throw new Error(`Store#createColumnFamilyStore produced a store bound to "${store.name}" instead of "${name}"; a custom Store must forward options to super() or override this method.`);
+		return store;
 	}
 	/**
 	* Closes the database.
@@ -1641,6 +1878,24 @@ var Store = class {
 		}
 		return result;
 	}
+	/**
+	* Estimates the number of keys in a range from RocksDB statistics
+	* (memtable stats + approximate SST sizes with range-local entry density)
+	* without iterating. Estimates always reflect committed state, so there is
+	* no transactional variant.
+	*/
+	estimateCount(options) {
+		let startBuffer;
+		let endBuffer;
+		const reverse = options?.reverse ?? false;
+		const start = reverse ? options?.end : options?.start;
+		const end = reverse ? options?.start : options?.end;
+		const exclusiveStart = options?.exclusiveStart ?? reverse;
+		const inclusiveEnd = options?.inclusiveEnd ?? reverse;
+		if (start !== void 0) startBuffer = copyEncodedKey(this.encodeKey(start), exclusiveStart);
+		if (end !== void 0) endBuffer = copyEncodedKey(this.encodeKey(end), inclusiveEnd);
+		return this.db.estimateCount(startBuffer, endBuffer);
+	}
 	getCount(context, options) {
 		options = { ...options };
 		if (options?.start !== void 0) {
@@ -1668,6 +1923,7 @@ var Store = class {
 		let endUnencoded = options?.key ?? options?.end;
 		const includeValues = options?.values ?? true;
 		const reverse = options?.reverse ?? false;
+		const txnId = this.getTxnId(options);
 		let exclusiveStart = options?.exclusiveStart ?? false;
 		let inclusiveEnd = options?.inclusiveEnd ?? false;
 		if (options?.key !== void 0) inclusiveEnd = true;
@@ -1686,13 +1942,15 @@ var Store = class {
 			startKeyEnd = this.writeKey(startUnencoded, keyBuffer, 0);
 			if (startKeyEnd === 0) throw new Error("Zero length key is not allowed");
 		}
-		if (endUnencoded !== void 0) if (endUnencoded === startUnencoded) {
-			endKeyStart = 0;
-			endKeyEnd = startKeyEnd;
-		} else {
-			endKeyStart = startKeyEnd;
-			endKeyEnd = this.writeKey(endUnencoded, keyBuffer, endKeyStart);
-			if (endKeyEnd === endKeyStart) throw new Error("Zero length key is not allowed");
+		if (endUnencoded !== void 0) {
+			if (endUnencoded === startUnencoded) {
+				endKeyStart = 0;
+				endKeyEnd = startKeyEnd;
+			} else {
+				endKeyStart = startKeyEnd;
+				endKeyEnd = this.writeKey(endUnencoded, keyBuffer, endKeyStart);
+				if (endKeyEnd === endKeyStart) throw new Error("Zero length key is not allowed");
+			}
 		}
 		let flags = 0;
 		if (reverse) flags |= ITERATOR_REVERSE_FLAG;
@@ -1701,8 +1959,9 @@ var Store = class {
 		if (includeValues) flags |= ITERATOR_INCLUDE_VALUES_FLAG;
 		if (includeValues && !this.decoderCopies) flags |= ITERATOR_NEEDS_STABLE_VALUE_BUFFER_FLAG;
 		if (context !== this.db) flags |= ITERATOR_CONTEXT_IS_TRANSACTION_FLAG;
+		if (txnId !== void 0) flags |= ITERATOR_HAS_TRANSACTION_ID_FLAG;
 		const advancedOptions = options !== void 0 && (options.adaptiveReadahead !== void 0 || options.asyncIO !== void 0 || options.autoReadaheadSize !== void 0 || options.backgroundPurgeOnIteratorCleanup !== void 0 || options.fillCache !== void 0 || options.readaheadSize !== void 0 || options.tailing !== void 0) ? options : void 0;
-		return new ExtendedIterable(new DBIterator(new NativeIterator(context, flags, startKeyEnd, endKeyStart, endKeyEnd, advancedOptions), this, includeValues, options?.limit));
+		return new ExtendedIterable(new DBIterator(new NativeIterator(context, flags, startKeyEnd, endKeyStart, endKeyEnd, advancedOptions, txnId), this, includeValues, options?.limit));
 	}
 	getSync(context, key, alwaysCreateNewBuffer = false, options) {
 		const keyParam = getKeyParam(this.encodeKey(key));
@@ -1723,9 +1982,12 @@ var Store = class {
 	*/
 	getTxnId(options) {
 		let txnId;
-		if (!this.readOnly && options?.transaction) {
-			txnId = options.transaction.id;
+		const transaction = options?.transaction;
+		if (!this.readOnly && transaction) {
+			txnId = transaction.id;
 			if (txnId === void 0) throw new TypeError("Invalid transaction");
+			if (transaction.store === void 0) throw new TypeError("Invalid transaction");
+			if (this.identityPath !== void 0 && transaction.store.identityPath !== this.identityPath) throw new TypeError("Transaction belongs to a different database");
 		}
 		return txnId;
 	}
@@ -1783,7 +2045,10 @@ var Store = class {
 	* are performed.
 	*/
 	open() {
-		if (this.db.opened) return true;
+		if (this.db.opened) {
+			this.identityPath = this.db.identityPath;
+			return true;
+		}
 		const { compression, compressionLevel } = normalizeCompression(this.compression);
 		this.db.open(this.path, {
 			compression,
@@ -1802,6 +2067,7 @@ var Store = class {
 			noBlockCache: this.noBlockCache,
 			parallelismThreads: this.parallelismThreads,
 			readOnly: this.readOnly,
+			secondaryPath: this.secondaryPath,
 			statsLevel: this.statsLevel,
 			transactionLogMaxAgeThreshold: this.transactionLogMaxAgeThreshold,
 			transactionLogMaxSize: this.transactionLogMaxSize,
@@ -1810,6 +2076,7 @@ var Store = class {
 			verificationTable: this.verificationTable,
 			writeBufferSize: this.writeBufferSize
 		});
+		this.identityPath = this.db.identityPath;
 		return false;
 	}
 	putSync(context, key, value, options) {
@@ -1854,7 +2121,7 @@ var Store = class {
 	useLog(context, name) {
 		if (typeof name !== "string" && typeof name !== "number") throw new TypeError("Log name must be a string or number");
 		if (typeof name === "string" && /[\t\n\r\\/]/.test(name)) throw new Error(`Invalid transaction log name "${name}"`);
-		return context.useLog(String(name));
+		return context.useLog(String(name), this.db);
 	}
 	/**
 	* Checks the process-global verification table for a fresh version match
@@ -1888,6 +2155,18 @@ var Store = class {
 	}
 };
 /**
+* Copies an encoded key out of the shared key buffer (which the next
+* `encodeKey` call would clobber), optionally appending a zero byte to
+* produce the key's bytewise successor.
+*/
+function copyEncodedKey(encoded, appendSuccessorByte) {
+	const length = encoded.end - encoded.start;
+	const copy = Buffer.allocUnsafe(length + (appendSuccessorByte ? 1 : 0));
+	copy.set(encoded.subarray(encoded.start, encoded.end));
+	if (appendSuccessorByte) copy[length] = 0;
+	return copy;
+}
+/**
 * Ensure that they key has been copied into our shared buffer, and return the ending position
 * @param keyBuffer
 */
@@ -2058,10 +2337,12 @@ var Transaction = class extends DBI {
 		return err;
 	}
 	/**
-	* Returns the transaction start timestamp in seconds. Defaults to the time at which
-	* the transaction was created.
+	* Returns the transaction timestamp in milliseconds since the Unix epoch. It
+	* defaults to a process-wide monotonic value assigned when the transaction
+	* was created. A producer may use this value as its write identity; the
+	* transaction log uses it as the batch key.
 	*
-	* @returns The transaction start timestamp in seconds.
+	* @returns The transaction timestamp in milliseconds.
 	*/
 	getTimestamp() {
 		return this.#txn.getTimestamp();
@@ -2073,9 +2354,14 @@ var Transaction = class extends DBI {
 		return this.#txn.id;
 	}
 	/**
-	* Set the transaction start timestamp in seconds.
+	* Overrides the transaction timestamp in milliseconds since the Unix epoch.
+	* Call this before reading the timestamp or staging writes when adopting an
+	* origin timestamp for replication or replay. Once a write or log entry is
+	* staged, the timestamp is frozen, but reapplying the same timestamp remains
+	* idempotent while the transaction is pending. The value must be finite,
+	* positive, and below 8640000000000000.
 	*
-	* @param timestamp - The timestamp to set in seconds.
+	* @param timestamp - The timestamp to set in milliseconds.
 	*/
 	setTimestamp(timestamp) {
 		this.#txn.setTimestamp(timestamp);
@@ -2084,6 +2370,16 @@ var Transaction = class extends DBI {
 
 //#endregion
 //#region src/database.ts
+const BACKGROUND_ERROR_SEVERITY_NAMES = [
+	"none",
+	"soft",
+	"hard",
+	"fatal",
+	"unrecoverable"
+];
+function backgroundErrorSeverityName(severity) {
+	return BACKGROUND_ERROR_SEVERITY_NAMES[severity] ?? "unknown";
+}
 /**
 * The main class for interacting with a RocksDB database.
 *
@@ -2099,9 +2395,23 @@ var Transaction = class extends DBI {
 */
 var RocksDatabase = class RocksDatabase extends DBI {
 	/**
-	* The name of the database.
+	* The name of the database's column family.
 	*/
 	#name;
+	/**
+	* Weak cache of column-family views opened via `use()`, keyed by column
+	* family name — mirroring `useLog`'s get-or-create semantics. The reference
+	* is weak so a view is never pinned for this database's lifetime: an
+	* unreferenced view can be collected (closing its own `DBHandle`), and the
+	* next `use()` transparently recreates it. `#columnFamilyRegistry` deletes an
+	* entry once its view is collected so a churn of distinct names (e.g.
+	* `use(uuid())`) does not grow the map without bound.
+	*/
+	#columnFamilies = /* @__PURE__ */ new Map();
+	#columnFamilyRegistry = new FinalizationRegistry((name) => {
+		const ref = this.#columnFamilies.get(name);
+		if (ref !== void 0 && ref.deref() === void 0) this.#columnFamilies.delete(name);
+	});
 	constructor(pathOrStore, options) {
 		let store;
 		if (typeof pathOrStore === "string") store = new Store(pathOrStore, options);
@@ -2109,7 +2419,7 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		else throw new TypeError("Invalid database path or store");
 		store.claim();
 		super(store);
-		this.#name = options?.name ?? "default";
+		this.#name = this.store.name;
 	}
 	/**
 	* Removes all data from the database asynchronously.
@@ -2155,6 +2465,9 @@ var RocksDatabase = class RocksDatabase extends DBI {
 	* Compacts the entire key range of the database asynchronously.
 	* This triggers manual compaction which removes tombstones and reclaims space.
 	*
+	* On a read-only database this is a no-op: arguments are still validated, but
+	* the returned promise resolves without compacting rather than rejecting.
+	*
 	* @example
 	* ```typescript
 	* const db = RocksDatabase.open('/path/to/database');
@@ -2206,6 +2519,9 @@ var RocksDatabase = class RocksDatabase extends DBI {
 	* Compacts the entire key range of the database synchronously.
 	* This triggers manual compaction which removes tombstones and reclaims space.
 	*
+	* On a read-only database this validates its arguments and then returns
+	* without compacting, rather than throwing.
+	*
 	* @example
 	* ```typescript
 	* const db = RocksDatabase.open('/path/to/database');
@@ -2322,6 +2638,40 @@ var RocksDatabase = class RocksDatabase extends DBI {
 	static notify(event, ...args) {
 		return globalNotify(event, args);
 	}
+	/**
+	* Advances a secondary instance to the primary's current state by tailing
+	* and replaying the primary's MANIFEST and WAL. A secondary does not see
+	* the primary's writes until this (or {@link catchUpWithPrimarySync}) is
+	* called. Concurrent reads through this handle remain safe while the
+	* catch-up runs.
+	*
+	* Only valid on a database opened with the `secondaryPath` option; throws
+	* with code `ERR_NOT_SECONDARY` otherwise.
+	*
+	* Advances the **database** view only. Against a cross-process primary,
+	* transaction-log reads keep serving the stores discovered at open (a store
+	* the primary creates later, and its appends, need a reopen); a primary in
+	* the same process shares the store registry, so its stores and appends are
+	* visible immediately. Either way a log entry can describe data this
+	* handle's database view does not have yet — the log write completes before
+	* the RocksDB commit for every writer, so consumers must tolerate the log
+	* leading the database.
+	*
+	* Await one call before starting the next: the replay holds a libuv worker
+	* for its whole duration and concurrent calls queue on a per-database mutex
+	* while holding theirs, so overlapping catch-ups on a backlogged follower
+	* can exhaust the default four-thread pool and stall unrelated I/O.
+	*/
+	catchUpWithPrimary() {
+		return new Promise((resolve, reject) => this.store.db.catchUpWithPrimary(resolve, reject));
+	}
+	/**
+	* Synchronous version of {@link catchUpWithPrimary}. The replay runs on the
+	* JS thread, so prefer the async form unless the caller is already blocking.
+	*/
+	catchUpWithPrimarySync() {
+		this.store.db.catchUpWithPrimarySync();
+	}
 	destroy() {
 		this.store.db.destroy();
 	}
@@ -2339,18 +2689,107 @@ var RocksDatabase = class RocksDatabase extends DBI {
 	/**
 	* Flushes the underlying database by performing a commit or clearing any buffered operations.
 	*
+	* On a read-only database this is a no-op: the options bag is still validated, but the
+	* returned promise resolves without flushing rather than rejecting.
+	*
+	* @param options - Flush options; see {@link FlushOptions.allowWriteStall} before relying on
+	* this resolving promptly under write pressure.
 	* @return {void} Does not return a value.
 	*/
-	flush() {
-		return new Promise((resolve, reject) => this.store.db.flush(resolve, reject));
+	flush(options) {
+		return new Promise((resolve, reject) => this.store.db.flush(resolve, reject, options));
 	}
 	/**
 	* Synchronously flushes the underlying database by performing a commit or clearing any buffered operations.
 	*
+	* The default `allowWriteStall: false` wait is taken on the JS thread here, so it freezes the
+	* event loop rather than parking a libuv worker — a larger blast radius than {@link flush}, not
+	* a smaller one.
+	*
+	* On a read-only database this validates its options and then returns without flushing, rather
+	* than throwing.
+	*
+	* @param options - Flush options; see {@link FlushOptions.allowWriteStall}.
 	* @return {void} Does not return a value.
 	*/
-	flushSync() {
-		return this.store.db.flushSync();
+	flushSync(options) {
+		return this.store.db.flushSync(options);
+	}
+	/**
+	* Returns the most recent {@link BackgroundError} observed on this database, or
+	* `null` when none has occurred. The `'error'` event is the push counterpart;
+	* this is the pull equivalent for on-demand checks (e.g. a health probe) and
+	* for catching an error that fired after open but before a listener was
+	* attached. (A background error that occurs *during* the initial open is a
+	* narrow startup window not yet captured, addressed separately.)
+	*
+	* Purely historical — it is not cleared by a successful {@link RocksDatabase.resume}.
+	* When the returned error's `writesDisabled` is `true`, writes are stopped
+	* until recovery.
+	*
+	* @example
+	* ```typescript
+	* const err = db.getLastError();
+	* if (err?.writesDisabled) {
+	*   // ...free disk space...
+	*   db.resume();
+	* }
+	* ```
+	*/
+	getLastError() {
+		return this.store.db.getLastError();
+	}
+	/**
+	* Sets or clears the last background error, mirroring the Win32
+	* `SetLastError`/`GetLastError` pair. Pass `null` (or no argument) to **reset**
+	* it — {@link RocksDatabase.getLastError} then returns `null` and no event
+	* fires; this is the intended way to clear the error after handling or
+	* recovering it (e.g. after {@link RocksDatabase.resume}). Pass an object to
+	* set it: it is stored and the `'error'` event fires with the reconstructed
+	* {@link BackgroundError}. `type` defaults to `'background'`.
+	*
+	* @example
+	* ```typescript
+	* db.resume();
+	* db.setLastError(null); // recovered — clear the historical error
+	* ```
+	*/
+	setLastError(error) {
+		if (error == null) return this.store.db.setLastError(null);
+		const severity = error.severity ?? 0;
+		return this.store.db.setLastError({
+			...error,
+			type: error.type ?? "background",
+			severity,
+			severityName: error.severityName ?? backgroundErrorSeverityName(severity),
+			writesDisabled: error.writesDisabled ?? severity >= 2
+		});
+	}
+	/**
+	* Attempts to recover the database from a background error by calling
+	* RocksDB's `DB::Resume()`. When a write fails at the filesystem level (e.g. a
+	* full disk), RocksDB stops accepting writes and this database emits an
+	* {@link BackgroundError} via the `'error'` event. Call `resume()` after the
+	* underlying condition has cleared — e.g. once disk space has been freed. On
+	* success writes are accepted again; on failure (the condition has not
+	* actually cleared) it throws and the database stays read-only. A no-op on a
+	* healthy database.
+	*
+	* Runs synchronously and may briefly block, since recovery can re-flush
+	* memtables.
+	*
+	* @example
+	* ```typescript
+	* db.on('error', (err) => {
+	*   if (err.writesDisabled) {
+	*     // ...free disk space...
+	*     db.resume();
+	*   }
+	* });
+	* ```
+	*/
+	resume() {
+		return this.store.db.resume();
 	}
 	/**
 	* Gets a RocksDB database property as an integer.
@@ -2385,7 +2824,32 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		return this.store.db.getDBProperty(propertyName);
 	}
 	/**
-	* Retrieves the estimated number of keys in the database.
+	* Whether RocksDB is currently applying write backpressure to this database —
+	* either delaying (rate-limiting) or fully stopping writes. This is the
+	* authoritative, live pull counterpart to the `'writeStall'`
+	* [event](../README.md#event-writestall): the event pushes per-column-family
+	* transitions (and is rate-limited), while this reads the current state on
+	* demand and can never be stale.
+	*
+	* The write controller is database-wide (shared across every column family),
+	* so this reflects the database as a whole, not a single column family — a
+	* stall triggered by any column family stops writes for all of them. Reads
+	* `rocksdb.is-write-stopped` and `rocksdb.actual-delayed-write-rate`.
+	*
+	* @example
+	* ```typescript
+	* db.on('writeStall', (cf) => {
+	* 	if (db.isWriteStalled()) log.warn(`writes throttled/blocked (triggered by ${cf})`);
+	* });
+	* ```
+	*/
+	isWriteStalled() {
+		return this.getDBIntProperty("rocksdb.is-write-stopped") === 1 || (this.getDBIntProperty("rocksdb.actual-delayed-write-rate") ?? 0) > 0;
+	}
+	/**
+	* Retrieves the estimated number of keys in the database. This is an alias
+	* for `db.estimateCount().count`; use `estimateCount()` for range support
+	* and a confidence indicator.
 	*
 	* @example
 	* ```typescript
@@ -2398,6 +2862,58 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		return this.getDBIntProperty("rocksdb.estimate-num-keys") ?? 0;
 	}
 	/**
+	* Estimates the number of keys in the database, or within a key range,
+	* returning `{ count, confidence }`. Unlike `getKeysCount()`, this never
+	* iterates: the estimate is derived from RocksDB statistics (memtable
+	* stats plus approximate SST sizes converted through the entry density of
+	* the SSTs overlapping the range), so its cost scales with the number of
+	* SSTs overlapping the range rather than the number of keys — though
+	* reading table properties for cold files can do I/O through the table
+	* cache, and a start-only range does the work of its complement below
+	* `start`. Accuracy improves with range size. Resolution is bounded by SST
+	* data-block granularity, so tiny ranges may over-report or report zero for
+	* present keys; low `confidence` is the signal. Recently deleted or
+	* overwritten entries may be counted until compaction. An inverted range
+	* (`start` >= `end`) returns `{ count: 0, confidence: 1 }`.
+	*
+	* `confidence` is a heuristic 0–1 trust indicator (1 only when exact) —
+	* see `CountEstimate`. Estimates always reflect committed state; writes
+	* pending in a transaction are not included.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* const { count, confidence } = db.estimateCount({ start: 'a', end: 'z' });
+	* ```
+	*/
+	estimateCount(options) {
+		return this.store.estimateCount(options);
+	}
+	/**
+	* Creates a `CountEstimator` for progressively refining a range count
+	* estimate while iterating the range: report progress with
+	* `advance(lastKey, count)` (e.g. once per page of results) and
+	* `estimate()` returns the exact traversed count plus a calibrated
+	* estimate of the remainder, converging toward the exact total. Call
+	* `finish()` when traversal completes to make `estimate()` exact.
+	*
+	* @example
+	* ```typescript
+	* const estimator = db.createCountEstimator({ start: 'a', end: 'z' });
+	* let lastKey;
+	* let pageSize = 0;
+	* for (const { key } of db.getRange({ start: 'a', end: 'z', limit: 25 })) {
+	*   lastKey = key;
+	*   pageSize++;
+	* }
+	* estimator.advance(lastKey, pageSize);
+	* const { count, confidence } = estimator.estimate();
+	* ```
+	*/
+	createCountEstimator(options) {
+		return new CountEstimator(this.store, options);
+	}
+	/**
 	* Returns the current timestamp as a monotonically increasing timestamp in
 	* milliseconds represented as a decimal number.
 	*
@@ -2508,18 +3024,29 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		return this.store.listLogs();
 	}
 	/**
-	* The name of the database.
+	* The name of the database's column family.
 	*/
 	get name() {
 		return this.#name;
 	}
 	/**
-	* Whether the database is open in readonly mode.
+	* Whether the database is open in readonly mode. Also `true` for a
+	* secondary instance (see {@link secondaryPath}), which is read-only by
+	* construction.
 	*/
 	get readOnly() {
 		return this.store.readOnly;
 	}
 	/**
+	* The secondary instance's workspace directory when the database was opened
+	* as a secondary (a read-only follower of a live primary — see the
+	* `secondaryPath` open option), or `undefined` for a regular or plain
+	* read-only open.
+	*/
+	get secondaryPath() {
+		return this.store.secondaryPath;
+	}
+	/**
 	* Sugar method for opening a database.
 	*
 	* @param pathOrStore - The filesystem path to the database or a custom store.
@@ -2792,6 +3319,57 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		return this.store.unlock(key);
 	}
 	/**
+	* Returns a `RocksDatabase` bound to the `name` column family of this same
+	* database, opening (and creating, if missing) the column family on first
+	* use. This is a factory — create-and-open sugar — not a stateful switch: the
+	* returned view is an independent instance whose own reads/writes target its
+	* column family, while sharing the underlying database (so a transaction,
+	* backup, or checkpoint still spans every column family). Because the view
+	* opens its own handle, this database need not itself be open — a discarded
+	* parent (`new RocksDatabase(path).use('events')`) still yields a valid,
+	* opened view.
+	*
+	* Get-or-create, backed by a weak cache: `db.use('events') === db.use('events')`
+	* while the view is still referenced **and open**, and calling with this
+	* database's own column-family name returns `this`. A view that has been
+	* closed (or garbage-collected — the cache does not pin it) is transparently
+	* recreated on the next `use()`. Views are independent handles: closing this
+	* database does not close them, and vice versa — the underlying database
+	* stays open until every handle is closed or collected.
+	*
+	* The view's store is derived by {@link Store#createColumnFamilyStore}, which
+	* builds an independent store of the same class with its own codec state (so
+	* views never share a mutable encoder/decoder) and inherits the options this
+	* store was constructed with; pass `options` to override them for this column
+	* family. A database configured with a pre-constructed encoder/decoder
+	* instance cannot derive views (its state would be shared) — use an encoder
+	* factory (`{ Encoder }`) or a named `encoding`, or override
+	* `createColumnFamilyStore` on a custom `Store`.
+	*
+	* @param name - The column family name.
+	* @param options - Options for the column family, overriding inherited ones.
+	* @returns A `RocksDatabase` bound to the column family.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* const events = db.use('events');
+	* await events.put('e1', payload);
+	* await db.put('k', 'v'); // default column family, unaffected
+	* ```
+	*/
+	use(name, options) {
+		if (typeof name !== "string" || name === "") throw new TypeError("Column family name must be a non-empty string");
+		if (name === this.#name) return this.open();
+		const cached = this.#columnFamilies.get(name)?.deref();
+		if (cached !== void 0 && cached.isOpen()) return cached;
+		const columnFamily = new RocksDatabase(this.store.createColumnFamilyStore(name, options));
+		columnFamily.open();
+		this.#columnFamilies.set(name, new WeakRef(columnFamily));
+		this.#columnFamilyRegistry.register(columnFamily, name);
+		return columnFamily;
+	}
+	/**
 	* Excecutes a function using a thread-safe lock to ensure mutual
 	* exclusion.
 	*
@@ -2903,6 +3481,98 @@ const FLOAT_TO_UINT32 = /* @__PURE__ */ new Float64Array(1);
 const UINT32_FROM_FLOAT = new Uint32Array(FLOAT_TO_UINT32.buffer);
 const { TRANSACTION_LOG_FILE_HEADER_SIZE, TRANSACTION_LOG_ENTRY_HEADER_SIZE } = constants;
 /**
+* Number of consecutive well-formed frames that, on their own, signal that real log data has
+* resumed after a framing break. Kept in step with `RESYNC_MIN_FRAMES` in
+* `src/binding/transaction_log/transaction_log_recovery.cpp`, which uses the same heuristic to
+* classify a break as mid-file corruption (valid entries follow) rather than a torn tail.
+*/
+const RESYNC_MIN_FRAMES = 8;
+/**
+* Thrown when an entry's framing is broken. `resyncPosition` is the offset where valid framing
+* resumes, when one was found: the frames after a mid-log break are intact and reachable, and
+* only the broken span between `position` and `resyncPosition` is unreadable. It is `undefined`
+* for a torn tail, where nothing follows the break.
+*
+* The iterator is left positioned at `resyncPosition` (or at end-of-log when there is none), so a
+* caller that chooses to recover the entries past the break calls `next()` again.
+*/
+var CorruptFrameError = class extends RangeError {
+	/** Sequence number of the log file the break is in. */
+	logId;
+	/** Offset of the broken frame. */
+	position;
+	/** Offset where valid framing resumes, or `undefined` when nothing valid follows. */
+	resyncPosition;
+	/** Bytes between the break and the resume point that cannot be read. */
+	unreadableBytes;
+	constructor(message, logId, position, resyncPosition) {
+		super(resyncPosition === void 0 ? message : `${message}; valid framing resumes at ${resyncPosition.toString(16)}, ${resyncPosition - position} byte(s) unreadable`);
+		this.name = "CorruptFrameError";
+		this.logId = logId;
+		this.position = position;
+		this.resyncPosition = resyncPosition;
+		this.unreadableBytes = resyncPosition === void 0 ? 0 : resyncPosition - position;
+	}
+};
+/**
+* Whether a complete, in-bounds frame begins at `pos`. The only sane bound on an entry's length is
+* the written extent: a single entry can legitimately exceed the rotation threshold (the first
+* entry written to a fresh file is always written in full). A zero timestamp is the
+* end-of-entries marker, not a frame.
+*/
+function frameFits(dataView, pos, dataEnd) {
+	if (pos + TRANSACTION_LOG_ENTRY_HEADER_SIZE > dataEnd) return false;
+	if (dataView.getFloat64(pos) === 0) return false;
+	const length = dataView.getUint32(pos + 8);
+	if (length === 0) return false;
+	return pos + TRANSACTION_LOG_ENTRY_HEADER_SIZE + length <= dataEnd;
+}
+/**
+* Finds the offset in `[from, dataEnd)` where valid log framing resumes: a run of at least
+* `RESYNC_MIN_FRAMES` well-formed frames, or a run that lands exactly on `dataEnd`. Returns
+* `undefined` when nothing resumes (a torn tail).
+*
+* `dataEnd` must be the **written extent**, not the mapped capacity. The log's memory map is
+* pre-extended well past the data, and every offset inside that zero padding reads as an
+* end-of-entries marker — so scanning against the map would both lose the exact-end signal (the
+* chain can never land on a capacity that data does not reach) and, if a zero were accepted as a
+* terminator, let a chain "end" anywhere in megabytes of padding. Against the written extent the
+* end is a single offset, so a chain landing on it is ~1/2^32 to be coincidence.
+*
+* The JS counterpart of `validFramingResumes()` in `transaction_log_recovery.cpp`, which answers
+* the same question at open time but keeps only the yes/no, discarding the offset.
+*/
+function findResyncPosition(dataView, from, dataEnd) {
+	const lastStart = dataEnd - TRANSACTION_LOG_ENTRY_HEADER_SIZE;
+	for (let start = from; start <= lastStart; start++) {
+		let pos = start;
+		let frames = 0;
+		while (frames < RESYNC_MIN_FRAMES && frameFits(dataView, pos, dataEnd)) {
+			pos += TRANSACTION_LOG_ENTRY_HEADER_SIZE + dataView.getUint32(pos + 8);
+			if (++frames >= RESYNC_MIN_FRAMES || pos === dataEnd) return start;
+		}
+	}
+}
+/**
+* Builds the report for a broken frame, with the offset iteration should continue from. Resolves
+* the written extent here rather than per frame: `getLogFileSize` crosses into native and takes
+* the store mutex, which a healthy read must never pay.
+*/
+function corruptFrame(message, transactionLog, dataView, logBuffer, position, limit, size, readUncommitted) {
+	let dataEnd = limit;
+	if (readUncommitted) try {
+		const writtenExtent = transactionLog.getLogFileSize(logBuffer.logId);
+		dataEnd = writtenExtent > 0 ? Math.min(logBuffer.length, writtenExtent) : 0;
+	} catch {
+		dataEnd = 0;
+	}
+	const resyncPosition = findResyncPosition(dataView, position + 1, dataEnd);
+	return {
+		error: new CorruptFrameError(message, logBuffer.logId, position, resyncPosition),
+		nextPosition: resyncPosition ?? Math.max(dataEnd || limit, size, position + 1)
+	};
+}
+/**
 * Returns an iterable for transaction entries within the specified range of timestamps
 * This iterable can be iterated over multiple times, and subsequent iterations will continue
 * from where the last iteration left off, allowing for iteration through the log file
@@ -2992,17 +3662,26 @@ Object.defineProperty(TransactionLog.prototype, "query", { value({ start, end, e
 					value: void 0
 				};
 				const limit = readUncommitted ? logBuffer.length : Math.min(size, logBuffer.length);
-				if (position + TRANSACTION_LOG_ENTRY_HEADER_SIZE > limit) throw new RangeError(`Corrupt transaction log: truncated entry header at position ${position.toString(16)} of log ${logBuffer.logId} (available=${limit - position})`);
+				if (position + TRANSACTION_LOG_ENTRY_HEADER_SIZE > limit) {
+					const broken = corruptFrame(`Corrupt transaction log: truncated entry header at position ${position.toString(16)} of log ${logBuffer.logId} (available=${limit - position})`, transactionLog, dataView, logBuffer, position, limit, size, !!readUncommitted);
+					position = broken.nextPosition;
+					throw broken.error;
+				}
 				const length = dataView.getUint32(position + 8);
-				if (position + TRANSACTION_LOG_ENTRY_HEADER_SIZE + length > limit) throw new RangeError(`Corrupt transaction log entry at position ${position.toString(16)} of log ${logBuffer.logId}: declared length ${length} overruns the log (limit=${limit})`);
+				if (length === 0 || position + TRANSACTION_LOG_ENTRY_HEADER_SIZE + length > limit) {
+					const broken = corruptFrame(length === 0 ? `Corrupt transaction log entry at position ${position.toString(16)} of log ${logBuffer.logId}: zero-length entry` : `Corrupt transaction log entry at position ${position.toString(16)} of log ${logBuffer.logId}: declared length ${length} overruns the log (limit=${limit})`, transactionLog, dataView, logBuffer, position, limit, size, !!readUncommitted);
+					position = broken.nextPosition;
+					throw broken.error;
+				}
 				position += TRANSACTION_LOG_ENTRY_HEADER_SIZE;
 				let matchesRange;
 				if (foundExactStart) matchesRange = (!exclusiveStart || timestamp !== start) && timestamp < end;
-				else if (exactStart) if (timestamp === start) {
-					matchesRange = !exclusiveStart;
-					foundExactStart = true;
-				} else matchesRange = false;
-				else matchesRange = (exclusiveStart ? timestamp > start : timestamp >= start) && timestamp < end;
+				else if (exactStart) {
+					if (timestamp === start) {
+						matchesRange = !exclusiveStart;
+						foundExactStart = true;
+					} else matchesRange = false;
+				} else matchesRange = (exclusiveStart ? timestamp > start : timestamp >= start) && timestamp < end;
 				const entryStart = position;
 				position += length;
 				if (matchesRange) return {
@@ -3085,9 +3764,9 @@ function loadLastPosition(transactionLog, readUncommitted) {
 //#region src/index.ts
 const versions = {
 	rocksdb: version,
-	"rocksdb-js": "2.7.1"
+	"rocksdb-js": "2.9.0"
 };
 
 //#endregion
-export { DBI, DBIterator, RocksDatabase, Store, Transaction, TransactionLog, backups, constants, coolTransactionLogs, currentThreadId, fileLockRelease, parseTransactionLog, registryStatus, shutdown, stats, supportedCompression, tryFileLock, validateTransactionLogStore, versions };
+export { BackgroundError, CorruptFrameError, CountEstimator, DBI, DBIterator, RocksDatabase, Store, Transaction, TransactionLog, backups, constants, coolTransactionLogs, currentThreadId, fileLockRelease, getWriteBufferManagerStats, parseTransactionLog, registryStatus, shutdown, stats, supportedCompression, tryFileLock, validateTransactionLogStore, versions };
 //# sourceMappingURL=index.mjs.map