@firebase/firestore 3.4.4-canary.0482aa5b7 → 3.4.4-canary.3e9f3e253

package/dist/index.node.cjs.js

@@ -12,7 +12,7 @@ var grpcJs = require('@grpc/grpc-js');
 var protoLoader = require('@grpc/proto-loader');
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.4-canary.0482aa5b7";
+const version$1 = "3.4.4-canary.3e9f3e253";
 
 /**
  * @license
@@ -65,7 +65,7 @@ User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');
 User.FIRST_PARTY = new User('first-party-uid');
 User.MOCK_USER = new User('mock-user');
 
-const version = "9.6.5-canary.0482aa5b7";
+const version = "9.6.6-canary.3e9f3e253";
 
 /**
  * @license
@@ -670,13 +670,19 @@ class FirebaseAppCheckTokenProvider {
         this.appCheckProvider = appCheckProvider;
         this.forceRefresh = false;
         this.appCheck = null;
+        this.latestAppCheckToken = null;
     }
     start(asyncQueue, changeListener) {
         const onTokenChanged = tokenResult => {
             if (tokenResult.error != null) {
                 logDebug('FirebaseAppCheckTokenProvider', `Error getting App Check token; using placeholder token instead. Error: ${tokenResult.error.message}`);
             }
-            return changeListener(tokenResult.token);
+            const tokenUpdated = tokenResult.token !== this.latestAppCheckToken;
+            this.latestAppCheckToken = tokenResult.token;
+            logDebug('FirebaseAppCheckTokenProvider', `Received ${tokenUpdated ? 'new' : 'existing'} token.`);
+            return tokenUpdated
+                ? changeListener(tokenResult.token)
+                : Promise.resolve();
         };
         this.tokenListener = (tokenResult) => {
             asyncQueue.enqueueRetryable(() => onTokenChanged(tokenResult));
@@ -711,6 +717,7 @@ class FirebaseAppCheckTokenProvider {
         return this.appCheck.getToken(forceRefresh).then(tokenResult => {
             if (tokenResult) {
                 hardAssert(typeof tokenResult.token === 'string');
+                this.latestAppCheckToken = tokenResult.token;
                 return new AppCheckToken(tokenResult.token);
             }
             else {
@@ -1214,9 +1221,10 @@ function decodeResourcePath(path) {
  *     an auto-incrementing ID. This is required for Index-Free queries.
  * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
  * 11. Add bundles and named_queries for bundle support.
- * 12. Add indexing support.
+ * 12. Add document overlays.
+ * 13. Add indexing support.
  */
-const SCHEMA_VERSION = 11;
+const SCHEMA_VERSION = 12;
 /**
  * Wrapper class to store timestamps (seconds and nanos) in IndexedDb objects.
  */
