@harperfast/rocksdb-js 2.13.0 → 2.14.0

package/dist/index.mjs

@@ -3,6 +3,7 @@ import { execSync } from "node:child_process";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isMainThread } from "node:worker_threads";
 import { access, cp, mkdir, readdir, rm } from "node:fs/promises";
 import * as orderedBinary from "ordered-binary";
 import { ExtendedIterable } from "@harperfast/extended-iterable";
@@ -54,6 +55,18 @@ function locateBinding() {
 	throw new Error("Unable to locate rocksdb-js native binding");
 }
 const binding = req(locateBinding());
+if (isMainThread) {
+	let exitShutdownRan = false;
+	const shutdownOnExit = () => {
+		if (exitShutdownRan) return;
+		exitShutdownRan = true;
+		if (!binding.shutdownOnExit() && !process.exitCode) process.exitCode = 1;
+	};
+	process.on("exit", shutdownOnExit);
+	process.on("uncaughtExceptionMonitor", () => {
+		if (process._exiting) shutdownOnExit();
+	});
+}
 /**
 * The native `BackgroundError` constructor (a real `Error` subclass). Exported
 * as both a value — for `err instanceof BackgroundError` — and, via declaration
@@ -116,7 +129,7 @@ const getRegistryStatus = binding.registryStatus;
 */
 const registryStatus = getRegistryStatus;
 /**
-* Flushes every open database and waits for outstanding compactions, then
+* Flushes every open database and cancels its outstanding compactions, then
 * releases the registry.
 *
 * **Throws** the first failure it encounters: a close whose native teardown
@@ -126,19 +139,10 @@ const registryStatus = getRegistryStatus;
 * `database:closeFailed`; a timeout has no event, so the throw is its only
 * signal.
 *
-* A `process.on('exit')` listener must therefore wrap it: an exception thrown
-* from an `exit` listener skips every `exit` listener registered after it (and
-* sets exit code 1 unless an `uncaughtException` handler is installed).
-*
-* ```typescript
-* process.on('exit', () => {
-* 	try {
-* 		shutdown();
-* 	} catch (error) {
-* 		console.error('rocksdb-js shutdown failed', error);
-* 	}
-* });
-* ```
+* You do not need to call it at exit: when rocksdb-js loads on the main
+* thread it registers a `process.on('exit')` listener that does the same and
+* reports failures to stderr and the exit code instead of throwing (see the
+* `shutdownOnExit` config option). Calling it yourself as well is safe.
 */
 const shutdown = binding.shutdown;
 const currentThreadId = binding.currentThreadId;
@@ -158,6 +162,30 @@ const currentThreadId = binding.currentThreadId;
 */
 const steadyClockNow = binding.steadyClockNow;
 /**
+* Raises the process-wide monotonic timestamp clock — the one behind
+* `db.getMonotonicTimestamp()`, every transaction's initial timestamp and so
+* every transaction-log batch key — to at least `timestamp` (Unix epoch
+* milliseconds). Every timestamp the process issues after the call is strictly
+* greater than `timestamp`, across every database and `worker_threads` worker.
+* Timestamps already issued and timestamps adopted with `txn.setTimestamp()`
+* are unaffected. No open database is needed.
+*
+* Use it to carry a floor the caller persisted across a restart, which a
+* backward wall-clock step would otherwise let the new process reissue. The
+* floor is in memory only and is not a fence: restore it before the process
+* starts any transaction it originates, and pass only floors this node
+* persisted itself, since the clock stays that far ahead until wall time
+* catches up.
+*
+* @returns `true` if the clock was raised: `timestamp` was ahead of both the
+* wall clock and every timestamp already issued. `false` if the clock was
+* already at or above it.
+* @throws {TypeError} If `timestamp` is not a number.
+* @throws {RangeError} If `timestamp` is not finite, is not greater than 0, is
+* not less than 8.64e15, or is more than ten years ahead of the wall clock.
+*/
+const raiseTimestampFloor = binding.raiseTimestampFloor;
+/**
 * Advises the kernel that the file-backed pages of every mapped transaction log
 * are cold (Linux MADV_COLD), so they are reclaimed first under memory pressure
 * without being freed — useful during replication catch-up, where a full read of
@@ -1796,6 +1824,10 @@ var Store = class {
 	*/
 	arenaBlockSize;
 	/**
+	* Bits per key of the whole-key filter in each SST; `0` disables filters.
+	*/
+	bloomFilterBitsPerKey;
+	/**
 	* The function used to encode keys using the shared `keyBuffer`.
 	*/
 	writeKey;
