@peerbit/document 13.0.34 → 13.0.35

package/src/search.ts

@@ -50,6 +50,12 @@ import MostCommonQueryPredictor, {
 import { type Operation, isPutOperation } from "./operation.js";
 import { Prefetch } from "./prefetch.js";
 import type { ExtractArgs } from "./program.js";
+import {
+	initializeResultType,
+	isResultIndexedValue,
+	isResultValue,
+	isResults,
+} from "./result-shape.js";
 import { ResumableIterators } from "./resumable-iterator.js";
 
 const WARNING_WHEN_ITERATING_FOR_MORE_THAN = 1e5;
@@ -411,19 +417,20 @@ const introduceEntries = async <
 			logger.error("Missing from for response");
 		}
 
-		if (response.response instanceof types.Results) {
+		if (isResults(response.response)) {
 			response.response.results.forEach((r) =>
-				r instanceof types.ResultValue
-					? r.init(documentType)
-					: r.init(indexedType),
+				initializeResultType(r, documentType, indexedType),
 			);
 			if (typeof options?.remote !== "boolean" && options?.remote?.replicate) {
 				const uniqueResults = response.response.results.filter((result) => {
+					const resultWithContext = result as
+						| types.ResultValue<T>
+						| types.ResultIndexedValue<I>;
 					const head =
-						result instanceof types.ResultIndexedValue &&
-						result.entries.length > 0
-							? result.entries[0]!.hash
-							: result.context.head;
+						isResultIndexedValue(resultWithContext) &&
+						resultWithContext.entries.length > 0
+							? resultWithContext.entries[0]!.hash
+							: resultWithContext.context.head;
 					if (replicatedHeads.has(head)) {
 						return false;
 					}
@@ -1491,24 +1498,24 @@ export class DocumentIndex<
 		options?: Options,
 	): Promise<WithContext<I>>;
 
-		public async get<
-			Options extends GetOptions<T, I, D, Resolve>,
-			Resolve extends boolean | undefined = ExtractResolveFromOptions<Options>,
-		>(key: indexerTypes.Ideable | indexerTypes.IdKey, options?: Options) {
-			let deferred:
-				| DeferredPromise<WithIndexedContext<T, I> | WithContext<I>>
-				| undefined;
-			let baseRemote:
-				| RemoteQueryOptions<
-						types.AbstractSearchRequest,
-						types.AbstractSearchResult,
-						D
-				  >
-				| undefined;
-
-			// Normalize the id key early so listeners can use it
-			let idKey =
-				key instanceof indexerTypes.IdKey ? key : indexerTypes.toId(key);
+	public async get<
+		Options extends GetOptions<T, I, D, Resolve>,
+		Resolve extends boolean | undefined = ExtractResolveFromOptions<Options>,
+	>(key: indexerTypes.Ideable | indexerTypes.IdKey, options?: Options) {
+		let deferred:
+			| DeferredPromise<WithIndexedContext<T, I> | WithContext<I>>
+			| undefined;
+		let baseRemote:
+			| RemoteQueryOptions<
+					types.AbstractSearchRequest,
+					types.AbstractSearchResult,
+					D
+			  >
+			| undefined;
+
+		// Normalize the id key early so listeners can use it
+		let idKey =
+			key instanceof indexerTypes.IdKey ? key : indexerTypes.toId(key);
 
 		if (options?.waitFor) {
 			// add change listener before query because we might get a concurrent change that matches the query,
@@ -1541,16 +1548,16 @@ export class DocumentIndex<
 
 			let timeout = setTimeout(resolveUndefined, options.waitFor);
 			this.events.addEventListener("close", resolveUndefined);
-				this.documentEvents.addEventListener("change", listener);
-				deferred.promise.then(cleanup);
-
-				// Prepare remote options without mutating caller options
-				baseRemote =
-					options?.remote === false
-						? undefined
-						: typeof options?.remote === "object"
-							? { ...options.remote }
-							: {};
+			this.documentEvents.addEventListener("change", listener);
+			deferred.promise.then(cleanup);
+
+			// Prepare remote options without mutating caller options
+			baseRemote =
+				options?.remote === false
+					? undefined
+					: typeof options?.remote === "object"
+						? { ...options.remote }
+						: {};
 			if (baseRemote) {
 				const waitPolicy = baseRemote.wait;
 				if (
@@ -1586,20 +1593,20 @@ export class DocumentIndex<
 							deferred!.resolve(first.value as any);
 						}
 					},
-					});
-				}
+				});
 			}
+		}
 
