@peerbit/document 10.0.4 → 10.1.1

package/dist/src/search.js

@@ -1,11 +1,36 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
 };
 import { field, serialize, variant } from "@dao-xyz/borsh";
 import { Cache } from "@peerbit/cache";
@@ -30,9 +55,14 @@ import { isPutOperation } from "./operation.js";
 import { Prefetch } from "./prefetch.js";
 import { ResumableIterators } from "./resumable-iterator.js";
 const WARNING_WHEN_ITERATING_FOR_MORE_THAN = 1e5;
-const logger = loggerFn({
-    module: "document-index",
-});
+const logger = loggerFn("peerbit:program:document:search");
+const warn = logger.newScope("warn");
+const documentIndexLogger = loggerFn("peerbit:document:index");
+const indexLifecycleLogger = documentIndexLogger.newScope("lifecycle");
+const indexRpcLogger = documentIndexLogger.newScope("rpc");
+const indexCacheLogger = documentIndexLogger.newScope("cache");
+const indexPrefetchLogger = documentIndexLogger.newScope("prefetch");
+const indexIteratorLogger = documentIndexLogger.newScope("iterate");
 const coerceQuery = (query, options, compatibility) => {
     const replicate = typeof options?.remote !== "boolean" ? options?.remote?.replicate : false;
     const shouldResolve = options?.resolve !== false;
@@ -163,6 +193,7 @@ function isSubclassOf(SubClass, SuperClass) {
     return false;
 }
 const DEFAULT_TIMEOUT = 1e4;
+const DEFAULT_KEEP_REMOTE_ITERATOR_TIMEOUT = 3e5;
 const DISCOVER_TIMEOUT_FALLBACK = 500;
 const DEFAULT_INDEX_BY = "id";
 const isTransformerWithFunction = (options) => {
@@ -178,1036 +209,1289 @@ export const coerceWithIndexed = (value, indexed) => {
     valueWithContext.__indexed = indexed;
     return valueWithContext;
 };
-let DocumentIndex = class DocumentIndex extends Program {
-    _query;
-    // Original document representation
-    documentType;
-    // transform options
-    transformer;
-    // The indexed document wrapped in a context
-    wrappedIndexedType;
-    indexedType;
-    // The database type, for recursive indexing
-    dbType;
-    indexedTypeIsDocumentType;
-    // Index key
-    indexBy;
-    indexByResolver;
-    index;
-    _resumableIterators;
-    _prefetch;
-    includeIndexed = undefined;
-    compatibility;
-    // Transformation, indexer
-    /* fields: IndexableFields<T, I>; */
-    _valueEncoding;
-    _sync;
-    _log;
-    _resolverProgramCache;
-    _resolverCache;
-    isProgramValued;
-    _maybeOpen;
-    canSearch;
-    canRead;
-    documentEvents;
-    _joinListener;
-    _resultQueue;
-    iteratorKeepAliveTimers;
-    constructor(properties) {
-        super();
-        this._query = properties?.query || new RPC();
-        this.iteratorKeepAliveTimers = new Map();
-    }
-    get valueEncoding() {
-        return this._valueEncoding;
-    }
-    get nestedProperties() {
-        return {
-            match: (obj) => obj instanceof this.dbType,
-            iterate: async (obj, query) => obj.index.search(query),
-        };
-    }
-    async open(properties) {
-        this._log = properties.log;
-        let prefectOptions = typeof properties.prefetch === "object"
-            ? properties.prefetch
-            : properties.prefetch
-                ? {}
-                : undefined;
-        this._prefetch = prefectOptions
-            ? {
-                ...prefectOptions,
-                predictor: prefectOptions.predictor || new MostCommonQueryPredictor(3),
-                ttl: prefectOptions.ttl ?? 5e3,
-                accumulator: prefectOptions.accumulator || new Prefetch(),
-            }
-            : undefined;
-        this.documentType = properties.documentType;
-        this.indexedTypeIsDocumentType =
-            !properties.transform?.type ||
-                properties.transform?.type === properties.documentType;
-        this.documentEvents = properties.documentEvents;
-        this.compatibility = properties.compatibility;
-        this.canRead = properties.canRead;
-        this.canSearch = properties.canSearch;
-        this.includeIndexed = properties.includeIndexed;
-        let IndexedClassWithContext = class IndexedClassWithContext {
-            __context;
-            constructor(value, context) {
-                Object.assign(this, value);
-                this.__context = context;
+let DocumentIndex = (() => {
+    let _classDecorators = [variant("documents_index")];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = Program;
+    let __query_decorators;
+    let __query_initializers = [];
+    let __query_extraInitializers = [];
+    var DocumentIndex = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __query_decorators = [field({ type: RPC })];
+            __esDecorate(null, null, __query_decorators, { kind: "field", name: "_query", static: false, private: false, access: { has: obj => "_query" in obj, get: obj => obj._query, set: (obj, value) => { obj._query = value; } }, metadata: _metadata }, __query_initializers, __query_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            DocumentIndex = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        _query = __runInitializers(this, __query_initializers, void 0);
+        // Original document representation
+        documentType = __runInitializers(this, __query_extraInitializers);
+        // transform options
+        transformer;
+        // The indexed document wrapped in a context
+        wrappedIndexedType;
+        indexedType;
+        // The database type, for recursive indexing
+        dbType;
+        indexedTypeIsDocumentType;
+        // Index key
+        indexBy;
+        indexByResolver;
+        index;
+        _resumableIterators;
+        _prefetch;
+        includeIndexed = undefined;
+        compatibility;
+        // Transformation, indexer
+        /* fields: IndexableFields<T, I>; */
+        _valueEncoding;
+        _sync;
+        _log;
+        _resolverProgramCache;
+        _resolverCache;
+        isProgramValued;
+        _maybeOpen;
+        canSearch;
+        canRead;
+        documentEvents;
+        _joinListener;
+        _resultQueue;
+        iteratorKeepAliveTimers;
+        constructor(properties) {
+            super();
+            this._query = properties?.query || new RPC();
+            this.iteratorKeepAliveTimers = new Map();
+        }
+        get valueEncoding() {
+            return this._valueEncoding;
+        }
+        ensurePrefetchAccumulator() {
+            if (!this._prefetch) {
+                this._prefetch = {
+                    accumulator: new Prefetch(),
+                    ttl: 5e3,
+                };
+                return;
             }
-        };
-        __decorate([
-            field({ type: types.Context }),
-            __metadata("design:type", types.Context)
-        ], IndexedClassWithContext.prototype, "__context", void 0);
-        IndexedClassWithContext = __decorate([
-            variant(0),
-            __metadata("design:paramtypes", [Object, types.Context])
-        ], IndexedClassWithContext);
-        // copy all prototype values from indexedType to IndexedClassWithContext
-        this.indexedType = (properties.transform?.type || properties.documentType);
-        copySerialization(this.indexedType, IndexedClassWithContext);
-        this.wrappedIndexedType = IndexedClassWithContext;
-        // if this.type is a class that extends Program we want to do special functionality
-        this.isProgramValued = isSubclassOf(this.documentType, Program);
-        this.dbType = properties.dbType;
-        this._resultQueue = new Map();
-        this._sync = (request, results) => {
-            let rq;
-            let rs;
-            if (request instanceof types.PredictedSearchRequest) {
-                // TODO is this codepath even reachable?
-                throw new Error("Unexpected PredictedSearchRequest in sync operation");
+            if (!this._prefetch.accumulator) {
+                this._prefetch.accumulator = new Prefetch();
             }
-            else {
-                rq = request;
-                rs = results;
+        }
+        async wrapPushResults(matches, resolve) {
+            if (!matches.length)
+                return [];
+            const results = [];
+            for (const match of matches) {
+                if (resolve) {
+                    const doc = match;
+                    const indexedValue = await this.transformer(doc, doc.__context);
+                    const wrappedIndexed = coerceWithContext(indexedValue, doc.__context);
+                    results.push(new types.ResultValue({
+                        context: doc.__context,
+                        value: doc,
+                        source: serialize(doc),
+                        indexed: wrappedIndexed,
+                    }));
+                }
+                else {
+                    const indexed = match;
+                    const head = await this._log.log.get(indexed.__context.head);
+                    results.push(new types.ResultIndexedValue({
+                        context: indexed.__context,
+                        source: serialize(indexed),
+                        indexed: indexed,
+                        entries: head ? [head] : [],
+                    }));
+                }
             }
-            return properties.replicate(rq, rs);
-        };
-        const transformOptions = properties.transform;
-        this.transformer = transformOptions
-            ? isTransformerWithFunction(transformOptions)
-                ? (obj, context) => transformOptions.transform(obj, context)
-                : transformOptions.type
-                    ? (obj, context) => new transformOptions.type(obj, context)
-                    : (obj) => obj
-            : (obj) => obj; // TODO types
-        const maybeArr = properties.indexBy || DEFAULT_INDEX_BY;
-        this.indexBy = Array.isArray(maybeArr) ? maybeArr : [maybeArr];
-        this.indexByResolver = (obj) => indexerTypes.extractFieldValue(obj, this.indexBy);
-        this._valueEncoding = BORSH_ENCODING(this.documentType);
-        this._resolverCache =
-            properties.cache?.resolver === 0
-                ? undefined
-                : new Cache({ max: properties.cache?.resolver ?? 100 }); // TODO choose limit better by default (adaptive)
-        this.index =
-            (await (await this.node.indexer.scope(sha256Base64Sync(concat([this._log.log.id, fromString("/document-index")])))).init({
-                indexBy: this.indexBy,
-                schema: this.wrappedIndexedType,
-                nested: this.nestedProperties,
-                /* maxBatchSize: MAX_BATCH_SIZE */
-            })) || new HashmapIndex();
-        if (properties.cache?.query) {
-            this.index = new CachedIndex(this.index, properties.cache.query);
+            return results;
         }
-        this._resumableIterators = new ResumableIterators(this.index);
-        this._maybeOpen = properties.maybeOpen;
-        if (this.isProgramValued) {
-            this._resolverProgramCache = new Map();
+        async drainQueuedResults(queueEntries, resolve) {
+            if (!queueEntries.length) {
+                return [];
+            }
+            const drained = queueEntries.splice(0);
+            const results = [];
+            for (const entry of drained) {
+                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,
+                    });
+                    if (!value)
+                        continue;
+                    results.push(new types.ResultValue({
+                        context: entry.value.__context,
+                        value: value.value,
+                        source: serialize(value.value),
+                        indexed: indexedUnwrapped,
+                    }));
+                }
+                else {
+                    const head = await this._log.log.get(entry.value.__context.head);
+                    results.push(new types.ResultIndexedValue({
+                        context: entry.value.__context,
+                        source: serialize(indexedUnwrapped),
+                        indexed: indexedUnwrapped,
+                        entries: head ? [head] : [],
+                    }));
+                }
+            }
+            return results;
         }
-        if (this.prefetch?.predictor) {
-            const predictor = this.prefetch.predictor;
-            this._joinListener = async (e) => {
-                // on join we emit predicted search results before peers query us (to save latency but for the price of errornous bandwidth usage)
-                if ((await this._log.isReplicating()) === false) {
-                    return;
+        handleDocumentChange = async (event) => {
+            const added = event.detail.added;
+            if (!added.length) {
+                return;
+            }
+            for (const [_iteratorId, queue] of this._resultQueue) {
+                if (!queue.pushMode ||
+                    queue.pushMode !== types.PushUpdatesMode.STREAM ||
+                    queue.pushInFlight) {
+                    continue;
                 }
-                // TODO
-                // it only makes sense for use to return predicted results if the peer is to choose us as a replicator
-                // so we need to calculate the cover set from the peers perspective
-                // create an iterator and send the peer the results
-                let request = predictor.predictedQuery(e.detail);
-                if (!request) {
-                    return;
+                if (!(queue.fromQuery instanceof types.IterationRequest)) {
+                    continue;
                 }
-                const results = await this.handleSearchRequest(request, {
-                    from: e.detail,
-                });
-                if (results instanceof types.AbstractSearchResult) {
-                    // start a resumable iterator for the peer
-                    const query = new types.PredictedSearchRequest({
-                        id: request.id,
-                        request,
-                        results,
+                queue.pushInFlight = true;
+                try {
+                    const resolveFlag = queue.resolveResults ??
+                        resolvesDocuments(queue.fromQuery);
+                    const batches = [];
+                    const queued = await this.drainQueuedResults(queue.queue, resolveFlag);
+                    if (queued.length) {
+                        batches.push(...queued);
+                    }
+                    // TODO drain only up to the changed document instead of flushing the entire queue
+                    const matches = await this.updateResults([], { added }, {
+                        query: queue.fromQuery.query,
+                        sort: queue.fromQuery.sort,
+                    }, resolveFlag);
+                    if (matches.length) {
+                        const wrapped = await this.wrapPushResults(matches, resolveFlag);
+                        if (wrapped.length) {
+                            batches.push(...wrapped);
+                        }
+                    }
+                    if (!batches.length) {
+                        continue;
+                    }
+                    const pushMessage = new types.PredictedSearchRequest({
+                        id: queue.fromQuery.id,
+                        request: queue.fromQuery,
+                        results: new types.Results({
+                            results: batches,
+                            kept: 0n,
+                        }),
                     });
-                    await this._query.send(query, {
-                        mode: new SilentDelivery({ to: [e.detail], redundancy: 1 }),
+                    await this._query.send(pushMessage, {
+                        mode: new SilentDelivery({
+                            to: [queue.from],
+                            redundancy: 1,
+                        }),
                     });
                 }
+                catch (error) {
+                    logger.error("Failed to push iterator update", error);
+                }
+                finally {
+                    queue.pushInFlight = false;
+                }
+            }
+        };
+        get nestedProperties() {
+            return {
+                match: (obj) => obj instanceof this.dbType,
+                iterate: async (obj, query) => obj.index.search(query),
             };
-            // we do this before _query.open so that we can receive the join event, even immediate ones
-            this._query.events.addEventListener("join", this._joinListener);
         }
-        await this._query.open({
-            topic: sha256Base64Sync(concat([this._log.log.id, fromString("/document")])),
-            responseHandler: this.queryRPCResponseHandler.bind(this),
-            responseType: types.AbstractSearchResult,
-            queryType: types.AbstractSearchRequest,
-        });
-    }
-    get prefetch() {
-        return this._prefetch;
-    }
-    async queryRPCResponseHandler(query, ctx) {
-        if (!ctx.from) {
-            logger.info("Receieved query without from");
-            return;
-        }
-        if (query instanceof types.PredictedSearchRequest) {
-            // put results in a waiting cache so that we eventually in the future will query a matching thing, we already have results available
-            this._prefetch?.accumulator.add({
-                message: ctx.message,
-                response: query,
-                from: ctx.from,
-            }, ctx.from.hashcode());
-            return;
-        }
-        if (this.prefetch?.predictor &&
-            (query instanceof types.SearchRequest ||
-                query instanceof types.SearchRequestIndexed ||
-                query instanceof types.IterationRequest)) {
-            const { ignore } = this.prefetch.predictor.onRequest(query, {
-                from: ctx.from,
+        async open(properties) {
+            this._log = properties.log;
+            // Allow reopening with partial options (tests override the index transform)
+            const previousEvents = this.documentEvents;
+            this.documentEvents =
+                properties.documentEvents ?? previousEvents ?? this.events;
+            this.compatibility =
+                properties.compatibility !== undefined
+                    ? properties.compatibility
+                    : this.compatibility;
+            let prefectOptions = typeof properties.prefetch === "object"
+                ? properties.prefetch
+                : properties.prefetch
+                    ? {}
+                    : undefined;
+            this._prefetch = prefectOptions
+                ? {
+                    ...prefectOptions,
+                    predictor: prefectOptions.predictor || new MostCommonQueryPredictor(3),
+                    ttl: prefectOptions.ttl ?? 5e3,
+                    accumulator: prefectOptions.accumulator || new Prefetch(),
+                }
+                : undefined;
+            this.documentType = properties.documentType;
+            this.indexedTypeIsDocumentType =
+                !properties.transform?.type ||
+                    properties.transform?.type === properties.documentType;
+            this.canRead = properties.canRead;
+            this.canSearch = properties.canSearch;
+            this.includeIndexed = properties.includeIndexed;
+            let IndexedClassWithContext = (() => {
+                let _classDecorators = [variant(0)];
+                let _classDescriptor;
+                let _classExtraInitializers = [];
+                let _classThis;
+                let ___context_decorators;
+                let ___context_initializers = [];
+                let ___context_extraInitializers = [];
+                var IndexedClassWithContext = class {
+                    static { _classThis = this; }
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+                        ___context_decorators = [field({ type: types.Context })];
+                        __esDecorate(null, null, ___context_decorators, { kind: "field", name: "__context", static: false, private: false, access: { has: obj => "__context" in obj, get: obj => obj.__context, set: (obj, value) => { obj.__context = value; } }, metadata: _metadata }, ___context_initializers, ___context_extraInitializers);
+                        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+                        IndexedClassWithContext = _classThis = _classDescriptor.value;
+                        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        __runInitializers(_classThis, _classExtraInitializers);
+                    }
+                    __context = __runInitializers(this, ___context_initializers, void 0);
+                    constructor(value, context) {
+                        __runInitializers(this, ___context_extraInitializers);
+                        Object.assign(this, value);
+                        this.__context = context;
+                    }
+                };
+                return IndexedClassWithContext = _classThis;
+            })();
+            // copy all prototype values from indexedType to IndexedClassWithContext
+            this.indexedType = (properties.transform?.type || properties.documentType);
+            copySerialization(this.indexedType, IndexedClassWithContext);
+            this.wrappedIndexedType = IndexedClassWithContext;
+            // if this.type is a class that extends Program we want to do special functionality
+            this.isProgramValued = isSubclassOf(this.documentType, Program);
+            this.dbType = properties.dbType;
+            this._resultQueue = new Map();
+            const replicateFn = properties.replicate ?? this._sync ?? (() => Promise.resolve());
+            this._sync = (request, results) => {
+                let rq;
+                let rs;
+                if (request instanceof types.PredictedSearchRequest) {
+                    // TODO is this codepath even reachable?
+                    throw new Error("Unexpected PredictedSearchRequest in sync operation");
+                }
+                else {
+                    rq = request;
+                    rs = results;
+                }
+                return replicateFn(rq, rs);
+            };
+            const transformOptions = properties.transform;
+            this.transformer = transformOptions
+                ? isTransformerWithFunction(transformOptions)
+                    ? (obj, context) => transformOptions.transform(obj, context)
+                    : transformOptions.type
+                        ? (obj, context) => new transformOptions.type(obj, context)
+                        : (obj) => obj
+                : (obj) => obj; // TODO types
+            const maybeArr = properties.indexBy || DEFAULT_INDEX_BY;
+            this.indexBy = Array.isArray(maybeArr) ? maybeArr : [maybeArr];
+            this.indexByResolver = (obj) => indexerTypes.extractFieldValue(obj, this.indexBy);
+            this._valueEncoding = BORSH_ENCODING(this.documentType);
+            this._resolverCache =
+                properties.cache?.resolver === 0
+                    ? undefined
+                    : new Cache({ max: properties.cache?.resolver ?? 100 }); // TODO choose limit better by default (adaptive)
+            this.index =
+                (await (await this.node.indexer.scope(sha256Base64Sync(concat([this._log.log.id, fromString("/document-index")])))).init({
+                    indexBy: this.indexBy,
+                    schema: this.wrappedIndexedType,
+                    nested: this.nestedProperties,
+                    /* maxBatchSize: MAX_BATCH_SIZE */
+                })) || new HashmapIndex();
+            if (properties.cache?.query) {
+                this.index = new CachedIndex(this.index, properties.cache.query);
+            }
+            indexLifecycleLogger("opened document index", {
+                peer: this.node.identity.publicKey.hashcode(),
+                indexBy: this.indexBy,
+                includeIndexed: this.includeIndexed === true,
+                cacheResolver: Boolean(this._resolverCache),
+                prefetch: Boolean(this.prefetch),
             });
-            if (ignore) {
-                if (this.prefetch.strict) {
-                    return;
+            this._resumableIterators = new ResumableIterators(this.index);
+            this._maybeOpen = properties.maybeOpen;
+            if (this.isProgramValued) {
+                this._resolverProgramCache = new Map();
+            }
+            if (this.prefetch?.predictor) {
+                indexPrefetchLogger("prefetch predictor enabled", {
+                    peer: this.node.identity.publicKey.hashcode(),
+                    strict: Boolean(this.prefetch?.strict),
+                });
+                const predictor = this.prefetch.predictor;
+                this._joinListener = async (e) => {
+                    // on join we emit predicted search results before peers query us (to save latency but for the price of errornous bandwidth usage)
+                    if ((await this._log.isReplicating()) === false) {
+                        return;
+                    }
+                    indexPrefetchLogger("peer join triggered predictor", {
+                        target: e.detail.hashcode(),
+                    });
+                    // TODO
+                    // it only makes sense for use to return predicted results if the peer is to choose us as a replicator
+                    // so we need to calculate the cover set from the peers perspective
+                    // create an iterator and send the peer the results
+                    let request = predictor.predictedQuery(e.detail);
+                    if (!request) {
+                        indexPrefetchLogger("predictor had no cached query", {
+                            target: e.detail.hashcode(),
+                        });
+                        return;
+                    }
+                    indexPrefetchLogger("sending predicted results", {
+                        target: e.detail.hashcode(),
+                        request: request.idString,
+                    });
+                    const results = await this.handleSearchRequest(request, {
+                        from: e.detail,
+                    });
+                    if (results instanceof types.AbstractSearchResult) {
+                        // start a resumable iterator for the peer
+                        const query = new types.PredictedSearchRequest({
+                            id: request.id,
+                            request,
+                            results,
+                        });
+                        await this._query.send(query, {
+                            mode: new SilentDelivery({ to: [e.detail], redundancy: 1 }),
+                        });
+                    }
+                };
+                // we do this before _query.open so that we can receive the join event, even immediate ones
+                if (this._joinListener) {
+                    this._query.events.addEventListener("join", this._joinListener);
                 }
             }
+            await this._query.open({
+                topic: sha256Base64Sync(concat([this._log.log.id, fromString("/document")])),
+                responseHandler: this.queryRPCResponseHandler.bind(this),
+                responseType: types.AbstractSearchResult,
+                queryType: types.AbstractSearchRequest,
+            });
+            if (this.handleDocumentChange) {
+                this.documentEvents.addEventListener("change", this.handleDocumentChange);
+            }
         }
-        return this.handleSearchRequest(query, {
-            from: ctx.from,
-        });
-    }
-    async handleSearchRequest(query, ctx) {
-        if (this.canSearch &&
-            (query instanceof types.SearchRequest ||
-                query instanceof types.IterationRequest ||
-                query instanceof types.CollectNextRequest) &&
-            !(await this.canSearch(query, ctx.from))) {
-            return new types.NoAccess();
+        get prefetch() {
+            return this._prefetch;
         }
-        if (query instanceof types.CloseIteratorRequest) {
-            this.processCloseIteratorRequest(query, ctx.from);
+        async queryRPCResponseHandler(query, ctx) {
+            if (!ctx.from) {
+                logger("Receieved query without from");
+                return;
+            }
+            indexRpcLogger("received request", {
+                type: query.constructor.name,
+                from: ctx.from.hashcode(),
+                id: query.idString,
+            });
+            if (query instanceof types.PredictedSearchRequest) {
+                // put results in a waiting cache so that we eventually in the future will query a matching thing, we already have results available
+                this._prefetch?.accumulator.add({
+                    message: ctx.message,
+                    response: query,
+                    from: ctx.from,
+                }, ctx.from.hashcode());
+                indexPrefetchLogger("cached predicted results", {
+                    from: ctx.from.hashcode(),
+                    request: query.idString,
+                });
+                return;
+            }
+            if (this.prefetch?.predictor &&
+                (query instanceof types.SearchRequest ||
+                    query instanceof types.SearchRequestIndexed ||
+                    query instanceof types.IterationRequest)) {
+                const { ignore } = this.prefetch.predictor.onRequest(query, {
+                    from: ctx.from,
+                });
+                if (ignore) {
+                    indexPrefetchLogger("predictor ignored request", {
+                        from: ctx.from.hashcode(),
+                        request: query.idString,
+                        strict: Boolean(this.prefetch?.strict),
+                    });
+                    if (this.prefetch.strict) {
+                        return;
+                    }
+                }
+            }
+            try {
+                const out = await this.handleSearchRequest(query, {
+                    from: ctx.from,
+                });
+                return out;
+            }
+            catch (error) {
+                throw error;
+            }
         }
-        else {
-            const fromQueued = query instanceof types.CollectNextRequest
-                ? this._resultQueue.get(query.idString)?.fromQuery
-                : undefined;
-            const queryResolvesDocuments = query instanceof types.CollectNextRequest
-                ? resolvesDocuments(fromQueued)
-                : resolvesDocuments(query);
-            const shouldIncludedIndexedResults = this.includeIndexed && queryResolvesDocuments;
-            const results = await this.processQuery(query, ctx.from, false, {
-                canRead: this.canRead,
+        async handleSearchRequest(query, ctx) {
+            indexRpcLogger("handling query", {
+                type: query.constructor.name,
+                id: query.idString,
+                from: ctx.from.hashcode(),
             });
-            if (shouldIncludedIndexedResults) {
-                let resultsWithIndexed = results.results;
-                let fromLength = results.results.length;
-                for (let i = 0; i < fromLength; i++) {
-                    let result = results.results[i];
-                    resultsWithIndexed.push(new types.ResultIndexedValue({
-                        source: serialize(result.indexed),
-                        indexed: result.indexed,
-                        context: result.context,
-                        entries: [],
-                    }));
+            if (this.canSearch &&
+                (query instanceof types.SearchRequest ||
+                    query instanceof types.IterationRequest ||
+                    query instanceof types.CollectNextRequest) &&
+                !(await this.canSearch(query, ctx.from))) {
+                indexRpcLogger("denied query", {
+                    id: query.idString,
+                    from: ctx.from.hashcode(),
+                });
+                return new types.NoAccess();
+            }
+            if (query instanceof types.CloseIteratorRequest) {
+                this.processCloseIteratorRequest(query, ctx.from);
+            }
+            else {
+                const fromQueued = query instanceof types.CollectNextRequest
+                    ? this._resultQueue.get(query.idString)?.fromQuery
+                    : undefined;
+                const queryResolvesDocuments = query instanceof types.CollectNextRequest
+                    ? resolvesDocuments(fromQueued)
+                    : resolvesDocuments(query);
+                const shouldIncludedIndexedResults = this.includeIndexed && queryResolvesDocuments;
+                const results = await this.processQuery(query, ctx.from, false, {
+                    canRead: this.canRead,
+                });
+                indexRpcLogger("query results ready", {
+                    id: query.idString,
+                    from: ctx.from.hashcode(),
+                    count: results.results.length,
+                    kept: results.kept,
+                    includeIndexed: shouldIncludedIndexedResults,
+                });
+                if (shouldIncludedIndexedResults) {
+                    let resultsWithIndexed = results.results;
+                    let fromLength = results.results.length;
+                    for (let i = 0; i < fromLength; i++) {
+                        let result = results.results[i];
+                        resultsWithIndexed.push(new types.ResultIndexedValue({
+                            source: serialize(result.indexed),
+                            indexed: result.indexed,
+                            context: result.context,
+                            entries: [],
+                        }));
+                    }
+                    return new types.Results({
+                        // Even if results might have length 0, respond, because then we now at least there are no matching results
+                        results: resultsWithIndexed,
+                        kept: results.kept,
+                    });
                 }
                 return new types.Results({
                     // Even if results might have length 0, respond, because then we now at least there are no matching results
-                    results: resultsWithIndexed,
+                    results: results.results,
                     kept: results.kept,
                 });
             }
-            return new types.Results({
-                // Even if results might have length 0, respond, because then we now at least there are no matching results
-                results: results.results,
-                kept: results.kept,
-            });
         }
-    }
-    async afterOpen() {
-        if (this.isProgramValued) {
-            // re-open the program cache
-            for (const { id, value } of await this.index.iterate().all()) {
-                const programValue = await this.resolveDocument({
-                    indexed: value,
-                    head: value.__context.head,
-                });
-                if (!programValue) {
-                    logger.error("Missing program value after re-opening the document index. Hash: " +
-                        value.__context.head);
-                    continue;
+        async afterOpen() {
+            if (this.isProgramValued) {
+                // re-open the program cache
+                for (const { id, value } of await this.index.iterate().all()) {
+                    const programValue = await this.resolveDocument({
+                        indexed: value,
+                        head: value.__context.head,
+                    });
+                    if (!programValue) {
+                        logger.error("Missing program value after re-opening the document index. Hash: " +
+                            value.__context.head);
+                        continue;
+                    }
+                    programValue.value = await this._maybeOpen(programValue.value);
+                    this._resolverProgramCache.set(id.primitive, programValue.value);
                 }
-                programValue.value = await this._maybeOpen(programValue.value);
-                this._resolverProgramCache.set(id.primitive, programValue.value);
             }
+            return super.afterOpen();
         }
-        return super.afterOpen();
-    }
-    async getPending(cursorId) {
-        const queue = this._resultQueue.get(cursorId);
-        if (queue) {
-            return queue.queue.length + queue.keptInIndex;
-        }
-        return this._resumableIterators.getPending(cursorId);
-    }
-    get hasPending() {
-        if (this._resultQueue.size > 0) {
-            return true;
-        }
-        return false;
-    }
-    async close(from) {
-        const closed = await super.close(from);
-        if (closed) {
-            this._query.events.removeEventListener("join", this._joinListener);
-            this.clearAllResultQueues();
-            await this.index.stop?.();
+        async getPending(cursorId) {
+            const queue = this._resultQueue.get(cursorId);
+            if (queue) {
+                return queue.queue.length + queue.keptInIndex;
+            }
+            return this._resumableIterators.getPending(cursorId);
         }
-        return closed;
-    }
-    async drop(from) {
-        const dropped = await super.drop(from);
-        if (dropped) {
-            this.clearAllResultQueues();
-            await this.index.drop?.();
-            await this.index.stop?.();
+        get hasPending() {
+            if (this._resultQueue.size > 0) {
+                return true;
+            }
+            return false;
         }
-        return dropped;
-    }
-    async get(key, options) {
-        let deferred;
-        // Normalize the id key early so listeners can use it
-        let idKey = key instanceof indexerTypes.IdKey ? key : indexerTypes.toId(key);
-        if (options?.waitFor) {
-            // add change listener before query because we might get a concurrent change that matches the query,
-            // that will not be included in the query result
-            deferred = pDefer();
-            const listener = (evt) => {
-                for (const added of evt.detail.added) {
-                    const id = indexerTypes.toId(this.indexByResolver(added.__indexed)).primitive;
-                    if (id === idKey.primitive) {
-                        deferred.resolve(added);
+        async close(from) {
+            const closed = await super.close(from);
+            if (closed) {
+                if (this._joinListener) {
+                    this._query.events.removeEventListener("join", this._joinListener);
+                }
+                if (this.handleDocumentChange) {
+                    this.documentEvents.removeEventListener("change", this.handleDocumentChange);
+                }
+                this.clearAllResultQueues();
+                await this.index.stop?.();
+            }
+            return closed;
+        }
+        async drop(from) {
+            const dropped = await super.drop(from);
+            if (dropped) {
+                this.documentEvents.removeEventListener("change", this.handleDocumentChange);
+                this.clearAllResultQueues();
+                await this.index.drop?.();
+                await this.index.stop?.();
+            }
+            return dropped;
+        }
+        async get(key, options) {
+            let deferred;
+            // Normalize the id key early so listeners can use it
+            let idKey = key instanceof indexerTypes.IdKey ? key : indexerTypes.toId(key);
+            if (options?.waitFor) {
+                // add change listener before query because we might get a concurrent change that matches the query,
+                // that will not be included in the query result
+                deferred = pDefer();
+                const listener = (evt) => {
+                    for (const added of evt.detail.added) {
+                        const id = indexerTypes.toId(this.indexByResolver(added.__indexed)).primitive;
+                        if (id === idKey.primitive) {
+                            deferred.resolve(added);
+                        }
+                    }
+                };
+                let cleanedUp = false;
+                let cleanup = () => {
+                    if (cleanedUp)
+                        return;
+                    cleanedUp = true;
+                    this.documentEvents.removeEventListener("change", listener);
+                    clearTimeout(timeout);
+                    this.events.removeEventListener("close", resolveUndefined);
+                    joinListener?.();
+                };
+                let resolveUndefined = () => {
+                    deferred.resolve(undefined);
+                };
+                let timeout = setTimeout(resolveUndefined, options.waitFor);
+                this.events.addEventListener("close", resolveUndefined);
+                this.documentEvents.addEventListener("change", listener);
+                deferred.promise.then(cleanup);
+                // Prepare remote options without mutating caller options
+                const baseRemote = options?.remote === false
+                    ? undefined
+                    : typeof options?.remote === "object"
+                        ? { ...options.remote }
+                        : {};
+                if (baseRemote) {
+                    const waitPolicy = baseRemote.wait;
+                    if (!waitPolicy ||
+                        (typeof waitPolicy === "object" &&
+                            (waitPolicy.timeout || 0) < options.waitFor)) {
+                        baseRemote.wait = {
+                            ...(typeof waitPolicy === "object" ? waitPolicy : {}),
+                            timeout: options.waitFor,
+                        };
                     }
                 }
-            };
-            let cleanedUp = false;
-            let cleanup = () => {
-                if (cleanedUp)
-                    return;
-                cleanedUp = true;
-                this.documentEvents.removeEventListener("change", listener);
-                clearTimeout(timeout);
-                this.events.removeEventListener("close", resolveUndefined);
-                joinListener?.();
-            };
-            let resolveUndefined = () => {
-                deferred.resolve(undefined);
-            };
-            let timeout = setTimeout(resolveUndefined, options.waitFor);
-            this.events.addEventListener("close", resolveUndefined);
-            this.documentEvents.addEventListener("change", listener);
-            deferred.promise.then(cleanup);
-            // Prepare remote options without mutating caller options
-            const baseRemote = options?.remote === false
-                ? undefined
-                : typeof options?.remote === "object"
-                    ? { ...options.remote }
-                    : {};
-            if (baseRemote) {
-                const waitPolicy = baseRemote.wait;
-                if (!waitPolicy ||
-                    (typeof waitPolicy === "object" &&
-                        (waitPolicy.timeout || 0) < options.waitFor)) {
-                    baseRemote.wait = {
-                        ...(typeof waitPolicy === "object" ? waitPolicy : {}),
-                        timeout: options.waitFor,
-                    };
+                // Re-query on peer joins (like iterate), scoped to the joining peer
+                let joinListener;
+                if (baseRemote) {
+                    joinListener = this.createReplicatorJoinListener({
+                        eager: baseRemote.reach?.eager,
+                        onPeer: async (pk) => {
+                            if (cleanedUp)
+                                return;
+                            const hash = pk.hashcode();
+                            const requeryOptions = {
+                                ...options,
+                                remote: {
+                                    ...(baseRemote || {}),
+                                    from: [hash],
+                                },
+                            };
+                            const re = await this.getDetailed(idKey, requeryOptions);
+                            const first = re?.[0]?.results[0];
+                            if (first) {
+                                deferred.resolve(first.value);
+                            }
+                        },
+                    });
                 }
             }
-            // Re-query on peer joins (like iterate), scoped to the joining peer
-            let joinListener;
-            if (baseRemote) {
-                joinListener = this.attachJoinListener({
-                    eager: baseRemote.reach?.eager,
-                    onPeer: async (pk) => {
-                        if (cleanedUp)
-                            return;
-                        const hash = pk.hashcode();
-                        const requeryOptions = {
-                            ...options,
-                            remote: {
-                                ...(baseRemote || {}),
-                                from: [hash],
-                            },
-                        };
-                        const re = await this.getDetailed(idKey, requeryOptions);
-                        const first = re?.[0]?.results[0];
-                        if (first) {
-                            deferred.resolve(first.value);
-                        }
-                    },
-                });
+            const result = (await this.getDetailed(idKey, options))?.[0]?.results[0];
+            // if no results, and we have remote joining options, we wait for the timout and if there are joining peers we re-query
+            if (!result) {
+                return deferred?.promise;
             }
-        }
-        const result = (await this.getDetailed(idKey, options))?.[0]?.results[0];
-        // if no results, and we have remote joining options, we wait for the timout and if there are joining peers we re-query
-        if (!result) {
-            return deferred?.promise;
-        }
-        else if (deferred) {
-            deferred.resolve(undefined);
-        }
-        return result?.value;
-    }
-    async getFromGid(gid) {
-        const iterator = this.index.iterate({ query: { gid } });
-        const one = await iterator.next(1);
-        await iterator.close();
-        return one[0];
-    }
-    async getFromHash(hash) {
-        const iterator = this.index.iterate({ query: { hash } });
-        const one = await iterator.next(1);
-        await iterator.close();
-        return one[0];
-    }
-    async put(value, id, entry, existing) {
-        const existingDefined = existing === undefined ? await this.index.get(id) : existing;
-        const context = new types.Context({
-            created: existingDefined?.value.__context.created ||
-                entry.meta.clock.timestamp.wallTime,
-            modified: entry.meta.clock.timestamp.wallTime,
-            head: entry.hash,
-            gid: entry.meta.gid,
-            size: entry.payload.byteLength,
-        });
-        return this.putWithContext(value, id, context);
-    }
-    async putWithContext(value, id, context) {
-        const idString = id.primitive;
-        if (this.isProgramValued /*
-        TODO should we skip caching program value if they are not openend through this db?
-        &&
-        (value as Program).closed === false &&
-        (value as Program).parents.includes(this._log) */) {
-            // TODO make last condition more efficient if there are many docs
-            this._resolverProgramCache.set(idString, value);
-        }
-        else {
-            this._resolverCache?.add(idString, value);
-        }
-        const valueToIndex = await this.transformer(value, context);
-        const wrappedValueToIndex = new this.wrappedIndexedType(valueToIndex, context);
-        coerceWithIndexed(value, valueToIndex);
-        coerceWithContext(value, context);
-        await this.index.put(wrappedValueToIndex);
-        return { context, indexable: valueToIndex };
-    }
-    del(key) {
-        if (this.isProgramValued) {
-            this._resolverProgramCache.delete(key.primitive);
-        }
-        else {
-            this._resolverCache?.del(key.primitive);
-        }
-        return this.index.del({
-            query: [indexerTypes.getMatcher(this.indexBy, key.key)],
-        });
-    }
-    async getDetailed(key, options) {
-        let coercedOptions = options;
-        if (options?.remote && typeof options.remote !== "boolean") {
-            coercedOptions = {
-                ...options,
-                remote: {
-                    ...options.remote,
-                    strategy: options.remote?.strategy ?? "fallback",
-                },
-            };
-        }
-        else if (options?.remote === undefined) {
-            coercedOptions = {
-                ...options,
-                remote: {
-                    strategy: "fallback",
-                },
-            };
-        }
-        let results;
-        const runAndClose = async (req) => {
-            const response = await this.queryCommence(req, coercedOptions);
-            this._resumableIterators.close({ idString: req.idString });
-            this.cancelIteratorKeepAlive(req.idString);
-            return response;
-        };
-        const resolve = coercedOptions?.resolve || coercedOptions?.resolve == null;
-        let requestClazz = resolve
-            ? types.SearchRequest
-            : types.SearchRequestIndexed;
-        if (key instanceof Uint8Array) {
-            const request = new requestClazz({
-                query: [
-                    new indexerTypes.ByteMatchQuery({ key: this.indexBy, value: key }),
-                ],
+            else if (deferred) {
+                deferred.resolve(undefined);
+            }
+            return result?.value;
+        }
+        async getFromGid(gid) {
+            const iterator = this.index.iterate({ query: { gid } });
+            const one = await iterator.next(1);
+            await iterator.close();
+            return one[0];
+        }
+        async getFromHash(hash) {
+            const iterator = this.index.iterate({ query: { hash } });
+            const one = await iterator.next(1);
+            await iterator.close();
+            return one[0];
+        }
+        async put(value, id, entry, existing) {
+            const existingDefined = existing === undefined ? await this.index.get(id) : existing;
+            const context = new types.Context({
+                created: existingDefined?.value.__context.created ||
+                    entry.meta.clock.timestamp.wallTime,
+                modified: entry.meta.clock.timestamp.wallTime,
+                head: entry.hash,
+                gid: entry.meta.gid,
+                size: entry.payload.byteLength,
             });
-            results = await runAndClose(request);
+            return this.putWithContext(value, id, context);
+        }
+        async putWithContext(value, id, context) {
+            const idString = id.primitive;
+            if (this.isProgramValued /*
+            TODO should we skip caching program value if they are not openend through this db?
+            &&
+            (value as Program).closed === false &&
+            (value as Program).parents.includes(this._log) */) {
+                // TODO make last condition more efficient if there are many docs
+                this._resolverProgramCache.set(idString, value);
+                indexCacheLogger("cache:set:program", { id: idString });
+            }
+            else {
+                if (this._resolverCache) {
+                    this._resolverCache.add(idString, value);
+                    indexCacheLogger("cache:set:value", { id: idString });
+                }
+            }
+            const valueToIndex = await this.transformer(value, context);
+            const wrappedValueToIndex = new this.wrappedIndexedType(valueToIndex, context);
+            coerceWithIndexed(value, valueToIndex);
+            coerceWithContext(value, context);
+            await this.index.put(wrappedValueToIndex);
+            return { context, indexable: valueToIndex };
         }
-        else {
-            const indexableKey = indexerTypes.toIdeable(key);
-            if (typeof indexableKey === "number" ||
-                typeof indexableKey === "bigint") {
-                const request = new requestClazz({
-                    query: [
-                        new indexerTypes.IntegerCompare({
-                            key: this.indexBy,
-                            compare: indexerTypes.Compare.Equal,
-                            value: indexableKey,
-                        }),
-                    ],
-                });
-                results = await runAndClose(request);
+        del(key) {
+            if (this.isProgramValued) {
+                this._resolverProgramCache.delete(key.primitive);
+                indexCacheLogger("cache:del:program", { id: key.primitive });
             }
-            else if (typeof indexableKey === "string") {
-                const request = new requestClazz({
-                    query: [
-                        new indexerTypes.StringMatch({
-                            key: this.indexBy,
-                            value: indexableKey,
-                        }),
-                    ],
-                });
-                results = await runAndClose(request);
+            else {
+                if (this._resolverCache?.del(key.primitive)) {
+                    indexCacheLogger("cache:del:value", { id: key.primitive });
+                }
             }
-            else if (indexableKey instanceof Uint8Array) {
-                const request = new requestClazz({
-                    query: [
-                        new indexerTypes.ByteMatchQuery({
-                            key: this.indexBy,
-                            value: indexableKey,
-                        }),
-                    ],
-                });
-                results = await runAndClose(request);
+            return this.index.del({
+                query: [indexerTypes.getMatcher(this.indexBy, key.key)],
+            });
+        }
+        async getDetailed(key, options) {
+            let coercedOptions = options;
+            if (options?.remote && typeof options.remote !== "boolean") {
+                coercedOptions = {
+                    ...options,
+                    remote: {
+                        ...options.remote,
+                        strategy: options.remote?.strategy ?? "fallback",
+                    },
+                };
             }
-            else if (indexableKey instanceof ArrayBuffer) {
+            else if (options?.remote === undefined) {
+                coercedOptions = {
+                    ...options,
+                    remote: {
+                        strategy: "fallback",
+                    },
+                };
+            }
+            let results;
+            const runAndClose = async (req) => {
+                const response = await this.queryCommence(req, coercedOptions);
+                this._resumableIterators.close({ idString: req.idString });
+                this.cancelIteratorKeepAlive(req.idString);
+                return response;
+            };
+            const resolve = coercedOptions?.resolve || coercedOptions?.resolve == null;
+            let requestClazz = resolve
+                ? types.SearchRequest
+                : types.SearchRequestIndexed;
+            if (key instanceof Uint8Array) {
                 const request = new requestClazz({
                     query: [
-                        new indexerTypes.ByteMatchQuery({
-                            key: this.indexBy,
-                            value: new Uint8Array(indexableKey),
-                        }),
+                        new indexerTypes.ByteMatchQuery({ key: this.indexBy, value: key }),
                     ],
                 });
                 results = await runAndClose(request);
             }
             else {
-                throw new Error("Unsupported key type");
+                const indexableKey = indexerTypes.toIdeable(key);
+                if (typeof indexableKey === "number" ||
+                    typeof indexableKey === "bigint") {
+                    const request = new requestClazz({
+                        query: [
+                            new indexerTypes.IntegerCompare({
+                                key: this.indexBy,
+                                compare: indexerTypes.Compare.Equal,
+                                value: indexableKey,
+                            }),
+                        ],
+                    });
+                    results = await runAndClose(request);
+                }
+                else if (typeof indexableKey === "string") {
+                    const request = new requestClazz({
+                        query: [
+                            new indexerTypes.StringMatch({
+                                key: this.indexBy,
+                                value: indexableKey,
+                            }),
+                        ],
+                    });
+                    results = await runAndClose(request);
+                }
+                else if (indexableKey instanceof Uint8Array) {
+                    const request = new requestClazz({
+                        query: [
+                            new indexerTypes.ByteMatchQuery({
+                                key: this.indexBy,
+                                value: indexableKey,
+                            }),
+                        ],
+                    });
+                    results = await runAndClose(request);
+                }
+                else if (indexableKey instanceof ArrayBuffer) {
+                    const request = new requestClazz({
+                        query: [
+                            new indexerTypes.ByteMatchQuery({
+                                key: this.indexBy,
+                                value: new Uint8Array(indexableKey),
+                            }),
+                        ],
+                    });
+                    results = await runAndClose(request);
+                }
+                else {
+                    throw new Error("Unsupported key type");
+                }
             }
-        }
-        // if we are to resolve the document we need to go through all results and replace the results with the resolved values
-        const shouldResolve = resolve &&
-            requestClazz === types.SearchRequestIndexed &&
-            !this.indexedTypeIsDocumentType &&
-            results;
-        if (results) {
-            for (const set of results) {
-                let missingValues = false;
-                for (let i = 0; i < set.results.length; i++) {
-                    let value = set.results[i];
-                    let resolved;
-                    if (shouldResolve) {
-                        resolved =
-                            value instanceof types.ResultIndexedValue
-                                ? (await this.resolveDocument({
-                                    indexed: value.value,
-                                    head: value.context.head,
-                                }))?.value
-                                : value.value;
-                    }
-                    else {
-                        resolved = value.value;
-                    }
-                    if (resolved) {
-                        let indexed = await this.resolveIndexed(set.results[i], set.results);
-                        let valueWithWindexed = coerceWithIndexed(resolved, indexed);
-                        set.results[i]._value = coerceWithContext(valueWithWindexed, set.results[i].context);
+            // if we are to resolve the document we need to go through all results and replace the results with the resolved values
+            const shouldResolve = resolve &&
+                requestClazz === types.SearchRequestIndexed &&
+                !this.indexedTypeIsDocumentType &&
+                results;
+            if (results) {
+                for (const set of results) {
+                    let missingValues = false;
+                    for (let i = 0; i < set.results.length; i++) {
+                        let value = set.results[i];
+                        let resolved;
+                        if (shouldResolve) {
+                            resolved =
+                                value instanceof types.ResultIndexedValue
+                                    ? (await this.resolveDocument({
+                                        indexed: value.value,
+                                        head: value.context.head,
+                                    }))?.value
+                                    : value.value;
+                        }
+                        else {
+                            resolved = value.value;
+                        }
+                        if (resolved) {
+                            let indexed = await this.resolveIndexed(set.results[i], set.results);
+                            let valueWithWindexed = coerceWithIndexed(resolved, indexed);
+                            set.results[i]._value = coerceWithContext(valueWithWindexed, set.results[i].context);
+                        }
+                        else {
+                            missingValues = true;
+                        }
                     }
-                    else {
-                        missingValues = true;
+                    if (missingValues) {
+                        set.results = set.results.filter((x) => !!x);
                     }
                 }
-                if (missingValues) {
-                    set.results = set.results.filter((x) => !!x);
-                }
             }
+            return results;
         }
-        return results;
-    }
-    getSize() {
-        return this.index.getSize();
-    }
-    async resolveDocument(value) {
-        const id = value.id ??
-            indexerTypes.toId(this.indexByResolver(value.indexed)).primitive;
-        const cached = this._resolverCache?.get(id) || this._resolverProgramCache?.get(id);
-        if (cached != null) {
-            return { value: cached };
-        }
-        if (this.indexedTypeIsDocumentType) {
-            // cast value to T, i.e. convert the class but keep all properties except the __context
-            const obj = Object.assign(Object.create(this.documentType.prototype), value.indexed);
-            delete obj.__context;
-            return { value: obj };
-        }
-        const head = await this._log.log.get(value.head);
-        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
-        }
-        const payloadValue = await head.getPayloadValue();
-        if (isPutOperation(payloadValue)) {
-            return {
-                value: this.valueEncoding.decoder(payloadValue.data),
-                /* size: payloadValue.data.byteLength */
-            };
-        }
-        throw new Error("Unexpected value type when getting document: " +
-            payloadValue?.constructor?.name || typeof payloadValue);
-    }
-    async processQuery(query, from, isLocal, options) {
-        // We do special case for querying the id as we can do it faster than iterating
-        let prevQueued = isLocal
-            ? undefined
-            : this._resultQueue.get(query.idString);
-        if (prevQueued && !from.equals(prevQueued.from)) {
-            throw new Error("Different from in queued results");
-        }
-        let indexedResult = undefined;
-        let fromQuery;
-        let keepAliveRequest;
-        if (query instanceof types.SearchRequest ||
-            query instanceof types.SearchRequestIndexed ||
-            query instanceof types.IterationRequest) {
-            fromQuery = query;
-            if (!isLocal &&
-                query instanceof types.IterationRequest &&
-                query.keepAliveTtl != null) {
-                keepAliveRequest = query;
-            }
-            indexedResult = await this._resumableIterators.iterateAndFetch(query, {
-                keepAlive: keepAliveRequest !== undefined,
-            });
-        }
-        else if (query instanceof types.CollectNextRequest) {
-            const cachedRequest = prevQueued?.fromQuery ||
-                this._resumableIterators.queues.get(query.idString)?.request;
-            fromQuery = cachedRequest;
-            if (!isLocal &&
-                cachedRequest instanceof types.IterationRequest &&
-                cachedRequest.keepAliveTtl != null) {
-                keepAliveRequest = cachedRequest;
-            }
-            indexedResult =
-                prevQueued?.keptInIndex === 0
-                    ? []
-                    : await this._resumableIterators.next(query, {
-                        keepAlive: keepAliveRequest !== undefined,
-                    });
-        }
-        else {
-            throw new Error("Unsupported");
+        getSize() {
+            return this.index.getSize();
         }
-        if (!isLocal && keepAliveRequest) {
-            this.scheduleIteratorKeepAlive(query.idString, keepAliveRequest.keepAliveTtl);
-        }
-        let resultSize = 0;
-        let toIterate = prevQueued
-            ? [...prevQueued.queue, ...indexedResult]
-            : indexedResult;
-        if (prevQueued) {
-            this._resultQueue.delete(query.idString);
-            clearTimeout(prevQueued.timeout);
-            prevQueued = undefined;
-        }
-        let kept = (await this._resumableIterators.getPending(query.idString)) ?? 0;
-        if (!isLocal) {
-            prevQueued = {
-                from,
-                queue: [],
-                timeout: setTimeout(() => {
-                    this._resultQueue.delete(query.idString);
-                }, 6e4),
-                keptInIndex: kept,
-                fromQuery: (fromQuery || query),
-            };
-            this._resultQueue.set(query.idString, prevQueued);
+        async resolveDocument(value) {
+            const id = value.id ??
+                indexerTypes.toId(this.indexByResolver(value.indexed)).primitive;
+            const cached = this._resolverCache?.get(id) || this._resolverProgramCache?.get(id);
+            if (cached != null) {
+                return { value: cached };
+            }
+            if (this.indexedTypeIsDocumentType) {
+                // cast value to T, i.e. convert the class but keep all properties except the __context
+                const obj = Object.assign(Object.create(this.documentType.prototype), value.indexed);
+                delete obj.__context;
+                return { value: obj };
+            }
+            const head = await this._log.log.get(value.head);
+            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
+            }
+            const payloadValue = await head.getPayloadValue();
+            if (isPutOperation(payloadValue)) {
+                return {
+                    value: this.valueEncoding.decoder(payloadValue.data),
+                    /* size: payloadValue.data.byteLength */
+                };
+            }
+            throw new Error("Unexpected value type when getting document: " +
+                payloadValue?.constructor?.name || typeof payloadValue);
         }
-        const filteredResults = [];
-        const resolveDocumentsFlag = resolvesDocuments(fromQuery);
-        const replicateIndexFlag = replicatesIndex(fromQuery);
-        for (const result of toIterate) {
-            if (!isLocal) {
-                resultSize += result.value.__context.size;
-                if (resultSize > MAX_BATCH_SIZE) {
-                    prevQueued.queue.push(result);
-                    continue;
+        async processQuery(query, from, isLocal, options) {
+            // We do special case for querying the id as we can do it faster than iterating
+            let prevQueued = isLocal
+                ? undefined
+                : this._resultQueue.get(query.idString);
+            if (prevQueued && !from.equals(prevQueued.from)) {
+                throw new Error("Different from in queued results");
+            }
+            let indexedResult = undefined;
+            let fromQuery;
+            let keepAliveRequest;
+            if (query instanceof types.SearchRequest ||
+                query instanceof types.SearchRequestIndexed ||
+                query instanceof types.IterationRequest) {
+                fromQuery = query;
+                if (!isLocal &&
+                    query instanceof types.IterationRequest &&
+                    query.keepAliveTtl != null) {
+                    keepAliveRequest = query;
                 }
+                indexedResult = await this._resumableIterators.iterateAndFetch(query, {
+                    keepAlive: keepAliveRequest !== undefined,
+                });
             }
-            const indexedUnwrapped = Object.assign(Object.create(this.indexedType.prototype), result.value);
-            if (options?.canRead &&
-                !(await options.canRead(indexedUnwrapped, from))) {
-                continue;
+            else if (query instanceof types.CollectNextRequest) {
+                const cachedRequest = prevQueued?.fromQuery ||
+                    this._resumableIterators.queues.get(query.idString)?.request;
+                fromQuery = cachedRequest;
+                if (!isLocal &&
+                    cachedRequest instanceof types.IterationRequest &&
+                    cachedRequest.keepAliveTtl != null) {
+                    keepAliveRequest = cachedRequest;
+                }
+                const hasResumable = this._resumableIterators.has(query.idString);
+                indexedResult = hasResumable
+                    ? await this._resumableIterators.next(query, {
+                        keepAlive: keepAliveRequest !== undefined,
+                    })
+                    : [];
             }
-            if (resolveDocumentsFlag) {
-                const value = await this.resolveDocument({
-                    indexed: result.value,
-                    head: result.value.__context.head,
-                });
-                if (!value) {
+            else {
+                throw new Error("Unsupported");
+            }
+            if (!isLocal && keepAliveRequest) {
+                this.scheduleIteratorKeepAlive(query.idString, keepAliveRequest.keepAliveTtl);
+            }
+            let resultSize = 0;
+            let toIterate = prevQueued
+                ? [...prevQueued.queue, ...indexedResult]
+                : indexedResult;
+            if (prevQueued) {
+                this._resultQueue.delete(query.idString);
+                clearTimeout(prevQueued.timeout);
+                prevQueued = undefined;
+            }
+            let kept = (await this._resumableIterators.getPending(query.idString)) ?? 0;
+            if (!isLocal) {
+                const resolveFlag = resolvesDocuments((fromQuery || query));
+                prevQueued = {
+                    from,
+                    queue: [],
+                    timeout: setTimeout(() => {
+                        this._resultQueue.delete(query.idString);
+                    }, 6e4),
+                    keptInIndex: kept,
+                    fromQuery: (fromQuery || query),
+                    resolveResults: resolveFlag,
+                };
+                if (fromQuery instanceof types.IterationRequest &&
+                    fromQuery.pushUpdates) {
+                    prevQueued.pushMode = fromQuery.pushUpdates;
+                }
+                this._resultQueue.set(query.idString, prevQueued);
+            }
+            const filteredResults = [];
+            const resolveDocumentsFlag = resolvesDocuments(fromQuery);
+            const replicateIndexFlag = replicatesIndex(fromQuery);
+            for (const result of toIterate) {
+                if (!isLocal) {
+                    resultSize += result.value.__context.size;
+                    if (resultSize > MAX_BATCH_SIZE) {
+                        prevQueued.queue.push(result);
+                        continue;
+                    }
+                }
+                const indexedUnwrapped = Object.assign(Object.create(this.indexedType.prototype), result.value);
+                if (options?.canRead &&
+                    !(await options.canRead(indexedUnwrapped, from))) {
                     continue;
                 }
-                filteredResults.push(new types.ResultValue({
-                    context: result.value.__context,
-                    value: value.value,
-                    source: serialize(value.value),
-                    indexed: indexedUnwrapped,
-                }));
+                if (resolveDocumentsFlag) {
+                    const value = await this.resolveDocument({
+                        indexed: result.value,
+                        head: result.value.__context.head,
+                    });
+                    if (!value) {
+                        continue;
+                    }
+                    filteredResults.push(new types.ResultValue({
+                        context: result.value.__context,
+                        value: value.value,
+                        source: serialize(value.value),
+                        indexed: indexedUnwrapped,
+                    }));
+                }
+                else {
+                    const context = result.value.__context;
+                    const head = await this._log.log.get(context.head);
+                    // assume remote peer will start to replicate (TODO is this ideal?)
+                    if (replicateIndexFlag) {
+                        this._log.addPeersToGidPeerHistory(context.gid, [from.hashcode()]);
+                    }
+                    filteredResults.push(new types.ResultIndexedValue({
+                        context,
+                        source: serialize(indexedUnwrapped),
+                        indexed: indexedUnwrapped,
+                        entries: head ? [head] : [],
+                    }));
+                }
             }
-            else {
-                const context = result.value.__context;
-                const head = await this._log.log.get(context.head);
-                // assume remote peer will start to replicate (TODO is this ideal?)
-                if (replicateIndexFlag) {
-                    this._log.addPeersToGidPeerHistory(context.gid, [from.hashcode()]);
-                }
-                filteredResults.push(new types.ResultIndexedValue({
-                    context,
-                    source: serialize(indexedUnwrapped),
-                    indexed: indexedUnwrapped,
-                    entries: head ? [head] : [],
-                }));
+            const results = new types.Results({
+                results: filteredResults,
+                kept: BigInt(kept + (prevQueued?.queue.length || 0)),
+            });
+            const keepAliveActive = keepAliveRequest !== undefined;
+            const pushActive = fromQuery instanceof types.IterationRequest &&
+                Boolean(fromQuery.pushUpdates);
+            if (!isLocal && results.kept === 0n && !keepAliveActive && !pushActive) {
+                this.clearResultsQueue(query);
             }
+            return results;
         }
-        const results = new types.Results({
-            results: filteredResults,
-            kept: BigInt(kept + (prevQueued?.queue.length || 0)),
-        });
-        if (!isLocal && results.kept === 0n) {
-            this.clearResultsQueue(query);
-        }
-        return results;
-    }
-    scheduleIteratorKeepAlive(idString, ttl) {
-        if (ttl == null) {
-            return;
-        }
-        const ttlNumber = Number(ttl);
-        if (!Number.isFinite(ttlNumber) || ttlNumber <= 0) {
-            return;
-        }
-        // Cap max timeout to 1 day	(TODO make configurable?)
-        const delay = Math.max(1, Math.min(ttlNumber, 86400000));
-        this.cancelIteratorKeepAlive(idString);
-        const timers = this.iteratorKeepAliveTimers ??
-            (this.iteratorKeepAliveTimers = new Map());
-        const timer = setTimeout(() => {
-            timers.delete(idString);
-            const queued = this._resultQueue.get(idString);
-            if (queued) {
-                clearTimeout(queued.timeout);
-                this._resultQueue.delete(idString);
-            }
-            this._resumableIterators.close({ idString });
-        }, delay);
-        timers.set(idString, timer);
-    }
-    cancelIteratorKeepAlive(idString) {
-        const timers = this.iteratorKeepAliveTimers;
-        if (!timers) {
-            return;
-        }
-        const timer = timers.get(idString);
-        if (timer) {
-            clearTimeout(timer);
-            timers.delete(idString);
-        }
-    }
-    clearResultsQueue(query) {
-        const queue = this._resultQueue.get(query.idString);
-        if (queue) {
-            clearTimeout(queue.timeout);
-            this._resultQueue.delete(query.idString);
-        }
-    }
-    get countIteratorsInProgress() {
-        return this._resumableIterators.queues.size;
-    }
-    clearAllResultQueues() {
-        for (const [key, queue] of this._resultQueue) {
-            clearTimeout(queue.timeout);
-            this._resultQueue.delete(key);
-            this.cancelIteratorKeepAlive(key);
-            this._resumableIterators.close({ idString: key });
-        }
-    }
-    async waitForCoverReady(params) {
-        const { domain, eager, settle, timeout, signal, onTimeout = "proceed", } = params;
-        if (settle !== "any") {
-            return;
-        }
-        const properties = domain && "range" in domain
-            ? { range: domain.range }
-            : { args: domain?.args };
-        const selfHash = this.node.identity.publicKey.hashcode();
-        const ready = async () => {
-            const cover = await this._log.getCover(properties, { eager });
-            return cover.some((hash) => hash !== selfHash);
-        };
-        if (await ready()) {
-            return;
+        scheduleIteratorKeepAlive(idString, ttl) {
+            if (ttl == null) {
+                return;
+            }
+            const ttlNumber = Number(ttl);
+            if (!Number.isFinite(ttlNumber) || ttlNumber <= 0) {
+                return;
+            }
+            // Cap max timeout to 1 day	(TODO make configurable?)
+            const delay = Math.max(1, Math.min(ttlNumber, 86400000));
+            this.cancelIteratorKeepAlive(idString);
+            const timers = this.iteratorKeepAliveTimers ??
+                (this.iteratorKeepAliveTimers = new Map());
+            const timer = setTimeout(() => {
+                timers.delete(idString);
+                const queued = this._resultQueue.get(idString);
+                if (queued) {
+                    clearTimeout(queued.timeout);
+                    this._resultQueue.delete(idString);
+                }
+                this._resumableIterators.close({ idString });
+            }, delay);
+            timers.set(idString, timer);
         }
-        const deferred = pDefer();
-        let settled = false;
-        let cleaned = false;
-        let timer;
-        let checking = false;
-        const cleanup = () => {
-            if (cleaned) {
+        cancelIteratorKeepAlive(idString) {
+            const timers = this.iteratorKeepAliveTimers;
+            if (!timers) {
                 return;
             }
-            cleaned = true;
-            this._log.events.removeEventListener("replicator:join", onEvent);
-            this._log.events.removeEventListener("replication:change", onEvent);
-            this._log.events.removeEventListener("replicator:mature", onEvent);
-            signal?.removeEventListener("abort", onAbort);
-            if (timer != null) {
+            const timer = timers.get(idString);
+            if (timer) {
                 clearTimeout(timer);
-                timer = undefined;
+                timers.delete(idString);
             }
-        };
-        const resolve = () => {
-            if (settled) {
-                return;
+        }
+        clearResultsQueue(query) {
+            const queue = this._resultQueue.get(query.idString);
+            if (queue) {
+                clearTimeout(queue.timeout);
+                this._resultQueue.delete(query.idString);
             }
-            settled = true;
-            cleanup();
-            deferred.resolve();
-        };
-        const reject = (error) => {
-            if (settled) {
+        }
+        get countIteratorsInProgress() {
+            return this._resumableIterators.queues.size;
+        }
+        clearAllResultQueues() {
+            for (const [key, queue] of this._resultQueue) {
+                clearTimeout(queue.timeout);
+                this._resultQueue.delete(key);
+                this.cancelIteratorKeepAlive(key);
+                this._resumableIterators.close({ idString: key });
+            }
+        }
+        async waitForCoverReady(params) {
+            const { domain, eager, settle, timeout, signal, onTimeout = "proceed", } = params;
+            if (settle !== "any") {
                 return;
             }
-            settled = true;
-            cleanup();
-            deferred.reject(error);
-        };
-        const onAbort = () => reject(new AbortError());
-        const onEvent = async () => {
-            if (checking) {
+            const properties = domain && "range" in domain
+                ? { range: domain.range }
+                : { args: domain?.args };
+            const selfHash = this.node.identity.publicKey.hashcode();
+            const ready = async () => {
+                const cover = await this._log.getCover(properties, { eager });
+                return cover.some((hash) => hash !== selfHash);
+            };
+            if (await ready()) {
                 return;
             }
-            checking = true;
-            try {
-                if (await ready()) {
-                    resolve();
+            const deferred = pDefer();
+            let settled = false;
+            let cleaned = false;
+            let timer;
+            let checking = false;
+            const cleanup = () => {
+                if (cleaned) {
+                    return;
+                }
+                cleaned = true;
+                this._log.events.removeEventListener("replicator:join", onEvent);
+                this._log.events.removeEventListener("replication:change", onEvent);
+                this._log.events.removeEventListener("replicator:mature", onEvent);
+                signal?.removeEventListener("abort", onAbort);
+                if (timer != null) {
+                    clearTimeout(timer);
+                    timer = undefined;
                 }
+            };
+            const resolve = () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                deferred.resolve();
+            };
+            const reject = (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                deferred.reject(error);
+            };
+            const onAbort = () => reject(new AbortError());
+            const onEvent = async () => {
+                if (checking) {
+                    return;
+                }
+                checking = true;
+                try {
+                    if (await ready()) {
+                        resolve();
+                    }
+                }
+                catch (error) {
+                    reject(error instanceof Error ? error : new Error(String(error)));
+                }
+                finally {
+                    checking = false;
+                }
+            };
+            if (signal) {
+                signal.addEventListener("abort", onAbort);
             }
-            catch (error) {
-                reject(error instanceof Error ? error : new Error(String(error)));
+            if (timeout > 0) {
+                timer = setTimeout(() => {
+                    if (onTimeout === "error") {
+                        reject(new TimeoutError("Timeout waiting for participating replicator"));
+                    }
+                    else {
+                        resolve();
+                    }
+                }, timeout);
+            }
+            this._log.events.addEventListener("replicator:join", onEvent);
+            this._log.events.addEventListener("replication:change", onEvent);
+            this._log.events.addEventListener("replicator:mature", onEvent);
+            try {
+                await deferred.promise;
             }
             finally {
-                checking = false;
+                cleanup();
             }
-        };
-        if (signal) {
-            signal.addEventListener("abort", onAbort);
         }
-        if (timeout > 0) {
-            timer = setTimeout(() => {
-                if (onTimeout === "error") {
-                    reject(new TimeoutError("Timeout waiting for participating replicator"));
+        // Utility: attach a join listener that waits until a peer is a replicator,
+        // then invokes the provided callback. Returns a detach function.
+        createReplicatorJoinListener(params) {
+            const active = new Set();
+            const listener = async (e) => {
+                const pk = e.detail;
+                const hash = pk.hashcode();
+                if (hash === this.node.identity.publicKey.hashcode())
+                    return;
+                if (params.signal?.aborted)
+                    return;
+                if (active.has(hash))
+                    return;
+                active.add(hash);
+                try {
+                    const isReplicator = await this._log
+                        .waitForReplicator(pk, {
+                        signal: params.signal,
+                        eager: params.eager,
+                    })
+                        .then(() => true)
+                        .catch(() => false);
+                    if (!isReplicator || params.signal?.aborted)
+                        return;
+                    indexIteratorLogger.trace("peer joined as replicator", { peer: hash });
+                    await params.onPeer(pk);
                 }
-                else {
-                    resolve();
+                finally {
+                    active.delete(hash);
                 }
-            }, timeout);
-        }
-        this._log.events.addEventListener("replicator:join", onEvent);
-        this._log.events.addEventListener("replication:change", onEvent);
-        this._log.events.addEventListener("replicator:mature", onEvent);
-        try {
-            await deferred.promise;
-        }
-        finally {
-            cleanup();
+            };
+            this._query.events.addEventListener("join", listener);
+            return () => this._query.events.removeEventListener("join", listener);
         }
-    }
-    // Utility: attach a join listener that waits until a peer is a replicator,
-    // then invokes the provided callback. Returns a detach function.
-    attachJoinListener(params) {
-        const active = new Set();
-        const listener = async (e) => {
-            const pk = e.detail;
-            const hash = pk.hashcode();
-            if (hash === this.node.identity.publicKey.hashcode())
-                return;
-            if (params.signal?.aborted)
-                return;
-            if (active.has(hash))
+        processCloseIteratorRequest(query, publicKey) {
+            indexIteratorLogger.trace("close request", {
+                id: query.idString,
+                from: publicKey.hashcode(),
+            });
+            const queueData = this._resultQueue.get(query.idString);
+            if (queueData && !queueData.from.equals(publicKey)) {
+                indexIteratorLogger.trace("Ignoring close iterator request from different peer");
                 return;
-            active.add(hash);
-            try {
-                await this._log
-                    .waitForReplicator(pk, {
-                    signal: params.signal,
-                    eager: params.eager,
-                })
-                    .catch(() => undefined);
-                if (params.signal?.aborted)
-                    return;
-                await params.onPeer(pk);
             }
-            finally {
-                active.delete(hash);
-            }
-        };
-        this._query.events.addEventListener("join", listener);
-        return () => this._query.events.removeEventListener("join", listener);
-    }
-    processCloseIteratorRequest(query, publicKey) {
-        const queueData = this._resultQueue.get(query.idString);
-        if (queueData && !queueData.from.equals(publicKey)) {
-            logger.info("Ignoring close iterator request from different peer");
-            return;
-        }
-        this.cancelIteratorKeepAlive(query.idString);
-        this.clearResultsQueue(query);
-        return this._resumableIterators.close(query);
-    }
-    /**
-     * Query and retrieve results with most details
-     * @param queryRequest
-     * @param options
-     * @returns
-     */
-    async queryCommence(queryRequest, options, fetchFirstForRemote) {
-        const local = typeof options?.local === "boolean" ? options?.local : true;
-        let remote = undefined;
-        if (typeof options?.remote === "boolean") {
-            if (options?.remote) {
-                remote = {};
+            this.cancelIteratorKeepAlive(query.idString);
+            this.clearResultsQueue(query);
+            return this._resumableIterators.close(query);
+        }
+        /**
+         * Query and retrieve results with most details
+         * @param queryRequest
+         * @param options
+         * @returns
+         */
+        async queryCommence(queryRequest, options, fetchFirstForRemote) {
+            const local = typeof options?.local === "boolean" ? options?.local : true;
+            let remote = undefined;
+            if (typeof options?.remote === "boolean") {
+                if (options?.remote) {
+                    remote = {};
+                }
+                else {
+                    remote = undefined;
+                }
             }
             else {
-                remote = undefined;
-            }
-        }
-        else {
-            remote = options?.remote || {};
-        }
-        if (remote && remote.priority == null) {
-            // give queries higher priority than other "normal" data activities
-            // without this, we might have a scenario that a peer joina  network with large amount of data to be synced, but can not query anything before that is done
-            // this will lead to bad UX as you usually want to list/expore whats going on before doing any replication work
-            remote.priority = 1;
-        }
-        if (!local && !remote) {
-            throw new Error("Expecting either 'options.remote' or 'options.local' to be true");
-        }
-        const allResults = [];
-        if (local) {
-            const results = await this.processQuery(queryRequest, this.node.identity.publicKey, true);
-            if (results.results.length > 0) {
-                options?.onResponse &&
-                    (await options.onResponse(results, this.node.identity.publicKey));
-                allResults.push(results);
+                remote = options?.remote || {};
+            }
+            if (remote && remote.priority == null) {
+                // give queries higher priority than other "normal" data activities
+                // without this, we might have a scenario that a peer joina  network with large amount of data to be synced, but can not query anything before that is done
+                // this will lead to bad UX as you usually want to list/expore whats going on before doing any replication work
+                remote.priority = 1;
+            }
+            if (!local && !remote) {
+                throw new Error("Expecting either 'options.remote' or 'options.local' to be true");
+            }
+            const allResults = [];
+            if (local) {
+                const results = await this.processQuery(queryRequest, this.node.identity.publicKey, true);
+                if (results.results.length > 0) {
+                    options?.onResponse &&
+                        (await options.onResponse(results, this.node.identity.publicKey));
+                    allResults.push(results);
+                }
             }
-        }
-        let resolved = [];
-        if (remote && (remote.strategy !== "fallback" || allResults.length === 0)) {
-            if (queryRequest instanceof types.CloseIteratorRequest) {
-                // don't wait for responses
-                throw new Error("Unexpected");
-            }
-            const replicatorGroups = options?.remote?.from
-                ? options?.remote?.from
-                : await this._log.getCover(remote.domain ?? { args: undefined }, {
-                    roleAge: remote.minAge,
-                    eager: remote.reach?.eager,
-                    reachableOnly: !!remote.wait, // when we want to merge joining we can ignore pending to be online peers and instead consider them once they become online
-                });
-            if (replicatorGroups) {
-                const responseHandler = async (results) => {
-                    const resultInitialized = await introduceEntries(queryRequest, results, this.documentType, this.indexedType, this._sync, options);
-                    for (const r of resultInitialized) {
-                        resolved.push(r.response);
-                    }
-                };
-                let extraPromises = undefined;
-                const groupHashes = replicatorGroups
-                    .filter((hash) => {
-                    if (hash === this.node.identity.publicKey.hashcode()) {
-                        return false;
-                    }
-                    if (fetchFirstForRemote?.has(hash)) {
-                        // we already fetched this one for remote, no need to do it again
-                        return false;
-                    }
-                    fetchFirstForRemote?.add(hash);
-                    const resultAlready = this._prefetch?.accumulator.consume(queryRequest, hash);
-                    if (resultAlready) {
-                        (extraPromises || (extraPromises = [])).push((async () => {
-                            let from = await this.node.services.pubsub.getPublicKey(hash);
-                            if (from) {
-                                return responseHandler([
-                                    {
-                                        response: resultAlready.response.results,
-                                        from,
-                                    },
-                                ]);
-                            }
-                        })());
-                        return false;
-                    }
-                    return true;
-                })
-                    .map((x) => [x]);
-                extraPromises && (await Promise.all(extraPromises));
-                let tearDown = undefined;
-                const search = this;
-                try {
-                    groupHashes.length > 0 &&
-                        (await queryAll(this._query, groupHashes, queryRequest, responseHandler, search._prefetch?.accumulator
-                            ? {
-                                ...remote,
-                                responseInterceptor(fn) {
-                                    const listener = (evt) => {
-                                        const consumable = search._prefetch?.accumulator.consume(queryRequest, evt.detail.consumable.from.hashcode());
-                                        if (consumable) {
-                                            fn({
-                                                message: consumable.message,
-                                                response: consumable.response.results,
-                                                from: consumable.from,
-                                            });
-                                        }
-                                    };
-                                    for (const groups of groupHashes) {
-                                        for (const hash of groups) {
-                                            const consumable = search._prefetch?.accumulator.consume(queryRequest, hash);
+            let resolved = [];
+            if (remote && (remote.strategy !== "fallback" || allResults.length === 0)) {
+                if (queryRequest instanceof types.CloseIteratorRequest) {
+                    // don't wait for responses
+                    throw new Error("Unexpected");
+                }
+                const replicatorGroups = options?.remote?.from
+                    ? options?.remote?.from
+                    : await this._log.getCover(remote.domain ?? { args: undefined }, {
+                        roleAge: remote.minAge,
+                        eager: remote.reach?.eager,
+                        reachableOnly: !!remote.wait, // when we want to merge joining we can ignore pending to be online peers and instead consider them once they become online
+                    });
+                if (replicatorGroups) {
+                    const responseHandler = async (results) => {
+                        const resultInitialized = await introduceEntries(queryRequest, results, this.documentType, this.indexedType, this._sync, options);
+                        for (const r of resultInitialized) {
+                            resolved.push(r.response);
+                        }
+                    };
+                    let extraPromises = undefined;
+                    const groupHashes = replicatorGroups
+                        .filter((hash) => {
+                        if (hash === this.node.identity.publicKey.hashcode()) {
+                            return false;
+                        }
+                        if (fetchFirstForRemote?.has(hash)) {
+                            // we already fetched this one for remote, no need to do it again
+                            return false;
+                        }
+                        fetchFirstForRemote?.add(hash);
+                        const resultAlready = this._prefetch?.accumulator.consume(queryRequest, hash);
+                        if (resultAlready) {
+                            (extraPromises || (extraPromises = [])).push((async () => {
+                                let from = await this.node.services.pubsub.getPublicKey(hash);
+                                if (from) {
+                                    return responseHandler([
+                                        {
+                                            response: resultAlready.response.results,
+                                            from,
+                                        },
+                                    ]);
+                                }
+                            })());
+                            return false;
+                        }
+                        return true;
+                    })
+                        .map((x) => [x]);
+                    extraPromises && (await Promise.all(extraPromises));
+                    let tearDown = undefined;
+                    const search = this;
+                    try {
+                        groupHashes.length > 0 &&
+                            (await queryAll(this._query, groupHashes, queryRequest, responseHandler, search._prefetch?.accumulator
+                                ? {
+                                    ...remote,
+                                    responseInterceptor(fn) {
+                                        const listener = (evt) => {
+                                            const consumable = search._prefetch?.accumulator.consume(queryRequest, evt.detail.consumable.from.hashcode());
                                             if (consumable) {
                                                 fn({
                                                     message: consumable.message,
@@ -1215,514 +1499,543 @@ let DocumentIndex = class DocumentIndex extends Program {
                                                     from: consumable.from,
                                                 });
                                             }
+                                        };
+                                        for (const groups of groupHashes) {
+                                            for (const hash of groups) {
+                                                const consumable = search._prefetch?.accumulator.consume(queryRequest, hash);
+                                                if (consumable) {
+                                                    fn({
+                                                        message: consumable.message,
+                                                        response: consumable.response.results,
+                                                        from: consumable.from,
+                                                    });
+                                                }
+                                            }
                                         }
-                                    }
-                                    search.prefetch?.accumulator.addEventListener("add", listener);
-                                    tearDown = () => {
-                                        search.prefetch?.accumulator.removeEventListener("add", listener);
-                                    };
-                                },
+                                        search.prefetch?.accumulator.addEventListener("add", listener);
+                                        tearDown = () => {
+                                            search.prefetch?.accumulator.removeEventListener("add", listener);
+                                        };
+                                    },
+                                }
+                                : remote));
+                    }
+                    catch (error) {
+                        if (error instanceof MissingResponsesError) {
+                            warn("Did not reciveve responses from all shard");
+                            if (remote?.throwOnMissing) {
+                                throw error;
                             }
-                            : remote));
-                }
-                catch (error) {
-                    if (error instanceof MissingResponsesError) {
-                        logger.warn("Did not reciveve responses from all shard");
-                        if (remote?.throwOnMissing) {
+                        }
+                        else {
                             throw error;
                         }
                     }
-                    else {
-                        throw error;
+                    finally {
+                        tearDown && tearDown();
                     }
                 }
-                finally {
-                    tearDown && tearDown();
-                }
-            }
-            else {
-                // TODO send without direction out to the world? or just assume we can insert?
-                /* 	promises.push(
-                        this._query
-                            .request(queryRequest, remote)
-                            .then((results) => introduceEntries(results, this.type, this._sync, options).then(x => x.map(y => y.response)))
-                    ); */
-                /* throw new Error(
-                    "Missing remote replicator info for performing distributed document query"
-                ); */
-            }
-        }
-        for (const r of resolved) {
-            if (r) {
-                if (r instanceof Array) {
-                    allResults.push(...r);
-                }
                 else {
-                    allResults.push(r);
+                    // TODO send without direction out to the world? or just assume we can insert?
+                    /* 	promises.push(
+                            this._query
+                                .request(queryRequest, remote)
+                                .then((results) => introduceEntries(results, this.type, this._sync, options).then(x => x.map(y => y.response)))
+                        ); */
+                    /* throw new Error(
+                        "Missing remote replicator info for performing distributed document query"
+                    ); */
                 }
             }
-        }
-        return allResults; // TODO types
-    }
-    /**
-     * Query and retrieve results
-     * @param queryRequest
-     * @param options
-     * @returns
-     */
-    async search(queryRequest, options) {
-        // Set fetch to search size, or max value (default to max u32 (4294967295))
-        const coercedRequest = coerceQuery(queryRequest, options, this.compatibility);
-        coercedRequest.fetch = coercedRequest.fetch ?? 0xffffffff;
-        // So that the iterator is pre-fetching the right amount of entries
-        const iterator = this.iterate(coercedRequest, options);
-        // So that this call will not do any remote requests
-        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);
-            }
-        }
-        await iterator.close();
-        // Deduplicate and return values directly
-        return dedup(allResults, this.indexByResolver);
-    }
-    resolveIndexed(result, results) {
-        if (result instanceof types.ResultIndexedValue) {
-            return coerceWithContext(result.value, result.context);
-        }
-        let resolveIndexedDefault = async (result) => coerceWithContext(result.indexed ||
-            (await this.transformer(result.value, result.context)), result.context);
-        let resolveIndexed = this.includeIndexed
-            ? (result, results) => {
-                // look through the search results and see if we can find the indexed representation
-                for (const otherResult of results) {
-                    if (otherResult instanceof types.ResultIndexedValue) {
-                        if (otherResult.context.head === result.context.head) {
-                            otherResult.init(this.indexedType);
-                            return coerceWithContext(otherResult.value, otherResult.context);
-                        }
+            for (const r of resolved) {
+                if (r) {
+                    if (r instanceof Array) {
+                        allResults.push(...r);
+                    }
+                    else {
+                        allResults.push(r);
                     }
                 }
-                return resolveIndexedDefault(result);
             }
-            : (result) => resolveIndexedDefault(result);
-        return resolveIndexed(result, results);
-    }
-    /**
-     * Query and retrieve documents in a iterator
-     * @param queryRequest
-     * @param optionsArg
-     * @returns
-     */
-    iterate(queryRequest, optionsArg) {
-        let options = optionsArg;
-        if (queryRequest instanceof types.SearchRequest &&
-            options?.resolve === false) {
-            throw new Error("Cannot use resolve=false with SearchRequest"); // TODO make this work
-        }
-        let queryRequestCoerced = coerceQuery(queryRequest ?? {}, options, this.compatibility);
-        const { mergePolicy, push: pushUpdates, callbacks: updateCallbacksRaw, } = normalizeUpdatesOption(options?.updates);
-        const hasLiveUpdates = mergePolicy !== undefined;
-        const originalRemote = options?.remote;
-        let remoteOptions = typeof originalRemote === "boolean"
-            ? originalRemote
-            : originalRemote
-                ? { ...originalRemote }
-                : undefined;
-        if (pushUpdates && remoteOptions !== false) {
-            if (typeof remoteOptions === "object") {
-                if (remoteOptions.replicate !== true) {
-                    remoteOptions.replicate = true;
+            return allResults; // TODO types
+        }
+        /**
+         * Query and retrieve results
+         * @param queryRequest
+         * @param options
+         * @returns
+         */
+        async search(queryRequest, options) {
+            // Set fetch to search size, or max value (default to max u32 (4294967295))
+            const coercedRequest = coerceQuery(queryRequest, options, this.compatibility);
+            coercedRequest.fetch = coercedRequest.fetch ?? 0xffffffff;
+            // So that the iterator is pre-fetching the right amount of entries
+            const iterator = this.iterate(coercedRequest, options);
+            // So that this call will not do any remote requests
+            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);
                 }
             }
-            else if (remoteOptions === undefined || remoteOptions === true) {
-                remoteOptions = { replicate: true };
-            }
-        }
-        if (remoteOptions !== originalRemote) {
-            options = Object.assign({}, options, { remote: remoteOptions });
-        }
-        let resolve = options?.resolve !== false;
-        if (!(queryRequestCoerced instanceof types.IterationRequest) &&
-            options?.remote &&
-            typeof options.remote !== "boolean" &&
-            (options.remote.replicate || pushUpdates) &&
-            options?.resolve !== false) {
-            if ((queryRequest instanceof types.SearchRequestIndexed === false &&
-                this.compatibility == null) ||
-                (this.compatibility != null && this.compatibility > 8)) {
-                queryRequestCoerced = new types.SearchRequestIndexed({
-                    query: queryRequestCoerced.query,
-                    fetch: queryRequestCoerced.fetch,
-                    sort: queryRequestCoerced.sort,
-                });
-                resolve = true;
-            }
-        }
-        let replicate = options?.remote &&
-            typeof options.remote !== "boolean" &&
-            (options.remote.replicate || pushUpdates);
-        if (replicate &&
-            queryRequestCoerced instanceof types.SearchRequestIndexed) {
-            queryRequestCoerced.replicate = true;
-        }
-        let fetchPromise = undefined;
-        const peerBufferMap = new Map();
-        const visited = new Set();
-        let indexedPlaceholders;
-        const ensureIndexedPlaceholders = () => {
-            if (!indexedPlaceholders) {
-                indexedPlaceholders = new Map();
-            }
-            return indexedPlaceholders;
-        };
-        let done = false;
-        let drain = false; // if true, close on empty once (overrides manual)
-        let first = false;
-        // TODO handle join/leave while iterating
-        let controller = undefined;
-        const ensureController = () => {
-            if (!controller) {
-                return (controller = new AbortController());
-            }
-            return controller;
-        };
-        let totalFetchedCounter = 0;
-        let lastValueInOrder = undefined;
-        const peerBuffers = () => {
-            return [...peerBufferMap.values()].map((x) => x.buffer).flat();
-        };
-        let maybeSetDone = () => {
-            cleanup();
-            done = true;
-        };
-        let unsetDone = () => {
-            done = false;
-        };
-        let cleanup = () => {
-            this.clearResultsQueue(queryRequestCoerced);
-        };
-        let warmupPromise = undefined;
-        let discoveredTargetHashes;
-        if (typeof options?.remote === "object") {
-            let waitForTime = undefined;
-            if (options.remote.wait) {
-                let t0 = +new Date();
-                waitForTime =
-                    typeof options.remote.wait === "boolean"
-                        ? DEFAULT_TIMEOUT
-                        : (options.remote.wait.timeout ?? DEFAULT_TIMEOUT);
-                let setDoneIfTimeout = false;
-                maybeSetDone = () => {
-                    if (t0 + waitForTime < +new Date()) {
-                        cleanup();
-                        done = true;
+            await iterator.close();
+            // Deduplicate and return values directly
+            return dedup(allResults, this.indexByResolver);
+        }
+        resolveIndexed(result, results) {
+            if (result instanceof types.ResultIndexedValue) {
+                return coerceWithContext(result.value, result.context);
+            }
+            let resolveIndexedDefault = async (result) => coerceWithContext(result.indexed ||
+                (await this.transformer(result.value, result.context)), result.context);
+            let resolveIndexed = this.includeIndexed
+                ? (result, results) => {
+                    // look through the search results and see if we can find the indexed representation
+                    for (const otherResult of results) {
+                        if (otherResult instanceof types.ResultIndexedValue) {
+                            if (otherResult.context.head === result.context.head) {
+                                otherResult.init(this.indexedType);
+                                return coerceWithContext(otherResult.value, otherResult.context);
+                            }
+                        }
                     }
-                    else {
-                        setDoneIfTimeout = true;
+                    return resolveIndexedDefault(result);
+                }
+                : (result) => resolveIndexedDefault(result);
+            return resolveIndexed(result, results);
+        }
+        /**
+         * Query and retrieve documents in a iterator
+         * @param queryRequest
+         * @param optionsArg
+         * @returns
+         */
+        iterate(queryRequest, optionsArg) {
+            let options = optionsArg;
+            if (queryRequest instanceof types.SearchRequest &&
+                options?.resolve === false) {
+                throw new Error("Cannot use resolve=false with SearchRequest"); // TODO make this work
+            }
+            let queryRequestCoerced = coerceQuery(queryRequest ?? {}, options, this.compatibility);
+            const self = this;
+            function normalizeUpdatesOption(u) {
+                const identityFilter = (evt) => evt;
+                const buildMergePolicy = (merge, defaultEnabled) => {
+                    const effective = merge === undefined ? (defaultEnabled ? true : undefined) : merge;
+                    if (effective === undefined || effective === false) {
+                        return undefined;
                     }
-                };
-                unsetDone = () => {
-                    setDoneIfTimeout = false;
-                    done = false;
-                };
-                let timeout = setTimeout(() => {
-                    if (setDoneIfTimeout) {
-                        cleanup();
-                        done = true;
+                    if (effective === true) {
+                        return {
+                            merge: {
+                                filter: identityFilter,
+                            },
+                        };
                     }
-                }, waitForTime);
-                cleanup = () => {
-                    this.clearResultsQueue(queryRequestCoerced);
-                    clearTimeout(timeout);
+                    return {
+                        merge: {
+                            filter: effective.filter ?? identityFilter,
+                        },
+                    };
                 };
-            }
-            if (options.remote.reach?.discover) {
-                const discoverTimeout = waitForTime ??
-                    (options.remote.wait ? DEFAULT_TIMEOUT : DISCOVER_TIMEOUT_FALLBACK);
-                const discoverPromise = this.waitFor(options.remote.reach.discover, {
-                    signal: ensureController().signal,
-                    seek: "present",
-                    timeout: discoverTimeout,
-                })
-                    .then((hashes) => {
-                    discoveredTargetHashes = hashes;
-                })
-                    .catch((error) => {
-                    if (error instanceof TimeoutError || error instanceof AbortError) {
-                        discoveredTargetHashes = [];
-                        return;
+                if (u == null || u === false) {
+                    return {};
+                }
+                if (u === true) {
+                    return {
+                        mergePolicy: buildMergePolicy(true, true),
+                        push: undefined,
+                    };
+                }
+                if (typeof u === "string") {
+                    if (u === "remote") {
+                        self.ensurePrefetchAccumulator();
+                        return { push: types.PushUpdatesMode.STREAM };
                     }
-                    throw error;
-                });
-                const prior = warmupPromise ?? Promise.resolve();
-                warmupPromise = prior.then(() => discoverPromise);
-                options.remote.reach.eager = true; // include the results from the discovered peer even if it is not mature
-            }
-            const waitPolicy = typeof options.remote.wait === "object"
-                ? options.remote.wait
-                : undefined;
-            if (waitPolicy?.behavior === "block" &&
-                (waitPolicy.until ?? "any") === "any") {
-                const blockPromise = this.waitForCoverReady({
-                    domain: options.remote.domain,
-                    eager: options.remote.reach?.eager,
-                    settle: "any",
-                    timeout: waitPolicy.timeout ?? DEFAULT_TIMEOUT,
-                    signal: ensureController().signal,
-                    onTimeout: waitPolicy.onTimeout,
-                });
-                warmupPromise = warmupPromise
-                    ? Promise.all([warmupPromise, blockPromise]).then(() => undefined)
-                    : blockPromise;
-            }
-        }
-        const fetchFirst = async (n, fetchOptions) => {
-            await warmupPromise;
-            let hasMore = false;
-            const discoverTargets = typeof options?.remote === "object"
-                ? options.remote.reach?.discover
-                : undefined;
-            const initialRemoteTargets = discoveredTargetHashes !== undefined
-                ? discoveredTargetHashes
-                : discoverTargets?.map((pk) => pk.hashcode().toString());
-            const skipRemoteDueToDiscovery = typeof options?.remote === "object" &&
-                options.remote.reach?.discover &&
-                discoveredTargetHashes?.length === 0;
-            queryRequestCoerced.fetch = n;
-            await this.queryCommence(queryRequestCoerced, {
-                local: fetchOptions?.from != null ? false : options?.local,
-                remote: options?.remote !== false && !skipRemoteDueToDiscovery
-                    ? {
-                        ...(typeof options?.remote === "object"
-                            ? options.remote
-                            : {}),
-                        from: fetchOptions?.from ?? initialRemoteTargets,
+                    if (u === "local") {
+                        return {
+                            mergePolicy: buildMergePolicy(true, true),
+                            push: undefined,
+                        };
                     }
-                    : false,
-                resolve,
-                onResponse: async (response, from) => {
-                    if (!from) {
-                        logger.error("Missing response from");
-                        return;
+                    if (u === "all") {
+                        self.ensurePrefetchAccumulator();
+                        return {
+                            mergePolicy: buildMergePolicy(true, true),
+                            push: types.PushUpdatesMode.STREAM,
+                        };
                     }
-                    if (response instanceof types.NoAccess) {
-                        logger.error("Dont have access");
-                        return;
+                }
+                if (typeof u === "object") {
+                    const hasMergeProp = Object.prototype.hasOwnProperty.call(u, "merge");
+                    const mergeValue = hasMergeProp ? u.merge : undefined;
+                    if (u.push) {
+                        self.ensurePrefetchAccumulator();
                     }
-                    else if (response instanceof types.Results) {
-                        const results = response;
-                        const existingBuffer = peerBufferMap.get(from.hashcode());
-                        const buffer = existingBuffer?.buffer || [];
-                        if (results.kept === 0n && results.results.length === 0) {
-                            if (keepRemoteAlive) {
-                                peerBufferMap.set(from.hashcode(), {
-                                    buffer,
-                                    kept: Number(response.kept),
-                                });
-                            }
-                            return;
-                        }
-                        if (results.kept > 0n) {
-                            hasMore = true;
+                    const callbacks = u.notify || u.onBatch
+                        ? {
+                            notify: u.notify,
+                            onBatch: u.onBatch,
                         }
-                        for (const result of results.results) {
-                            const indexKey = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
-                            if (result instanceof types.ResultValue) {
-                                const existingIndexed = indexedPlaceholders?.get(indexKey);
-                                if (existingIndexed) {
-                                    existingIndexed.value =
-                                        result.value;
-                                    existingIndexed.context = result.context;
-                                    existingIndexed.from = from;
-                                    existingIndexed.indexed = await this.resolveIndexed(result, results.results);
-                                    indexedPlaceholders?.delete(indexKey);
-                                    continue;
-                                }
-                                if (visited.has(indexKey)) {
-                                    continue;
-                                }
-                                visited.add(indexKey);
-                                buffer.push({
-                                    value: result.value,
-                                    context: result.context,
-                                    from,
-                                    indexed: await this.resolveIndexed(result, results.results),
-                                });
-                            }
-                            else {
-                                if (visited.has(indexKey) &&
-                                    !indexedPlaceholders?.has(indexKey)) {
-                                    continue;
-                                }
-                                visited.add(indexKey);
-                                const indexed = coerceWithContext(result.indexed || result.value, result.context);
-                                const placeholder = {
-                                    value: result.value,
-                                    context: result.context,
-                                    from,
-                                    indexed,
-                                };
-                                buffer.push(placeholder);
-                                ensureIndexedPlaceholders().set(indexKey, placeholder);
-                            }
-                        }
-                        peerBufferMap.set(from.hashcode(), {
-                            buffer,
-                            kept: Number(response.kept),
-                        });
-                    }
-                    else {
-                        throw new Error("Unsupported result type: " + response?.constructor?.name);
+                        : undefined;
+                    return {
+                        mergePolicy: buildMergePolicy(mergeValue, !hasMergeProp || mergeValue === undefined),
+                        push: typeof u.push === "number"
+                            ? u.push
+                            : u.push
+                                ? types.PushUpdatesMode.STREAM
+                                : undefined,
+                        callbacks,
+                    };
+                }
+                return {};
+            }
+            const { mergePolicy, push: pushUpdates, callbacks: updateCallbacksRaw, } = normalizeUpdatesOption(options?.updates);
+            const hasLiveUpdates = mergePolicy !== undefined;
+            const originalRemote = options?.remote;
+            let remoteOptions = typeof originalRemote === "boolean"
+                ? originalRemote
+                : originalRemote
+                    ? { ...originalRemote }
+                    : undefined;
+            if (pushUpdates && remoteOptions !== false) {
+                if (typeof remoteOptions === "object") {
+                    if (remoteOptions.replicate !== true) {
+                        remoteOptions.replicate = true;
                     }
-                },
-            }, fetchOptions?.fetchedFirstForRemote);
-            if (!hasMore) {
-                maybeSetDone();
+                }
+                else if (remoteOptions === undefined || remoteOptions === true) {
+                    remoteOptions = { replicate: true };
+                }
             }
-            return !hasMore;
-        };
-        const fetchAtLeast = async (n) => {
-            if (done && first) {
-                return;
+            if (remoteOptions !== originalRemote) {
+                options = Object.assign({}, options, { remote: remoteOptions });
+            }
+            let resolve = options?.resolve !== false;
+            if (!(queryRequestCoerced instanceof types.IterationRequest) &&
+                options?.remote &&
+                typeof options.remote !== "boolean" &&
+                (options.remote.replicate || pushUpdates) &&
+                options?.resolve !== false) {
+                if ((queryRequest instanceof types.SearchRequestIndexed === false &&
+                    this.compatibility == null) ||
+                    (this.compatibility != null && this.compatibility > 8)) {
+                    queryRequestCoerced = new types.SearchRequestIndexed({
+                        query: queryRequestCoerced.query,
+                        fetch: queryRequestCoerced.fetch,
+                        sort: queryRequestCoerced.sort,
+                    });
+                    resolve = true;
+                }
             }
-            if (this.closed) {
-                throw new ClosedError();
-            }
-            await fetchPromise;
-            totalFetchedCounter += n;
-            if (!first) {
-                first = true;
-                fetchPromise = fetchFirst(n);
-                return fetchPromise;
-            }
-            const promises = [];
-            let resultsLeft = 0;
-            for (const [peer, buffer] of peerBufferMap) {
-                if (buffer.buffer.length < n) {
-                    const hasExistingRemoteResults = buffer.kept > 0;
-                    if (!hasExistingRemoteResults && !keepRemoteAlive) {
-                        if (peerBufferMap.get(peer)?.buffer.length === 0) {
-                            peerBufferMap.delete(peer); // No more results
-                        }
-                        continue;
+            let replicate = options?.remote &&
+                typeof options.remote !== "boolean" &&
+                (options.remote.replicate || pushUpdates);
+            if (replicate &&
+                queryRequestCoerced instanceof types.SearchRequestIndexed) {
+                queryRequestCoerced.replicate = true;
+            }
+            indexIteratorLogger.trace("Iterate with options", {
+                query: queryRequestCoerced,
+                options,
+            });
+            let fetchPromise = undefined;
+            const peerBufferMap = new Map();
+            const visited = new Set();
+            let indexedPlaceholders;
+            const ensureIndexedPlaceholders = () => {
+                if (!indexedPlaceholders) {
+                    indexedPlaceholders = new Map();
+                }
+                return indexedPlaceholders;
+            };
+            let done = false;
+            let drain = false; // if true, close on empty once (overrides manual)
+            let first = false;
+            // TODO handle join/leave while iterating
+            let controller = undefined;
+            const ensureController = () => {
+                if (!controller) {
+                    return (controller = new AbortController());
+                }
+                return controller;
+            };
+            let totalFetchedCounter = 0;
+            let lastValueInOrder = undefined;
+            let lastDeliveredIndexed;
+            const peerBuffers = () => {
+                return [...peerBufferMap.values()].map((x) => x.buffer).flat();
+            };
+            const toIndexedForOrdering = (value) => {
+                const candidate = value;
+                if (candidate && typeof candidate === "object") {
+                    if ("__indexed" in candidate && candidate.__indexed) {
+                        return coerceWithContext(candidate.__indexed, candidate.__context);
                     }
-                    // TODO buffer more than deleted?
-                    // TODO batch to multiple 'to's
-                    const lacking = n - buffer.buffer.length;
-                    const amount = lacking > 0 ? lacking : keepRemoteAlive ? 1 : 0;
-                    if (amount <= 0) {
-                        continue;
+                    if ("__context" in candidate) {
+                        return candidate;
                     }
-                    const collectRequest = new types.CollectNextRequest({
-                        id: queryRequestCoerced.id,
-                        amount,
+                }
+                return undefined;
+            };
+            const updateLastDelivered = (batch) => {
+                if (!batch.length) {
+                    return;
+                }
+                const indexed = toIndexedForOrdering(batch[batch.length - 1]);
+                if (indexed) {
+                    lastDeliveredIndexed = indexed;
+                }
+            };
+            const compareIndexed = (a, b) => {
+                return indexerTypes.extractSortCompare(a, b, queryRequestCoerced.sort);
+            };
+            const isLateResult = (indexed) => {
+                if (!lastDeliveredIndexed) {
+                    return false;
+                }
+                return compareIndexed(indexed, lastDeliveredIndexed) < 0;
+            };
+            let maybeSetDone = () => {
+                cleanup();
+                done = true;
+            };
+            let unsetDone = () => {
+                done = false;
+            };
+            let cleanup = () => {
+                this.clearResultsQueue(queryRequestCoerced);
+            };
+            let warmupPromise = undefined;
+            let discoveredTargetHashes;
+            if (typeof options?.remote === "object") {
+                let waitForTime = undefined;
+                if (options.remote.wait) {
+                    let t0 = +new Date();
+                    waitForTime =
+                        typeof options.remote.wait === "boolean"
+                            ? DEFAULT_TIMEOUT
+                            : (options.remote.wait.timeout ?? DEFAULT_TIMEOUT);
+                    let setDoneIfTimeout = false;
+                    maybeSetDone = () => {
+                        if (t0 + waitForTime < +new Date()) {
+                            cleanup();
+                            done = true;
+                        }
+                        else {
+                            setDoneIfTimeout = true;
+                        }
+                    };
+                    unsetDone = () => {
+                        setDoneIfTimeout = false;
+                        done = false;
+                    };
+                    let timeout = setTimeout(() => {
+                        if (setDoneIfTimeout) {
+                            cleanup();
+                            done = true;
+                        }
+                    }, waitForTime);
+                    cleanup = () => {
+                        this.clearResultsQueue(queryRequestCoerced);
+                        clearTimeout(timeout);
+                    };
+                }
+                if (options.remote.reach?.discover) {
+                    const discoverTimeout = waitForTime ??
+                        (options.remote.wait ? DEFAULT_TIMEOUT : DISCOVER_TIMEOUT_FALLBACK);
+                    const discoverPromise = this.waitFor(options.remote.reach.discover, {
+                        signal: ensureController().signal,
+                        seek: "present",
+                        timeout: discoverTimeout,
+                    })
+                        .then((hashes) => {
+                        discoveredTargetHashes = hashes;
+                    })
+                        .catch((error) => {
+                        if (error instanceof TimeoutError || error instanceof AbortError) {
+                            discoveredTargetHashes = [];
+                            return;
+                        }
+                        throw error;
+                    });
+                    const prior = warmupPromise ?? Promise.resolve();
+                    warmupPromise = prior.then(() => discoverPromise);
+                    options.remote.reach.eager = true; // include the results from the discovered peer even if it is not mature
+                }
+                const waitPolicy = typeof options.remote.wait === "object"
+                    ? options.remote.wait
+                    : undefined;
+                if (waitPolicy?.behavior === "block" &&
+                    (waitPolicy.until ?? "any") === "any") {
+                    const blockPromise = this.waitForCoverReady({
+                        domain: options.remote.domain,
+                        eager: options.remote.reach?.eager,
+                        settle: "any",
+                        timeout: waitPolicy.timeout ?? DEFAULT_TIMEOUT,
+                        signal: ensureController().signal,
+                        onTimeout: waitPolicy.onTimeout,
                     });
-                    // Fetch locally?
-                    if (peer === this.node.identity.publicKey.hashcode()) {
-                        if (!this._resumableIterators.has(queryRequestCoerced.idString)) {
-                            continue; // no more results
+                    warmupPromise = warmupPromise
+                        ? Promise.all([warmupPromise, blockPromise]).then(() => undefined)
+                        : blockPromise;
+                }
+            }
+            const fetchFirst = async (n, fetchOptions) => {
+                await warmupPromise;
+                let hasMore = false;
+                const discoverTargets = typeof options?.remote === "object"
+                    ? options.remote.reach?.discover
+                    : undefined;
+                const initialRemoteTargets = discoveredTargetHashes !== undefined
+                    ? discoveredTargetHashes
+                    : discoverTargets?.map((pk) => pk.hashcode().toString());
+                const skipRemoteDueToDiscovery = typeof options?.remote === "object" &&
+                    options.remote.reach?.discover &&
+                    discoveredTargetHashes?.length === 0;
+                queryRequestCoerced.fetch = n;
+                await this.queryCommence(queryRequestCoerced, {
+                    local: fetchOptions?.from != null ? false : options?.local,
+                    remote: options?.remote !== false && !skipRemoteDueToDiscovery
+                        ? {
+                            ...(typeof options?.remote === "object"
+                                ? options.remote
+                                : {}),
+                            from: fetchOptions?.from ?? initialRemoteTargets,
+                        }
+                        : false,
+                    resolve,
+                    onResponse: async (response, from) => {
+                        if (!from) {
+                            logger.error("Missing response from");
+                            return;
+                        }
+                        if (response instanceof types.NoAccess) {
+                            logger.error("Dont have access");
+                            return;
                         }
-                        promises.push(this.processQuery(collectRequest, this.node.identity.publicKey, true)
-                            .then(async (results) => {
-                            resultsLeft += Number(results.kept);
-                            if (results.results.length === 0) {
-                                if (!keepRemoteAlive &&
-                                    peerBufferMap.get(peer)?.buffer.length === 0) {
-                                    peerBufferMap.delete(peer); // No more results
+                        else if (response instanceof types.Results) {
+                            const results = response;
+                            const existingBuffer = peerBufferMap.get(from.hashcode());
+                            const buffer = existingBuffer?.buffer || [];
+                            if (results.kept === 0n && results.results.length === 0) {
+                                if (keepRemoteAlive) {
+                                    peerBufferMap.set(from.hashcode(), {
+                                        buffer,
+                                        kept: 0,
+                                    });
                                 }
+                                return;
                             }
-                            else {
-                                const peerBuffer = peerBufferMap.get(peer);
-                                if (!peerBuffer) {
-                                    return;
-                                }
-                                peerBuffer.kept = Number(results.kept);
-                                for (const result of results.results) {
-                                    const keyPrimitive = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
-                                    if (result instanceof types.ResultValue) {
-                                        const existingIndexed = indexedPlaceholders?.get(keyPrimitive);
-                                        if (existingIndexed) {
-                                            existingIndexed.value =
-                                                result.value;
-                                            existingIndexed.context = result.context;
-                                            existingIndexed.from = this.node.identity.publicKey;
-                                            existingIndexed.indexed =
-                                                await this.resolveIndexed(result, results.results);
-                                            indexedPlaceholders?.delete(keyPrimitive);
-                                            continue;
-                                        }
-                                        if (visited.has(keyPrimitive)) {
-                                            continue;
-                                        }
-                                        visited.add(keyPrimitive);
-                                        const indexed = await this.resolveIndexed(result, results.results);
-                                        peerBuffer.buffer.push({
-                                            value: result.value,
-                                            context: result.context,
-                                            from: this.node.identity.publicKey,
-                                            indexed,
-                                        });
+                            const reqFetch = queryRequestCoerced.fetch ?? 0;
+                            const inferredMore = reqFetch > 0 && results.results.length > reqFetch;
+                            const effectiveKept = Math.max(Number(results.kept), inferredMore ? 1 : 0);
+                            if (effectiveKept > 0) {
+                                hasMore = true;
+                            }
+                            for (const result of results.results) {
+                                const indexKey = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
+                                if (result instanceof types.ResultValue) {
+                                    const existingIndexed = indexedPlaceholders?.get(indexKey);
+                                    if (existingIndexed) {
+                                        existingIndexed.value =
+                                            result.value;
+                                        existingIndexed.context = result.context;
+                                        existingIndexed.from = from;
+                                        existingIndexed.indexed = await this.resolveIndexed(result, results.results);
+                                        indexedPlaceholders?.delete(indexKey);
+                                        continue;
                                     }
-                                    else {
-                                        if (visited.has(keyPrimitive) &&
-                                            !indexedPlaceholders?.has(keyPrimitive)) {
-                                            continue;
-                                        }
-                                        visited.add(keyPrimitive);
-                                        const indexed = coerceWithContext(result.indexed || result.value, result.context);
-                                        const placeholder = {
-                                            value: result.value,
-                                            context: result.context,
-                                            from: this.node.identity.publicKey,
-                                            indexed,
-                                        };
-                                        peerBuffer.buffer.push(placeholder);
-                                        ensureIndexedPlaceholders().set(keyPrimitive, placeholder);
+                                    if (visited.has(indexKey)) {
+                                        continue;
                                     }
+                                    visited.add(indexKey);
+                                    buffer.push({
+                                        value: result.value,
+                                        context: result.context,
+                                        from,
+                                        indexed: await this.resolveIndexed(result, results.results),
+                                    });
+                                }
+                                else {
+                                    if (visited.has(indexKey) &&
+                                        !indexedPlaceholders?.has(indexKey)) {
+                                        continue;
+                                    }
+                                    visited.add(indexKey);
+                                    const indexed = coerceWithContext(result.indexed || result.value, result.context);
+                                    const placeholder = {
+                                        value: result.value,
+                                        context: result.context,
+                                        from,
+                                        indexed,
+                                    };
+                                    buffer.push(placeholder);
+                                    ensureIndexedPlaceholders().set(indexKey, placeholder);
                                 }
                             }
-                        })
-                            .catch((e) => {
-                            logger.error("Failed to collect sorted results from self. " + e?.message);
-                            peerBufferMap.delete(peer);
-                        }));
-                    }
-                    else {
-                        // Fetch remotely
-                        const idTranslation = this._prefetch?.accumulator.getTranslationMap(queryRequestCoerced);
-                        let remoteCollectRequest = collectRequest;
-                        if (idTranslation) {
-                            remoteCollectRequest = new types.CollectNextRequest({
-                                id: idTranslation.get(peer) || collectRequest.id,
-                                amount: collectRequest.amount,
+                            peerBufferMap.set(from.hashcode(), {
+                                buffer,
+                                kept: effectiveKept,
                             });
                         }
-                        promises.push(this._query
-                            .request(remoteCollectRequest, {
-                            ...options,
-                            signal: options?.signal
-                                ? AbortSignal.any([
-                                    options.signal,
-                                    ensureController().signal,
-                                ])
-                                : ensureController().signal,
-                            priority: 1,
-                            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;
-                                }
-                                if (response.response.results.length === 0) {
+                        else {
+                            throw new Error("Unsupported result type: " + response?.constructor?.name);
+                        }
+                    },
+                }, fetchOptions?.fetchedFirstForRemote);
+                if (!hasMore) {
+                    maybeSetDone();
+                }
+                return !hasMore;
+            };
+            const fetchAtLeast = async (n) => {
+                if (done && first) {
+                    return;
+                }
+                if (this.closed) {
+                    throw new ClosedError();
+                }
+                await fetchPromise;
+                totalFetchedCounter += n;
+                if (!first) {
+                    first = true;
+                    fetchPromise = fetchFirst(n);
+                    return fetchPromise;
+                }
+                const promises = [];
+                let resultsLeft = 0;
+                for (const [peer, buffer] of peerBufferMap) {
+                    if (buffer.buffer.length < n) {
+                        const hasExistingRemoteResults = buffer.kept > 0;
+                        if (!hasExistingRemoteResults && !keepRemoteAlive) {
+                            if (peerBufferMap.get(peer)?.buffer.length === 0) {
+                                peerBufferMap.delete(peer); // No more results
+                            }
+                            continue;
+                        }
+                        // TODO buffer more than deleted?
+                        // TODO batch to multiple 'to's
+                        const lacking = n - buffer.buffer.length;
+                        const amount = lacking > 0 ? lacking : keepRemoteAlive ? 1 : 0;
+                        if (amount <= 0) {
+                            continue;
+                        }
+                        const collectRequest = new types.CollectNextRequest({
+                            id: queryRequestCoerced.id,
+                            amount,
+                        });
+                        // Fetch locally?
+                        if (peer === this.node.identity.publicKey.hashcode()) {
+                            if (!this._resumableIterators.has(queryRequestCoerced.idString)) {
+                                continue; // no more results
+                            }
+                            promises.push(this.processQuery(collectRequest, this.node.identity.publicKey, true)
+                                .then(async (results) => {
+                                resultsLeft += Number(results.kept);
+                                if (results.results.length === 0) {
                                     if (!keepRemoteAlive &&
                                         peerBufferMap.get(peer)?.buffer.length === 0) {
                                         peerBufferMap.delete(peer); // No more results
@@ -1733,799 +2046,843 @@ let DocumentIndex = class DocumentIndex extends Program {
                                     if (!peerBuffer) {
                                         return;
                                     }
-                                    peerBuffer.kept = Number(response.response.kept);
-                                    for (const result of response.response.results) {
-                                        const indexKey = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
+                                    peerBuffer.kept = Number(results.kept);
+                                    for (const result of results.results) {
+                                        const keyPrimitive = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
                                         if (result instanceof types.ResultValue) {
-                                            const existingIndexed = indexedPlaceholders?.get(indexKey);
+                                            const existingIndexed = indexedPlaceholders?.get(keyPrimitive);
                                             if (existingIndexed) {
                                                 existingIndexed.value =
                                                     result.value;
                                                 existingIndexed.context = result.context;
-                                                existingIndexed.from = from;
+                                                existingIndexed.from = this.node.identity.publicKey;
                                                 existingIndexed.indexed =
-                                                    await this.resolveIndexed(result, response.response
-                                                        .results);
-                                                indexedPlaceholders?.delete(indexKey);
+                                                    await this.resolveIndexed(result, results.results);
+                                                indexedPlaceholders?.delete(keyPrimitive);
                                                 continue;
                                             }
-                                            if (visited.has(indexKey)) {
+                                            if (visited.has(keyPrimitive)) {
                                                 continue;
                                             }
-                                            visited.add(indexKey);
-                                            const indexed = await this.resolveIndexed(result, response.response
-                                                .results);
+                                            visited.add(keyPrimitive);
+                                            const indexed = await this.resolveIndexed(result, results.results);
                                             peerBuffer.buffer.push({
                                                 value: result.value,
                                                 context: result.context,
-                                                from: from,
+                                                from: this.node.identity.publicKey,
                                                 indexed,
                                             });
                                         }
                                         else {
-                                            if (visited.has(indexKey) &&
-                                                !indexedPlaceholders?.has(indexKey)) {
+                                            if (visited.has(keyPrimitive) &&
+                                                !indexedPlaceholders?.has(keyPrimitive)) {
                                                 continue;
                                             }
-                                            visited.add(indexKey);
-                                            const indexed = coerceWithContext(result.value, result.context);
+                                            visited.add(keyPrimitive);
+                                            const indexed = coerceWithContext(result.indexed || result.value, result.context);
                                             const placeholder = {
                                                 value: result.value,
                                                 context: result.context,
-                                                from: from,
+                                                from: this.node.identity.publicKey,
                                                 indexed,
                                             };
                                             peerBuffer.buffer.push(placeholder);
-                                            ensureIndexedPlaceholders().set(indexKey, placeholder);
+                                            ensureIndexedPlaceholders().set(keyPrimitive, placeholder);
                                         }
                                     }
                                 }
+                            })
+                                .catch((e) => {
+                                logger.error("Failed to collect sorted results from self. " + e?.message);
+                                peerBufferMap.delete(peer);
                             }));
-                        })
-                            .catch((e) => {
-                            logger.error("Failed to collect sorted results from: " +
-                                peer +
-                                ". " +
-                                e?.message);
-                            peerBufferMap.delete(peer);
-                        })));
-                    }
-                }
-                else {
-                    resultsLeft += peerBufferMap.get(peer)?.kept || 0;
-                }
-            }
-            return (fetchPromise = Promise.all(promises).then(() => {
-                return resultsLeft === 0; // 0 results left to fetch and 0 pending results
-            }));
-        };
-        const next = async (n) => {
-            if (n < 0) {
-                throw new Error("Expecting to fetch a positive amount of element");
-            }
-            if (n === 0) {
-                return [];
-            }
-            // TODO everything below is not very optimized
-            const fetchedAll = await fetchAtLeast(n);
-            // get n next top entries, shift and pull more results
-            const peerBuffersArr = peerBuffers();
-            const results = peerBuffersArr.sort((a, b) => indexerTypes.extractSortCompare(a.indexed, b.indexed, queryRequestCoerced.sort));
-            lastValueInOrder = results[0] || lastValueInOrder;
-            const pendingMoreResults = n < results.length; // check if there are more results to fetch, before splicing
-            const batch = results.splice(0, n);
-            const hasMore = !fetchedAll || pendingMoreResults;
-            for (const result of batch) {
-                const arr = peerBufferMap.get(result.from.hashcode());
-                if (!arr) {
-                    logger.error("Unexpected empty result buffer");
-                    continue;
-                }
-                const idx = arr.buffer.findIndex((x) => x.value === result.value);
-                if (idx >= 0) {
-                    arr.buffer.splice(idx, 1);
-                    const consumedId = indexerTypes.toId(this.indexByResolver(result.indexed)).primitive;
-                    indexedPlaceholders?.delete(consumedId);
-                }
-            }
-            if (hasMore) {
-                unsetDone();
-            }
-            else {
-                maybeSetDone();
-            }
-            let coercedBatch;
-            if (resolve) {
-                coercedBatch = (await Promise.all(batch.map(async (x) => {
-                    const withContext = coerceWithContext(x.value instanceof this.documentType
-                        ? x.value
-                        : (await this.resolveDocument({
-                            head: x.context.head,
-                            indexed: x.indexed,
-                        }))?.value, x.context);
-                    const withIndexed = coerceWithIndexed(withContext, x.indexed);
-                    return withIndexed;
-                }))).filter((x) => !!x);
-            }
-            else {
-                coercedBatch = batch.map((x) => coerceWithContext(coerceWithIndexed(x.value, x.indexed), x.context));
-            }
-            // no extra queued-first/last in simplified API
-            const deduped = dedup(coercedBatch, this.indexByResolver);
-            const fallbackReason = hasDeliveredResults ? "next" : "initial";
-            await emitOnResults(deduped, fallbackReason);
-            return deduped;
-        };
-        let cleanupAndDone = () => {
-            cleanup();
-            controller?.abort(new AbortError("Iterator closed"));
-            controller = undefined;
-            this.prefetch?.accumulator.clear(queryRequestCoerced);
-            this.processCloseIteratorRequest(queryRequestCoerced, this.node.identity.publicKey);
-            done = true;
-        };
-        let close = async () => {
-            cleanupAndDone();
-            // send close to remote
-            const closeRequest = new types.CloseIteratorRequest({
-                id: queryRequestCoerced.id,
-            });
-            const promises = [];
-            for (const [peer, buffer] of peerBufferMap) {
-                if (buffer.kept === 0) {
-                    peerBufferMap.delete(peer);
-                    continue;
-                }
-                if (peer !== this.node.identity.publicKey.hashcode()) {
-                    // Close remote
-                    promises.push(this._query.send(closeRequest, {
-                        ...options,
-                        mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
-                    }));
-                }
-            }
-            await Promise.all(promises);
-        };
-        options?.signal && options.signal.addEventListener("abort", close);
-        let doneFn = () => {
-            return done;
-        };
-        let joinListener;
-        let fetchedFirstForRemote = undefined;
-        let updateDeferred;
-        const signalUpdate = (reason) => {
-            updateDeferred?.resolve();
-        };
-        const _waitForUpdate = () => updateDeferred ? updateDeferred.promise : Promise.resolve();
-        // ---------------- Live updates wiring (sorted-only with optional filter) ----------------
-        function normalizeUpdatesOption(u) {
-            const identityFilter = (evt) => evt;
-            const buildMergePolicy = (merge, defaultEnabled) => {
-                const effective = merge === undefined ? (defaultEnabled ? true : undefined) : merge;
-                if (effective === undefined || effective === false) {
-                    return undefined;
-                }
-                if (effective === true) {
-                    return {
-                        merge: {
-                            filter: identityFilter,
-                        },
-                    };
-                }
-                return {
-                    merge: {
-                        filter: effective.filter ?? identityFilter,
-                    },
-                };
-            };
-            if (u == null || u === false) {
-                return { push: false };
-            }
-            if (u === true) {
-                return {
-                    mergePolicy: buildMergePolicy(true, true),
-                    push: false,
-                };
-            }
-            if (typeof u === "string") {
-                if (u === "remote") {
-                    return { push: true };
-                }
-                if (u === "local") {
-                    return {
-                        mergePolicy: buildMergePolicy(true, true),
-                        push: false,
-                    };
-                }
-                if (u === "all") {
-                    return {
-                        mergePolicy: buildMergePolicy(true, true),
-                        push: true,
-                    };
-                }
-            }
-            if (typeof u === "object") {
-                const hasMergeProp = Object.prototype.hasOwnProperty.call(u, "merge");
-                const mergeValue = hasMergeProp ? u.merge : undefined;
-                return {
-                    mergePolicy: buildMergePolicy(mergeValue, !hasMergeProp || mergeValue === undefined),
-                    push: Boolean(u.push),
-                    callbacks: u,
-                };
-            }
-            return { push: false };
-        }
-        const updateCallbacks = updateCallbacksRaw;
-        let pendingResultsReason;
-        let hasDeliveredResults = false;
-        const emitOnResults = async (batch, defaultReason) => {
-            if (!updateCallbacks?.onResults || batch.length === 0) {
-                return;
-            }
-            let reason;
-            if (pendingResultsReason) {
-                reason = pendingResultsReason;
-            }
-            else if (!hasDeliveredResults) {
-                reason = "initial";
-            }
-            else {
-                reason = defaultReason;
-            }
-            pendingResultsReason = undefined;
-            hasDeliveredResults = true;
-            await updateCallbacks.onResults(batch, { reason });
-        };
-        // sorted-only mode: no per-queue handling
-        // If live updates enabled, ensure deferred exists so awaiting paths can block until changes
-        if (hasLiveUpdates && !updateDeferred) {
-            updateDeferred = pDefer();
-        }
-        const keepRemoteAlive = (options?.closePolicy === "manual" || hasLiveUpdates || pushUpdates) &&
-            remoteOptions !== false;
-        if (queryRequestCoerced instanceof types.IterationRequest) {
-            queryRequestCoerced.resolve = resolve;
-            queryRequestCoerced.fetch = queryRequestCoerced.fetch ?? 10;
-            const replicateFlag = !resolve && replicate ? true : false;
-            queryRequestCoerced.replicate = replicateFlag;
-            const ttlSource = typeof remoteOptions === "object" &&
-                typeof remoteOptions?.wait === "object"
-                ? (remoteOptions.wait.timeout ?? DEFAULT_TIMEOUT)
-                : DEFAULT_TIMEOUT;
-            queryRequestCoerced.keepAliveTtl = keepRemoteAlive
-                ? BigInt(ttlSource)
-                : undefined;
-            queryRequestCoerced.pushUpdates = pushUpdates ? true : undefined;
-            queryRequestCoerced.mergeUpdates = mergePolicy?.merge ? true : undefined;
-        }
-        if (pushUpdates && this.prefetch?.accumulator) {
-            const targetPrefetchKey = idAgnosticQueryKey(queryRequestCoerced);
-            const mergePrefetchedResults = async (from, results) => {
-                const peerHash = from.hashcode();
-                const existingBuffer = peerBufferMap.get(peerHash);
-                const buffer = existingBuffer?.buffer || [];
-                if (results.kept === 0n && results.results.length === 0) {
-                    peerBufferMap.set(peerHash, {
-                        buffer,
-                        kept: Number(results.kept),
-                    });
-                    return;
-                }
-                for (const result of results.results) {
-                    const indexKey = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
-                    if (result instanceof types.ResultValue) {
-                        const existingIndexed = indexedPlaceholders?.get(indexKey);
-                        if (existingIndexed) {
-                            existingIndexed.value =
-                                result.value;
-                            existingIndexed.context = result.context;
-                            existingIndexed.from = from;
-                            existingIndexed.indexed = await this.resolveIndexed(result, results.results);
-                            indexedPlaceholders?.delete(indexKey);
-                            continue;
                         }
-                        if (visited.has(indexKey)) {
-                            continue;
+                        else {
+                            // Fetch remotely
+                            const idTranslation = this._prefetch?.accumulator.getTranslationMap(queryRequestCoerced);
+                            let remoteCollectRequest = collectRequest;
+                            if (idTranslation) {
+                                remoteCollectRequest = new types.CollectNextRequest({
+                                    id: idTranslation.get(peer) || collectRequest.id,
+                                    amount: collectRequest.amount,
+                                });
+                            }
+                            promises.push(this._query
+                                .request(remoteCollectRequest, {
+                                ...options,
+                                signal: options?.signal
+                                    ? AbortSignal.any([
+                                        options.signal,
+                                        ensureController().signal,
+                                    ])
+                                    : ensureController().signal,
+                                priority: 1,
+                                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;
+                                    }
+                                    if (response.response.results.length === 0) {
+                                        if (!keepRemoteAlive &&
+                                            peerBufferMap.get(peer)?.buffer.length === 0) {
+                                            peerBufferMap.delete(peer); // No more results
+                                        }
+                                    }
+                                    else {
+                                        const peerBuffer = peerBufferMap.get(peer);
+                                        if (!peerBuffer) {
+                                            return;
+                                        }
+                                        peerBuffer.kept = Number(response.response.kept);
+                                        for (const result of response.response.results) {
+                                            const indexKey = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
+                                            if (result instanceof types.ResultValue) {
+                                                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)) {
+                                                    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 {
+                                                if (visited.has(indexKey) &&
+                                                    !indexedPlaceholders?.has(indexKey)) {
+                                                    continue;
+                                                }
+                                                visited.add(indexKey);
+                                                const indexed = coerceWithContext(result.value, result.context);
+                                                const placeholder = {
+                                                    value: result.value,
+                                                    context: result.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);
+                            })));
                         }
-                        visited.add(indexKey);
-                        buffer.push({
-                            value: result.value,
-                            context: result.context,
-                            from,
-                            indexed: await this.resolveIndexed(result, results.results),
-                        });
                     }
                     else {
-                        if (visited.has(indexKey) && !indexedPlaceholders?.has(indexKey)) {
-                            continue;
-                        }
-                        visited.add(indexKey);
-                        const indexed = coerceWithContext(result.indexed || result.value, result.context);
-                        const placeholder = {
-                            value: result.value,
-                            context: result.context,
-                            from,
-                            indexed,
-                        };
-                        buffer.push(placeholder);
-                        ensureIndexedPlaceholders().set(indexKey, placeholder);
+                        resultsLeft += peerBufferMap.get(peer)?.kept || 0;
                     }
                 }
-                peerBufferMap.set(peerHash, {
-                    buffer,
-                    kept: Number(results.kept),
-                });
+                return (fetchPromise = Promise.all(promises).then(() => {
+                    return resultsLeft === 0; // 0 results left to fetch and 0 pending results
+                }));
             };
-            const consumePrefetch = async (consumable) => {
-                const request = consumable.response?.request;
-                if (!request) {
-                    return;
+            const next = async (n) => {
+                if (n < 0) {
+                    throw new Error("Expecting to fetch a positive amount of element");
                 }
-                if (idAgnosticQueryKey(request) !== targetPrefetchKey) {
-                    return;
+                if (n === 0) {
+                    return [];
                 }
-                try {
-                    const prepared = await introduceEntries(queryRequestCoerced, [
-                        {
-                            response: consumable.response.results,
-                            from: consumable.from,
-                        },
-                    ], this.documentType, this.indexedType, this._sync, options);
-                    for (const response of prepared) {
-                        if (!response.from) {
-                            continue;
-                        }
-                        const payload = response.response;
-                        if (!(payload instanceof types.Results)) {
-                            continue;
-                        }
-                        await mergePrefetchedResults(response.from, payload);
+                // TODO everything below is not very optimized
+                const fetchedAll = await fetchAtLeast(n);
+                // get n next top entries, shift and pull more results
+                const peerBuffersArr = peerBuffers();
+                const results = peerBuffersArr.sort((a, b) => indexerTypes.extractSortCompare(a.indexed, b.indexed, queryRequestCoerced.sort));
+                lastValueInOrder = results[0] || lastValueInOrder;
+                const pendingMoreResults = n < results.length; // check if there are more results to fetch, before splicing
+                const batch = results.splice(0, n);
+                const hasMore = !fetchedAll || pendingMoreResults;
+                for (const result of batch) {
+                    const arr = peerBufferMap.get(result.from.hashcode());
+                    if (!arr) {
+                        logger.error("Unexpected empty result buffer");
+                        continue;
                     }
-                    if (!pendingResultsReason) {
-                        pendingResultsReason = "change";
+                    const idx = arr.buffer.findIndex((x) => x.value === result.value);
+                    if (idx >= 0) {
+                        arr.buffer.splice(idx, 1);
+                        const consumedId = indexerTypes.toId(this.indexByResolver(result.indexed)).primitive;
+                        indexedPlaceholders?.delete(consumedId);
                     }
-                    signalUpdate("prefetch-add");
                 }
-                catch (error) {
-                    logger.warn("Failed to merge prefetched results", error);
+                if (hasMore) {
+                    unsetDone();
+                }
+                else {
+                    maybeSetDone();
+                }
+                let coercedBatch;
+                if (resolve) {
+                    coercedBatch = (await Promise.all(batch.map(async (x) => {
+                        const withContext = coerceWithContext(x.value instanceof this.documentType
+                            ? x.value
+                            : (await this.resolveDocument({
+                                head: x.context.head,
+                                indexed: x.indexed,
+                            }))?.value, x.context);
+                        const withIndexed = coerceWithIndexed(withContext, x.indexed);
+                        return withIndexed;
+                    }))).filter((x) => !!x);
+                }
+                else {
+                    coercedBatch = batch.map((x) => coerceWithContext(coerceWithIndexed(x.value, x.indexed), x.context));
                 }
+                // no extra queued-first/last in simplified API
+                const deduped = dedup(coercedBatch, this.indexByResolver);
+                const fallbackReason = hasDeliveredResults ? "manual" : "initial";
+                updateLastDelivered(deduped);
+                await emitOnBatch(deduped, fallbackReason);
+                return deduped;
             };
-            const onPrefetchAdd = (evt) => {
-                void consumePrefetch(evt.detail.consumable);
+            let cleanupAndDone = () => {
+                cleanup();
+                controller?.abort(new AbortError("Iterator closed"));
+                controller = undefined;
+                this.prefetch?.accumulator.clear(queryRequestCoerced);
+                this.processCloseIteratorRequest(queryRequestCoerced, this.node.identity.publicKey);
+                done = true;
             };
-            this.prefetch.accumulator.addEventListener("add", onPrefetchAdd);
-            const cleanupDefault = cleanup;
-            cleanup = () => {
-                this.prefetch?.accumulator.removeEventListener("add", onPrefetchAdd);
-                return cleanupDefault();
+            let close = async () => {
+                cleanupAndDone();
+                // send close to remote
+                const closeRequest = new types.CloseIteratorRequest({
+                    id: queryRequestCoerced.id,
+                });
+                const promises = [];
+                for (const [peer, buffer] of peerBufferMap) {
+                    if (buffer.kept === 0) {
+                        peerBufferMap.delete(peer);
+                        continue;
+                    }
+                    if (peer !== this.node.identity.publicKey.hashcode()) {
+                        // Close remote
+                        promises.push(this._query.send(closeRequest, {
+                            ...options,
+                            mode: new SilentDelivery({ to: [peer], redundancy: 1 }),
+                        }));
+                    }
+                }
+                await Promise.all(promises);
             };
-        }
-        let updatesCleanup;
-        if (hasLiveUpdates) {
-            const localHash = this.node.identity.publicKey.hashcode();
-            if (mergePolicy?.merge) {
-                // Ensure local buffer exists for sorted merging
-                if (!peerBufferMap.has(localHash)) {
-                    peerBufferMap.set(localHash, { kept: 0, buffer: [] });
-                }
-            }
-            const queryFiltersForUpdates = indexerTypes.toQuery(queryRequestCoerced.query);
-            const hasQueryFiltersForUpdates = queryFiltersForUpdates.length > 0;
-            const createUpdateFilterIndex = async () => {
-                const index = new HashmapIndex();
-                await index.init({
-                    schema: this.wrappedIndexedType,
-                    indexBy: this.indexBy,
-                    nested: this.nestedProperties,
+            options?.signal && options.signal.addEventListener("abort", close);
+            let doneFn = () => {
+                return done;
+            };
+            let joinListener;
+            let fetchedFirstForRemote = undefined;
+            let updateDeferred;
+            const onLateResults = typeof options?.remote === "object" &&
+                typeof options.remote.onLateResults === "function"
+                ? options.remote.onLateResults
+                : undefined;
+            const runNotify = (reason) => {
+                if (!updateCallbacks?.notify) {
+                    return;
+                }
+                Promise.resolve(updateCallbacks.notify(reason)).catch((error) => {
+                    warn("Update notify callback failed", error);
                 });
-                return index;
             };
-            const toIndexedWithContext = async (value) => {
-                const candidate = value;
-                if ("__indexed" in candidate && candidate.__indexed) {
-                    return coerceWithContext(candidate.__indexed, candidate.__context);
+            const signalUpdate = (reason) => {
+                if (reason) {
+                    runNotify(reason);
+                }
+                updateDeferred?.resolve();
+            };
+            const _waitForUpdate = () => updateDeferred ? updateDeferred.promise : Promise.resolve();
+            // ---------------- Live updates wiring (sorted-only with optional filter) ----------------
+            const updateCallbacks = updateCallbacksRaw;
+            let pendingBatchReason;
+            let hasDeliveredResults = false;
+            const emitOnBatch = async (batch, defaultReason) => {
+                if (!updateCallbacks?.onBatch || batch.length === 0) {
+                    return;
+                }
+                let reason;
+                if (pendingBatchReason) {
+                    reason = pendingBatchReason;
                 }
-                if (value instanceof this.documentType) {
-                    const transformed = await this.transformer(value, value.__context);
-                    return coerceWithContext(transformed, value.__context);
+                else if (!hasDeliveredResults) {
+                    reason = "initial";
+                }
+                else {
+                    reason = defaultReason;
                 }
-                return value;
+                pendingBatchReason = undefined;
+                hasDeliveredResults = true;
+                await updateCallbacks.onBatch(batch, { reason });
             };
-            const onChange = async (evt) => {
-                // Optional filter to mutate/suppress change events
-                let filtered = evt.detail;
-                if (mergePolicy?.merge?.filter) {
-                    filtered = await mergePolicy.merge?.filter(evt.detail);
-                }
-                if (filtered) {
-                    const changeForCallback = {
-                        added: [],
-                        removed: [],
-                    };
-                    let hasRelevantChange = false;
-                    // Remove entries that were deleted from all pending structures
-                    if (filtered.removed?.length) {
-                        const removedIds = new Set();
-                        for (const removed of filtered.removed) {
-                            const id = indexerTypes.toId(this.indexByResolver(removed.__indexed)).primitive;
-                            removedIds.add(id);
-                        }
-                        const matchedRemovedIds = new Set();
-                        for (const [_peer, entry] of peerBufferMap) {
-                            if (entry.buffer.length === 0) {
+            // sorted-only mode: no per-queue handling
+            // If live updates enabled, ensure deferred exists so awaiting paths can block until changes
+            if (hasLiveUpdates && !updateDeferred) {
+                updateDeferred = pDefer();
+            }
+            const keepRemoteAlive = (options?.closePolicy === "manual" || hasLiveUpdates || pushUpdates) &&
+                remoteOptions !== false;
+            if (queryRequestCoerced instanceof types.IterationRequest) {
+                queryRequestCoerced.resolve = resolve;
+                queryRequestCoerced.fetch = queryRequestCoerced.fetch ?? 10;
+                const replicateFlag = !resolve && replicate ? true : false;
+                queryRequestCoerced.replicate = replicateFlag;
+                const ttlSource = typeof remoteOptions === "object" &&
+                    typeof remoteOptions?.wait === "object" &&
+                    remoteOptions.wait.behavior === "block"
+                    ? (remoteOptions.wait.timeout ?? DEFAULT_KEEP_REMOTE_ITERATOR_TIMEOUT)
+                    : DEFAULT_KEEP_REMOTE_ITERATOR_TIMEOUT;
+                queryRequestCoerced.keepAliveTtl = keepRemoteAlive
+                    ? BigInt(ttlSource)
+                    : undefined;
+                queryRequestCoerced.pushUpdates = pushUpdates;
+                queryRequestCoerced.mergeUpdates = mergePolicy?.merge ? true : undefined;
+            }
+            if (pushUpdates && this.prefetch?.accumulator) {
+                const currentPrefetchKey = () => idAgnosticQueryKey(queryRequestCoerced);
+                const mergePrefetchedResults = async (from, results) => {
+                    const peerHash = from.hashcode();
+                    const existingBuffer = peerBufferMap.get(peerHash);
+                    const buffer = existingBuffer?.buffer || [];
+                    if (results.kept === 0n && results.results.length === 0) {
+                        peerBufferMap.set(peerHash, {
+                            buffer,
+                            kept: Number(results.kept),
+                        });
+                        return;
+                    }
+                    for (const result of results.results) {
+                        const indexKey = indexerTypes.toId(this.indexByResolver(result.value)).primitive;
+                        if (result instanceof types.ResultValue) {
+                            const existingIndexed = indexedPlaceholders?.get(indexKey);
+                            if (existingIndexed) {
+                                existingIndexed.value =
+                                    result.value;
+                                existingIndexed.context = result.context;
+                                existingIndexed.from = from;
+                                existingIndexed.indexed = await this.resolveIndexed(result, results.results);
+                                indexedPlaceholders?.delete(indexKey);
                                 continue;
                             }
-                            entry.buffer = entry.buffer.filter((x) => {
-                                const id = indexerTypes.toId(this.indexByResolver(x.indexed)).primitive;
-                                if (removedIds.has(id)) {
-                                    matchedRemovedIds.add(id);
-                                    indexedPlaceholders?.delete(id);
-                                    return false;
-                                }
-                                return true;
+                            if (visited.has(indexKey)) {
+                                continue;
+                            }
+                            visited.add(indexKey);
+                            const indexed = await this.resolveIndexed(result, results.results);
+                            if (isLateResult(indexed)) {
+                                onLateResults?.({ amount: 1, peer: from });
+                                continue;
+                            }
+                            buffer.push({
+                                value: result.value,
+                                context: result.context,
+                                from,
+                                indexed,
                             });
                         }
-                        if (matchedRemovedIds.size > 0) {
-                            hasRelevantChange = true;
-                            for (const removed of filtered.removed) {
-                                const id = indexerTypes.toId(this.indexByResolver(removed.__indexed)).primitive;
-                                if (matchedRemovedIds.has(id)) {
-                                    changeForCallback.removed.push(removed);
-                                }
+                        else {
+                            if (visited.has(indexKey) && !indexedPlaceholders?.has(indexKey)) {
+                                continue;
                             }
+                            visited.add(indexKey);
+                            const indexed = coerceWithContext(result.indexed || result.value, result.context);
+                            if (isLateResult(indexed)) {
+                                onLateResults?.({ amount: 1, peer: from });
+                                continue;
+                            }
+                            const placeholder = {
+                                value: result.value,
+                                context: result.context,
+                                from,
+                                indexed,
+                            };
+                            buffer.push(placeholder);
+                            ensureIndexedPlaceholders().set(indexKey, placeholder);
                         }
                     }
-                    // Add new entries per strategy (sorted-only)
-                    if (filtered.added?.length) {
-                        let buf = peerBufferMap.get(localHash);
-                        if (!buf) {
-                            const created = { kept: 0, buffer: [] };
-                            peerBufferMap.set(localHash, created);
-                            buf = created;
+                    peerBufferMap.set(peerHash, {
+                        buffer,
+                        // Prefetched batches should not claim remote pending counts;
+                        // we'll collect more explicitly if needed.
+                        kept: 0,
+                    });
+                };
+                const consumePrefetch = async (consumable) => {
+                    const request = consumable.response?.request;
+                    if (!request) {
+                        return;
+                    }
+                    if (idAgnosticQueryKey(request) !== currentPrefetchKey()) {
+                        return;
+                    }
+                    try {
+                        const prepared = await introduceEntries(queryRequestCoerced, [
+                            {
+                                response: consumable.response.results,
+                                from: consumable.from,
+                            },
+                        ], this.documentType, this.indexedType, this._sync, options);
+                        for (const response of prepared) {
+                            if (!response.from) {
+                                continue;
+                            }
+                            const payload = response.response;
+                            if (!(payload instanceof types.Results)) {
+                                continue;
+                            }
+                            await mergePrefetchedResults(response.from, payload);
+                        }
+                        if (!pendingBatchReason) {
+                            pendingBatchReason = "push";
                         }
-                        const filterIndex = hasQueryFiltersForUpdates
-                            ? await createUpdateFilterIndex()
-                            : undefined;
-                        for (const added of filtered.added) {
-                            const addedValue = added;
-                            const indexedCandidate = await toIndexedWithContext(addedValue);
-                            if (filterIndex) {
-                                filterIndex.drop();
-                                filterIndex.put(indexedCandidate);
-                                const matches = (await filterIndex
-                                    .iterate({
-                                    query: queryFiltersForUpdates,
-                                    sort: queryRequestCoerced.sort,
-                                }, { reference: true, shape: undefined })
-                                    .next(1)).length > 0;
-                                if (!matches) {
+                        signalUpdate("push");
+                    }
+                    catch (error) {
+                        warn("Failed to merge prefetched results", error);
+                    }
+                };
+                const onPrefetchAdd = (evt) => {
+                    void consumePrefetch(evt.detail.consumable);
+                };
+                this.prefetch.accumulator.addEventListener("add", onPrefetchAdd);
+                const cleanupDefault = cleanup;
+                cleanup = () => {
+                    this.prefetch?.accumulator.removeEventListener("add", onPrefetchAdd);
+                    return cleanupDefault();
+                };
+            }
+            let updatesCleanup;
+            if (hasLiveUpdates) {
+                const localHash = this.node.identity.publicKey.hashcode();
+                if (mergePolicy?.merge) {
+                    // Ensure local buffer exists for sorted merging
+                    if (!peerBufferMap.has(localHash)) {
+                        peerBufferMap.set(localHash, { kept: 0, buffer: [] });
+                    }
+                }
+                const queryFiltersForUpdates = indexerTypes.toQuery(queryRequestCoerced.query);
+                const hasQueryFiltersForUpdates = queryFiltersForUpdates.length > 0;
+                const createUpdateFilterIndex = async () => {
+                    const index = new HashmapIndex();
+                    await index.init({
+                        schema: this.wrappedIndexedType,
+                        indexBy: this.indexBy,
+                        nested: this.nestedProperties,
+                    });
+                    return index;
+                };
+                const toIndexedWithContext = async (value) => {
+                    const candidate = value;
+                    if ("__indexed" in candidate && candidate.__indexed) {
+                        return coerceWithContext(candidate.__indexed, candidate.__context);
+                    }
+                    if (value instanceof this.documentType) {
+                        const transformed = await this.transformer(value, value.__context);
+                        return coerceWithContext(transformed, value.__context);
+                    }
+                    return value;
+                };
+                const onChange = async (evt) => {
+                    // Optional filter to mutate/suppress change events
+                    indexIteratorLogger.trace("processing live update change event", evt.detail);
+                    let filtered = evt.detail;
+                    if (mergePolicy?.merge?.filter) {
+                        filtered = await mergePolicy.merge?.filter(evt.detail);
+                    }
+                    if (filtered) {
+                        let hasRelevantChange = false;
+                        // Remove entries that were deleted from all pending structures
+                        if (filtered.removed?.length) {
+                            const removedIds = new Set();
+                            for (const removed of filtered.removed) {
+                                const id = indexerTypes.toId(this.indexByResolver(removed.__indexed)).primitive;
+                                removedIds.add(id);
+                            }
+                            const matchedRemovedIds = new Set();
+                            for (const [_peer, entry] of peerBufferMap) {
+                                if (entry.buffer.length === 0) {
                                     continue;
                                 }
+                                entry.buffer = entry.buffer.filter((x) => {
+                                    const id = indexerTypes.toId(this.indexByResolver(x.indexed)).primitive;
+                                    if (removedIds.has(id)) {
+                                        matchedRemovedIds.add(id);
+                                        indexedPlaceholders?.delete(id);
+                                        return false;
+                                    }
+                                    return true;
+                                });
                             }
-                            const id = indexerTypes.toId(this.indexByResolver(indexedCandidate)).primitive;
-                            const existingIndexed = indexedPlaceholders?.get(id);
-                            if (existingIndexed) {
-                                if (resolve) {
-                                    existingIndexed.value = added;
-                                    existingIndexed.context = added.__context;
-                                    existingIndexed.from = this.node.identity.publicKey;
-                                    existingIndexed.indexed = indexedCandidate;
-                                    indexedPlaceholders?.delete(id);
+                            if (matchedRemovedIds.size > 0) {
+                                hasRelevantChange = true;
+                            }
+                        }
+                        // Add new entries per strategy (sorted-only)
+                        if (filtered.added?.length) {
+                            let buf = peerBufferMap.get(localHash);
+                            if (!buf) {
+                                const created = { kept: 0, buffer: [] };
+                                peerBufferMap.set(localHash, created);
+                                buf = created;
+                            }
+                            const filterIndex = hasQueryFiltersForUpdates
+                                ? await createUpdateFilterIndex()
+                                : undefined;
+                            for (const added of filtered.added) {
+                                const addedValue = added;
+                                const indexedCandidate = await toIndexedWithContext(addedValue);
+                                if (filterIndex) {
+                                    filterIndex.drop();
+                                    filterIndex.put(indexedCandidate);
+                                    const matches = (await filterIndex
+                                        .iterate({
+                                        query: queryFiltersForUpdates,
+                                        sort: queryRequestCoerced.sort,
+                                    }, { reference: true, shape: undefined })
+                                        .next(1)).length > 0;
+                                    if (!matches) {
+                                        continue;
+                                    }
                                 }
-                                continue;
+                                if (isLateResult(indexedCandidate)) {
+                                    onLateResults?.({ amount: 1 });
+                                    continue;
+                                }
+                                const id = indexerTypes.toId(this.indexByResolver(indexedCandidate)).primitive;
+                                const existingIndexed = indexedPlaceholders?.get(id);
+                                if (existingIndexed) {
+                                    if (resolve) {
+                                        existingIndexed.value = added;
+                                        existingIndexed.context = added.__context;
+                                        existingIndexed.from = this.node.identity.publicKey;
+                                        existingIndexed.indexed = indexedCandidate;
+                                        indexedPlaceholders?.delete(id);
+                                    }
+                                    continue;
+                                }
+                                if (visited.has(id))
+                                    continue; // already presented
+                                visited.add(id);
+                                const valueForBuffer = resolve
+                                    ? added
+                                    : indexedCandidate;
+                                const placeholder = {
+                                    value: valueForBuffer,
+                                    context: added.__context,
+                                    from: this.node.identity.publicKey,
+                                    indexed: indexedCandidate,
+                                };
+                                buf.buffer.push(placeholder);
+                                if (!resolve) {
+                                    ensureIndexedPlaceholders().set(id, placeholder);
+                                }
+                                hasRelevantChange = true;
                             }
-                            if (visited.has(id))
-                                continue; // already presented
-                            visited.add(id);
-                            const valueForBuffer = resolve
-                                ? added
-                                : indexedCandidate;
-                            const placeholder = {
-                                value: valueForBuffer,
-                                context: added.__context,
-                                from: this.node.identity.publicKey,
-                                indexed: indexedCandidate,
-                            };
-                            buf.buffer.push(placeholder);
-                            if (!resolve) {
-                                ensureIndexedPlaceholders().set(id, placeholder);
+                        }
+                        if (hasRelevantChange) {
+                            runNotify("change");
+                            if (!pendingBatchReason) {
+                                pendingBatchReason = "change";
                             }
-                            hasRelevantChange = true;
-                            changeForCallback.added.push(added);
+                            signalUpdate();
                         }
                     }
-                    if (hasRelevantChange) {
-                        if (!pendingResultsReason) {
-                            pendingResultsReason = "change";
+                    signalUpdate();
+                };
+                this.documentEvents.addEventListener("change", onChange);
+                updatesCleanup = () => {
+                    this.documentEvents.removeEventListener("change", onChange);
+                };
+                const cleanupDefaultUpdates = cleanup;
+                cleanup = () => {
+                    updatesCleanup?.();
+                    return cleanupDefaultUpdates();
+                };
+            }
+            if (typeof options?.remote === "object" && options?.remote.wait) {
+                // was used to account for missed results when a peer joins; omitted in this minimal handler
+                updateDeferred = pDefer();
+                const waitForTime = typeof options.remote.wait === "object" && options.remote.wait.timeout;
+                const prevMaybeSetDone = maybeSetDone;
+                maybeSetDone = () => {
+                    prevMaybeSetDone();
+                    if (done)
+                        signalUpdate(); // break deferred waits
+                };
+                let joinTimeoutId = waitForTime &&
+                    setTimeout(() => {
+                        signalUpdate();
+                    }, waitForTime);
+                ensureController().signal.addEventListener("abort", () => signalUpdate());
+                fetchedFirstForRemote = new Set();
+                joinListener = this.createReplicatorJoinListener({
+                    signal: ensureController().signal,
+                    eager: options.remote.reach?.eager,
+                    onPeer: async (pk) => {
+                        if (done)
+                            return;
+                        const hash = pk.hashcode();
+                        await fetchPromise; // ensure fetches in flight are done
+                        if (peerBufferMap.has(hash))
+                            return;
+                        if (fetchedFirstForRemote.has(hash))
+                            return;
+                        if (totalFetchedCounter > 0) {
+                            fetchPromise = fetchFirst(totalFetchedCounter, {
+                                from: [hash],
+                                fetchedFirstForRemote,
+                            });
+                            await fetchPromise;
+                            if (onLateResults) {
+                                const pending = peerBufferMap.get(hash)?.buffer;
+                                if (pending && pending.length > 0) {
+                                    if (lastValueInOrder) {
+                                        const pendingWithLast = [...pending.flat(), lastValueInOrder];
+                                        const results = pendingWithLast.sort((a, b) => indexerTypes.extractSortCompare(a.indexed, b.indexed, queryRequestCoerced.sort));
+                                        const lateResults = results.findIndex((x) => x === lastValueInOrder);
+                                        if (lateResults > 0) {
+                                            onLateResults({ amount: lateResults });
+                                        }
+                                    }
+                                    else {
+                                        onLateResults({ amount: pending.length });
+                                    }
+                                }
+                            }
                         }
-                        if (changeForCallback.added.length > 0 ||
-                            changeForCallback.removed.length > 0) {
-                            updateCallbacks?.onChange?.(changeForCallback);
-                            signalUpdate("change");
+                        if (!pendingBatchReason) {
+                            pendingBatchReason = "join";
                         }
+                        signalUpdate("join");
+                    },
+                });
+                const cleanupDefault = cleanup;
+                cleanup = () => {
+                    joinListener && joinListener();
+                    joinTimeoutId && clearTimeout(joinTimeoutId);
+                    updateDeferred?.resolve();
+                    updateDeferred = undefined;
+                    return cleanupDefault();
+                };
+            }
+            if (keepRemoteAlive) {
+                const prevMaybeSetDone = maybeSetDone;
+                maybeSetDone = () => {
+                    if (drain) {
+                        prevMaybeSetDone();
+                    }
+                };
+            }
+            const remoteWaitActive = typeof options?.remote === "object" && !!options.remote.wait;
+            const waitForUpdateAndResetDeferred = async () => {
+                if (remoteWaitActive) {
+                    // wait until: join fetch adds results, cleanup runs, or the join-wait times out
+                    await _waitForUpdate();
+                    // re-arm the deferred for the next cycle (only if joining is enabled and we're not done)
+                    if (updateDeferred && !doneFn()) {
+                        updateDeferred = pDefer();
                     }
                 }
-                signalUpdate();
-            };
-            this.documentEvents.addEventListener("change", onChange);
-            updatesCleanup = () => {
-                this.documentEvents.removeEventListener("change", onChange);
-            };
-            const cleanupDefaultUpdates = cleanup;
-            cleanup = () => {
-                updatesCleanup?.();
-                return cleanupDefaultUpdates();
-            };
-        }
-        if (typeof options?.remote === "object" && options?.remote.wait) {
-            // was used to account for missed results when a peer joins; omitted in this minimal handler
-            updateDeferred = pDefer();
-            // derive optional onMissedResults callback if provided
-            let onMissedResults = typeof options?.remote?.wait === "object" &&
-                typeof options?.remote.onLateResults === "function"
-                ? options.remote.onLateResults
-                : undefined;
-            const waitForTime = typeof options.remote.wait === "object" && options.remote.wait.timeout;
-            const prevMaybeSetDone = maybeSetDone;
-            maybeSetDone = () => {
-                prevMaybeSetDone();
-                if (done)
-                    signalUpdate(); // break deferred waits
             };
-            let joinTimeoutId = waitForTime &&
-                setTimeout(() => {
-                    signalUpdate();
-                }, waitForTime);
-            ensureController().signal.addEventListener("abort", () => signalUpdate());
-            fetchedFirstForRemote = new Set();
-            joinListener = this.attachJoinListener({
-                signal: ensureController().signal,
-                eager: options.remote.reach?.eager,
-                onPeer: async (pk) => {
-                    if (done)
-                        return;
-                    const hash = pk.hashcode();
-                    await fetchPromise; // ensure fetches in flight are done
-                    if (peerBufferMap.has(hash))
-                        return;
-                    if (fetchedFirstForRemote.has(hash))
-                        return;
-                    if (totalFetchedCounter > 0) {
-                        fetchPromise = fetchFirst(totalFetchedCounter, {
-                            from: [hash],
-                            fetchedFirstForRemote,
-                        });
+            return {
+                close,
+                next,
+                done: doneFn,
+                pending: async () => {
+                    try {
                         await fetchPromise;
-                        if (onMissedResults) {
-                            const pending = peerBufferMap.get(hash)?.buffer;
-                            if (pending && pending.length > 0) {
-                                if (lastValueInOrder) {
-                                    const pendingWithLast = [...pending.flat(), lastValueInOrder];
-                                    const results = pendingWithLast.sort((a, b) => indexerTypes.extractSortCompare(a.indexed, b.indexed, queryRequestCoerced.sort));
-                                    const lateResults = results.findIndex((x) => x === lastValueInOrder);
-                                    if (lateResults > 0) {
-                                        onMissedResults({ amount: lateResults });
-                                    }
-                                }
-                                else {
-                                    onMissedResults({ amount: pending.length });
-                                }
-                            }
+                        if (!done && keepRemoteAlive) {
+                            await fetchAtLeast(1);
                         }
                     }
-                    if (!pendingResultsReason) {
-                        pendingResultsReason = "join";
+                    catch (error) {
+                        warn("Failed to refresh iterator pending state", error);
                     }
-                    signalUpdate();
+                    let pendingCount = 0;
+                    for (const buffer of peerBufferMap.values()) {
+                        pendingCount += buffer.kept + buffer.buffer.length;
+                    }
+                    return pendingCount;
+                },
+                all: async () => {
+                    drain = true;
+                    let result = [];
+                    let c = 0;
+                    while (doneFn() !== true) {
+                        let batch = await next(100);
+                        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();
+                    }
+                    cleanupAndDone();
+                    return result;
+                },
+                first: async () => {
+                    if (doneFn()) {
+                        return undefined;
+                    }
+                    let batch = await next(1);
+                    cleanupAndDone();
+                    return batch[0];
+                },
+                [Symbol.asyncIterator]: async function* () {
+                    drain = true;
+                    let c = 0;
+                    while (doneFn() !== true) {
+                        const batch = await next(100);
+                        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();
+                    }
+                    cleanupAndDone();
                 },
-            });
-            const cleanupDefault = cleanup;
-            cleanup = () => {
-                joinListener && joinListener();
-                joinTimeoutId && clearTimeout(joinTimeoutId);
-                updateDeferred?.resolve();
-                updateDeferred = undefined;
-                return cleanupDefault();
             };
         }
-        if (keepRemoteAlive) {
-            const prevMaybeSetDone = maybeSetDone;
-            maybeSetDone = () => {
-                if (drain) {
-                    prevMaybeSetDone();
+        async updateResults(into, change, query, resolve) {
+            let intoIndexable;
+            if (into.length > 0) {
+                if (resolve && into[0] instanceof this.documentType === false) {
+                    throw new Error("Expecting 'into' to be of type " + this.documentType.name);
                 }
-            };
-        }
-        const remoteWaitActive = typeof options?.remote === "object" && !!options.remote.wait;
-        const waitForUpdateAndResetDeferred = async () => {
-            if (remoteWaitActive) {
-                // wait until: join fetch adds results, cleanup runs, or the join-wait times out
-                await _waitForUpdate();
-                // re-arm the deferred for the next cycle (only if joining is enabled and we're not done)
-                if (updateDeferred && !doneFn()) {
-                    updateDeferred = pDefer();
+                else if (!resolve && into[0] instanceof this.indexedType === false) {
+                    throw new Error("Expecting 'into' to be of type " + this.indexedType.name);
                 }
-            }
-        };
-        return {
-            close,
-            next,
-            done: doneFn,
-            pending: async () => {
-                try {
-                    await fetchPromise;
-                    if (!done && keepRemoteAlive) {
-                        await fetchAtLeast(1);
-                    }
+                if (resolve) {
+                    intoIndexable = await Promise.all(into.map(async (x) => {
+                        const transformed = await this.transformer(x, x.__context);
+                        return coerceWithContext(transformed, x.__context);
+                    }));
                 }
-                catch (error) {
-                    logger.warn("Failed to refresh iterator pending state", error);
-                }
-                let pendingCount = 0;
-                for (const buffer of peerBufferMap.values()) {
-                    pendingCount += buffer.kept + buffer.buffer.length;
-                }
-                return pendingCount;
-            },
-            all: async () => {
-                drain = true;
-                let result = [];
-                let c = 0;
-                while (doneFn() !== true) {
-                    let batch = await next(100);
-                    c += batch.length;
-                    if (c > WARNING_WHEN_ITERATING_FOR_MORE_THAN) {
-                        logger.warn("Iterating for more than " +
-                            WARNING_WHEN_ITERATING_FOR_MORE_THAN +
-                            " results");
-                    }
-                    if (batch.length > 0) {
-                        result.push(...batch);
-                        continue;
-                    }
-                    await waitForUpdateAndResetDeferred();
+                else {
+                    intoIndexable = into;
                 }
-                cleanupAndDone();
-                return result;
-            },
-            first: async () => {
-                if (doneFn()) {
-                    return undefined;
+            }
+            else {
+                intoIndexable = [];
+            }
+            const temporaryIndex = new HashmapIndex();
+            await temporaryIndex.init({
+                schema: this.wrappedIndexedType,
+                indexBy: this.indexBy,
+                nested: this.nestedProperties,
+            });
+            for (const value of intoIndexable) {
+                temporaryIndex.put(value);
+            }
+            let anyChange = false;
+            if (change.added && change.added.length > 0) {
+                for (const added of change.added) {
+                    const indexed = added instanceof this.documentType
+                        ? coerceWithContext(await this.transformer(added, added.__context), added.__context)
+                        : added;
+                    temporaryIndex.put(indexed);
+                    anyChange = true;
                 }
-                let batch = await next(1);
-                cleanupAndDone();
-                return batch[0];
-            },
-            [Symbol.asyncIterator]: async function* () {
-                drain = true;
-                let c = 0;
-                while (doneFn() !== true) {
-                    const batch = await next(100);
-                    c += batch.length;
-                    if (c > WARNING_WHEN_ITERATING_FOR_MORE_THAN) {
-                        logger.warn("Iterating for more than " +
-                            WARNING_WHEN_ITERATING_FOR_MORE_THAN +
-                            " results");
-                    }
-                    for (const entry of batch) {
-                        yield entry;
+            }
+            if (change.removed && change.removed.length > 0) {
+                for (const removed of change.removed) {
+                    const indexed = removed instanceof this.documentType
+                        ? await this.transformer(removed, removed.__context)
+                        : removed;
+                    const id = indexerTypes.toId(this.indexByResolver(indexed)).primitive;
+                    const deleted = await temporaryIndex.del({
+                        query: [indexerTypes.getMatcher(this.indexBy, id)],
+                    });
+                    if (deleted.length > 0) {
+                        anyChange = true;
                     }
-                    await waitForUpdateAndResetDeferred();
                 }
-                cleanupAndDone();
-            },
-        };
-    }
-    async updateResults(into, change, query, resolve) {
-        let intoIndexable;
-        if (into.length > 0) {
-            if (resolve && into[0] instanceof this.documentType === false) {
-                throw new Error("Expecting 'into' to be of type " + this.documentType.name);
             }
-            else if (!resolve && into[0] instanceof this.indexedType === false) {
-                throw new Error("Expecting 'into' to be of type " + this.indexedType.name);
+            if (!anyChange) {
+                return into;
             }
+            let all = await temporaryIndex
+                .iterate({
+                query: indexerTypes.toQuery(query.query),
+                sort: indexerTypes.toSort(query.sort),
+            }, { reference: true, shape: undefined })
+                .all();
             if (resolve) {
-                intoIndexable = await Promise.all(into.map(async (x) => {
-                    const transformed = await this.transformer(x, x.__context);
-                    return coerceWithContext(transformed, x.__context);
-                }));
-            }
-            else {
-                intoIndexable = into;
-            }
-        }
-        else {
-            intoIndexable = [];
-        }
-        const temporaryIndex = new HashmapIndex();
-        await temporaryIndex.init({
-            schema: this.wrappedIndexedType,
-            indexBy: this.indexBy,
-            nested: this.nestedProperties,
-        });
-        for (const value of intoIndexable) {
-            temporaryIndex.put(value);
-        }
-        let anyChange = false;
-        if (change.added && change.added.length > 0) {
-            for (const added of change.added) {
-                const indexed = added instanceof this.documentType
-                    ? coerceWithContext(await this.transformer(added, added.__context), added.__context)
-                    : added;
-                temporaryIndex.put(indexed);
-                anyChange = true;
+                return (await Promise.all(all.map(async ({ id, value }) => {
+                    return this.resolveDocument({
+                        indexed: value,
+                        head: value.__context.head,
+                        id: id.primitive,
+                    }).then((resolved) => {
+                        if (resolved) {
+                            return coerceWithContext(resolved.value, value.__context);
+                        }
+                        return undefined;
+                    });
+                }))).filter((x) => !!x);
             }
+            return all.map((x) => x.value);
         }
-        if (change.removed && change.removed.length > 0) {
-            for (const removed of change.removed) {
-                const indexed = removed instanceof this.documentType
-                    ? await this.transformer(removed, removed.__context)
-                    : removed;
-                const id = indexerTypes.toId(this.indexByResolver(indexed)).primitive;
-                const deleted = await temporaryIndex.del({
-                    query: [indexerTypes.getMatcher(this.indexBy, id)],
-                });
-                if (deleted.length > 0) {
-                    anyChange = true;
+        /**
+         * Resolve the primary key for a document or indexed representation using the configured indexBy fields.
+         * Useful when consumers need a stable id without assuming a specific property name exists.
+         */
+        resolveId(value) {
+            let candidate = value;
+            if (candidate && typeof candidate === "object") {
+                if ("__indexed" in candidate && candidate.__indexed) {
+                    candidate = candidate.__indexed;
                 }
             }
+            const resolved = this.indexByResolver(candidate);
+            return indexerTypes.toId(resolved);
         }
-        if (!anyChange) {
-            return into;
-        }
-        let all = await temporaryIndex
-            .iterate({
-            query: indexerTypes.toQuery(query.query),
-            sort: indexerTypes.toSort(query.sort),
-        }, { reference: true, shape: undefined })
-            .all();
-        if (resolve) {
-            return (await Promise.all(all.map(async ({ id, value }) => {
-                return this.resolveDocument({
-                    indexed: value,
-                    head: value.__context.head,
-                    id: id.primitive,
-                }).then((resolved) => {
-                    if (resolved) {
-                        return coerceWithContext(resolved.value, value.__context);
-                    }
-                    return undefined;
-                });
-            }))).filter((x) => !!x);
-        }
-        return all.map((x) => x.value);
-    }
-    /**
-     * Resolve the primary key for a document or indexed representation using the configured indexBy fields.
-     * Useful when consumers need a stable id without assuming a specific property name exists.
-     */
-    resolveId(value) {
-        let candidate = value;
-        if (candidate && typeof candidate === "object") {
-            if ("__indexed" in candidate && candidate.__indexed) {
-                candidate = candidate.__indexed;
+        async waitFor(other, options) {
+            const hashes = await super.waitFor(other, options);
+            for (const key of hashes) {
+                await waitFor(async () => (await this._log.replicationIndex.count({ query: { hash: key } })) >
+                    0, options);
             }
+            return hashes;
         }
-        const resolved = this.indexByResolver(candidate);
-        return indexerTypes.toId(resolved);
-    }
-    async waitFor(other, options) {
-        const hashes = await super.waitFor(other, options);
-        for (const key of hashes) {
-            await waitFor(async () => (await this._log.replicationIndex.count({ query: { hash: key } })) >
-                0, options);
-        }
-        return hashes;
-    }
-};
-__decorate([
-    field({ type: RPC }),
-    __metadata("design:type", RPC)
-], DocumentIndex.prototype, "_query", void 0);
-DocumentIndex = __decorate([
-    variant("documents_index"),
-    __metadata("design:paramtypes", [Object])
-], DocumentIndex);
+    };
+    return DocumentIndex = _classThis;
+})();
 export { DocumentIndex };
 //# sourceMappingURL=search.js.map