@@ -1849,6 +1881,7 @@ var Store = class {
 		this.verificationTable = options?.verificationTable;
 		this.writeBufferSize = options?.writeBufferSize;
 		this.arenaBlockSize = options?.arenaBlockSize;
+		this.bloomFilterBitsPerKey = options?.bloomFilterBitsPerKey;
 		this.writeKey = writeKey;
 		this.#columnFamilyOptions = options ? { ...options } : void 0;
 	}
@@ -2008,7 +2041,7 @@ var Store = class {
 		const result = context.getSync(keyParam, flags | ONLY_IF_IN_MEMORY_CACHE_FLAG, txnId, expectedVersion);
 		if (typeof result === "number") {
 			if (result === NOT_IN_MEMORY_CACHE_FLAG) return new Promise((resolve, reject) => {
-				context.get(keyParam, resolve, reject, txnId, expectedVersion);
+				context.get(keyParam, resolve, reject, txnId, expectedVersion, flags);
 			});
 			if (result === FRESH_VERSION_FLAG) return result;
 			VALUE_BUFFER.end = result;
@@ -2216,7 +2249,8 @@ var Store = class {
 			timestampFloorLog: this.timestampFloorLog,
 			verificationTable: this.verificationTable,
 			writeBufferSize: this.writeBufferSize,
-			arenaBlockSize: this.arenaBlockSize
+			arenaBlockSize: this.arenaBlockSize,
+			bloomFilterBitsPerKey: this.bloomFilterBitsPerKey
 		});
 		this.identityPath = this.db.identityPath;
 		return false;
@@ -3772,6 +3806,40 @@ function parseTransactionLog(path, options = {}) {
 const FLOAT_TO_UINT32 = /* @__PURE__ */ new Float64Array(1);
 const UINT32_FROM_FLOAT = new Uint32Array(FLOAT_TO_UINT32.buffer);
 const EXACT_START_SPAN = /* @__PURE__ */ new Float64Array(3);
+const ITERATOR_TOKEN = Symbol("transactionLogIterator");
+const logEquals = TransactionLog.prototype.equals;
+var LogIterator = class {
+	#sourceLog;
+	#control;
+	next;
+	constructor(token, sourceLog, next, control) {
+		if (token !== ITERATOR_TOKEN) throw new TypeError("Transaction log iterators require query()");
+		this.#sourceLog = sourceLog;
+		this.next = next;
+		this.#control = control;
+	}
+	static cursor(value) {
+		if (typeof value === "object" && value !== null && #control in value) return value;
+	}
+	static isFrom(value, sourceLog) {
+		return logEquals.call(sourceLog, value.#sourceLog);
+	}
+	[Symbol.iterator]() {
+		return this;
+	}
+	peek() {
+		return this.#control("peek");
+	}
+	close() {
+		this.#control("close");
+	}
+	static reached(value, logId, position, atSegmentEnd) {
+		return value.#control("reached", logId, position, atSegmentEnd);
+	}
+	static scanEnd(value, logId, size) {
+		return value.#control("scanEnd", logId, size);
+	}
+};
 const { TRANSACTION_LOG_FILE_HEADER_SIZE, TRANSACTION_LOG_ENTRY_HEADER_SIZE, TRANSACTION_LOG_ENTRY_LAST_FLAG, TRANSACTION_LOG_ENTRY_ABORTED_FLAG } = constants;
 /**
 * Number of consecutive well-formed frames that, on their own, signal that real log data has
@@ -3833,6 +3901,17 @@ var TransactionLogGapError = class extends Error {
 		this.unavailableLogCount = unavailableLogCount;
 	}
 };
+/** Readable input ended before the iterator's physical `until` bound. Retry after input is available. */
+var TransactionLogUntilUnreachedError = class extends Error {
+	logId;
+	position;
+	constructor(logId, position) {
+		super(`Transaction log reader stopped at position ${position.toString(16)} of log ${logId}, short of the iterator it reads until`);
+		this.name = "TransactionLogUntilUnreachedError";
+		this.logId = logId;
+		this.position = 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
@@ -3895,7 +3974,9 @@ function corruptFrame(message, transactionLog, dataView, logBuffer, position, li
 * exactly matches the start timestamp, and then return all subsequent transactions in the log
 * regardless of whether their timestamp is before or after the start
 */
-Object.defineProperty(TransactionLog.prototype, "query", { value({ start, end, exactStart, startFromLastFlushed, readUncommitted, exclusiveStart } = {}) {
+Object.defineProperty(TransactionLog.prototype, "query", { value({ start, end, exactStart, startFromLastFlushed, readUncommitted, exclusiveStart, until } = {}) {
+	let untilCursor = LogIterator.cursor(until);
+	if (until !== void 0 && (!untilCursor || !LogIterator.isFrom(untilCursor, this))) throw new TypeError("until must be an iterator from query() on the same transaction log");
 	if (!this._lastCommittedPosition) {
 		const lastCommittedPosition = this._getLastCommittedPosition();
 		this._lastCommittedPosition = new Float64Array(lastCommittedPosition.buffer);
@@ -3942,7 +4023,7 @@ Object.defineProperty(TransactionLog.prototype, "query", { value({ start, end, e
 		if (position === 0) position = TRANSACTION_LOG_FILE_HEADER_SIZE;
 	}
 	const positionedAt = position;
-	if (stopLogId !== 0 && pastStop(logId, position, stopLogId, stopPosition)) {
+	if (stopLogId !== 0 && pastStop(logId, position, stopLogId, stopPosition) && mayJumpTo(untilCursor, tailLogId, tailPosition)) {
 		stopLogId = 0;
 		if (skipToTail(this, logId, position, tailLogId, tailPosition, segmentRemovals)) {
 			logId = tailLogId;
@@ -3952,95 +4033,144 @@ Object.defineProperty(TransactionLog.prototype, "query", { value({ start, end, e
 		tailLogBuffer = void 0;
 	}
 	let gapFloor = logId;
+	let startUnmapped = false;
+	let startMissing = false;
 	if (logBuffer === void 0 || logBuffer.logId !== logId) {
 		logBuffer = getLogMemoryMap(this, logId);
 		if (logBuffer && latestLogId === logId && !readUncommitted && this._currentLogBuffer?.deref() !== logBuffer) this._currentLogBuffer = new WeakRef(logBuffer);
 		if (logBuffer === void 0) {
 			logBuffer = Buffer.alloc(0);
-			logBuffer.logId = 0;
+			logBuffer.logId = logId;
 			logBuffer.size = 0;
 			logBuffer.dataView = new DataView(logBuffer.buffer);
 			size = 0;
+			startUnmapped = logId > 0;
 			if (positionedAt <= TRANSACTION_LOG_FILE_HEADER_SIZE || logId > 0 && this.getLogFileSize(logId) > 0) gapFloor = logId - 1;
 		}
 	}
 	dataView = logBuffer.dataView;
 	if (latestLogId < logId) size = 0;
-	else if (latestLogId > logId) {
+	else if (latestLogId > logId && !startUnmapped) {
 		const cachedSize = logBuffer.size;
 		if (cachedSize === void 0) size = logBuffer.size = readableExtent(logBuffer);
 		else size = cachedSize;
 	}
-	const iterator = {
-		[Symbol.iterator]() {
-			return this;
-		},
-		next() {
-			let timestamp;
-			if (position >= size) {
-				const { logId: latestLogId, size: latestSize } = loadLastPosition(transactionLog, !!readUncommitted);
-				size = latestLogId < logBuffer.logId ? 0 : latestSize;
-				if (latestLogId > logBuffer.logId) {
-					size = logBuffer.size ?? (logBuffer.size = readableExtent(logBuffer));
-					if (position >= size) {
-						const fromLogId = logBuffer.logId;
-						const nextLogBuffer = nextReadableLogBuffer(transactionLog, fromLogId, latestLogId, gapFloor);
-						if (nextLogBuffer) {
-							const unavailable = unavailableLogCount;
-							dataView = nextLogBuffer.dataView;
-							logBuffer = nextLogBuffer;
-							if (latestLogId > logBuffer.logId) size = logBuffer.size ?? (logBuffer.size = readableExtent(logBuffer));
-							else size = latestSize;
-							position = TRANSACTION_LOG_FILE_HEADER_SIZE;
-							previousEndedTransaction = true;
-							if (unavailable > 0) throw new TransactionLogGapError(Math.max(fromLogId, gapFloor), logBuffer.logId, unavailable);
-						}
-					}
+	let peeked;
+	let peekedLogId = 0;
+	let peekedPosition = 0;
+	let closed = false;
+	let needsCursorCheck = untilCursor !== void 0 || startUnmapped;
+	const iterator = new LogIterator(ITERATOR_TOKEN, transactionLog, function next() {
+		let scanEnd = size;
+		if (needsCursorCheck) {
+			if (peeked) {
+				const result = peeked;
+				if (!closed) {
+					peeked = void 0;
+					needsCursorCheck = untilCursor !== void 0;
 				}
+				return result;
 			}
-			while (position < size) {
-				try {
-					timestamp = dataView.getFloat64(position);
-				} catch (error) {
-					error.message += ` at position ${position.toString(16)} of log ${logBuffer.logId} (size=${size}, log buffer length=${logBuffer.length})`;
-					throw error;
+			if (untilCursor) {
+				const limit = LogIterator.scanEnd(untilCursor, logBuffer.logId, size);
+				if (limit === void 0) {
+					untilCursor = void 0;
+					needsCursorCheck = startUnmapped;
+				} else {
+					if (position >= limit && LogIterator.reached(untilCursor, logBuffer.logId, position, position >= size && logBuffer.length > 0 && position >= readableExtent(logBuffer))) return {
+						done: true,
+						value: void 0
+					};
+					scanEnd = limit;
 				}
-				if (!timestamp) return {
-					done: true,
-					value: void 0
-				};
-				const limit = readUncommitted ? logBuffer.length : Math.min(size, logBuffer.length);
-				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;
-					previousEndedTransaction = true;
-					throw broken.error;
-				}
-				const length = dataView.getUint32(position + 8);
-				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;
-					previousEndedTransaction = true;
-					throw broken.error;
+			}
+			if (startUnmapped) {
+				const mapped = getLogMemoryMap(transactionLog, logBuffer.logId);
+				if (mapped) {
+					logBuffer = mapped;
+					dataView = mapped.dataView;
+				} else {
+					const latestLogId = loadLastPosition(transactionLog, !!readUncommitted).logId;
+					const fileSize = transactionLog.getLogFileSize(logBuffer.logId);
+					if (logBuffer.logId >= latestLogId || fileSize > position) return endOfReadable(untilCursor, logBuffer, position);
+					if (fileSize === 0) startMissing = true;
 				}
-				position += TRANSACTION_LOG_ENTRY_HEADER_SIZE;
-				const flags = logBuffer[position - 1];
-				const aborted = (flags & TRANSACTION_LOG_ENTRY_ABORTED_FLAG) !== 0;
-				if (previousEndedTransaction || timestamp !== previousTimestamp || aborted) skippingAborted = aborted;
-				previousEndedTransaction = (flags & TRANSACTION_LOG_ENTRY_LAST_FLAG) !== 0;
-				previousTimestamp = timestamp;
-				let matchesRange;
-				if (skippingAborted) matchesRange = false;
-				else if (foundExactStart) matchesRange = (!exclusiveStart || timestamp !== start) && timestamp < end;
-				else if (exactStart) {
-					matchesRange = false;
-					if (timestamp === start) {
-						matchesRange = !exclusiveStart;
-						foundExactStart = true;
-						stopLogId = 0;
+				startUnmapped = false;
+				needsCursorCheck = untilCursor !== void 0;
+				size = 0;
+			}
+		}
+		let timestamp;
+		if (position >= size) {
+			const { logId: latestLogId, size: latestSize } = loadLastPosition(transactionLog, !!readUncommitted);
+			size = latestLogId < logBuffer.logId ? 0 : latestSize;
+			if (latestLogId > logBuffer.logId) {
+				size = logBuffer.size ?? (logBuffer.size = readableExtent(logBuffer));
+				if (position >= size) {
+					if (untilCursor && LogIterator.reached(untilCursor, logBuffer.logId, position, logBuffer.length > 0 && position >= readableExtent(logBuffer))) return {
+						done: true,
+						value: void 0
+					};
+					const fromLogId = logBuffer.logId - (startMissing ? 1 : 0);
+					const nextLogBuffer = nextReadableLogBuffer(transactionLog, fromLogId, latestLogId, gapFloor);
+					if (nextLogBuffer) {
+						startMissing = false;
+						const unavailable = unavailableLogCount;
+						dataView = nextLogBuffer.dataView;
+						logBuffer = nextLogBuffer;
+						if (latestLogId > logBuffer.logId) size = logBuffer.size ?? (logBuffer.size = readableExtent(logBuffer));
+						else size = latestSize;
+						position = TRANSACTION_LOG_FILE_HEADER_SIZE;
+						previousEndedTransaction = true;
+						if (unavailable > 0) throw new TransactionLogGapError(Math.max(fromLogId, gapFloor), logBuffer.logId, unavailable);
 					}
-				} else matchesRange = (exclusiveStart ? timestamp > start : timestamp >= start) && timestamp < end;
-				if (!matchesRange && stopLogId !== 0 && pastStop(logBuffer.logId, position + length, stopLogId, stopPosition)) {
+				}
+			}
+			scanEnd = untilCursor ? LogIterator.scanEnd(untilCursor, logBuffer.logId, size) ?? size : size;
+		}
+		if (position >= scanEnd) return endOfReadable(untilCursor, logBuffer, position);
+		let jumpRefused = false;
+		let limit = Math.min(size, logBuffer.length);
+		do {
+			try {
+				timestamp = dataView.getFloat64(position);
+			} catch (error) {
+				error.message += ` at position ${position.toString(16)} of log ${logBuffer.logId} (size=${size}, log buffer length=${logBuffer.length})`;
+				throw error;
+			}
+			if (!timestamp) return endOfReadable(untilCursor, logBuffer, 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;
+				previousEndedTransaction = true;
+				throw broken.error;
+			}
+			const length = dataView.getUint32(position + 8);
+			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;
+				previousEndedTransaction = true;
+				throw broken.error;
+			}
+			position += TRANSACTION_LOG_ENTRY_HEADER_SIZE;
+			const flags = logBuffer[position - 1];
+			const aborted = (flags & TRANSACTION_LOG_ENTRY_ABORTED_FLAG) !== 0;
+			if (previousEndedTransaction || timestamp !== previousTimestamp || aborted) skippingAborted = aborted;
+			previousEndedTransaction = (flags & TRANSACTION_LOG_ENTRY_LAST_FLAG) !== 0;
+			previousTimestamp = timestamp;
+			let matchesRange;
+			if (skippingAborted) matchesRange = false;
+			else if (foundExactStart) matchesRange = (!exclusiveStart || timestamp !== start) && timestamp < end;
+			else if (exactStart) {
+				matchesRange = false;
+				if (timestamp === start) {
+					matchesRange = !exclusiveStart;
+					foundExactStart = true;
+					stopLogId = 0;
+				}
+			} else matchesRange = (exclusiveStart ? timestamp > start : timestamp >= start) && timestamp < end;
+			if (!matchesRange && stopLogId !== 0 && !jumpRefused && pastStop(logBuffer.logId, position + length, stopLogId, stopPosition)) {
+				if (mayJumpTo(untilCursor, tailLogId, tailPosition)) {
 					stopLogId = 0;
 					position += length;
 					if (skipToTail(transactionLog, logBuffer.logId, position, tailLogId, tailPosition, segmentRemovals)) {
@@ -4055,57 +4185,108 @@ Object.defineProperty(TransactionLog.prototype, "query", { value({ start, end, e
 					tailLogBuffer = void 0;
 					return iterator.next();
 				}
-				const entryStart = position;
-				position += length;
-				if (matchesRange) return {
-					done: false,
-					value: {
-						timestamp,
-						endTxn: previousEndedTransaction,
-						data: logBuffer.subarray(entryStart, position)
-					}
+				jumpRefused = true;
+			}
+			const entryStart = position;
+			position += length;
+			if (matchesRange) return {
+				done: false,
+				value: {
+					timestamp,
+					endTxn: previousEndedTransaction,
+					data: logBuffer.subarray(entryStart, position)
+				}
+			};
+			if (position >= scanEnd) {
+				if (untilCursor && LogIterator.reached(untilCursor, logBuffer.logId, position)) return {
+					done: true,
+					value: void 0
 				};
-				if (position >= size) {
-					const { logId: latestLogId, size: latestSize } = loadLastPosition(transactionLog, !!readUncommitted);
-					size = latestLogId < logBuffer.logId ? 0 : latestSize;
-					if (latestLogId > logBuffer.logId) {
-						size = logBuffer.size ?? readableExtent(logBuffer);
-						if (!readUncommitted) logBuffer.size = size;
-						if (position < size) continue;
-						const fromLogId = logBuffer.logId;
-						const nextLogBuffer = nextReadableLogBuffer(transactionLog, fromLogId, latestLogId, gapFloor);
-						if (!nextLogBuffer) return {
-							done: true,
-							value: void 0
-						};
-						const unavailable = unavailableLogCount;
-						logBuffer = nextLogBuffer;
-						dataView = logBuffer.dataView;
-						if (latestLogId === logBuffer.logId) size = latestSize;
-						else {
-							const cachedSize = logBuffer.size;
-							if (cachedSize === void 0) {
-								size = readableExtent(logBuffer);
-								if (!readUncommitted) logBuffer.size = size;
-							} else size = cachedSize;
-						}
-						position = TRANSACTION_LOG_FILE_HEADER_SIZE;
-						previousEndedTransaction = true;
-						if (unavailable > 0) throw new TransactionLogGapError(Math.max(fromLogId, gapFloor), logBuffer.logId, unavailable);
+				const { logId: latestLogId, size: latestSize } = loadLastPosition(transactionLog, !!readUncommitted);
+				size = latestLogId < logBuffer.logId ? 0 : latestSize;
+				if (latestLogId > logBuffer.logId) {
+					size = logBuffer.size ?? readableExtent(logBuffer);
+					if (!readUncommitted) logBuffer.size = size;
+					if (position < size) {
+						scanEnd = untilCursor ? LogIterator.scanEnd(untilCursor, logBuffer.logId, size) ?? size : size;
+						limit = Math.min(size, logBuffer.length);
+						continue;
+					}
+					if (untilCursor && LogIterator.reached(untilCursor, logBuffer.logId, position, logBuffer.length > 0 && position >= readableExtent(logBuffer))) return {
+						done: true,
+						value: void 0
+					};
+					const fromLogId = logBuffer.logId;
+					const nextLogBuffer = nextReadableLogBuffer(transactionLog, fromLogId, latestLogId, gapFloor);
+					if (!nextLogBuffer) return endOfReadable(untilCursor, logBuffer, position);
+					const unavailable = unavailableLogCount;
+					logBuffer = nextLogBuffer;
+					dataView = logBuffer.dataView;
+					if (latestLogId === logBuffer.logId) size = latestSize;
+					else {
+						const cachedSize = logBuffer.size;
+						if (cachedSize === void 0) {
+							size = readableExtent(logBuffer);
+							if (!readUncommitted) logBuffer.size = size;
+						} else size = cachedSize;
 					}
+					position = TRANSACTION_LOG_FILE_HEADER_SIZE;
+					previousEndedTransaction = true;
+					if (unavailable > 0) throw new TransactionLogGapError(Math.max(fromLogId, gapFloor), logBuffer.logId, unavailable);
 				}
+				scanEnd = untilCursor ? LogIterator.scanEnd(untilCursor, logBuffer.logId, size) ?? size : size;
+				limit = Math.min(size, logBuffer.length);
+			}
+		} while (position < scanEnd);
+		return endOfReadable(untilCursor, logBuffer, position);
+	}, function control(operation, fromLogId, fromPosition, atSegmentEnd) {
+		if (operation === "peek") {
+			if (peeked) return peeked;
+			const result = iterator.next();
+			if (!result.done) {
+				peeked = result;
+				needsCursorCheck = true;
+				peekedLogId = logBuffer.logId;
+				peekedPosition = position - result.value.data.length - TRANSACTION_LOG_ENTRY_HEADER_SIZE;
 			}
-			return {
+			return result;
+		}
+		if (operation === "close") {
+			closed = true;
+			needsCursorCheck = true;
+			peeked = {
 				done: true,
 				value: void 0
 			};
+			logBuffer = void 0;
+			dataView = void 0;
+			untilCursor = void 0;
+			return;
 		}
-	};
+		if (closed) return;
+		const boundLogId = peeked ? peekedLogId : logBuffer.logId;
+		const boundPosition = peeked ? peekedPosition : position;
+		if (operation === "scanEnd") {
+			if (boundLogId !== fromLogId) return boundLogId > fromLogId ? fromPosition : 0;
+			return boundPosition < fromPosition ? boundPosition : fromPosition;
+		}
+		return pastStop(fromLogId, fromPosition, boundLogId, boundPosition) || !!atSegmentEnd && boundLogId === fromLogId + 1 && boundPosition === TRANSACTION_LOG_FILE_HEADER_SIZE;
+	});
 	return iterator;
 } });
+function endOfReadable(untilCursor, logBuffer, position) {
+	if (untilCursor && LogIterator.reached(untilCursor, logBuffer.logId, position, logBuffer.length > 0 && position >= readableExtent(logBuffer)) === false) throw new TransactionLogUntilUnreachedError(logBuffer.logId, position);
+	return {
+		done: true,
+		value: void 0
+	};
+}
 function pastStop(logId, position, stopLogId, stopPosition) {
 	return logId > stopLogId || logId === stopLogId && position >= stopPosition;
 }
+function mayJumpTo(untilCursor, logId, position) {
+	return !untilCursor || LogIterator.reached(untilCursor, logId, position - 1) !== true;
+}
 let tailLogBuffer;
 /**
 * Whether an exact-start lookup at `position` of `fromLogId` may take its one-shot jump to the tail.
@@ -4204,8 +4385,8 @@ function loadLastPosition(transactionLog, readUncommitted) {
 // src/index.ts
 const versions = {
 	rocksdb: version,
-	"rocksdb-js": "2.13.0"
+	"rocksdb-js": "2.14.0"
 };
 
-export { BackgroundError, ConflictKind, CorruptFrameError, CountEstimator, DBI, DBIterator, RocksDatabase, Store, Transaction, TransactionAbortUnresolvedError, TransactionLog, TransactionLogGapError, backups, constants, coolTransactionLogs, currentThreadId, fileLockRelease, getRegistryStatus, getWriteBufferManagerStats, parseTransactionLog, registryStatus, shutdown, stats, steadyClockNow, supportedCompression, tryFileLock, validateTransactionLogStore, versions };
+export { BackgroundError, ConflictKind, CorruptFrameError, CountEstimator, DBI, DBIterator, RocksDatabase, Store, Transaction, TransactionAbortUnresolvedError, TransactionLog, TransactionLogGapError, TransactionLogUntilUnreachedError, backups, constants, coolTransactionLogs, currentThreadId, fileLockRelease, getRegistryStatus, getWriteBufferManagerStats, parseTransactionLog, raiseTimestampFloor, registryStatus, shutdown, stats, steadyClockNow, supportedCompression, tryFileLock, validateTransactionLogStore, versions };
 //# sourceMappingURL=index.mjs.map