-			const initialOptions = baseRemote
-				? ({ ...(options as any), remote: baseRemote } as Options)
-				: options;
-			const result =
-				(await this.getDetailed(idKey, initialOptions))?.[0]?.results[0];
+		const initialOptions = baseRemote
+			? ({ ...(options as any), remote: baseRemote } as Options)
+			: options;
+		const result = (await this.getDetailed(idKey, initialOptions))?.[0]
+			?.results[0];
 
-			// if no results, and we have remote joining options, we wait for the timout and if there are joining peers we re-query
-			if (!result) {
-				return deferred?.promise;
-			} else if (deferred) {
+		// if no results, and we have remote joining options, we wait for the timout and if there are joining peers we re-query
+		if (!result) {
+			return deferred?.promise;
+		} else if (deferred) {
 			deferred.resolve(undefined);
 		}
 		return result?.value;
@@ -1822,15 +1829,14 @@ export class DocumentIndex<
 					let value = set.results[i];
 					let resolved: T | undefined;
 					if (shouldResolve) {
-						resolved =
-							value instanceof types.ResultIndexedValue
-								? (
-										await this.resolveDocument({
-											indexed: value.value,
-											head: value.context.head,
-										})
-									)?.value
-								: value.value;
+						resolved = isResultIndexedValue(value)
+							? (
+									await this.resolveDocument({
+										indexed: value.value,
+										head: value.context.head,
+									})
+								)?.value
+							: value.value;
 					} else {
 						resolved = value.value as T;
 					}
@@ -2001,26 +2007,26 @@ export class DocumentIndex<
 			const resolveFlag = resolvesDocuments(
 				(fromQuery || query) as AnyIterationRequest,
 			);
-				prevQueued = {
-					from,
-					queue: [],
-					timeout: setTimeout(() => {
-						this._resultQueue.delete(query.idString);
-					}, 6e4),
-					keptInIndex: kept,
-					fromQuery: (fromQuery || query) as
-						| types.SearchRequest
-						| types.SearchRequestIndexed
-						| types.IterationRequest,
-					resolveResults: resolveFlag,
-				};
-				// Don't keep Node alive just to GC old remote iterator state.
-				prevQueued.timeout.unref?.();
-				if (
-					fromQuery instanceof types.IterationRequest &&
-					fromQuery.pushUpdates
-				) {
-					prevQueued.pushMode = fromQuery.pushUpdates;
+			prevQueued = {
+				from,
+				queue: [],
+				timeout: setTimeout(() => {
+					this._resultQueue.delete(query.idString);
+				}, 6e4),
+				keptInIndex: kept,
+				fromQuery: (fromQuery || query) as
+					| types.SearchRequest
+					| types.SearchRequestIndexed
+					| types.IterationRequest,
+				resolveResults: resolveFlag,
+			};
+			// Don't keep Node alive just to GC old remote iterator state.
+			prevQueued.timeout.unref?.();
+			if (
+				fromQuery instanceof types.IterationRequest &&
+				fromQuery.pushUpdates
+			) {
+				prevQueued.pushMode = fromQuery.pushUpdates;
 			}
 			this._resultQueue.set(query.idString, prevQueued);
 		}
@@ -2118,19 +2124,19 @@ export class DocumentIndex<
 				string,
 				ReturnType<typeof setTimeout>
 			>());