@@ -1778,7 +1786,10 @@ DbNamedQuery.keyPath = 'name';
 /** An object representing the global configuration for a field index. */
 class DbIndexConfiguration {
     constructor(
-    /** The index id for this entry. */
+    /**
+     * The index id for this entry. Undefined for indexes that are not yet
+     * persisted.
+     */
     indexId, 
     /** The collection group this index belongs to. */
     collectionGroup, 
@@ -1792,6 +1803,16 @@ class DbIndexConfiguration {
 /** Name of the IndexedDb object store. */
 DbIndexConfiguration.store = 'indexConfiguration';
 DbIndexConfiguration.keyPath = 'indexId';
+/**
+ * An index that provides access to the index configurations by collection
+ * group.
+ *
+ * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+ * not possible here as the Web client supports concurrent access to
+ * persistence via multi-tab.
+ */
+DbIndexConfiguration.collectionGroupIndex = 'collectionGroupIndex';
+DbIndexConfiguration.collectionGroupIndexPath = 'collectionGroup';
 /**
  * An object describing how up-to-date the index backfill is for each user and
  * index.
@@ -1833,8 +1854,18 @@ class DbIndexState {
 /** Name of the IndexedDb object store. */
 DbIndexState.store = 'indexState';
 DbIndexState.keyPath = ['indexId', 'uid'];
+/**
+ * An index that provides access to documents in a collection sorted by last
+ * update time. Used by the backfiller.
+ *
+ * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+ * not possible here as the Web client supports concurrent access to
+ * persistence via multi-tab.
+ */
+DbIndexState.sequenceNumberIndex = 'sequenceNumberIndex';
+DbIndexState.sequenceNumberIndexPath = ['uid', 'sequenceNumber'];
 /** An object that stores the encoded entries for all documents and fields. */
-class DbIndexEntries {
+class DbIndexEntry {
     constructor(
     /** The index id for this entry. */
     indexId, 
@@ -1854,14 +1885,54 @@ class DbIndexEntries {
     }
 }
 /** Name of the IndexedDb object store. */
-DbIndexEntries.store = 'indexEntries';
-DbIndexEntries.keyPath = [
+DbIndexEntry.store = 'indexEntries';
+DbIndexEntry.keyPath = [
     'indexId',
     'uid',
     'arrayValue',
     'directionalValue',
     'documentKey'
 ];
+/**
+ * An object representing a document overlay.
+ */
+class DbDocumentOverlay {
+    constructor(
+    /** The user ID to whom this overlay belongs. */
+    userId, 
+    /** The path to the collection that contains the document. */
+    collectionPath, 
+    /** The ID (key) of the document within the collection. */
+    documentId, 
+    /** The collection group to which the document belongs. */
+    collectionGroup, 
+    /** The largest batch ID that's been applied for this overlay. */
+    largestBatchId, 
+    /** The overlay mutation. */
+    overlayMutation) {
+        this.userId = userId;
+        this.collectionPath = collectionPath;
+        this.documentId = documentId;
+        this.collectionGroup = collectionGroup;
+        this.largestBatchId = largestBatchId;
+        this.overlayMutation = overlayMutation;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbDocumentOverlay.store = 'documentOverlays';
+DbDocumentOverlay.keyPath = ['userId', 'collectionPath', 'documentId'];
+DbDocumentOverlay.collectionPathOverlayIndex = 'collectionPathOverlayIndex';
+DbDocumentOverlay.collectionPathOverlayIndexPath = [
+    'userId',
+    'collectionPath',
+    'largestBatchId'
+];
+DbDocumentOverlay.collectionGroupOverlayIndex = 'collectionGroupOverlayIndex';
+DbDocumentOverlay.collectionGroupOverlayIndexPath = [
+    'userId',
+    'collectionGroup',
+    'largestBatchId'
+];
 // Visible for testing
 const V1_STORES = [
     DbMutationQueue.store,
@@ -1885,18 +1956,28 @@ const V8_STORES = [...V6_STORES, DbCollectionParent.store];
 // V9 does not change the set of stores.
 // V10 does not change the set of stores.
 const V11_STORES = [...V8_STORES, DbBundle.store, DbNamedQuery.store];
-[
-    ...V11_STORES,
+const V12_STORES = [...V11_STORES, DbDocumentOverlay.store];
+const V13_STORES = [
+    ...V12_STORES,
     DbIndexConfiguration.store,
     DbIndexState.store,
-    DbIndexEntries.store
+    DbIndexEntry.store
 ];
-/**
- * The list of all default IndexedDB stores used throughout the SDK. This is
- * used when creating transactions so that access across all stores is done
- * atomically.
- */
-const ALL_STORES = V11_STORES;
+/** Returns the object stores for the provided schema. */
+function getObjectStores(schemaVersion) {
+    if (schemaVersion === 13) {
+        return V13_STORES;
+    }
+    else if (schemaVersion === 12) {
+        return V12_STORES;
+    }
+    else if (schemaVersion === 11) {
+        return V11_STORES;
+    }
+    else {
+        fail();
+    }
+}
 
 /**
  * @license
@@ -2193,6 +2274,15 @@ class SimpleDbTransaction {
             this.transaction.abort();
         }
     }
+    maybeCommit() {
+        // If the browser supports V3 IndexedDB, we invoke commit() explicitly to
+        // speed up index DB processing if the event loop remains blocks.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const maybeV3IndexedDb = this.transaction;
+        if (!this.aborted && typeof maybeV3IndexedDb.commit === 'function') {
+            maybeV3IndexedDb.commit();
+        }
+    }
     /**
      * Returns a SimpleDbStore<KeyType, ValueType> for the specified store. All
      * operations performed on the SimpleDbStore happen within the context of this
@@ -2389,6 +2479,10 @@ class SimpleDb {
                 this.db = await this.ensureDb(action);
                 const transaction = SimpleDbTransaction.open(this.db, action, readonly ? 'readonly' : 'readwrite', objectStores);
                 const transactionFnResult = transactionFn(transaction)
+                    .next(result => {
+                    transaction.maybeCommit();
+                    return result;
+                })
                     .catch(error => {
                     // Abort the transaction if there was an error.
                     transaction.abort(error);
@@ -2561,13 +2655,29 @@ class SimpleDbStore {
         return wrapRequest(request);
     }
     loadAll(indexOrRange, range) {
-        const cursor = this.cursor(this.options(indexOrRange, range));
-        const results = [];
-        return this.iterateCursor(cursor, (key, value) => {
-            results.push(value);
-        }).next(() => {
-            return results;
-        });
+        const iterateOptions = this.options(indexOrRange, range);
+        // Use `getAll()` if the browser supports IndexedDB v3, as it is roughly
+        // 20% faster. Unfortunately, getAll() does not support custom indices.
+        if (!iterateOptions.index && typeof this.store.getAll === 'function') {
+            const request = this.store.getAll(iterateOptions.range);
+            return new PersistencePromise((resolve, reject) => {
+                request.onerror = (event) => {
+                    reject(event.target.error);
+                };
+                request.onsuccess = (event) => {
+                    resolve(event.target.result);
+                };
+            });
+        }
+        else {
+            const cursor = this.cursor(iterateOptions);
+            const results = [];
+            return this.iterateCursor(cursor, (key, value) => {
+                results.push(value);
+            }).next(() => {
+                return results;
+            });
+        }
     }
     deleteAll(indexOrRange, range) {
         logDebug(LOG_TAG$g, 'DELETE ALL', this.store.name);
@@ -3598,6 +3708,14 @@ class DocumentKey {
         return (this.path.length >= 2 &&
             this.path.get(this.path.length - 2) === collectionId);
     }
+    /** Returns the collection group (i.e. the name of the parent collection) for this key. */
+    getCollectionGroup() {
+        return this.path.get(this.path.length - 2);
+    }
+    /** Returns the fully qualified path to the parent collection. */
+    getCollectionPath() {
+        return this.path.popLast();
+    }
     isEqual(other) {
         return (other !== null && ResourcePath.comparator(this.path, other.path) === 0);
     }
@@ -4421,12 +4539,12 @@ class FieldIndex {
     /** The collection ID this index applies to. */
     collectionGroup, 
     /** The field segments for this index. */
-    segments, 
+    fields, 
     /** Shows how up-to-date the index is for the current user. */
     indexState) {
         this.indexId = indexId;
         this.collectionGroup = collectionGroup;
-        this.segments = segments;
+        this.fields = fields;
         this.indexState = indexState;
     }
 }
@@ -6686,6 +6804,47 @@ class MutationBatchResult {
     }
 }
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Representation of an overlay computed by Firestore.
+ *
+ * Holds information about a mutation and the largest batch id in Firestore when
+ * the mutation was created.
+ */
+class Overlay {
+    constructor(largestBatchId, mutation) {
+        this.largestBatchId = largestBatchId;
+        this.mutation = mutation;
+    }
+    getKey() {
+        return this.mutation.key;
+    }
+    isEqual(other) {
+        return other !== null && this.mutation === other.mutation;
+    }
+    toString() {
+        return `Overlay{
+      largestBatchId: ${this.largestBatchId},
+      mutation: ${this.mutation.toString()}
+    }`;
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -8687,6 +8846,37 @@ function fromBundleMetadata(metadata) {
         version: metadata.version,
         createTime: fromVersion(metadata.createTime)
     };
+}
+/** Encodes a DbDocumentOverlay object to an Overlay model object. */
+function fromDbDocumentOverlay(localSerializer, dbDocumentOverlay) {
+    return new Overlay(dbDocumentOverlay.largestBatchId, fromMutation(localSerializer.remoteSerializer, dbDocumentOverlay.overlayMutation));
+}
+/** Decodes an Overlay model object into a DbDocumentOverlay object. */
+function toDbDocumentOverlay(localSerializer, userId, overlay) {
+    const [_, collectionPath, documentId] = toDbDocumentOverlayKey(userId, overlay.mutation.key);
+    return new DbDocumentOverlay(userId, collectionPath, documentId, overlay.mutation.key.getCollectionGroup(), overlay.largestBatchId, toMutation(localSerializer.remoteSerializer, overlay.mutation));
+}
+/**
+ * Returns the DbDocumentOverlayKey corresponding to the given user and
+ * document key.
+ */
+function toDbDocumentOverlayKey(userId, docKey) {
+    const docId = docKey.path.lastSegment();
+    const collectionPath = encodeResourcePath(docKey.path.popLast());
+    return [userId, collectionPath, docId];
+}
+function toDbIndexConfiguration(index) {
+    return new DbIndexConfiguration(index.indexId, index.collectionGroup, index.fields.map(s => [s.fieldPath.canonicalString(), s.kind]));
+}
+function fromDbIndexConfiguration(index, state) {
+    const decodedState = state
+        ? new IndexState(state.sequenceNumber, new IndexOffset(fromDbTimestamp(state.readTime), new DocumentKey(decodeResourcePath(state.documentKey)), state.largestBatchId))
+        : IndexState.empty();
+    const decodedSegments = index.fields.map(([fieldPath, kind]) => new IndexSegment(FieldPath$1.fromServerFormat(fieldPath), kind));
+    return new FieldIndex(index.indexId, index.collectionGroup, decodedSegments, decodedState);
+}
+function toDbIndexState(indexId, user, sequenceNumber, offset) {
+    return new DbIndexState(indexId, user.uid || '', sequenceNumber, toDbTimestamp(offset.readTime), encodeResourcePath(offset.documentKey.path), offset.largestBatchId);
 }
 
 /**
@@ -8746,6 +8936,125 @@ function namedQueriesStore(txn) {
     return getStore(txn, DbNamedQuery.store);
 }
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Implementation of DocumentOverlayCache using IndexedDb.
+ */
+class IndexedDbDocumentOverlayCache {
+    /**
+     * @param serializer - The document serializer.
+     * @param userId - The userId for which we are accessing overlays.
+     */
+    constructor(serializer, userId) {
+        this.serializer = serializer;
+        this.userId = userId;
+    }
+    static forUser(serializer, user) {
+        const userId = user.uid || '';
+        return new IndexedDbDocumentOverlayCache(serializer, userId);
+    }
+    getOverlay(transaction, key) {
+        return documentOverlayStore(transaction)
+            .get(toDbDocumentOverlayKey(this.userId, key))
+            .next(dbOverlay => {
+            if (dbOverlay) {
+                return fromDbDocumentOverlay(this.serializer, dbOverlay);
+            }
+            return null;
+        });
+    }
+    saveOverlays(transaction, largestBatchId, overlays) {
+        const promises = [];
+        overlays.forEach(mutation => {
+            const overlay = new Overlay(largestBatchId, mutation);
+            promises.push(this.saveOverlay(transaction, overlay));
+        });
+        return PersistencePromise.waitFor(promises);
+    }
+    removeOverlaysForBatchId(transaction, documentKeys, batchId) {
+        const collectionPaths = new Set();
+        // Get the set of unique collection paths.
+        documentKeys.forEach(key => collectionPaths.add(encodeResourcePath(key.getCollectionPath())));
+        const promises = [];
+        collectionPaths.forEach(collectionPath => {
+            const range = IDBKeyRange.bound([this.userId, collectionPath, batchId], [this.userId, collectionPath, batchId + 1], 
+            /*lowerOpen=*/ false, 
+            /*upperOpen=*/ true);
+            promises.push(documentOverlayStore(transaction).deleteAll(DbDocumentOverlay.collectionPathOverlayIndex, range));
+        });
+        return PersistencePromise.waitFor(promises);
+    }
+    getOverlaysForCollection(transaction, collection, sinceBatchId) {
+        const result = new Map();
+        const collectionPath = encodeResourcePath(collection);
+        // We want batch IDs larger than `sinceBatchId`, and so the lower bound
+        // is not inclusive.
+        const range = IDBKeyRange.bound([this.userId, collectionPath, sinceBatchId], [this.userId, collectionPath, Number.POSITIVE_INFINITY], 
+        /*lowerOpen=*/ true);
+        return documentOverlayStore(transaction)
+            .loadAll(DbDocumentOverlay.collectionPathOverlayIndex, range)
+            .next(dbOverlays => {
+            for (const dbOverlay of dbOverlays) {
+                const overlay = fromDbDocumentOverlay(this.serializer, dbOverlay);
+                result.set(overlay.getKey(), overlay);
+            }
+            return result;
+        });
+    }
+    getOverlaysForCollectionGroup(transaction, collectionGroup, sinceBatchId, count) {
+        const result = new Map();
+        let currentBatchId = undefined;
+        // We want batch IDs larger than `sinceBatchId`, and so the lower bound
+        // is not inclusive.
+        const range = IDBKeyRange.bound([this.userId, collectionGroup, sinceBatchId], [this.userId, collectionGroup, Number.POSITIVE_INFINITY], 
+        /*lowerOpen=*/ true);
+        return documentOverlayStore(transaction)
+            .iterate({
+            index: DbDocumentOverlay.collectionGroupOverlayIndex,
+            range
+        }, (_, dbOverlay, control) => {
+            // We do not want to return partial batch overlays, even if the size
+            // of the result set exceeds the given `count` argument. Therefore, we
+            // continue to aggregate results even after the result size exceeds
+            // `count` if there are more overlays from the `currentBatchId`.
+            const overlay = fromDbDocumentOverlay(this.serializer, dbOverlay);
+            if (result.size < count ||
+                overlay.largestBatchId === currentBatchId) {
+                result.set(overlay.getKey(), overlay);
+                currentBatchId = overlay.largestBatchId;
+            }
+            else {
+                control.done();
+            }
+        })
+            .next(() => result);
+    }
+    saveOverlay(transaction, overlay) {
+        return documentOverlayStore(transaction).put(toDbDocumentOverlay(this.serializer, this.userId, overlay));
+    }
+}
+/**
+ * Helper to get a typed SimpleDbStore for the document overlay object store.
+ */
+function documentOverlayStore(txn) {
+    return getStore(txn, DbDocumentOverlay.store);
+}
+
 /**
  * @license
  * Copyright 2019 Google LLC
@@ -8859,17 +9168,22 @@ class MemoryCollectionParentIndex {
  */
 /**
  * A persisted implementation of IndexManager.
+ *
+ * PORTING NOTE: Unlike iOS and Android, the Web SDK does not memoize index
+ * data as it supports multi-tab access.
  */
 class IndexedDbIndexManager {
-    constructor() {
+    constructor(user) {
+        this.user = user;
         /**
          * An in-memory copy of the index entries we've already written since the SDK
          * launched. Used to avoid re-writing the same entry repeatedly.
          *
-         * This is *NOT* a complete cache of what's in persistence and so can never be used to
-         * satisfy reads.
+         * This is *NOT* a complete cache of what's in persistence and so can never be
+         * used to satisfy reads.
          */
         this.collectionParentsCache = new MemoryCollectionParentIndex();
+        this.uid = user.uid || '';
     }
     /**
      * Adds a new entry to the collection parent index.
@@ -8917,12 +9231,25 @@ class IndexedDbIndexManager {
         });
     }
     addFieldIndex(transaction, index) {
-        // TODO(indexing): Implement
-        return PersistencePromise.resolve();
+        // TODO(indexing): Verify that the auto-incrementing index ID works in
+        // Safari & Firefox.
+        const indexes = indexConfigurationStore(transaction);
+        const dbIndex = toDbIndexConfiguration(index);
+        delete dbIndex.indexId; // `indexId` is auto-populated by IndexedDb
+        return indexes.add(dbIndex).next();
     }
     deleteFieldIndex(transaction, index) {
-        // TODO(indexing): Implement
-        return PersistencePromise.resolve();
+        const indexes = indexConfigurationStore(transaction);
+        const states = indexStateStore(transaction);
+        const entries = indexEntriesStore(transaction);
+        return indexes
+            .delete(index.indexId)
+            .next(() => states.delete(IDBKeyRange.bound([index.indexId], [index.indexId + 1], 
+        /*lowerOpen=*/ false, 
+        /*upperOpen=*/ true)))
+            .next(() => entries.delete(IDBKeyRange.bound([index.indexId], [index.indexId + 1], 
+        /*lowerOpen=*/ false, 
+        /*upperOpen=*/ true)));
     }
     getDocumentsMatchingTarget(transaction, fieldIndex, target) {
         // TODO(indexing): Implement
@@ -8933,21 +9260,55 @@ class IndexedDbIndexManager {
         return PersistencePromise.resolve(null);
     }
     getFieldIndexes(transaction, collectionGroup) {
-        // TODO(indexing): Implement
-        return PersistencePromise.resolve([]);
+        const indexes = indexConfigurationStore(transaction);
+        const states = indexStateStore(transaction);
+        return (collectionGroup
+            ? indexes.loadAll(DbIndexConfiguration.collectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
+            : indexes.loadAll()).next(indexConfigs => {
+            const result = [];
+            return PersistencePromise.forEach(indexConfigs, (indexConfig) => {
+                return states
+                    .get([indexConfig.indexId, this.uid])
+                    .next(indexState => {
+                    result.push(fromDbIndexConfiguration(indexConfig, indexState));
+                });
+            }).next(() => result);
+        });
     }
     getNextCollectionGroupToUpdate(transaction) {
-        // TODO(indexing): Implement
-        return PersistencePromise.resolve(null);
+        return this.getFieldIndexes(transaction).next(indexes => {
+            if (indexes.length === 0) {
+                return null;
+            }
+            indexes.sort((l, r) => l.indexState.sequenceNumber - r.indexState.sequenceNumber);
+            return indexes[0].collectionGroup;
+        });
     }
     updateCollectionGroup(transaction, collectionGroup, offset) {
-        // TODO(indexing): Implement
-        return PersistencePromise.resolve();
+        const indexes = indexConfigurationStore(transaction);
+        const states = indexStateStore(transaction);
+        return this.getNextSequenceNumber(transaction).next(nextSequenceNumber => indexes
+            .loadAll(DbIndexConfiguration.collectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
+            .next(configs => PersistencePromise.forEach(configs, (config) => states.put(toDbIndexState(config.indexId, this.user, nextSequenceNumber, offset)))));
     }
     updateIndexEntries(transaction, documents) {
         // TODO(indexing): Implement
         return PersistencePromise.resolve();
     }
+    getNextSequenceNumber(transaction) {
+        let nextSequenceNumber = 1;
+        const states = indexStateStore(transaction);
+        return states
+            .iterate({
+            index: DbIndexState.sequenceNumberIndex,
+            reverse: true,
+            range: IDBKeyRange.upperBound([this.uid, Number.MAX_SAFE_INTEGER])
+        }, (_, state, controller) => {
+            controller.done();
+            nextSequenceNumber = state.sequenceNumber + 1;
+        })
+            .next(() => nextSequenceNumber);
+    }
 }
 /**
  * Helper to get a typed SimpleDbStore for the collectionParents
@@ -8955,6 +9316,24 @@ class IndexedDbIndexManager {
  */
 function collectionParentsStore(txn) {
     return getStore(txn, DbCollectionParent.store);
+}
+/**
+ * Helper to get a typed SimpleDbStore for the index entry object store.
+ */
+function indexEntriesStore(txn) {
+    return getStore(txn, DbIndexEntry.store);
+}
+/**
+ * Helper to get a typed SimpleDbStore for the index configuration object store.
+ */
+function indexConfigurationStore(txn) {
+    return getStore(txn, DbIndexConfiguration.store);
+}
+/**
+ * Helper to get a typed SimpleDbStore for the index state object store.
+ */
+function indexStateStore(txn) {
+    return getStore(txn, DbIndexState.store);
 }
 
 /**
@@ -10424,12 +10803,10 @@ class RemoteDocumentChangeBuffer {
  * `newIndexedDbRemoteDocumentCache()`.
  */
 class IndexedDbRemoteDocumentCacheImpl {
-    /**
-     * @param serializer - The document serializer.
-     * @param indexManager - The query indexes that need to be maintained.
-     */
-    constructor(serializer, indexManager) {
+    constructor(serializer) {
         this.serializer = serializer;
+    }
+    setIndexManager(indexManager) {
         this.indexManager = indexManager;
     }
     /**
@@ -10551,21 +10928,21 @@ class IndexedDbRemoteDocumentCacheImpl {
             }
         });
     }
-    getDocumentsMatchingQuery(transaction, query, sinceReadTime) {
+    getAll(transaction, collection, sinceReadTime) {
         let results = mutableDocumentMap();
-        const immediateChildrenPathLength = query.path.length + 1;
+        const immediateChildrenPathLength = collection.length + 1;
         const iterationOptions = {};
         if (sinceReadTime.isEqual(SnapshotVersion.min())) {
             // Documents are ordered by key, so we can use a prefix scan to narrow
             // down the documents we need to match the query against.
-            const startKey = query.path.toArray();
+            const startKey = collection.toArray();
             iterationOptions.range = IDBKeyRange.lowerBound(startKey);
         }
         else {
             // Execute an index-free query and filter by read time. This is safe
             // since all document changes to queries that have a
             // lastLimboFreeSnapshotVersion (`sinceReadTime`) have a read time set.
-            const collectionKey = query.path.toArray();
+            const collectionKey = collection.toArray();
             const readTimeKey = toDbTimestampKey(sinceReadTime);
             iterationOptions.range = IDBKeyRange.lowerBound([collectionKey, readTimeKey], 
             /* open= */ true);
@@ -10582,12 +10959,12 @@ class IndexedDbRemoteDocumentCacheImpl {
                 return;
             }
             const document = this.maybeDecodeDocument(DocumentKey.fromSegments(key), dbRemoteDoc);
-            if (!query.path.isPrefixOf(document.key.path)) {
-                control.done();
-            }
-            else if (queryMatches(query, document)) {
+            if (collection.isPrefixOf(document.key.path)) {
                 results = results.insert(document.key, document);
             }
+            else {
+                control.done();
+            }
         })
             .next(() => results);
     }
@@ -10625,14 +11002,9 @@ class IndexedDbRemoteDocumentCacheImpl {
         return MutableDocument.newInvalidDocument(documentKey);
     }
 }
-/**
- * Creates a new IndexedDbRemoteDocumentCache.
- *
- * @param serializer - The document serializer.
- * @param indexManager - The query indexes that need to be maintained.
- */
-function newIndexedDbRemoteDocumentCache(serializer, indexManager) {
-    return new IndexedDbRemoteDocumentCacheImpl(serializer, indexManager);
+/** Creates a new IndexedDbRemoteDocumentCache. */
+function newIndexedDbRemoteDocumentCache(serializer) {
+    return new IndexedDbRemoteDocumentCacheImpl(serializer);
 }
 /**
  * Returns the set of documents that have changed since the specified read
@@ -10866,6 +11238,11 @@ class SchemaConverter {
             });
         }
         if (fromVersion < 12 && toVersion >= 12) {
+            p = p.next(() => {
+                createDocumentOverlayStore(db);
+            });
+        }
+        if (fromVersion < 13 && toVersion >= 13) {
             p = p.next(() => {
                 createFieldIndex(db);
             });
@@ -11078,15 +11455,25 @@ function createNamedQueriesStore(db) {
     });
 }
 function createFieldIndex(db) {
-    db.createObjectStore(DbIndexConfiguration.store, {
-        keyPath: DbIndexConfiguration.keyPath
+    const indexConfiguratioStore = db.createObjectStore(DbIndexConfiguration.store, {
+        keyPath: DbIndexConfiguration.keyPath,
+        autoIncrement: true
     });
-    db.createObjectStore(DbIndexState.store, {
+    indexConfiguratioStore.createIndex(DbIndexConfiguration.collectionGroupIndex, DbIndexConfiguration.collectionGroupIndexPath, { unique: false });
+    const indexStateStore = db.createObjectStore(DbIndexState.store, {
         keyPath: DbIndexState.keyPath
     });
-    db.createObjectStore(DbIndexEntries.store, {
-        keyPath: DbIndexEntries.keyPath
+    indexStateStore.createIndex(DbIndexState.sequenceNumberIndex, DbIndexState.sequenceNumberIndexPath, { unique: false });
+    db.createObjectStore(DbIndexEntry.store, {
+        keyPath: DbIndexEntry.keyPath
+    });
+}
+function createDocumentOverlayStore(db) {
+    const documentOverlayStore = db.createObjectStore(DbDocumentOverlay.store, {
+        keyPath: DbDocumentOverlay.keyPath
     });
+    documentOverlayStore.createIndex(DbDocumentOverlay.collectionPathOverlayIndex, DbDocumentOverlay.collectionPathOverlayIndexPath, { unique: false });
+    documentOverlayStore.createIndex(DbDocumentOverlay.collectionGroupOverlayIndex, DbDocumentOverlay.collectionGroupOverlayIndexPath, { unique: false });
 }
 
 /**
@@ -11198,7 +11585,7 @@ class IndexedDbPersistence {
      * If set to true, forcefully obtains database access. Existing tabs will
      * no longer be able to access IndexedDB.
      */
-    forceOwningTab) {
+    forceOwningTab, schemaVersion = SCHEMA_VERSION) {
         this.allowTabSynchronization = allowTabSynchronization;
         this.persistenceKey = persistenceKey;
         this.clientId = clientId;
@@ -11207,6 +11594,7 @@ class IndexedDbPersistence {
         this.document = document;
         this.sequenceNumberSyncer = sequenceNumberSyncer;
         this.forceOwningTab = forceOwningTab;
+        this.schemaVersion = schemaVersion;
         this.listenSequence = null;
         this._started = false;
         this.isPrimary = false;
@@ -11228,10 +11616,9 @@ class IndexedDbPersistence {
         this.referenceDelegate = new IndexedDbLruDelegateImpl(this, lruParams);
         this.dbName = persistenceKey + MAIN_DATABASE;
         this.serializer = new LocalSerializer(serializer);
-        this.simpleDb = new SimpleDb(this.dbName, SCHEMA_VERSION, new SchemaConverter(this.serializer));
+        this.simpleDb = new SimpleDb(this.dbName, this.schemaVersion, new SchemaConverter(this.serializer));
         this.targetCache = new IndexedDbTargetCache(this.referenceDelegate, this.serializer);
-        this.indexManager = new IndexedDbIndexManager();
-        this.remoteDocumentCache = newIndexedDbRemoteDocumentCache(this.serializer, this.indexManager);
+        this.remoteDocumentCache = newIndexedDbRemoteDocumentCache(this.serializer);
         this.bundleCache = new IndexedDbBundleCache();
         if (this.window && this.window.localStorage) {
             this.webStorage = this.window.localStorage;
@@ -11567,8 +11954,8 @@ class IndexedDbPersistence {
     get started() {
         return this._started;
     }
-    getMutationQueue(user) {
-        return IndexedDbMutationQueue.forUser(user, this.serializer, this.indexManager, this.referenceDelegate);
+    getMutationQueue(user, indexManager) {
+        return IndexedDbMutationQueue.forUser(user, this.serializer, indexManager, this.referenceDelegate);
     }
     getTargetCache() {
         return this.targetCache;
@@ -11576,8 +11963,11 @@ class IndexedDbPersistence {
     getRemoteDocumentCache() {
         return this.remoteDocumentCache;
     }
-    getIndexManager() {
-        return this.indexManager;
+    getIndexManager(user) {
+        return new IndexedDbIndexManager(user);
+    }
+    getDocumentOverlayCache(user) {
+        return IndexedDbDocumentOverlayCache.forUser(this.serializer, user);
     }
     getBundleCache() {
         return this.bundleCache;
@@ -11585,11 +11975,12 @@ class IndexedDbPersistence {
     runTransaction(action, mode, transactionOperation) {
         logDebug(LOG_TAG$d, 'Starting transaction:', action);
         const simpleDbMode = mode === 'readonly' ? 'readonly' : 'readwrite';
+        const objectStores = getObjectStores(this.schemaVersion);
         let persistenceTransaction;
         // Do all transactions as readwrite against all object stores, since we
         // are the only reader/writer.
         return this.simpleDb
-            .runTransaction(action, simpleDbMode, ALL_STORES, simpleDbTxn => {
+            .runTransaction(action, simpleDbMode, objectStores, simpleDbTxn => {
             persistenceTransaction = new IndexedDbTransaction(simpleDbTxn, this.listenSequence
                 ? this.listenSequence.next()
                 : ListenSequence.INVALID);
@@ -11961,39 +12352,28 @@ class LocalDocumentsView {
     getDocumentsMatchingCollectionQuery(transaction, query, sinceReadTime) {
         // Query the remote documents and overlay mutations.
         let results;
-        let mutationBatches;
         return this.remoteDocumentCache
-            .getDocumentsMatchingQuery(transaction, query, sinceReadTime)
+            .getAll(transaction, query.path, sinceReadTime)
             .next(queryResults => {
             results = queryResults;
             return this.mutationQueue.getAllMutationBatchesAffectingQuery(transaction, query);
         })
-            .next(matchingMutationBatches => {
-            mutationBatches = matchingMutationBatches;
-            // It is possible that a PatchMutation can make a document match a query, even if
-            // the version in the RemoteDocumentCache is not a match yet (waiting for server
-            // to ack). To handle this, we find all document keys affected by the PatchMutations
-            // that are not in `result` yet, and back fill them via `remoteDocumentCache.getEntries`,
-            // otherwise those `PatchMutations` will be ignored because no base document can be found,
-            // and lead to missing result for the query.
-            return this.addMissingBaseDocuments(transaction, mutationBatches, results).next(mergedDocuments => {
-                results = mergedDocuments;
-                for (const batch of mutationBatches) {
-                    for (const mutation of batch.mutations) {
-                        const key = mutation.key;
-                        let document = results.get(key);
-                        if (document == null) {
-                            // Create invalid document to apply mutations on top of
-                            document = MutableDocument.newInvalidDocument(key);
-                            results = results.insert(key, document);
-                        }
-                        mutationApplyToLocalView(mutation, document, batch.localWriteTime);
-                        if (!document.isFoundDocument()) {
-                            results = results.remove(key);
-                        }
+            .next(mutationBatches => {
+            for (const batch of mutationBatches) {
+                for (const mutation of batch.mutations) {
+                    const key = mutation.key;
+                    let document = results.get(key);
+                    if (document == null) {
+                        // Create invalid document to apply mutations on top of
+                        document = MutableDocument.newInvalidDocument(key);
+                        results = results.insert(key, document);
+                    }
+                    mutationApplyToLocalView(mutation, document, batch.localWriteTime);
+                    if (!document.isFoundDocument()) {
+                        results = results.remove(key);
                     }
                 }
-            });
+            }
         })
             .next(() => {
             // Finally, filter out any documents that don't actually match
@@ -12006,29 +12386,6 @@ class LocalDocumentsView {
             return results;
         });
     }
-    addMissingBaseDocuments(transaction, matchingMutationBatches, existingDocuments) {
-        let missingBaseDocEntriesForPatching = documentKeySet();
-        for (const batch of matchingMutationBatches) {
-            for (const mutation of batch.mutations) {
-                if (mutation instanceof PatchMutation &&
-                    existingDocuments.get(mutation.key) === null) {
-                    missingBaseDocEntriesForPatching =
-                        missingBaseDocEntriesForPatching.add(mutation.key);
-                }
-            }
-        }
-        let mergedDocuments = existingDocuments;
-        return this.remoteDocumentCache
-            .getEntries(transaction, missingBaseDocEntriesForPatching)
-            .next(missingBaseDocs => {
-            missingBaseDocs.forEach((key, doc) => {
-                if (doc.isFoundDocument()) {
-                    mergedDocuments = mergedDocuments.insert(key, doc);
-                }
-            });
-            return mergedDocuments;
-        });
-    }
 }
 
 /**
@@ -12087,11 +12444,18 @@ class LocalStoreImpl {
          * PORTING NOTE: This is only used for multi-tab synchronization.
          */
         this.lastDocumentChangeReadTime = SnapshotVersion.min();
-        this.mutationQueue = persistence.getMutationQueue(initialUser);
         this.remoteDocuments = persistence.getRemoteDocumentCache();
         this.targetCache = persistence.getTargetCache();
-        this.localDocuments = new LocalDocumentsView(this.remoteDocuments, this.mutationQueue, this.persistence.getIndexManager());
         this.bundleCache = persistence.getBundleCache();
+        this.initializeUserComponents(initialUser);
+    }
+    initializeUserComponents(user) {
+        // TODO(indexing): Add spec tests that test these components change after a
+        // user change
+        this.indexManager = this.persistence.getIndexManager(user);
+        this.mutationQueue = this.persistence.getMutationQueue(user, this.indexManager);
+        this.localDocuments = new LocalDocumentsView(this.remoteDocuments, this.mutationQueue, this.indexManager);
+        this.remoteDocuments.setIndexManager(this.indexManager);
         this.queryEngine.setLocalDocumentsView(this.localDocuments);
     }
     collectGarbage(garbageCollector) {
@@ -12113,8 +12477,6 @@ persistence, queryEngine, initialUser, serializer) {
 // change.
 async function localStoreHandleUserChange(localStore, user) {
     const localStoreImpl = debugCast(localStore);
-    let newMutationQueue = localStoreImpl.mutationQueue;
-    let newLocalDocuments = localStoreImpl.localDocuments;
     const result = await localStoreImpl.persistence.runTransaction('Handle user change', 'readonly', txn => {
         // Swap out the mutation queue, grabbing the pending mutation batches
         // before and after.
@@ -12123,11 +12485,8 @@ async function localStoreHandleUserChange(localStore, user) {
             .getAllMutationBatches(txn)
             .next(promisedOldBatches => {
             oldBatches = promisedOldBatches;
-            newMutationQueue = localStoreImpl.persistence.getMutationQueue(user);
-            // Recreate our LocalDocumentsView using the new
-            // MutationQueue.
-            newLocalDocuments = new LocalDocumentsView(localStoreImpl.remoteDocuments, newMutationQueue, localStoreImpl.persistence.getIndexManager());
-            return newMutationQueue.getAllMutationBatches(txn);
+            localStoreImpl.initializeUserComponents(user);
+            return localStoreImpl.mutationQueue.getAllMutationBatches(txn);
         })
             .next(newBatches => {
             const removedBatchIds = [];
@@ -12148,7 +12507,7 @@ async function localStoreHandleUserChange(localStore, user) {
             }
             // Return the set of all (potentially) changed documents and the list
             // of mutation batch IDs that were affected by change.
-            return newLocalDocuments
+            return localStoreImpl.localDocuments
                 .getDocuments(txn, changedKeys)
                 .next(affectedDocuments => {
                 return {
@@ -12159,9 +12518,6 @@ async function localStoreHandleUserChange(localStore, user) {
             });
         });
     });
-    localStoreImpl.mutationQueue = newMutationQueue;
-    localStoreImpl.localDocuments = newLocalDocuments;
-    localStoreImpl.queryEngine.setLocalDocumentsView(localStoreImpl.localDocuments);
     return result;
 }
 /* Accepts locally generated Mutations and commit them to storage. */
@@ -12874,6 +13230,122 @@ class MemoryBundleCache {
     }
 }
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * An in-memory implementation of DocumentOverlayCache.
+ */
+class MemoryDocumentOverlayCache {
+    constructor() {
+        // A map sorted by DocumentKey, whose value is a pair of the largest batch id
+        // for the overlay and the overlay itself.
+        this.overlays = new SortedMap(DocumentKey.comparator);
+        this.overlayByBatchId = new Map();
+    }
+    getOverlay(transaction, key) {
+        return PersistencePromise.resolve(this.overlays.get(key));
+    }
+    saveOverlays(transaction, largestBatchId, overlays) {
+        overlays.forEach(mutation => {
+            this.saveOverlay(transaction, largestBatchId, mutation);
+        });
+        return PersistencePromise.resolve();
+    }
+    removeOverlaysForBatchId(transaction, documentKeys, batchId) {
+        const keys = this.overlayByBatchId.get(batchId);
+        if (keys !== undefined) {
+            keys.forEach(key => (this.overlays = this.overlays.remove(key)));
+            this.overlayByBatchId.delete(batchId);
+        }
+        return PersistencePromise.resolve();
+    }
+    getOverlaysForCollection(transaction, collection, sinceBatchId) {
+        const result = new Map();
+        const immediateChildrenPathLength = collection.length + 1;
+        const prefix = new DocumentKey(collection.child(''));
+        const iter = this.overlays.getIteratorFrom(prefix);
+        while (iter.hasNext()) {
+            const entry = iter.getNext();
+            const overlay = entry.value;
+            const key = overlay.getKey();
+            if (!collection.isPrefixOf(key.path)) {
+                break;
+            }
+            // Documents from sub-collections
+            if (key.path.length !== immediateChildrenPathLength) {
+                continue;
+            }
+            if (overlay.largestBatchId > sinceBatchId) {
+                result.set(overlay.getKey(), overlay);
+            }
+        }
+        return PersistencePromise.resolve(result);
+    }
+    getOverlaysForCollectionGroup(transaction, collectionGroup, sinceBatchId, count) {
+        let batchIdToOverlays = new SortedMap((key1, key2) => key1 - key2);
+        const iter = this.overlays.getIterator();
+        while (iter.hasNext()) {
+            const entry = iter.getNext();
+            const overlay = entry.value;
+            const key = overlay.getKey();
+            if (key.getCollectionGroup() !== collectionGroup) {
+                continue;
+            }
+            if (overlay.largestBatchId > sinceBatchId) {
+                let overlaysForBatchId = batchIdToOverlays.get(overlay.largestBatchId);
+                if (overlaysForBatchId === null) {
+                    overlaysForBatchId = new Map();
+                    batchIdToOverlays = batchIdToOverlays.insert(overlay.largestBatchId, overlaysForBatchId);
+                }
+                overlaysForBatchId.set(overlay.getKey(), overlay);
+            }
+        }
+        const result = new Map();
+        const batchIter = batchIdToOverlays.getIterator();
+        while (batchIter.hasNext()) {
+            const entry = batchIter.getNext();
+            const overlays = entry.value;
+            overlays.forEach((overlay, key) => result.set(key, overlay));
+            if (result.size >= count) {
+                break;
+            }
+        }
+        return PersistencePromise.resolve(result);
+    }
+    saveOverlay(transaction, largestBatchId, mutation) {
+        if (mutation === null) {
+            return;
+        }
+        // Remove the association of the overlay to its batch id.
+        const existing = this.overlays.get(mutation.key);
+        if (existing !== null) {
+            this.overlayByBatchId.get(existing.largestBatchId).delete(mutation.key);
+        }
+        this.overlays = this.overlays.insert(mutation.key, new Overlay(largestBatchId, mutation));
+        // Create the association of this overlay to the given largestBatchId.
+        let batch = this.overlayByBatchId.get(largestBatchId);
+        if (batch === undefined) {
+            batch = new Set();
+            this.overlayByBatchId.set(largestBatchId, batch);
+        }
+        batch.add(mutation.key);
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -13227,14 +13699,16 @@ class MemoryRemoteDocumentCacheImpl {
      * expected to just return 0 to avoid unnecessarily doing the work of
      * calculating the size.
      */
-    constructor(indexManager, sizer) {
-        this.indexManager = indexManager;
+    constructor(sizer) {
         this.sizer = sizer;
         /** Underlying cache of documents and their read times. */
         this.docs = documentEntryMap();
         /** Size of all cached documents. */
         this.size = 0;
     }
+    setIndexManager(indexManager) {
+        this.indexManager = indexManager;
+    }
     /**
      * Adds the supplied entry to the cache and updates the cache size as appropriate.
      *
@@ -13282,21 +13756,22 @@ class MemoryRemoteDocumentCacheImpl {
         });
         return PersistencePromise.resolve(results);
     }
-    getDocumentsMatchingQuery(transaction, query, sinceReadTime) {
+    getAll(transaction, collectionPath, sinceReadTime) {
         let results = mutableDocumentMap();
         // Documents are ordered by key, so we can use a prefix scan to narrow down
         // the documents we need to match the query against.
-        const prefix = new DocumentKey(query.path.child(''));
+        const prefix = new DocumentKey(collectionPath.child(''));
         const iterator = this.docs.getIteratorFrom(prefix);
         while (iterator.hasNext()) {
             const { key, value: { document } } = iterator.getNext();
-            if (!query.path.isPrefixOf(key.path)) {
+            if (!collectionPath.isPrefixOf(key.path)) {
                 break;
             }
-            if (document.readTime.compareTo(sinceReadTime) <= 0) {
+            if (key.path.length > collectionPath.length + 1) {
+                // Exclude entries from subcollections.
                 continue;
             }
-            if (!queryMatches(query, document)) {
+            if (document.readTime.compareTo(sinceReadTime) <= 0) {
                 continue;
             }
             results = results.insert(document.key, document.mutableCopy());
@@ -13318,13 +13793,12 @@ class MemoryRemoteDocumentCacheImpl {
 /**
  * Creates a new memory-only RemoteDocumentCache.
  *
- * @param indexManager - A class that manages collection group indices.
  * @param sizer - Used to assess the size of a document. For eager GC, this is
  * expected to just return 0 to avoid unnecessarily doing the work of
  * calculating the size.
  */
-function newMemoryRemoteDocumentCache(indexManager, sizer) {
-    return new MemoryRemoteDocumentCacheImpl(indexManager, sizer);
+function newMemoryRemoteDocumentCache(sizer) {
+    return new MemoryRemoteDocumentCacheImpl(sizer);
 }
 /**
  * Handles the details of adding and updating documents in the MemoryRemoteDocumentCache.
@@ -13518,6 +13992,7 @@ class MemoryPersistence {
      */
     constructor(referenceDelegateFactory, serializer) {
         this.mutationQueues = {};
+        this.overlays = {};
         this.listenSequence = new ListenSequence(0);
         this._started = false;
         this._started = true;
@@ -13525,7 +14000,7 @@ class MemoryPersistence {
         this.targetCache = new MemoryTargetCache(this);
         const sizer = (doc) => this.referenceDelegate.documentSize(doc);
         this.indexManager = new MemoryIndexManager();
-        this.remoteDocumentCache = newMemoryRemoteDocumentCache(this.indexManager, sizer);
+        this.remoteDocumentCache = newMemoryRemoteDocumentCache(sizer);
         this.serializer = new LocalSerializer(serializer);
         this.bundleCache = new MemoryBundleCache(this.serializer);
     }
@@ -13546,13 +14021,23 @@ class MemoryPersistence {
     setNetworkEnabled() {
         // No op.
     }
-    getIndexManager() {
+    getIndexManager(user) {
+        // We do not currently support indices for memory persistence, so we can
+        // return the same shared instance of the memory index manager.
         return this.indexManager;
     }
-    getMutationQueue(user) {
+    getDocumentOverlayCache(user) {
+        let overlay = this.overlays[user.toKey()];
+        if (!overlay) {
+            overlay = new MemoryDocumentOverlayCache();
+            this.overlays[user.toKey()] = overlay;
+        }
+        return overlay;
+    }
+    getMutationQueue(user, indexManager) {
         let queue = this.mutationQueues[user.toKey()];
         if (!queue) {
-            queue = new MemoryMutationQueue(this.indexManager, this.referenceDelegate);
+            queue = new MemoryMutationQueue(indexManager, this.referenceDelegate);
             this.mutationQueues[user.toKey()] = queue;
         }
         return queue;
@@ -20515,12 +21000,12 @@ async function syncEngineListen(syncEngine, query) {
     }
     else {
         const targetData = await localStoreAllocateTarget(syncEngineImpl.localStore, queryToTarget(query));
-        const status = syncEngineImpl.sharedClientState.addLocalQueryTarget(targetData.targetId);
-        targetId = targetData.targetId;
-        viewSnapshot = await initializeViewAndComputeSnapshot(syncEngineImpl, query, targetId, status === 'current');
         if (syncEngineImpl.isPrimaryClient) {
             remoteStoreListen(syncEngineImpl.remoteStore, targetData);
         }
+        const status = syncEngineImpl.sharedClientState.addLocalQueryTarget(targetData.targetId);
+        targetId = targetData.targetId;
+        viewSnapshot = await initializeViewAndComputeSnapshot(syncEngineImpl, query, targetId, status === 'current');
     }
     return viewSnapshot;
 }