@peerbit/document 13.1.6 → 13.1.8

package/dist/src/search.js

@@ -48,7 +48,7 @@ import { SharedLog, } from "@peerbit/shared-log";
 import { DataMessage, FOREGROUND_READ_MESSAGE_PRIORITY, SilentDelivery, } from "@peerbit/stream-interface";
 import { AbortError, TimeoutError, waitFor } from "@peerbit/time";
 import pDefer, {} from "p-defer";
-import { concat, fromString } from "uint8arrays";
+import { concat, equals, fromString } from "uint8arrays";
 import { copySerialization } from "./borsh.js";
 import { MAX_BATCH_SIZE } from "./constants.js";
 import MostCommonQueryPredictor, { idAgnosticQueryKey, } from "./most-common-query-predictor.js";
@@ -377,6 +377,7 @@ function isSubclassOf(SubClass, SuperClass) {
 const DEFAULT_TIMEOUT = 1e4;
 const DEFAULT_KEEP_REMOTE_ITERATOR_TIMEOUT = 3e5;
 const DISCOVER_TIMEOUT_FALLBACK = 500;
+const CLOSE_ITERATOR_REQUEST_TIMEOUT = 5e3;
 const DEFAULT_INDEX_BY = "id";
 export const INDEX_CONTEXT_SHAPE = {
     __context: {
@@ -2794,6 +2795,7 @@ let DocumentIndex = (() => {
                     };
                     let extraPromises = undefined;
                     const seenRemoteHashes = new Set();
+                    const selectedRemoteHashes = [];
                     const groupHashes = replicatorGroups
                         .filter((hash) => {
                         if (hash === this.node.identity.publicKey.hashcode()) {
@@ -2808,6 +2810,7 @@ let DocumentIndex = (() => {
                             return false;
                         }
                         fetchFirstForRemote?.add(hash);
+                        selectedRemoteHashes.push(hash);
                         const resultAlready = this._prefetch?.accumulator.consume(queryRequest, hash);
                         if (resultAlready) {
                             (extraPromises || (extraPromises = [])).push((async () => {
@@ -2826,6 +2829,7 @@ let DocumentIndex = (() => {
                         return true;
                     })
                         .map((x) => [x]);
+                    options?.onRemoteTargets?.(selectedRemoteHashes);
                     extraPromises && (await Promise.all(extraPromises));
                     let tearDown = undefined;
                     const search = this;
@@ -2930,16 +2934,20 @@ let DocumentIndex = (() => {
             // Use an iterator so large results respect message size limits.
             const iterator = this.iterate(coercedRequest, searchOptions);
             const allResults = [];
-            while (iterator.done() !== true &&
-                coercedRequest.fetch > allResults.length) {
-                // We might need to pull .next multiple time due to data message size limitations
-                for (const result of await iterator.next(coercedRequest.fetch - allResults.length)) {
-                    allResults.push(result);
+            try {
+                while (iterator.done() !== true &&
+                    coercedRequest.fetch > allResults.length) {
+                    // We might need to pull .next multiple time due to data message size limitations
+                    for (const result of await iterator.next(coercedRequest.fetch - allResults.length)) {
+                        allResults.push(result);
+                    }
                 }
+                // Deduplicate and return values directly
+                return dedup(allResults, this.indexByResolver);
+            }
+            finally {
+                await iterator.close();
             }
-            await iterator.close();
-            // Deduplicate and return values directly
-            return dedup(allResults, this.indexByResolver);
         }
         resolveIndexed(result, results) {
             if (isResultIndexedValue(result)) {
@@ -3135,6 +3143,48 @@ let DocumentIndex = (() => {
                 return tracked;
             };
             const peerBufferMap = new Map();
+            const remoteIteratorPeersToClose = new Set();
+            const staleRemoteIteratorIdsToClose = new Map();
+            const retiredRemoteIteratorPeers = new Set();
+            const pendingMissingResponseRetryPeers = new Set();
+            const missingResponseRetryAttempts = new Map();
+            const maxMissingResponseRetryAttempts = 2;
+            const retireRemoteIteratorPeer = (peer) => {
+                remoteIteratorPeersToClose.add(peer);
+                retiredRemoteIteratorPeers.add(peer);
+                const peerBuffer = peerBufferMap.get(peer);
+                if (!peerBuffer || peerBuffer.buffer.length === 0) {
+                    peerBufferMap.delete(peer);
+                }
+                else {
+                    // Keep already-received values available to the caller, but do not
+                    // issue another CollectNextRequest until a fresh iteration succeeds.
+                    peerBuffer.kept = 0;
+                }
+            };
+            const recordMissingResponseGroups = (missingGroups) => {
+                const selfHash = this.node.identity.publicKey.hashcode();
+                for (const group of missingGroups) {
+                    for (const hash of group) {
+                        if (hash && hash !== selfHash) {
+                            retireRemoteIteratorPeer(hash);
+                        }
+                    }
+                    if (!retryMissingResponseGroups) {
+                        continue;
+                    }
+                    const target = group.find((hash) => {
+                        if (!hash || hash === selfHash)
+                            return false;
+                        const attempts = missingResponseRetryAttempts.get(hash) ?? 0;
+                        return attempts < maxMissingResponseRetryAttempts;
+                    });
+                    if (!target)
+                        continue;
+                    pendingMissingResponseRetryPeers.add(target);
+                    missingResponseRetryAttempts.set(target, (missingResponseRetryAttempts.get(target) ?? 0) + 1);
+                }
+            };
             const visited = new Set();
             let indexedPlaceholders;
             const ensureIndexedPlaceholders = () => {
@@ -3314,6 +3364,15 @@ let DocumentIndex = (() => {
                 }
             }
             const fetchFirst = async (n, fetchOptions) => {
+                const remoteRequestOptions = typeof options?.remote === "object" ? options.remote : undefined;
+                const fetchSignals = [
+                    options?.signal,
+                    remoteRequestOptions?.signal,
+                    ensureController().signal,
+                ].filter((signal) => signal != null);
+                const fetchSignal = fetchSignals.length === 1
+                    ? fetchSignals[0]
+                    : AbortSignal.any(fetchSignals);
                 await warmupPromise;
                 let hasMore = false;
                 let missingResponses = false;
@@ -3326,43 +3385,56 @@ let DocumentIndex = (() => {
                 const skipRemoteDueToDiscovery = typeof options?.remote === "object" &&
                     options.remote.reach?.discover &&
                     discoveredTargetHashes?.length === 0;
+                const queryRemote = options?.remote !== false && !skipRemoteDueToDiscovery;
+                const remoteFrom = fetchOptions?.from ??
+                    initialRemoteTargets ??
+                    remoteRequestOptions?.from;
+                if (queryRemote) {
+                    const selfHash = this.node.identity.publicKey.hashcode();
+                    for (const peer of remoteFrom ?? []) {
+                        if (peer !== selfHash) {
+                            remoteIteratorPeersToClose.add(peer);
+                        }
+                    }
+                }
                 queryRequestCoerced.fetch = n;
                 await this.queryCommence(queryRequestCoerced, {
                     local: fetchOptions?.from != null ? false : options?.local,
-                    remote: options?.remote !== false && !skipRemoteDueToDiscovery
+                    remote: queryRemote
                         ? {
-                            ...(typeof options?.remote === "object"
-                                ? options.remote
-                                : {}),
-                            from: fetchOptions?.from ??
-                                initialRemoteTargets ??
-                                (typeof options?.remote === "object"
-                                    ? options.remote.from
-                                    : undefined),
+                            ...remoteRequestOptions,
+                            from: remoteFrom,
+                            signal: fetchSignal,
                         }
                         : false,
                     resolve,
-                    signal: options?.signal,
+                    signal: fetchSignal,
                     onResponse: async (response, from) => {
                         if (!from) {
                             logger.error("Missing response from");
                             return;
                         }
+                        const fromHash = from.hashcode();
+                        remoteIteratorPeersToClose.add(fromHash);
+                        retiredRemoteIteratorPeers.delete(fromHash);
                         if (response instanceof types.NoAccess) {
                             logger.error("Dont have access");
                             return;
                         }
                         else if (isResults(response)) {
                             const results = response;
-                            const existingBuffer = peerBufferMap.get(from.hashcode());
+                            const existingBuffer = peerBufferMap.get(fromHash);
                             const buffer = existingBuffer?.buffer || [];
                             if (results.kept === 0n && results.results.length === 0) {
                                 if (keepRemoteAlive) {
-                                    peerBufferMap.set(from.hashcode(), {
+                                    peerBufferMap.set(fromHash, {
                                         buffer,
                                         kept: 0,
                                     });
                                 }
+                                else {
+                                    remoteIteratorPeersToClose.delete(fromHash);
+                                }
                                 return;
                             }
                             const reqFetch = queryRequestCoerced.fetch ?? 0;
@@ -3371,6 +3443,9 @@ let DocumentIndex = (() => {
                             if (effectiveKept > 0) {
                                 hasMore = true;
                             }
+                            else if (!keepRemoteAlive) {
+                                remoteIteratorPeersToClose.delete(fromHash);
+                            }
                             for (const result of results.results) {
                                 const indexKey = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
                                 if (isResultValue(result)) {
@@ -3415,7 +3490,7 @@ let DocumentIndex = (() => {
                                     ensureIndexedPlaceholders().set(indexKey, placeholder);
                                 }
                             }
-                            peerBufferMap.set(from.hashcode(), {
+                            peerBufferMap.set(fromHash, {
                                 buffer,
                                 kept: effectiveKept,
                             });
@@ -3426,29 +3501,21 @@ let DocumentIndex = (() => {
                     },
                     onMissingResponses: (error) => {
                         missingResponses = true;
-                        if (!retryMissingResponseGroups) {
-                            return;
-                        }
                         const missingGroups = error.missingGroups;
                         if (!missingGroups?.length) {
                             return;
                         }
-                        const selfHash = this.node.identity.publicKey.hashcode();
-                        for (const group of missingGroups) {
-                            const target = group.find((hash) => {
-                                if (!hash || hash === selfHash)
-                                    return false;
-                                const attempts = missingResponseRetryAttempts.get(hash) ?? 0;
-                                return attempts < maxMissingResponseRetryAttempts;
-                            });
-                            if (!target)
-                                continue;
-                            pendingMissingResponseRetryPeers.add(target);
-                            missingResponseRetryAttempts.set(target, (missingResponseRetryAttempts.get(target) ?? 0) + 1);
+                        recordMissingResponseGroups(missingGroups);
+                    },
+                    onRemoteTargets: (targets) => {
+                        for (const peer of targets) {
+                            remoteIteratorPeersToClose.add(peer);
                         }
                     },
                 }, fetchOptions?.fetchedFirstForRemote);
-                if (missingResponses && retryMissingResponseGroups) {
+                if (missingResponses &&
+                    retryMissingResponseGroups &&
+                    pendingMissingResponseRetryPeers.size > 0) {
                     hasMore = true;
                     unsetDone();
                 }
@@ -3473,6 +3540,18 @@ let DocumentIndex = (() => {
                 if (pendingMissingResponseRetryPeers.size > 0) {
                     const retryTargets = [...pendingMissingResponseRetryPeers];
                     pendingMissingResponseRetryPeers.clear();
+                    const idTranslation = this._prefetch?.accumulator.getTranslationMap(queryRequestCoerced);
+                    for (const peer of retryTargets) {
+                        const staleRemoteIteratorId = idTranslation?.get(peer);
+                        if (staleRemoteIteratorId) {
+                            const staleIds = staleRemoteIteratorIdsToClose.get(peer) ?? [];
+                            if (!staleIds.some((id) => equals(id, staleRemoteIteratorId))) {
+                                staleIds.push(staleRemoteIteratorId);
+                                staleRemoteIteratorIdsToClose.set(peer, staleIds);
+                            }
+                            idTranslation.delete(peer);
+                        }
+                    }
                     return setFetchPromise(fetchFirst(n, {
                         from: retryTargets,
                         // retries for missing groups should not be suppressed by first-fetch dedupe
@@ -3482,6 +3561,12 @@ let DocumentIndex = (() => {
                 const promises = [];
                 let resultsLeft = 0;
                 for (const [peer, buffer] of peerBufferMap) {
+                    if (retiredRemoteIteratorPeers.has(peer)) {
+                        if (buffer.buffer.length === 0) {
+                            peerBufferMap.delete(peer);
+                        }
+                        continue;
+                    }
                     if (buffer.buffer.length < n) {
                         const hasExistingRemoteResults = buffer.kept > 0;
                         if (!hasExistingRemoteResults && !keepRemoteAlive) {
@@ -3576,6 +3661,7 @@ let DocumentIndex = (() => {
                         }
                         else {
                             // Fetch remotely
+                            remoteIteratorPeersToClose.add(peer);
                             const idTranslation = this._prefetch?.accumulator.getTranslationMap(queryRequestCoerced);
                             let remoteCollectRequest = collectRequest;
                             if (idTranslation) {
@@ -3584,97 +3670,118 @@ let DocumentIndex = (() => {
                                     amount: collectRequest.amount,
                                 });
                             }
+                            const remoteRequestOptions = typeof options?.remote === "object" ? options.remote : undefined;
+                            const collectSignals = [
+                                options?.signal,
+                                remoteRequestOptions?.signal,
+                                ensureController().signal,
+                            ].filter((signal) => signal != null);
+                            const collectSignal = collectSignals.length === 1
+                                ? collectSignals[0]
+                                : AbortSignal.any(collectSignals);
                             promises.push(this._query
                                 .request(remoteCollectRequest, {
                                 ...options,
-                                signal: options?.signal
-                                    ? AbortSignal.any([
-                                        options.signal,
-                                        ensureController().signal,
-                                    ])
-                                    : ensureController().signal,
+                                ...remoteRequestOptions,
+                                signal: collectSignal,
                                 priority: getRemoteQueryPriority(options?.remote),
                                 mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
                             })
-                                .then((response) => introduceEntries(queryRequestCoerced, response, this.documentType, this.indexedType, this._sync, options)
-                                .then(async (responses) => {
-                                return Promise.all(responses.map(async (response, i) => {
-                                    resultsLeft += Number(response.response.kept);
-                                    const from = responses[i].from;
-                                    if (!from) {
-                                        logger.error("Missing from for sorted query");
-                                        return;
+                                .then((response) => {
+                                if (!response.some((result) => result.from?.hashcode() === peer)) {
+                                    const missingGroups = [[peer]];
+                                    if (remoteRequestOptions?.throwOnMissing) {
+                                        retireRemoteIteratorPeer(peer);
+                                        throw new MissingResponsesError("Did not receive responses from all shards: " +
+                                            JSON.stringify(missingGroups), missingGroups);
                                     }
-                                    if (response.response.results.length === 0) {
+                                    recordMissingResponseGroups(missingGroups);
+                                    return;
+                                }
+                                return introduceEntries(queryRequestCoerced, response, this.documentType, this.indexedType, this._sync, options)
+                                    .then(async (responses) => {
+                                    return Promise.all(responses.map(async (response, i) => {
+                                        resultsLeft += Number(response.response.kept);
+                                        const from = responses[i].from;
+                                        if (!from) {
+                                            logger.error("Missing from for sorted query");
+                                            return;
+                                        }
                                         if (!keepRemoteAlive &&
-                                            peerBufferMap.get(peer)?.buffer.length === 0) {
-                                            peerBufferMap.delete(peer); // No more results
+                                            response.response.kept === 0n) {
+                                            remoteIteratorPeersToClose.delete(peer);
                                         }
-                                    }
-                                    else {
-                                        const peerBuffer = peerBufferMap.get(peer);
-                                        if (!peerBuffer) {
-                                            return;
+                                        if (response.response.results.length === 0) {
+                                            if (!keepRemoteAlive &&
+                                                peerBufferMap.get(peer)?.buffer.length === 0) {
+                                                peerBufferMap.delete(peer); // No more results
+                                            }
                                         }
-                                        peerBuffer.kept = Number(response.response.kept);
-                                        for (const result of response.response.results) {
-                                            const indexKey = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
-                                            if (isResultValue(result)) {
-                                                const existingIndexed = indexedPlaceholders?.get(indexKey);
-                                                if (existingIndexed) {
-                                                    existingIndexed.value =
-                                                        result.value;
-                                                    existingIndexed.context = result.context;
-                                                    existingIndexed.from = from;
-                                                    existingIndexed.indexed =
-                                                        await this.resolveIndexed(result, response.response
-                                                            .results);
-                                                    indexedPlaceholders?.delete(indexKey);
-                                                    continue;
-                                                }
-                                                if (visited.has(indexKey) &&
-                                                    !evictStaleBuffered(indexKey, result.context)) {
-                                                    continue;
-                                                }
-                                                visited.add(indexKey);
-                                                const indexed = await this.resolveIndexed(result, response.response
-                                                    .results);
-                                                peerBuffer.buffer.push({
-                                                    value: result.value,
-                                                    context: result.context,
-                                                    from: from,
-                                                    indexed,
-                                                });
+                                        else {
+                                            const peerBuffer = peerBufferMap.get(peer);
+                                            if (!peerBuffer) {
+                                                return;
                                             }
-                                            else {
-                                                const indexedResult = result;
-                                                if (visited.has(indexKey) &&
-                                                    !indexedPlaceholders?.has(indexKey) &&
-                                                    !evictStaleBuffered(indexKey, indexedResult.context)) {
-                                                    continue;
+                                            peerBuffer.kept = Number(response.response.kept);
+                                            for (const result of response.response.results) {
+                                                const indexKey = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
+                                                if (isResultValue(result)) {
+                                                    const existingIndexed = indexedPlaceholders?.get(indexKey);
+                                                    if (existingIndexed) {
+                                                        existingIndexed.value =
+                                                            result.value;
+                                                        existingIndexed.context = result.context;
+                                                        existingIndexed.from = from;
+                                                        existingIndexed.indexed =
+                                                            await this.resolveIndexed(result, response.response
+                                                                .results);
+                                                        indexedPlaceholders?.delete(indexKey);
+                                                        continue;
+                                                    }
+                                                    if (visited.has(indexKey) &&
+                                                        !evictStaleBuffered(indexKey, result.context)) {
+                                                        continue;
+                                                    }
+                                                    visited.add(indexKey);
+                                                    const indexed = await this.resolveIndexed(result, response.response
+                                                        .results);
+                                                    peerBuffer.buffer.push({
+                                                        value: result.value,
+                                                        context: result.context,
+                                                        from: from,
+                                                        indexed,
+                                                    });
+                                                }
+                                                else {
+                                                    const indexedResult = result;
+                                                    if (visited.has(indexKey) &&
+                                                        !indexedPlaceholders?.has(indexKey) &&
+                                                        !evictStaleBuffered(indexKey, indexedResult.context)) {
+                                                        continue;
+                                                    }
+                                                    visited.add(indexKey);
+                                                    const indexed = coerceWithContext(indexedResult.value, indexedResult.context);
+                                                    const placeholder = {
+                                                        value: indexedResult.value,
+                                                        context: indexedResult.context,
+                                                        from: from,
+                                                        indexed,
+                                                    };
+                                                    peerBuffer.buffer.push(placeholder);
+                                                    ensureIndexedPlaceholders().set(indexKey, placeholder);
                                                 }
-                                                visited.add(indexKey);
-                                                const indexed = coerceWithContext(indexedResult.value, indexedResult.context);
-                                                const placeholder = {
-                                                    value: indexedResult.value,
-                                                    context: indexedResult.context,
-                                                    from: from,
-                                                    indexed,
-                                                };
-                                                peerBuffer.buffer.push(placeholder);
-                                                ensureIndexedPlaceholders().set(indexKey, placeholder);
                                             }
                                         }
-                                    }
-                                }));
-                            })
-                                .catch((e) => {
-                                logger.error("Failed to collect sorted results from: " +
-                                    peer +
-                                    ". " +
-                                    e?.message);
-                                peerBufferMap.delete(peer);
-                            })));
+                                    }));
+                                })
+                                    .catch((e) => {
+                                    logger.error("Failed to collect sorted results from: " +
+                                        peer +
+                                        ". " +
+                                        e?.message);
+                                    peerBufferMap.delete(peer);
+                                });
+                            }));
                         }
                     }
                     else {
@@ -3697,7 +3804,7 @@ let DocumentIndex = (() => {
                             }
                         }
                     }
-                    return resultsLeft === 0; // 0 results left to fetch and 0 pending results
+                    return (resultsLeft === 0 && pendingMissingResponseRetryPeers.size === 0); // 0 results left to fetch and 0 pending results
                 }));
             };
             const next = async (n) => {
@@ -3779,35 +3886,83 @@ let DocumentIndex = (() => {
                 this.processCloseIteratorRequest(queryRequestCoerced, this.node.identity.publicKey);
                 done = true;
             };
-            let close = async () => {
+            const outerSignal = options?.signal;
+            let outerAbortListener;
+            let closeStarted = false;
+            let closePromise;
+            const performClose = async () => {
+                const idTranslation = this._prefetch?.accumulator.getTranslationMap(queryRequestCoerced);
+                const remoteIteratorIds = idTranslation
+                    ? new Map(idTranslation)
+                    : undefined;
                 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
+                const activeRemotePeers = new Set(keepRemoteAlive
                     ? [...peerBufferMap.keys()].filter((peer) => peer !== selfHash)
                     : [...peerBufferMap.entries()]
                         .filter(([peer, buffer]) => peer !== selfHash && buffer.kept > 0)
-                        .map(([peer]) => peer);
+                        .map(([peer]) => peer));
+                for (const peer of remoteIteratorPeersToClose) {
+                    if (peer !== selfHash) {
+                        activeRemotePeers.add(peer);
+                    }
+                }
+                const staleRemoteIteratorIds = new Map([...staleRemoteIteratorIdsToClose].map(([peer, ids]) => [
+                    peer,
+                    [...ids],
+                ]));
+                const remotePeers = new Set([
+                    ...activeRemotePeers,
+                    ...staleRemoteIteratorIds.keys(),
+                ]);
                 peerBufferMap.clear();
-                await Promise.allSettled(remotePeers.map((peer) => this._query.send(closeRequest, {
-                    ...options,
-                    priority: getRemoteQueryPriority(options?.remote),
-                    mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
-                })));
+                retiredRemoteIteratorPeers.clear();
+                remoteIteratorPeersToClose.clear();
+                staleRemoteIteratorIdsToClose.clear();
+                if (remotePeers.size === 0) {
+                    return;
+                }
+                const remoteCloseOptions = typeof options?.remote === "object" ? options.remote : undefined;
+                const closeSignal = AbortSignal.timeout(CLOSE_ITERATOR_REQUEST_TIMEOUT);
+                await Promise.allSettled([...remotePeers].flatMap((peer) => {
+                    const ids = [];
+                    if (activeRemotePeers.has(peer)) {
+                        ids.push(remoteIteratorIds?.get(peer) ?? queryRequestCoerced.id);
+                    }
+                    for (const staleRemoteIteratorId of staleRemoteIteratorIds.get(peer) ?? []) {
+                        if (!ids.some((id) => equals(id, staleRemoteIteratorId))) {
+                            ids.push(staleRemoteIteratorId);
+                        }
+                    }
+                    return ids.map((id) => {
+                        const closeRequest = new types.CloseIteratorRequest({ id });
+                        return this._query.send(closeRequest, {
+                            ...remoteCloseOptions,
+                            signal: closeSignal,
+                            priority: getRemoteQueryPriority(options?.remote),
+                            mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
+                        });
+                    });
+                }));
+            };
+            const close = () => {
+                if (closeStarted)
+                    return closePromise;
+                closeStarted = true;
+                if (outerAbortListener) {
+                    outerSignal?.removeEventListener("abort", outerAbortListener);
+                    outerAbortListener = undefined;
+                }
+                closePromise = performClose();
+                return closePromise;
             };
-            options?.signal && options.signal.addEventListener("abort", close);
             let doneFn = () => {
                 return done;
             };
             let joinListener;
             let fetchedFirstForRemote = undefined;
-            const pendingMissingResponseRetryPeers = new Set();
-            const missingResponseRetryAttempts = new Map();
-            const maxMissingResponseRetryAttempts = 2;
             let joinFetchesInFlight = 0;
             let updateDeferred;
             const updateWaiters = new Set();
@@ -4460,6 +4615,15 @@ let DocumentIndex = (() => {
                     }
                 }
             };
+            if (outerSignal) {
+                outerAbortListener = () => {
+                    void close();
+                };
+                outerSignal.addEventListener("abort", outerAbortListener, { once: true });
+                if (outerSignal.aborted) {
+                    void close();
+                }
+            }
             return {
                 close,
                 next,
@@ -4529,49 +4693,61 @@ let DocumentIndex = (() => {
                     const drainBatchSize = replicate ? 1000 : 100;
                     let result = [];
                     let c = 0;
-                    while (doneFn() !== true) {
-                        let batch = await next(drainBatchSize);
-                        c += batch.length;
-                        if (c > WARNING_WHEN_ITERATING_FOR_MORE_THAN) {
-                            warn("Iterating for more than " +
-                                WARNING_WHEN_ITERATING_FOR_MORE_THAN +
-                                " results");
-                        }
-                        if (batch.length > 0) {
-                            result.push(...batch);
-                            continue;
+                    try {
+                        while (doneFn() !== true) {
+                            let batch = await next(drainBatchSize);
+                            c += batch.length;
+                            if (c > WARNING_WHEN_ITERATING_FOR_MORE_THAN) {
+                                warn("Iterating for more than " +
+                                    WARNING_WHEN_ITERATING_FOR_MORE_THAN +
+                                    " results");
+                            }
+                            if (batch.length > 0) {
+                                result.push(...batch);
+                                continue;
+                            }
+                            await waitForUpdateAndResetDeferred();
                         }
-                        await waitForUpdateAndResetDeferred();
+                        return result;
+                    }
+                    finally {
+                        await close();
                     }
-                    cleanupAndDone();
-                    return result;
                 },
                 first: async () => {
-                    if (doneFn()) {
-                        return undefined;
+                    try {
+                        if (doneFn()) {
+                            return undefined;
+                        }
+                        let batch = await next(1);
+                        return batch[0];
+                    }
+                    finally {
+                        await close();
                     }
-                    let batch = await next(1);
-                    cleanupAndDone();
-                    return batch[0];
                 },
                 [Symbol.asyncIterator]: async function* () {
                     drain = true;
                     const drainBatchSize = replicate ? 1000 : 100;
                     let c = 0;
-                    while (doneFn() !== true) {
-                        const batch = await next(drainBatchSize);
-                        c += batch.length;
-                        if (c > WARNING_WHEN_ITERATING_FOR_MORE_THAN) {
-                            warn("Iterating for more than " +
-                                WARNING_WHEN_ITERATING_FOR_MORE_THAN +
-                                " results");
-                        }
-                        for (const entry of batch) {
-                            yield entry;
+                    try {
+                        while (doneFn() !== true) {
+                            const batch = await next(drainBatchSize);
+                            c += batch.length;
+                            if (c > WARNING_WHEN_ITERATING_FOR_MORE_THAN) {
+                                warn("Iterating for more than " +
+                                    WARNING_WHEN_ITERATING_FOR_MORE_THAN +
+                                    " results");
+                            }
+                            for (const entry of batch) {
+                                yield entry;
+                            }
+                            await waitForUpdateAndResetDeferred();
                         }
-                        await waitForUpdateAndResetDeferred();
                     }
-                    cleanupAndDone();
+                    finally {
+                        await close();
+                    }
                 },
             };
         }