@harperfast/harper 5.3.0 → 5.3.1

package/resources/FULL_TEXT.md

@@ -88,10 +88,14 @@ Weight and highlighting changes preserve the physical index and refresh query re
 
 ## Native package and limits
 
-Harper pins `@harperfast/fulltext` to **0.3.0** and validates the native runtime capabilities before activation. Full-text activation requires RocksDB and an audited table. Declare new schema tables with `@table(audit: true)` and keep audit logging enabled while an index is declared. LMDB is rejected. A missing or incompatible native package prevents activation.
+Harper pins `@harperfast/fulltext` to **0.5.0** and validates the native runtime capabilities before activation. Full-text activation requires RocksDB and an audited table. Declare new schema tables with `@table(audit: true)` and keep audit logging enabled while an index is declared. LMDB is rejected. A missing or incompatible native package prevents activation.
+
+A format-incompatible native package upgrade causes each node to rebuild its local derived index from authoritative records. Full-text queries on that node return 503 until the index is ready. Use a rolling upgrade to keep full-text search available on other replicas while each local index rebuilds.
 
 Earlier beta declarations and indexes are unsupported. This field-only API does not provide a compatibility or upgrade path for them.
 
-Native queries have finite result windows and execution budgets. Reduce the requested offset/limit or narrow the query when a window is exceeded; filtering can also exhaust the window. Prefix modes use the native autocomplete window. Highlight tracing has separate record and source-byte bounds. These are functional constraints, not catalog-scale performance guarantees.
+Native queries have finite result windows and execution budgets. Reduce the requested offset/limit or narrow the query when a window is exceeded; filtering can also exhaust the window. Prefix modes use the native autocomplete window, clamped when necessary so its maximum result set fits in one native response. Highlight tracing has separate record and source-byte bounds. These are functional constraints, not catalog-scale performance guarantees.
+
+Harper does not configure Fulltext's native filter metadata or submit native filter or candidate-ID requests. Ordinary conditions continue through Harper's secondary-index gates and authoritative record predicates.
 
 For implementation details, see the [full-text invariants in the Resource design guide](DESIGN.md#full-text-declarations-and-reader-snapshots). The schema contract lives in [schema.graphql](../schema.graphql); the compiler and generation rules are in [fullTextSchema.ts](fullTextSchema.ts).

package/resources/IterableEventQueue.ts

@@ -30,19 +30,26 @@ export class IterableEventQueue<Event extends object = any> extends EventEmitter
 		return true;
 	}
 	/**
-	 * Permanently close the queue. A final message is delivered before iteration ends when supplied.
+	 * Permanently close the queue. A final message is delivered before iteration ends when supplied. The queue
+	 * closes and emits 'close' once even if a listener throws on the final message; that error is then rethrown.
 	 */
 	close(finalMessage?: Event) {
 		if (this.closed) return;
 		// Closing is authoritative: buffered events must not leak after revocation or policy failure.
 		if (this.queue) this.queue.length = 0;
-		if (finalMessage !== undefined) this.send(finalMessage);
-		this.closed = true;
-		if (this.resolveNext) {
-			this.resolveNext({ value: undefined, done: true });
-			this.resolveNext = null;
+		try {
+			if (finalMessage !== undefined) this.send(finalMessage);
+		} finally {
+			// a listener handling the final message may already have closed the queue
+			if (!this.closed) {
+				this.closed = true;
+				if (this.resolveNext) {
+					this.resolveNext({ value: undefined, done: true });
+					this.resolveNext = null;
+				}
+				this.emit('close');
+			}
 		}
-		this.emit('close');
 	}
 	getNextMessage() {
 		const message = this.queue?.shift();

package/resources/LMDBTransaction.ts

@@ -1,8 +1,10 @@
 import {
 	DatabaseTransaction,
 	closeWriteInstance,
+	deferForCommitInFlight,
 	validateWrite,
 	shouldSpareCommitPhase,
+	requestAbortedError,
 	transactionOpenTooLongError,
 	type CommitOptions,
 	type TransactionWrite,
@@ -43,6 +45,16 @@ export class LMDBTransaction extends DatabaseTransaction {
 		this.timeout = Math.max(txnExpiration, this.timeoutBudget ?? 0);
 	}
 
+	protected markNativeCommitSubmitted(): void {
+		super.markNativeCommitSubmitted();
+		this.timeout = Math.max(this.timeout || 0, txnExpiration, this.timeoutBudget ?? 0);
+		trackedTxns.add(this);
+	}
+
+	protected nativeCommitAttemptEnded(): void {
+		if (!this.readTxn) trackedTxns.delete(this);
+	}
+
 	getReadTxn(): any {
 		// used optimistically
 		this.readTxnRefCount = (this.readTxnRefCount || 0) + 1;
@@ -58,6 +70,7 @@ export class LMDBTransaction extends DatabaseTransaction {
 		this.readTxn = (this.db as any).useReadTransaction();
 
 		this.readTxnsUsed = 1;
+		this.baseReadRefConsumed = false;
 		if ((this.readTxn as any).openTimer) (this.readTxn as any).openTimer = 0;
 		trackedTxns.add(this as any);
 		return this.readTxn;
@@ -84,8 +97,11 @@ export class LMDBTransaction extends DatabaseTransaction {
 			(this.readTxn as any).done();
 		}
 		if (--this.readTxnsUsed === 0) {
-			trackedTxns.delete(this as any);
+			// A submitted write remains monitor-visible after its separate read snapshot is released.
+			// nativeCommitAttemptEnded() removes this enrollment once the outcome is known.
+			if (!this.nativeCommitSubmitted) trackedTxns.delete(this as any);
 			this.readTxn = null;
+			this.completeDeferredContextRelease();
 		}
 	}
 
@@ -96,16 +112,16 @@ export class LMDBTransaction extends DatabaseTransaction {
 	}
 
 	addWrite(operation: TransactionWrite): any {
-		if (this.timedOut) throw transactionOpenTooLongError();
-		if (this.open === TRANSACTION_STATE.CLOSED) {
-			throw new Error('Can not use a transaction that is no longer open');
-		}
-
+		if (this.timedOut || this.postSubmitPoisoned) throw transactionOpenTooLongError();
+		if (this.disconnected) throw requestAbortedError();
 		if (this.open === TRANSACTION_STATE.LINGERING) {
 			// if the transaction is lingering, it is already committed, so we need to commit the write immediately
 			const immediateTxn = new ImmediateTransaction(this.db);
+			// The throwaway owns this write, so it owns the request's cancellation too: this settled chain
+			// would neither refuse on its behalf nor ever release a subscription taken for it.
+			immediateTxn.requestSignal = (this.root ?? this).requestSignal;
 			immediateTxn.addWrite(operation);
-			const result = immediateTxn.commit({});
+			const result = immediateTxn.commit({}) as any;
 			// Nothing may be sent back to this throwaway: the write is already committed, and its
 			// durability is the promise below.
 			operation.stagedIn = undefined;
@@ -116,6 +132,10 @@ export class LMDBTransaction extends DatabaseTransaction {
 			}
 			return result;
 		}
+		this.admitRequestWrite();
+		if (this.open === TRANSACTION_STATE.CLOSED) {
+			throw new Error('Can not use a transaction that is no longer open');
+		}
 
 		this.linkWrite(operation);
 		this.writes.push(operation); // standard path, add to current transaction
@@ -132,8 +152,20 @@ export class LMDBTransaction extends DatabaseTransaction {
 	/**
 	 * Resolves with information on the timestamp and success of the commit
 	 */
-	commit(options: CommitOptions = {}): any {
-		if (this.timedOut) throw transactionOpenTooLongError();
+	protected performCommit(options: CommitOptions = {}): any {
+		const next = this.next;
+		let result;
+		try {
+			result = this.performCommitAttempt(options);
+		} catch (error) {
+			this.abortCommitFailure(error, next);
+		}
+		if (typeof result?.then === 'function') return result.catch((error) => this.abortCommitFailure(error, next));
+		return result;
+	}
+
+	/** Preserve the synchronous empty-commit path while the outer method funnels every failure once. */
+	private performCommitAttempt(options: CommitOptions = {}): any {
 		options = options || {};
 		let txnTime = this.timestamp;
 		if (!txnTime) txnTime = this.timestamp = options.timestamp || getNextMonotonicTime();
@@ -141,74 +173,73 @@ export class LMDBTransaction extends DatabaseTransaction {
 		const retries = options.retries || 0;
 		// now validate
 		if (this.validated < this.writes.length) {
-			try {
-				const start = this.validated;
-				// record the number of writes that have been validated so if we re-execute
-				// and the number is increased we can validate the new entries
-				this.validated = this.writes.length;
-				for (let i = start; i < this.validated; i++) {
-					const write = this.writes[i];
-					try {
-						if (write) validateWrite(write, this.timestamp, this);
-					} finally {
-						closeWriteInstance(write);
-					}
+			const start = this.validated;
+			// record the number of writes that have been validated so if we re-execute
+			// and the number is increased we can validate the new entries
+			this.validated = this.writes.length;
+			for (let i = start; i < this.validated; i++) {
+				const write = this.writes[i];
+				try {
+					if (write) validateWrite(write, this.timestamp, this);
+				} finally {
+					closeWriteInstance(write);
 				}
-				let hasBefore;
-				for (let i = start; i < this.validated; i++) {
-					const write = this.writes[i];
-					if (!write) continue;
-					if (write.before || write.beforeIntermediate) {
-						hasBefore = true;
-					}
+			}
+			let hasBefore;
+			for (let i = start; i < this.validated; i++) {
+				const write = this.writes[i];
+				if (!write) continue;
+				if (write.before || write.beforeIntermediate) {
+					hasBefore = true;
 				}
-				// Now we need to let any "before" actions execute. These are calls to the sources,
-				// and we want to follow the order of the source sequence so that later, more canonical
-				// source writes will finish (with right to refuse/abort) before proceeeding to less
-				// canonical sources.
-				if (hasBefore) {
-					// see `committing` in DatabaseTransaction (issue #2062)
-					this.setCommitPhase(true);
-					const stagedWrites = this.writes.length;
-					return (async () => {
-						try {
-							for (let phase = 0; phase < 2; phase++) {
-								let completion;
-								for (let i = start; i < this.validated; i++) {
-									const write = this.writes[i];
-									if (!write) continue;
-									const before = write[phase === 0 ? 'before' : 'beforeIntermediate'];
-									if (before) {
-										const nextCompletion = before();
-										if (completion) {
-											if (completion.push) completion.push(nextCompletion);
-											else completion = [completion, nextCompletion];
-										} else completion = nextCompletion;
-									}
+			}
+			// Now we need to let any "before" actions execute. These are calls to the sources,
+			// and we want to follow the order of the source sequence so that later, more canonical
+			// source writes will finish (with right to refuse/abort) before proceeeding to less
+			// canonical sources.
+			if (hasBefore) {
+				// see `committing` in DatabaseTransaction (issue #2062)
+				this.setCommitPhase(true);
+				const stagedWrites = this.writes.length;
+				return (async () => {
+					try {
+						for (let phase = 0; phase < 2; phase++) {
+							let completion;
+							for (let i = start; i < this.validated; i++) {
+								const write = this.writes[i];
+								if (!write) continue;
+								const before = write[phase === 0 ? 'before' : 'beforeIntermediate'];
+								if (before) {
+									const nextCompletion = before();
+									if (completion) {
+										if (completion.push) completion.push(nextCompletion);
+										else completion = [completion, nextCompletion];
+									} else completion = nextCompletion;
 								}
-								if (completion) await (completion.push ? Promise.all(completion) : completion);
 							}
-						} catch (error) {
-							this.setCommitPhase(false);
-							this.abort();
-							throw error;
+							if (completion) await (completion.push ? Promise.all(completion) : completion);
 						}
+					} finally {
 						this.setCommitPhase(false);
-						// aborted underneath us while parked above — see DatabaseTransaction's twin guard
+					}
+					// aborted underneath us while parked above — see DatabaseTransaction's twin guard. A chain
+					// poisoned after one of its stores submitted rides the cascade instead (abortAndPoison).
+					if (!this.poisonedMidCommit) {
 						if (this.timedOut) throw transactionOpenTooLongError();
-						if (stagedWrites > 0 && this.writes.length === 0 && this.open === TRANSACTION_STATE.CLOSED)
-							throw new ServerError('Transaction was aborted while its commit was waiting on pre-commit work', 500);
-						return this.commit(options);
-					})();
-				}
-			} catch (error) {
-				this.abort();
-				throw error;
+						if (this.disconnected) throw requestAbortedError();
+					}
+					if (stagedWrites > 0 && this.writes.length === 0 && this.open === TRANSACTION_STATE.CLOSED)
+						throw new ServerError('Transaction was aborted while its commit was waiting on pre-commit work', 500);
+					return this.commit({ ...options, continuation: true });
+				})();
 			}
 		}
 		if (!retries && this.writes.some((write) => write)) this.renewChainForNativeCommit();
 		// release the read snapshot so we don't keep it open longer than necessary
-		if (!retries) this.doneReadTxn();
+		if (!retries && !this.baseReadRefConsumed) {
+			this.baseReadRefConsumed = true;
+			this.doneReadTxn();
+		}
 		this.open = options?.doneWriting ? TRANSACTION_STATE.LINGERING : TRANSACTION_STATE.OPEN;
 		let resolution;
 		const completions = [];
@@ -264,6 +295,7 @@ export class LMDBTransaction extends DatabaseTransaction {
 			// use a real (async) transaction to get exclusive access to the data
 			if (db?.retryRisk) db.retryRisk *= 0.99; // gradually decay the retry risk
 			if (this.writes.length + (db?.retryRisk || 0) < MAX_OPTIMISTIC_SIZE >> retries) {
+				this.markNativeCommitSubmitted();
 				nextCondition();
 				if (commitCompletions) {
 					if (resolution) {
@@ -278,6 +310,7 @@ export class LMDBTransaction extends DatabaseTransaction {
 			} else {
 				// if it is too big to expect optimistic writes to work, or we have done too many retries we use
 				// a real LMDB transaction to get exclusive access to reading and writing
+				this.markNativeCommitSubmitted();
 				const transactionResolution = this.writes[0].store.transaction(() => {
 					for (const write of this.writes) {
 						// we load latest data while in the transaction
@@ -296,17 +329,18 @@ export class LMDBTransaction extends DatabaseTransaction {
 			return resolution.then((resolution) => {
 				if (resolution) {
 					if (this.next) {
-						completions.push(this.next.commit(options));
+						completions.push(this.next.commit({ ...options, continuation: true }));
 					}
 					if (options?.flush) {
-						completions.push(this.writes[0].store.flushed);
+						const store = this.writes[0]?.store;
+						if (store) completions.push(store.flushed);
 					}
 					if (this.replicatedConfirmation) {
 						// if we want to wait for replication confirmation, we need to track the transaction times
 						// and when replication notifications come in, we count the number of confirms until we reach the desired number
-						const databaseName = this.writes[0].store.rootStore.databaseName;
+						const databaseName = this.writes[0]?.store.rootStore.databaseName;
 						const lastEntry = this.lastConfirmableEntry();
-						if (confirmReplication && lastEntry)
+						if (confirmReplication && databaseName && lastEntry)
 							completions.push(
 								confirmReplication(databaseName, (lastEntry as any).localTime, this.replicatedConfirmation)
 							);
@@ -337,7 +371,8 @@ export class LMDBTransaction extends DatabaseTransaction {
 					}
 					if (options) options.retries = retries + 1;
 					else options = { retries: 1 };
-					return this.commit(options); // try again
+					// A continuation: a poison that landed mid-commit must not abandon the retry ladder.
+					return this.commit({ ...options, continuation: true }); // try again
 				}
 			});
 		}
@@ -346,7 +381,7 @@ export class LMDBTransaction extends DatabaseTransaction {
 		};
 		if (this.next) {
 			// now run any other transactions
-			const nextResolution = this.next?.commit(options);
+			const nextResolution = this.next?.commit({ ...options, continuation: true });
 			if ((nextResolution as any)?.then)
 				return (nextResolution as any)?.then((nextResolution) => ({
 					txnTime,
@@ -356,19 +391,79 @@ export class LMDBTransaction extends DatabaseTransaction {
 		}
 		return txnResolution;
 	}
-	abort(): void {
-		while (this.readTxnsUsed > 0) this.doneReadTxn(); // release the read snapshot when we abort, we assume we don't need it
-		this.open = TRANSACTION_STATE.CLOSED;
-		this.drainCompletions();
-		// any blobs that were pre-saved as part of these writes will never be referenced; schedule deletion
-		// (retaining any fileId the current on-disk record still references — an aborted write may carry an
-		// already-saved blob shared with the surviving record; see harper-pro#406).
-		for (const write of this.writes) {
-			if (write?.savedBlobs)
-				cleanupUnusedBlobs(write.savedBlobs, collectRetainedFileIds(write.store.getEntry(write.key)?.value));
+
+	private abortCommitFailure(error, next: DatabaseTransaction | undefined): never {
+		const nextWasAttached = Boolean(next && this.next === next);
+		try {
+			this.abort(true);
+		} catch (abortError) {
+			harperLogger.debug?.('aborting LMDB transaction after a failed commit', abortError);
+		}
+		// A detached pre-submit child has no other cleanup path. A submitted child owns an unknown native
+		// outcome and will clean itself when its own commit promise settles.
+		if (next && !nextWasAttached && !next.nativeCommitSubmitted) {
+			try {
+				next.abort(true);
+			} catch (abortError) {
+				harperLogger.debug?.('aborting a detached LMDB transaction after a failed commit', abortError);
+			}
+		}
+		throw error;
+	}
+	/**
+	 * Force-release the retained read snapshot without touching staged writes. The base class's
+	 * version acts on `this.transaction`; LMDB's snapshot lives on `this.readTxn`, so the monitor
+	 * would otherwise have nothing that can reclaim a handle abort(true) retained.
+	 */
+	releaseReadTxn(): void {
+		while (this.readTxn && this.readTxnsUsed > 0) this.doneReadTxn();
+		this.completeDeferredContextRelease();
+	}
+
+	abort(retainReadTransaction = false, cascade = true): void {
+		const next = cascade ? this.next : undefined;
+		if (cascade && !retainReadTransaction) this.next = null;
+		try {
+			const hasOpenReadIterator =
+				retainReadTransaction &&
+				this.readTxn &&
+				(this.readTxnsUsed > 1 || (this.baseReadRefConsumed && this.readTxnsUsed > 0));
+			if (hasOpenReadIterator) {
+				if (!this.baseReadRefConsumed) {
+					this.doneReadTxn();
+					this.baseReadRefConsumed = true;
+				}
+			} else {
+				while (this.readTxnsUsed > 0) this.doneReadTxn(); // release the read snapshot when we abort, we assume we don't need it
+			}
+			this.open = TRANSACTION_STATE.CLOSED;
+			this.drainCompletions();
+			// Any blobs that were pre-saved as part of these writes will never be referenced; schedule deletion
+			// (retaining any fileId the current on-disk record still references — an aborted write may carry an
+			// already-saved blob shared with the surviving record; see harper-pro#406).
+			for (const write of this.writes) {
+				if (write?.savedBlobs)
+					cleanupUnusedBlobs(write.savedBlobs, collectRetainedFileIds(write.store.getEntry(write.key)?.value));
+			}
+		} finally {
+			try {
+				this.open = TRANSACTION_STATE.CLOSED;
+				this.endScopeOwnership();
+				this.clearWrites();
+				this.releaseContext(!this.timedOut && !this.disconnected);
+				if (!this.root) this.releaseRequestAbortListener();
+			} finally {
+				// Same guard as DatabaseTransaction.abort(): a child whose native commit is outstanding owns
+				// its own cleanup, and clearing its writes here would unlink blobs that commit still references.
+				if (next && !(next.nativeCommitSubmitted && next.commitsInFlight)) {
+					try {
+						next.abort(retainReadTransaction);
+					} catch (error) {
+						harperLogger.debug?.('cleaning up a chained LMDB transaction during abort', error);
+					}
+				}
+			}
 		}
-		// reset the transaction
-		this.clearWrites();
 	}
 	save(..._args: any[]): any {
 		// noop for LMDB
@@ -382,6 +477,7 @@ export class ImmediateTransaction extends LMDBTransaction {
 		this.db = db;
 	}
 	save(..._args: any[]): any {
+		this.admitRequestWrite(); // a deferred save reaches here without passing through addWrite()
 		return this.commit();
 	}
 	// @ts-expect-error accessor overriding property
@@ -406,6 +502,38 @@ function startMonitoringTxns() {
 			const commitChainHead = txn.commitChainHead ?? txn;
 			if (txn.timeout <= 0) {
 				const url = (txn.getContext() as any)?.url;
+				if (deferForCommitInFlight(txn, url, txnExpiration)) continue;
+				if (
+					txn.open === TRANSACTION_STATE.CLOSED &&
+					!txn.commitAttemptDoomedByPoison() &&
+					shouldSpareCommitPhase(txn, checkedCommitPhaseChains)
+				) {
+					harperLogger.warn?.(
+						`Transaction has been in its commit phase past the open-transaction limit, waiting on pre-commit work; letting it complete, from table: ${
+							(txn.db as any)?.name + (url ? ' path: ' + url : '')
+						}`
+					);
+					txn.timeout = Math.max(txnExpiration, txn.timeoutBudget ?? 0);
+					continue;
+				}
+				if (txn.open === TRANSACTION_STATE.CLOSED) {
+					// Only reachable through abort(true), which retained the snapshot for read iterators
+					// that own it. Nothing else here can reclaim it: the branches below would re-enter
+					// commit() on a poisoned transaction every tick, throw on its own poison check, and
+					// re-arm the timer — pinning an LMDB read snapshot, which blocks free-page reuse and
+					// grows the data file, for the life of the process. Close the owning iterators first so
+					// the reference comes back through doneReadTxn(), and force the release if it does not.
+					const closedIterators = txn.closeOwnedReadIterators();
+					if (closedIterators > 0 || txn.readTxn)
+						harperLogger.warn?.(
+							`Read iterators held a closed transaction's snapshot past the open-transaction limit; ${
+								txn.readTxn ? 'releasing it' : `closed ${closedIterators} abandoned iterator(s)`
+							}, from table: ${(txn.db as any)?.name + (url ? ' path: ' + url : '')}`
+						);
+					if (txn.readTxn) txn.releaseReadTxn();
+					trackedTxns.delete(txn);
+					continue;
+				}
 				if (shouldSpareCommitPhase(txn, checkedCommitPhaseChains)) {
 					// see DatabaseTransaction's monitor (issue #2062)
 					harperLogger.warn?.(

package/resources/RecordEncoder.ts

@@ -967,10 +967,9 @@ export function recordUpdater(store, tableId, auditStore) {
 				extendedType |= HAS_ADDITIONAL_AUDIT_REFS_AUDIT;
 			}
 			if (options?.localOnly) {
-				// Mark this write as local-only: set the bit in BOTH the persisted record metadata
-				// (so the full-copy send loop, which reads entry.metadataFlags, skips it) AND the audit
-				// entry's extendedType (so the audit-forward send path skips it by bitmask without decode).
 				metadataInNextEncoding |= LOCAL_ONLY;
+			}
+			if (options?.localOnly || options?.auditLocalOnly) {
 				extendedType |= LOCAL_ONLY;
 			}
 			if (previousResidencyId !== residencyId) {

package/resources/Resource.ts

@@ -873,15 +873,14 @@ function transactional(
 		// opposite treatment:
 		//  - committed: the prior call ran to completion normally. Safe to silently start a fresh
 		//    transaction for this independent call (the case above).
-		//  - aborted due to exceeding storage.maxTransactionOpenTime (#1411, DatabaseTransaction.ts
-		//    abortDueToTimeout(), marked via the `timedOut` poison flag): the whole logical operation
+		//  - poisoned (`timedOut`, #1411; or `disconnected`, harper#2001): the whole logical operation
 		//    must fail atomically, not have this write quietly land on a brand-new transaction while
 		//    the earlier write(s) were rolled back. Joining the poisoned transaction here (instead of
-		//    starting fresh) makes the write throw transactionOpenTooLongError via addWrite()/commit()'s
-		//    poison check, correctly propagating the abort to the caller. See
+		//    starting fresh) makes the write throw transactionOpenTooLongError/requestAbortedError via
+		//    addWrite()/commit()'s poison check, correctly propagating the abort to the caller. See
 		//    integrationTests/resources/txn-overtime-atomicity.test.ts.
-		if (isJoinableScope(context?.transaction) || context?.transaction?.timedOut) {
-			// we are already in a transaction (or it was poisoned by a timeout abort and must fail), proceed
+		if (isJoinableScope(context?.transaction) || context?.transaction?.timedOut || context?.transaction?.disconnected) {
+			// we are already in a transaction (or it was poisoned and must fail), proceed
 			const resource = this.getResource(query, context, resourceOptions);
 			return resource.then
 				? resource.then(authorizeActionOnResource)

package/resources/ResourceInterface.ts

@@ -143,7 +143,9 @@ export interface Context {
 	/**
 	 * Abort signal carried through ALS so generator bodies can forward cancellation to
 	 * external work (e.g. `scope.models.generateStream({ signal })`). Populated on the
-	 * Request that becomes the ALS-bound Context for HTTP/WS paths via #513.
+	 * Request that becomes the ALS-bound Context for HTTP/WS paths via #513. Also the request's
+	 * lifetime for its writes (harper#2001): once it aborts, no write for the request is admitted
+	 * and a write-bearing transaction is aborted at once (`DatabaseTransaction.admitRequestWrite`).
 	 */
 	signal?: AbortSignal;
 }

package/resources/RocksIndexStore.ts

@@ -4,6 +4,7 @@ import {
 	type CountEstimateOptions,
 	DBI,
 	type StoreIteratorOptions,
+	type StoreGetOptions,
 	type StorePutOptions,
 	type StoreRemoveOptions,
 	RocksDatabase,
@@ -44,6 +45,10 @@ function translateIndexBounds<
  * RocksDatabase rather than a store because it actually alters the interface
  */
 export class RocksIndexStore extends RocksDatabase {
+	hasIndexEntry(indexedValue: any, primaryKey: Id, options?: StoreGetOptions): boolean {
+		return super.getBinaryFastSync([indexedValue, primaryKey], options) !== undefined;
+	}
+
 	/**
 	 * Get all entries matching the range
 	 * @param options