@peerbit/document 13.1.5 → 13.1.7

package/dist/src/search.js

@@ -40,7 +40,7 @@ import { tryProjectDocumentIndexSimple, } from "./native-rust.js";
 import { CachedIndex } from "@peerbit/indexer-cache";
 import * as indexerTypes from "@peerbit/indexer-interface";
 import { HashmapIndex } from "@peerbit/indexer-simple";
-import { BORSH_ENCODING, Entry } from "@peerbit/log";
+import { BORSH_ENCODING } from "@peerbit/log";
 import { logger as loggerFn } from "@peerbit/logger";
 import { ClosedError, Program } from "@peerbit/program";
 import { MissingResponsesError, RPC, queryAll, } from "@peerbit/rpc";
@@ -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: {
@@ -551,33 +552,76 @@ let DocumentIndex = (() => {
                 this._prefetch.accumulator = new Prefetch();
             }
         }
-        /** Head entry safe to borsh-serialize into ResultIndexedValue.entries over the
-         * document RPC. Under the native block store, this._log.log.get can return a
-         * hollow entry whose payload bytes were never materialized on the JS side;
-         * serializing it throws and aborts the whole RPC response. The complete entry is
-         * in the block store keyed by hash, so recover it there. No-op for pure JS. */
-        async getSerializableHead(hash) {
-            const head = await this._log.log.get(hash);
-            if (!head?.hash)
-                return head ?? undefined;
-            try {
-                head.getStorageBytes(); // = serialize(head); throws on a hollow native entry
-                return head;
-            }
-            catch {
-                try {
-                    return await Entry.fromMultihash(this._log.log.blocks, head.hash);
+        /**
+         * Resolve documents without bypassing the resolver/program caches. Cache and
+         * identity-index hits are collected first; only the remaining heads cross the
+         * log read boundary, and those reads stay aligned in one batch.
+         */
+        async resolveDocumentsWithBatchedHeads(values) {
+            const resolved = new Array(values.length);
+            const heads = new Array(values.length);
+            const unresolvedPositions = [];
+            for (let i = 0; i < values.length; i++) {
+                const value = values[i];
+                const cached = await this.resolveDocument({
+                    ...value,
+                    headEntry: null,
+                });
+                if (cached) {
+                    resolved[i] = cached;
                 }
-                catch {
-                    return head; // block absent (e.g. pruned) — preserve today's behavior
+                else {
+                    unresolvedPositions.push(i);
                 }
             }
+            if (unresolvedPositions.length === 0) {
+                return { resolved, heads };
+            }
+            const unresolvedHeads = await this._log.log.getMany(unresolvedPositions.map((position) => values[position].head));
+            for (let i = 0; i < unresolvedPositions.length; i++) {
+                const position = unresolvedPositions[i];
+                const head = unresolvedHeads[i];
+                heads[position] = head;
+                resolved[position] = await this.resolveDocument({
+                    ...values[position],
+                    headEntry: head ?? null,
+                });
+            }
+            return { resolved, heads };
         }
         async wrapPushResults(matches, resolve) {
             if (!matches.length)
                 return [];
+            const headsByMatch = [];
+            const resolvedByMatch = [];
+            if (!resolve) {
+                headsByMatch.push(...(await this._log.log.getMany(matches.map((match) => match.__context.head))));
+            }
+            else {
+                const indexedPositions = [];
+                for (let i = 0; i < matches.length; i++) {
+                    if (!(matches[i] instanceof this.documentType)) {
+                        indexedPositions.push(i);
+                    }
+                }
+                const indexedBatch = indexedPositions.length
+                    ? await this.resolveDocumentsWithBatchedHeads(indexedPositions.map((position) => {
+                        const indexed = matches[position];
+                        return {
+                            indexed,
+                            head: indexed.__context.head,
+                        };
+                    }))
+                    : { resolved: [], heads: [] };
+                for (let i = 0; i < indexedPositions.length; i++) {
+                    const position = indexedPositions[i];
+                    resolvedByMatch[position] = indexedBatch.resolved[i];
+                    headsByMatch[position] = indexedBatch.heads[i];
+                }
+            }
             const results = [];
-            for (const match of matches) {
+            for (let i = 0; i < matches.length; i++) {
+                const match = matches[i];
                 if (resolve) {
                     if (match instanceof this.documentType) {
                         const doc = match;
@@ -592,10 +636,7 @@ let DocumentIndex = (() => {
                         continue;
                     }
                     const indexed = match;
-                    const resolved = await this.resolveDocument({
-                        indexed,
-                        head: indexed.__context.head,
-                    });
+                    const resolved = resolvedByMatch[i];
                     if (resolved) {
                         results.push(new types.ResultValue({
                             context: indexed.__context,
@@ -605,7 +646,7 @@ let DocumentIndex = (() => {
                         }));
                         continue;
                     }
-                    const head = await this.getSerializableHead(indexed.__context.head);
+                    const head = headsByMatch[i];
                     results.push(new types.ResultIndexedValue({
                         context: indexed.__context,
                         source: serialize(indexed),
@@ -615,7 +656,7 @@ let DocumentIndex = (() => {
                 }
                 else {
                     const indexed = match;
-                    const head = await this.getSerializableHead(indexed.__context.head);
+                    const head = headsByMatch[i];
                     results.push(new types.ResultIndexedValue({
                         context: indexed.__context,
                         source: serialize(indexed),
@@ -631,14 +672,21 @@ let DocumentIndex = (() => {
                 return [];
             }
             const drained = queueEntries.splice(0);
+            const resolvedBatch = resolve
+                ? await this.resolveDocumentsWithBatchedHeads(drained.map((entry) => ({
+                    indexed: entry.value,
+                    head: entry.value.__context.head,
+                })))
+                : undefined;
+            const heads = resolvedBatch
+                ? resolvedBatch.heads
+                : await this._log.log.getMany(drained.map((entry) => entry.value.__context.head));
             const results = [];
-            for (const entry of drained) {
+            for (let i = 0; i < drained.length; i++) {
+                const entry = drained[i];
                 const indexedUnwrapped = Object.assign(Object.create(this.indexedType.prototype), entry.value);
                 if (resolve) {
-                    const value = await this.resolveDocument({
-                        indexed: entry.value,
-                        head: entry.value.__context.head,
-                    });
+                    const value = resolvedBatch.resolved[i];
                     if (value) {
                         results.push(new types.ResultValue({
                             context: entry.value.__context,
@@ -648,7 +696,7 @@ let DocumentIndex = (() => {
                         }));
                         continue;
                     }
-                    const head = await this.getSerializableHead(entry.value.__context.head);
+                    const head = heads[i];
                     results.push(new types.ResultIndexedValue({
                         context: entry.value.__context,
                         source: serialize(indexedUnwrapped),
@@ -657,7 +705,7 @@ let DocumentIndex = (() => {
                     }));
                 }
                 else {
-                    const head = await this.getSerializableHead(entry.value.__context.head);
+                    const head = heads[i];
                     results.push(new types.ResultIndexedValue({
                         context: entry.value.__context,
                         source: serialize(indexedUnwrapped),
@@ -697,6 +745,7 @@ let DocumentIndex = (() => {
                     let pendingAdded = added;
                     do {
                         const batches = [];
+                        let claimedIds = [];
                         const queued = await this.drainQueuedResults(queue.queue, resolveFlag);
                         if (queued.length) {
                             batches.push(...queued);
@@ -710,6 +759,13 @@ let DocumentIndex = (() => {
                             const wrapped = await this.wrapPushResults(matches, resolveFlag);
                             if (wrapped.length) {
                                 batches.push(...wrapped);
+                                claimedIds = wrapped
+                                    .map((result) => result instanceof types.ResultValue && result.indexed
+                                    ? indexerTypes.toId(this.indexByResolver(result.indexed))
+                                    : result instanceof types.ResultIndexedValue
+                                        ? indexerTypes.toId(this.indexByResolver(result.value))
+                                        : undefined)
+                                    .filter((id) => id !== undefined);
                             }
                         }
                         if (batches.length) {
@@ -727,6 +783,9 @@ let DocumentIndex = (() => {
                                     redundancy: 1,
                                 }),
                             });
+                            if (claimedIds.length) {
+                                await this._resumableIterators.markYielded(_iteratorId, claimedIds);
+                            }
                         }
                         pendingAdded = queue.pendingAdded ?? [];
                         queue.pendingAdded = undefined;
@@ -2235,7 +2294,9 @@ let DocumentIndex = (() => {
                 delete obj.__context;
                 return { value: obj };
             }
-            const head = await this._log.log.get(value.head);
+            const head = value.headEntry === undefined
+                ? await this._log.log.get(value.head)
+                : (value.headEntry ?? undefined);
             if (!head) {
                 return undefined; // we could end up here if we recently pruned the document and other peers never persisted the entry
                 // TODO update changes in index before removing entries from log entry storage
@@ -2326,7 +2387,7 @@ let DocumentIndex = (() => {
                 }
                 this._resultQueue.set(query.idString, prevQueued);
             }
-            const filteredResults = [];
+            const candidates = [];
             const resolveDocumentsFlag = resolvesDocuments(fromQuery);
             const replicateIndexFlag = replicatesIndex(fromQuery);
             for (const result of toIterate) {
@@ -2342,11 +2403,24 @@ let DocumentIndex = (() => {
                     !(await options.canRead(indexedUnwrapped, from))) {
                     continue;
                 }
+                candidates.push({ result, indexed: indexedUnwrapped });
+            }
+            const resolvedBatch = resolveDocumentsFlag
+                ? await this.resolveDocumentsWithBatchedHeads(candidates.map(({ result }) => ({
+                    indexed: result.value,
+                    head: result.value.__context.head,
+                })))
+                : undefined;
+            const heads = resolvedBatch
+                ? resolvedBatch.heads
+                : candidates.length > 0
+                    ? await this._log.log.getMany(candidates.map(({ result }) => result.value.__context.head))
+                    : [];
+            const filteredResults = [];
+            for (let i = 0; i < candidates.length; i++) {
+                const { result, indexed: indexedUnwrapped } = candidates[i];
                 if (resolveDocumentsFlag) {
-                    const value = await this.resolveDocument({
-                        indexed: result.value,
-                        head: result.value.__context.head,
-                    });
+                    const value = resolvedBatch.resolved[i];
                     if (!value) {
                         continue;
                     }
@@ -2359,7 +2433,7 @@ let DocumentIndex = (() => {
                 }
                 else {
                     const context = result.value.__context;
-                    const head = await this.getSerializableHead(context.head);
+                    const head = heads[i];
                     if (replicateIndexFlag) {
                         if (!head) {
                             continue;
@@ -2721,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()) {
@@ -2735,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 () => {
@@ -2753,6 +2829,7 @@ let DocumentIndex = (() => {
                         return true;
                     })
                         .map((x) => [x]);
+                    options?.onRemoteTargets?.(selectedRemoteHashes);
                     extraPromises && (await Promise.all(extraPromises));
                     let tearDown = undefined;
                     const search = this;
@@ -2857,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)) {
@@ -3062,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 = () => {
@@ -3241,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;
@@ -3253,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;
@@ -3298,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)) {
@@ -3342,7 +3490,7 @@ let DocumentIndex = (() => {
                                     ensureIndexedPlaceholders().set(indexKey, placeholder);
                                 }
                             }
-                            peerBufferMap.set(from.hashcode(), {
+                            peerBufferMap.set(fromHash, {
                                 buffer,
                                 kept: effectiveKept,
                             });
@@ -3353,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();
                 }
@@ -3400,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
@@ -3409,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) {
@@ -3503,6 +3661,7 @@ let DocumentIndex = (() => {
                         }
                         else {
                             // Fetch remotely
+                            remoteIteratorPeersToClose.add(peer);
                             const idTranslation = this._prefetch?.accumulator.getTranslationMap(queryRequestCoerced);
                             let remoteCollectRequest = collectRequest;
                             if (idTranslation) {
@@ -3511,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 {
@@ -3624,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) => {
@@ -3706,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();
@@ -4107,7 +4335,8 @@ let DocumentIndex = (() => {
                                         continue;
                                     }
                                 }
-                                const id = indexerTypes.toId(this.indexByResolver(indexedCandidate)).primitive;
+                                const indexId = indexerTypes.toId(this.indexByResolver(indexedCandidate));
+                                const id = indexId.primitive;
                                 const existingIndexed = indexedPlaceholders?.get(id);
                                 if (existingIndexed) {
                                     if (resolve) {
@@ -4149,6 +4378,7 @@ let DocumentIndex = (() => {
                                 if (!resolve) {
                                     ensureIndexedPlaceholders().set(id, placeholder);
                                 }
+                                await this._resumableIterators.markYielded(queryRequestCoerced.idString, [indexId]);
                                 hasRelevantChange = true;
                             }
                         }
@@ -4385,6 +4615,15 @@ let DocumentIndex = (() => {
                     }
                 }
             };
+            if (outerSignal) {
+                outerAbortListener = () => {
+                    void close();
+                };
+                outerSignal.addEventListener("abort", outerAbortListener, { once: true });
+                if (outerSignal.aborted) {
+                    void close();
+                }
+            }
             return {
                 close,
                 next,
@@ -4454,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();
+                    }
                 },
             };
         }