-			const timer = setTimeout(() => {
-				timers.delete(idString);
-				const queued = this._resultQueue.get(idString);
-				if (queued) {
-					clearTimeout(queued.timeout);
-					this._resultQueue.delete(idString);
-				}
-				this._resumableIterators.close({ idString });
-			}, delay);
-			// This is a best-effort cleanup timer; it should not keep Node alive.
-			timer.unref?.();
-			timers.set(idString, timer);
-		}
+		const timer = setTimeout(() => {
+			timers.delete(idString);
+			const queued = this._resultQueue.get(idString);
+			if (queued) {
+				clearTimeout(queued.timeout);
+				this._resultQueue.delete(idString);
+			}
+			this._resumableIterators.close({ idString });
+		}, delay);
+		// This is a best-effort cleanup timer; it should not keep Node alive.
+		timer.unref?.();
+		timers.set(idString, timer);
+	}
 
 	private cancelIteratorKeepAlive(idString: string) {
 		const timers = this.iteratorKeepAliveTimers;
@@ -2325,16 +2331,17 @@ export class DocumentIndex<
 		const onQueryJoin = (e: { detail: PublicSignKey }) => {
 			void handlePeer(e.detail);
 		};
-		const onReplicatorEvent = (e: {
-			detail: { publicKey: PublicSignKey };
-		}) => {
+		const onReplicatorEvent = (e: { detail: { publicKey: PublicSignKey } }) => {
 			void handlePeer(e.detail.publicKey);
 		};
 
 		this._query.events.addEventListener("join", onQueryJoin);
 		this._log?.events?.addEventListener("replicator:join", onReplicatorEvent);
 		this._log?.events?.addEventListener("replicator:mature", onReplicatorEvent);
-		this._log?.events?.addEventListener("replication:change", onReplicatorEvent);
+		this._log?.events?.addEventListener(
+			"replication:change",
+			onReplicatorEvent,
+		);
 
 		return () => {
 			this._query.events.removeEventListener("join", onQueryJoin);
@@ -2389,20 +2396,20 @@ export class DocumentIndex<
 		queryRequest: R,
 		options?: QueryDetailedOptions<T, I, D, boolean | undefined>,
 		fetchFirstForRemote?: Set<string>,
-		): Promise<types.Results<RT>[]> {
-			const local = typeof options?.local === "boolean" ? options?.local : true;
-			let remote:
-				| RemoteQueryOptions<
-						types.AbstractSearchRequest,
-						types.AbstractSearchResult,
-						D
-				  >
-				| undefined = undefined;
-			if (typeof options?.remote === "boolean") {
-				remote = options.remote ? {} : undefined;
-			} else {
-				remote = options?.remote || {};
-			}
+	): Promise<types.Results<RT>[]> {
+		const local = typeof options?.local === "boolean" ? options?.local : true;
+		let remote:
+			| RemoteQueryOptions<
+					types.AbstractSearchRequest,
+					types.AbstractSearchResult,
+					D
+			  >
+			| undefined = undefined;
+		if (typeof options?.remote === "boolean") {
+			remote = options.remote ? {} : undefined;
+		} else {
+			remote = options?.remote || {};
+		}
 		if (remote && remote.priority == null) {
 			// give queries higher priority than other "normal" data activities
 			// without this, we might have a scenario that a peer joina  network with large amount of data to be synced, but can not query anything before that is done
@@ -2447,58 +2454,61 @@ export class DocumentIndex<
 				throw new Error("Unexpected");
 			}
 
-				const coverProps = remote.domain ?? { args: undefined };
-				const isDefaultDomainArgs =
-					!("range" in coverProps) &&
-					(!("args" in coverProps) || (coverProps as any).args == null);
-				const remoteWasExplicit = options?.remote != null;
-
-				let replicatorGroups = options?.remote?.from
-					? options?.remote?.from
-					: await this._log.getCover(coverProps, {
-							roleAge: remote.minAge,
-							eager: remote.reach?.eager,
-							reachableOnly: !!remote.wait, // when we want to merge joining we can ignore pending to be online peers and instead consider them once they become online
-							signal: options?.signal,
-						});
+			const coverProps = remote.domain ?? { args: undefined };
+			const isDefaultDomainArgs =
+				!("range" in coverProps) &&
+				(!("args" in coverProps) || (coverProps as any).args == null);
+			const remoteWasExplicit = options?.remote != null;
+
+			let replicatorGroups = options?.remote?.from
+				? options?.remote?.from
+				: await this._log.getCover(coverProps, {
+						roleAge: remote.minAge,
+						eager: remote.reach?.eager,
+						reachableOnly: !!remote.wait, // when we want to merge joining we can ignore pending to be online peers and instead consider them once they become online
+						signal: options?.signal,
+					});
 
-					// Cold start: cover can be temporarily self-only while replication metadata
-					// converges. For explicit remote searches, query bounded connected peers
-					// instead of waiting for replicator metadata to catch up.
-					if (!options?.remote?.from && isDefaultDomainArgs && remoteWasExplicit) {
-						const selfHash = this.node.identity.publicKey.hashcode();
-						const remoteCount = replicatorGroups.filter((h) => h !== selfHash).length;
-						if (remoteCount === 0) {
-							const waitEnabled = Boolean(remote.wait);
-							const coverIsSelfOnly =
-								replicatorGroups.length === 1 && replicatorGroups[0] === selfHash;
-
-							// If the cover is explicitly empty (no shards), don't override it unless
-							// the caller requested waiting for joins (e.g. get(waitFor)).
-							if (waitEnabled || coverIsSelfOnly) {
-								const peerMap: Map<string, unknown> | undefined = (this.node.services
-									.pubsub as any)?.peers;
-								if (peerMap?.keys) {
-									const extra: string[] = [];
-									for (const hash of peerMap.keys()) {
-										if (!hash || hash === selfHash) continue;
-										extra.push(hash);
-										if (extra.length >= 8) break;
-									}
-									if (extra.length > 0) {
-										replicatorGroups = [
-											...new Set([...replicatorGroups, ...extra]),
-										];
-									}
-								}
+			// Cold start: cover can be temporarily self-only while replication metadata
+			// converges. For explicit remote searches, query bounded connected peers
+			// instead of waiting for replicator metadata to catch up.
+			if (!options?.remote?.from && isDefaultDomainArgs && remoteWasExplicit) {
+				const selfHash = this.node.identity.publicKey.hashcode();
+				const remoteCount = replicatorGroups.filter(
+					(h) => h !== selfHash,
+				).length;
+				if (remoteCount === 0) {
+					const waitEnabled = Boolean(remote.wait);
+					const coverIsSelfOnly =
+						replicatorGroups.length === 1 && replicatorGroups[0] === selfHash;
+
+					// If the cover is explicitly empty (no shards), don't override it unless
+					// the caller requested waiting for joins (e.g. get(waitFor)).
+					if (waitEnabled || coverIsSelfOnly) {
+						const peerMap: Map<string, unknown> | undefined = (
+							this.node.services.pubsub as any
+						)?.peers;
+						if (peerMap?.keys) {
+							const extra: string[] = [];
+							for (const hash of peerMap.keys()) {
+								if (!hash || hash === selfHash) continue;
+								extra.push(hash);
+								if (extra.length >= 8) break;
+							}
+							if (extra.length > 0) {
+								replicatorGroups = [
+									...new Set([...replicatorGroups, ...extra]),
+								];
 							}
 						}
 					}
+				}
+			}
 
-				if (replicatorGroups) {
-					const responseHandler = async (
-						results: {
-							response: types.AbstractSearchResult;
+			if (replicatorGroups) {
+				const responseHandler = async (
+					results: {
+						response: types.AbstractSearchResult;
 						from?: PublicSignKey;
 					}[],
 				) => {
@@ -2734,7 +2744,7 @@ export class DocumentIndex<
 		result: types.ResultValue<T> | types.ResultIndexedValue<I>,
 		results: types.ResultTypeFromRequest<R, T, I>[],
 	) {
-		if (result instanceof types.ResultIndexedValue) {
+		if (isResultIndexedValue(result)) {
 			return coerceWithContext(result.value as I, result.context);
 		}
 
@@ -2752,7 +2762,7 @@ export class DocumentIndex<
 				) => {
 					// look through the search results and see if we can find the indexed representation
 					for (const otherResult of results) {
-						if (otherResult instanceof types.ResultIndexedValue) {
+						if (isResultIndexedValue(otherResult)) {
 							if (otherResult.context.head === result.context.head) {
 								otherResult.init(this.indexedType);
 								return coerceWithContext(
@@ -2991,7 +3001,7 @@ export class DocumentIndex<
 		}
 		const retryMissingResponseGroups =
 			typeof options?.remote === "object"
-				? options.remote.retryMissingResponses ?? true
+				? (options.remote.retryMissingResponses ?? true)
 				: true;
 
 		indexIteratorLogger.trace("Iterate with options", {
@@ -3243,7 +3253,7 @@ export class DocumentIndex<
 						if (response instanceof types.NoAccess) {
 							logger.error("Dont have access");
 							return;
-						} else if (response instanceof types.Results) {
+						} else if (isResults(response)) {
 							const results = response as types.Results<
 								types.ResultTypeFromRequest<R, T, I>
 							>;
@@ -3280,7 +3290,7 @@ export class DocumentIndex<
 								const indexKey = indexerTypes.toId(
 									this.indexByResolver(result.value),
 								).primitive;
-								if (result instanceof types.ResultValue) {
+								if (isResultValue(result)) {
 									const existingIndexed = indexedPlaceholders?.get(indexKey);
 									if (existingIndexed) {
 										existingIndexed.value =
@@ -3309,6 +3319,8 @@ export class DocumentIndex<
 										),
 									});
 								} else {
+									const indexedResult =
+										result as unknown as types.ResultIndexedValue<I>;
 									if (
 										visited.has(indexKey) &&
 										!indexedPlaceholders?.has(indexKey)
@@ -3317,12 +3329,12 @@ export class DocumentIndex<
 									}
 									visited.add(indexKey);
 									const indexed = coerceWithContext(
-										result.indexed || result.value,
-										result.context,
+										indexedResult.indexed || indexedResult.value,
+										indexedResult.context,
 									);
 									const placeholder = {
-										value: result.value,
-										context: result.context,
+										value: indexedResult.value,
+										context: indexedResult.context,
 										from,
 										indexed,
 									};
@@ -3346,9 +3358,11 @@ export class DocumentIndex<
 						if (!retryMissingResponseGroups) {
 							return;
 						}
-						const missingGroups = (error as MissingResponsesError & {
-							missingGroups?: string[][];
-						}).missingGroups;
+						const missingGroups = (
+							error as MissingResponsesError & {
+								missingGroups?: string[][];
+							}
+						).missingGroups;
 						if (!missingGroups?.length) {
 							return;
 						}
@@ -3472,7 +3486,7 @@ export class DocumentIndex<
 											const keyPrimitive = indexerTypes.toId(
 												this.indexByResolver(result.value),
 											).primitive;
-											if (result instanceof types.ResultValue) {
+											if (isResultValue(result)) {
 												const existingIndexed =
 													indexedPlaceholders?.get(keyPrimitive);
 												if (existingIndexed) {
@@ -3519,6 +3533,8 @@ export class DocumentIndex<
 													indexed,
 												});
 											} else {
+												const indexedResult =
+													result as unknown as types.ResultIndexedValue<I>;
 												if (
 													visited.has(keyPrimitive) &&
 													!indexedPlaceholders?.has(keyPrimitive)
@@ -3527,12 +3543,12 @@ export class DocumentIndex<
 												}
 												visited.add(keyPrimitive);
 												const indexed = coerceWithContext(
-													result.indexed || result.value,
-													result.context,
+													indexedResult.indexed || indexedResult.value,
+													indexedResult.context,
 												);
 												const placeholder = {
-													value: result.value,
-													context: result.context,
+													value: indexedResult.value,
+													context: indexedResult.context,
 													from: this.node.identity.publicKey,
 													indexed,
 												};
@@ -3621,7 +3637,7 @@ export class DocumentIndex<
 															const indexKey = indexerTypes.toId(
 																this.indexByResolver(result.value),
 															).primitive;
-															if (result instanceof types.ResultValue) {
+															if (isResultValue(result)) {
 																const existingIndexed =
 																	indexedPlaceholders?.get(indexKey);
 																if (existingIndexed) {
@@ -3672,6 +3688,8 @@ export class DocumentIndex<
 																	indexed,
 																});
 															} else {
+																const indexedResult =
+																	result as unknown as types.ResultIndexedValue<I>;
 																if (
 																	visited.has(indexKey) &&
 																	!indexedPlaceholders?.has(indexKey)
@@ -3680,12 +3698,12 @@ export class DocumentIndex<
 																}
 																visited.add(indexKey);
 																const indexed = coerceWithContext(
-																	result.value,
-																	result.context,
+																	indexedResult.value,
+																	indexedResult.context,
 																);
 																const placeholder = {
-																	value: result.value,
-																	context: result.context,
+																	value: indexedResult.value,
+																	context: indexedResult.context,
 																	from: from!,
 																	indexed,
 																};
@@ -3764,9 +3782,7 @@ export class DocumentIndex<
 			// blocking on an eager remote top-up for the full requested batch size.
 			// This keeps `next(n)` responsive when a late push/update arrives while a
 			// remote iterator has no more immediate items to collect.
-			const fetchedAll = preferBufferedResults
-				? false
-				: await fetchAtLeast(n);
+			const fetchedAll = preferBufferedResults ? false : await fetchAtLeast(n);
 
 			// get n next top entries, shift and pull more results
 			const peerBuffersArr = peerBuffers();
@@ -3854,32 +3870,30 @@ export class DocumentIndex<
 			done = true;
 		};
 
-			let close = async () => {
-				cleanupAndDone();
+		let close = async () => {
+			cleanupAndDone();
 
-				// Keep-open iterators can still have active remote state even when
-				// their pending count has already drained to zero.
-				const closeRequest = new types.CloseIteratorRequest({
-					id: queryRequestCoerced.id,
-				});
-				const selfHash = this.node.identity.publicKey.hashcode();
-				const remotePeers = keepRemoteAlive
-					? [...peerBufferMap.keys()].filter((peer) => peer !== selfHash)
-					: [...peerBufferMap.entries()]
-							.filter(
-								([peer, buffer]) => peer !== selfHash && buffer.kept > 0,
-							)
-							.map(([peer]) => peer);
-				peerBufferMap.clear();
-				await Promise.allSettled(
-					remotePeers.map((peer) =>
-						this._query.send(closeRequest, {
-							...options,
-							mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
-						}),
-					),
-				);
-			};
+			// Keep-open iterators can still have active remote state even when
+			// their pending count has already drained to zero.
+			const closeRequest = new types.CloseIteratorRequest({
+				id: queryRequestCoerced.id,
+			});
+			const selfHash = this.node.identity.publicKey.hashcode();
+			const remotePeers = keepRemoteAlive
+				? [...peerBufferMap.keys()].filter((peer) => peer !== selfHash)
+				: [...peerBufferMap.entries()]
+						.filter(([peer, buffer]) => peer !== selfHash && buffer.kept > 0)
+						.map(([peer]) => peer);
+			peerBufferMap.clear();
+			await Promise.allSettled(
+				remotePeers.map((peer) =>
+					this._query.send(closeRequest, {
+						...options,
+						mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
+					}),
+				),
+			);
+		};
 		options?.signal && options.signal.addEventListener("abort", close);
 
 		let doneFn = () => {
@@ -4122,7 +4136,7 @@ export class DocumentIndex<
 					const indexKey = indexerTypes.toId(
 						this.indexByResolver(result.value),
 					).primitive;
-					if (result instanceof types.ResultValue) {
+					if (isResultValue(result)) {
 						const existingIndexed = indexedPlaceholders?.get(indexKey);
 						if (existingIndexed) {
 							existingIndexed.value =
@@ -4165,18 +4179,20 @@ export class DocumentIndex<
 							indexed,
 						});
 					} else {
+						const indexedResult =
+							result as unknown as types.ResultIndexedValue<I>;
 						const indexed = coerceWithContext(
-							result.indexed || result.value,
-							result.context,
+							indexedResult.indexed || indexedResult.value,
+							indexedResult.context,
 						);
 						const late = isLateResult(indexed);
 						if (late) {
 							lateCount++;
 							lateResults?.push({
 								indexed,
-								context: result.context,
+								context: indexedResult.context,
 								from: from!,
-								value: result.value,
+								value: indexedResult.value,
 							});
 							if (outOfOrderMode === "drop") {
 								visited.add(indexKey);
@@ -4188,8 +4204,8 @@ export class DocumentIndex<
 						}
 						visited.add(indexKey);
 						const placeholder = {
-							value: result.value,
-							context: result.context,
+							value: indexedResult.value,
+							context: indexedResult.context,
 							from,
 							indexed,
 						};
@@ -4240,7 +4256,7 @@ export class DocumentIndex<
 							continue;
 						}
 						const payload = response.response;
-						if (!(payload instanceof types.Results)) {
+						if (!isResults(payload)) {
 							continue;
 						}
 						await mergePrefetchedResults(
@@ -4477,7 +4493,9 @@ export class DocumentIndex<
 		}
 
 		const remoteConfig =
-			options && typeof options.remote === "object" ? options.remote : undefined;
+			options && typeof options.remote === "object"
+				? options.remote
+				: undefined;
 		const remoteWaitPolicy =
 			remoteConfig && typeof remoteConfig.wait === "object"
 				? remoteConfig.wait
@@ -4485,63 +4503,62 @@ export class DocumentIndex<
 		const remoteWaitBehavior: WaitBehavior =
 			remoteWaitPolicy?.behavior ?? "keep-open";
 		const keepRemoteWaitOpen =
-			!!remoteConfig?.wait &&
-			remoteWaitBehavior === "keep-open";
+			!!remoteConfig?.wait && remoteWaitBehavior === "keep-open";
 		let fetchLateJoinPeers = async (
 			_candidateHashes?: Iterable<string>,
 			_candidateKeys?: Map<string, PublicSignKey>,
 		) => false;
 
-			if (keepRemoteWaitOpen) {
-				// was used to account for missed results when a peer joins; omitted in this minimal handler
-
-				updateDeferred = pDefer<void>();
-				const lateJoinFetchesInFlight = new Set<string>();
-				const shouldIgnoreLateJoinFetchError = (error: unknown) => {
-					if (
-						this.closed ||
-						ensureController().signal.aborted ||
-						error instanceof ClosedError ||
-						error instanceof AbortError
-					) {
-						return true;
-					}
-					return (
-						error instanceof Error &&
-						error.message.trim().toLowerCase() === "closed"
-					);
-				};
+		if (keepRemoteWaitOpen) {
+			// was used to account for missed results when a peer joins; omitted in this minimal handler
 
-					fetchLateJoinPeers = async (
-						candidateHashes?: Iterable<string>,
-						candidateKeys?: Map<string, PublicSignKey>,
-					) => {
-						if (totalFetchedCounter === 0) {
-							return false;
-						}
-						if (this.closed || ensureController().signal.aborted) {
-							return false;
-						}
+			updateDeferred = pDefer<void>();
+			const lateJoinFetchesInFlight = new Set<string>();
+			const shouldIgnoreLateJoinFetchError = (error: unknown) => {
+				if (
+					this.closed ||
+					ensureController().signal.aborted ||
+					error instanceof ClosedError ||
+					error instanceof AbortError
+				) {
+					return true;
+				}
+				return (
+					error instanceof Error &&
+					error.message.trim().toLowerCase() === "closed"
+				);
+			};
 
-						if (done) {
-							unsetDone();
-						}
+			fetchLateJoinPeers = async (
+				candidateHashes?: Iterable<string>,
+				candidateKeys?: Map<string, PublicSignKey>,
+			) => {
+				if (totalFetchedCounter === 0) {
+					return false;
+				}
+				if (this.closed || ensureController().signal.aborted) {
+					return false;
+				}
 
-					const selfHash = this.node.identity.publicKey.hashcode();
-					const knownCandidateKeys = candidateKeys
-						? new Map(candidateKeys)
-						: new Map<string, PublicSignKey>();
-					let hashes: string[];
-					try {
-						hashes = candidateHashes
-							? [...candidateHashes]
-							: [...(await this._log.getReplicators()).keys()];
-					} catch (error) {
-						if (shouldIgnoreLateJoinFetchError(error)) {
-							return false;
-						}
-						throw error;
+				if (done) {
+					unsetDone();
+				}
+
+				const selfHash = this.node.identity.publicKey.hashcode();
+				const knownCandidateKeys = candidateKeys
+					? new Map(candidateKeys)
+					: new Map<string, PublicSignKey>();
+				let hashes: string[];
+				try {
+					hashes = candidateHashes
+						? [...candidateHashes]
+						: [...(await this._log.getReplicators()).keys()];
+				} catch (error) {
+					if (shouldIgnoreLateJoinFetchError(error)) {
+						return false;
 					}
+					throw error;
+				}
 				let missing = hashes.filter((hash) => {
 					if (hash === selfHash) return false;
 					if (peerBufferMap.has(hash)) return false;
@@ -4604,23 +4621,23 @@ export class DocumentIndex<
 						return false;
 					}
 
-						const lateJoinFetchPromise = trackFetch(
-							fetchFirst(totalFetchedCounter, {
-								from: unresolved,
-								fetchedFirstForRemote,
-							}),
-						);
-						try {
-							await lateJoinFetchPromise;
-						} catch (error) {
-							if (shouldIgnoreLateJoinFetchError(error)) {
-								return false;
-							}
-							throw error;
+					const lateJoinFetchPromise = trackFetch(
+						fetchFirst(totalFetchedCounter, {
+							from: unresolved,
+							fetchedFirstForRemote,
+						}),
+					);
+					try {
+						await lateJoinFetchPromise;
+					} catch (error) {
+						if (shouldIgnoreLateJoinFetchError(error)) {
+							return false;
 						}
-						for (const hash of unresolved) {
-							if (!peerBufferMap.has(hash)) {
-								fetchedFirstForRemote?.delete(hash);
+						throw error;
+					}
+					for (const hash of unresolved) {
+						if (!peerBufferMap.has(hash)) {
+							fetchedFirstForRemote?.delete(hash);
 						}
 					}