@firebase/firestore 3.4.6 → 3.4.7-canary.05dc9d6a0

package/dist/index.node.mjs

@@ -8,7 +8,7 @@ import * as grpc from '@grpc/grpc-js';
 import * as protoLoader from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.6";
+const version$1 = "3.4.7-canary.05dc9d6a0";
 
 /**
  * @license
@@ -61,7 +61,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.9";
+const version = "9.6.10-canary.05dc9d6a0";
 
 /**
  * @license
@@ -1200,6 +1200,24 @@ function decodeResourcePath(path) {
     return new ResourcePath(segments);
 }
 
+/**
+ * @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.
+ */
+const DbRemoteDocumentStore$1 = 'remoteDocuments';
+
 /**
  * @license
  * Copyright 2022 Google LLC
@@ -1270,26 +1288,36 @@ function newDbDocumentMutationKey(userId, path, batchId) {
  */
 const DbDocumentMutationPlaceholder = {};
 const DbDocumentMutationStore = 'documentMutations';
-const DbRemoteDocumentStore = 'remoteDocuments';
+const DbRemoteDocumentStore = 'remoteDocumentsV14';
 /**
- * An index that provides access to all entries sorted by read time (which
- * corresponds to the last modification time of each row).
- *
- * This index is used to provide a changelog for Multi-Tab.
+ * The primary key of the remote documents store, which allows for efficient
+ * access by collection path and read time.
  */
-const DbRemoteDocumentReadTimeIndex = 'readTimeIndex';
-const DbRemoteDocumentReadTimeIndexPath = 'readTime';
+const DbRemoteDocumentKeyPath = [
+    'prefixPath',
+    'collectionGroup',
+    'readTime',
+    'documentId'
+];
+/** An index that provides access to documents by key. */
+const DbRemoteDocumentDocumentKeyIndex = 'documentKeyIndex';
+const DbRemoteDocumentDocumentKeyIndexPath = [
+    'prefixPath',
+    'collectionGroup',
+    'documentId'
+];
 /**
- * An index that provides access to documents in a collection sorted by read
+ * An index that provides access to documents by collection group and read
  * time.
  *
- * This index is used to allow the RemoteDocumentCache to fetch newly changed
- * documents in a collection.
+ * This index is used by the index backfiller.
  */
-const DbRemoteDocumentCollectionReadTimeIndex = 'collectionReadTimeIndex';
-const DbRemoteDocumentCollectionReadTimeIndexPath = [
-    'parentPath',
-    'readTime'
+const DbRemoteDocumentCollectionGroupIndex = 'collectionGroupIndex';
+const DbRemoteDocumentCollectionGroupIndexPath = [
+    'collectionGroup',
+    'readTime',
+    'prefixPath',
+    'documentId'
 ];
 const DbRemoteDocumentGlobalStore = 'remoteDocumentGlobal';
 const DbRemoteDocumentGlobalKey = 'remoteDocumentGlobalKey';
@@ -1365,13 +1393,14 @@ const DbIndexEntryKeyPath = [
     'uid',
     'arrayValue',
     'directionalValue',
+    'orderedDocumentKey',
     'documentKey'
 ];
 const DbIndexEntryDocumentKeyIndex = 'documentKeyIndex';
 const DbIndexEntryDocumentKeyIndexPath = [
     'indexId',
     'uid',
-    'documentKey'
+    'orderedDocumentKey'
 ];
 /** Name of the IndexedDb object store. */
 const DbDocumentOverlayStore = 'documentOverlays';
@@ -1397,7 +1426,7 @@ const V1_STORES = [
     DbMutationQueueStore,
     DbMutationBatchStore,
     DbDocumentMutationStore,
-    DbRemoteDocumentStore,
+    DbRemoteDocumentStore$1,
     DbTargetStore,
     DbPrimaryClientStore,
     DbTargetGlobalStore,
@@ -1412,14 +1441,33 @@ const V8_STORES = [...V6_STORES, DbCollectionParentStore];
 const V11_STORES = [...V8_STORES, DbBundleStore, DbNamedQueryStore];
 const V12_STORES = [...V11_STORES, DbDocumentOverlayStore];
 const V13_STORES = [
-    ...V12_STORES,
+    DbMutationQueueStore,
+    DbMutationBatchStore,
+    DbDocumentMutationStore,
+    DbRemoteDocumentStore,
+    DbTargetStore,
+    DbPrimaryClientStore,
+    DbTargetGlobalStore,
+    DbTargetDocumentStore,
+    DbClientMetadataStore,
+    DbRemoteDocumentGlobalStore,
+    DbCollectionParentStore,
+    DbBundleStore,
+    DbNamedQueryStore,
+    DbDocumentOverlayStore
+];
+const V14_STORES = [
+    ...V13_STORES,
     DbIndexConfigurationStore,
     DbIndexStateStore,
     DbIndexEntryStore
 ];
 /** Returns the object stores for the provided schema. */
 function getObjectStores(schemaVersion) {
-    if (schemaVersion === 13) {
+    if (schemaVersion === 14) {
+        return V14_STORES;
+    }
+    else if (schemaVersion === 13) {
         return V13_STORES;
     }
     else if (schemaVersion === 12) {
@@ -2238,9 +2286,7 @@ class SimpleDbStore {
                     cursor.continue(controller.skipToKey);
                 }
             };
-        }).next(() => {
-            return PersistencePromise.waitFor(results);
-        });
+        }).next(() => PersistencePromise.waitFor(results));
     }
     options(indexOrRange, range) {
         let indexName = undefined;
@@ -2630,6 +2676,9 @@ class SnapshotVersion {
     static min() {
         return new SnapshotVersion(new Timestamp(0, 0));
     }
+    static max() {
+        return new SnapshotVersion(new Timestamp(253402300799, 1e9 - 1));
+    }
     compareTo(other) {
         return this.timestamp._compareTo(other.timestamp);
     }
@@ -4146,6 +4195,17 @@ function fieldIndexGetArraySegment(fieldIndex) {
 function fieldIndexGetDirectionalSegments(fieldIndex) {
     return fieldIndex.fields.filter(s => s.kind !== 2 /* CONTAINS */);
 }
+/**
+ * Returns the order of the document key component for the given index.
+ *
+ * PORTING NOTE: This is only used in the Web IndexedDb implementation.
+ */
+function fieldIndexGetKeyOrder(fieldIndex) {
+    const directionalSegments = fieldIndexGetDirectionalSegments(fieldIndex);
+    return directionalSegments.length === 0
+        ? 0 /* ASCENDING */
+        : directionalSegments[directionalSegments.length - 1].kind;
+}
 /** Returns a debug representation of the field index */
 function fieldIndexToString(fieldIndex) {
     return `id=${fieldIndex.indexId}|cg=${fieldIndex.collectionGroup}|f=${fieldIndex.fields.map(f => `${f.fieldPath}:${f.kind}`).join(',')}`;
@@ -4181,6 +4241,28 @@ class IndexState {
         return new IndexState(INITIAL_SEQUENCE_NUMBER, IndexOffset.min());
     }
 }
+/**
+ * Creates an offset that matches all documents with a read time higher than
+ * `readTime`.
+ */
+function newIndexOffsetSuccessorFromReadTime(readTime, largestBatchId) {
+    // We want to create an offset that matches all documents with a read time
+    // greater than the provided read time. To do so, we technically need to
+    // create an offset for `(readTime, MAX_DOCUMENT_KEY)`. While we could use
+    // Unicode codepoints to generate MAX_DOCUMENT_KEY, it is much easier to use
+    // `(readTime + 1, DocumentKey.empty())` since `> DocumentKey.empty()` matches
+    // all valid document IDs.
+    const successorSeconds = readTime.toTimestamp().seconds;
+    const successorNanos = readTime.toTimestamp().nanoseconds + 1;
+    const successor = SnapshotVersion.fromTimestamp(successorNanos === 1e9
+        ? new Timestamp(successorSeconds + 1, 0)
+        : new Timestamp(successorSeconds, successorNanos));
+    return new IndexOffset(successor, DocumentKey.empty(), largestBatchId);
+}
+/** Creates a new offset based on the provided document. */
+function newIndexOffsetFromDocument(document) {
+    return new IndexOffset(document.readTime, document.key, INITIAL_LARGEST_BATCH_ID);
+}
 /**
  * Stores the latest read time, document and batch ID that were processed for an
  * index.
@@ -4205,10 +4287,25 @@ class IndexOffset {
         this.documentKey = documentKey;
         this.largestBatchId = largestBatchId;
     }
-    /** The state of an index that has not yet been backfilled. */
+    /** Returns an offset that sorts before all regular offsets. */
     static min() {
         return new IndexOffset(SnapshotVersion.min(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
     }
+    /** Returns an offset that sorts after all regular offsets. */
+    static max() {
+        return new IndexOffset(SnapshotVersion.max(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
+    }
+}
+function indexOffsetComparator(left, right) {
+    let cmp = left.readTime.compareTo(right.readTime);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    cmp = DocumentKey.comparator(left.documentKey, right.documentKey);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    return primitiveComparator(left.largestBatchId, right.largestBatchId);
 }
 
 /**
@@ -4409,58 +4506,15 @@ function targetGetLowerBound(target, fieldIndex) {
     // For each segment, retrieve a lower bound if there is a suitable filter or
     // startAt.
     for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-        let segmentValue = undefined;
-        let segmentInclusive = true;
-        // Process all filters to find a value for the current field segment
-        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
-            let filterValue = undefined;
-            let filterInclusive = true;
-            switch (fieldFilter.op) {
-                case "<" /* LESS_THAN */:
-                case "<=" /* LESS_THAN_OR_EQUAL */:
-                    filterValue = valuesGetLowerBound(fieldFilter.value);
-                    break;
-                case "==" /* EQUAL */:
-                case "in" /* IN */:
-                case ">=" /* GREATER_THAN_OR_EQUAL */:
-                    filterValue = fieldFilter.value;
-                    break;
-                case ">" /* GREATER_THAN */:
-                    filterValue = fieldFilter.value;
-                    filterInclusive = false;
-                    break;
-                case "!=" /* NOT_EQUAL */:
-                case "not-in" /* NOT_IN */:
-                    filterValue = MIN_VALUE;
-                    break;
-                // Remaining filters cannot be used as lower bounds.
-            }
-            if (valuesMax(segmentValue, filterValue) === filterValue) {
-                segmentValue = filterValue;
-                segmentInclusive = filterInclusive;
-            }
-        }
-        // If there is a startAt bound, compare the values against the existing
-        // boundary to see if we can narrow the scope.
-        if (target.startAt !== null) {
-            for (let i = 0; i < target.orderBy.length; ++i) {
-                const orderBy = target.orderBy[i];
-                if (orderBy.field.isEqual(segment.fieldPath)) {
-                    const cursorValue = target.startAt.position[i];
-                    if (valuesMax(segmentValue, cursorValue) === cursorValue) {
-                        segmentValue = cursorValue;
-                        segmentInclusive = target.startAt.inclusive;
-                    }
-                    break;
-                }
-            }
-        }
-        if (segmentValue === undefined) {
+        const segmentBound = segment.kind === 0 /* ASCENDING */
+            ? targetGetLowerBoundForField(target, segment.fieldPath, target.startAt)
+            : targetGetUpperBoundForField(target, segment.fieldPath, target.startAt);
+        if (!segmentBound.value) {
             // No lower bound exists
             return null;
         }
-        values.push(segmentValue);
-        inclusive && (inclusive = segmentInclusive);
+        values.push(segmentBound.value);
+        inclusive && (inclusive = segmentBound.inclusive);
     }
     return new Bound(values, inclusive);
 }
@@ -4475,62 +4529,125 @@ function targetGetUpperBound(target, fieldIndex) {
     // For each segment, retrieve an upper bound if there is a suitable filter or
     // endAt.
     for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-        let segmentValue = undefined;
-        let segmentInclusive = true;
-        // Process all filters to find a value for the current field segment
-        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
-            let filterValue = undefined;
-            let filterInclusive = true;
-            switch (fieldFilter.op) {
-                case ">=" /* GREATER_THAN_OR_EQUAL */:
-                case ">" /* GREATER_THAN */:
-                    filterValue = valuesGetUpperBound(fieldFilter.value);
-                    filterInclusive = false;
-                    break;
-                case "==" /* EQUAL */:
-                case "in" /* IN */:
-                case "<=" /* LESS_THAN_OR_EQUAL */:
-                    filterValue = fieldFilter.value;
-                    break;
-                case "<" /* LESS_THAN */:
-                    filterValue = fieldFilter.value;
-                    filterInclusive = false;
-                    break;
-                case "!=" /* NOT_EQUAL */:
-                case "not-in" /* NOT_IN */:
-                    filterValue = MAX_VALUE;
-                    break;
-                // Remaining filters cannot be used as upper bounds.
-            }
-            if (valuesMin(segmentValue, filterValue) === filterValue) {
-                segmentValue = filterValue;
-                segmentInclusive = filterInclusive;
-            }
-        }
-        // If there is a endAt bound, compare the values against the existing
-        // boundary to see if we can narrow the scope.
-        if (target.endAt !== null) {
-            for (let i = 0; i < target.orderBy.length; ++i) {
-                const orderBy = target.orderBy[i];
-                if (orderBy.field.isEqual(segment.fieldPath)) {
-                    const cursorValue = target.endAt.position[i];
-                    if (valuesMin(segmentValue, cursorValue) === cursorValue) {
-                        segmentValue = cursorValue;
-                        segmentInclusive = target.endAt.inclusive;
-                    }
-                    break;
-                }
-            }
-        }
-        if (segmentValue === undefined) {
+        const segmentBound = segment.kind === 0 /* ASCENDING */
+            ? targetGetUpperBoundForField(target, segment.fieldPath, target.endAt)
+            : targetGetLowerBoundForField(target, segment.fieldPath, target.endAt);
+        if (!segmentBound.value) {
             // No upper bound exists
             return null;
         }
-        values.push(segmentValue);
-        inclusive && (inclusive = segmentInclusive);
+        values.push(segmentBound.value);
+        inclusive && (inclusive = segmentBound.inclusive);
     }
     return new Bound(values, inclusive);
 }
+/**
+ * Returns the value to use as the lower bound for ascending index segment at
+ * the provided `fieldPath` (or the upper bound for an descending segment).
+ */
+function targetGetLowerBoundForField(target, fieldPath, bound) {
+    let value = undefined;
+    let inclusive = true;
+    // Process all filters to find a value for the current field segment
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
+        let filterValue = undefined;
+        let filterInclusive = true;
+        switch (fieldFilter.op) {
+            case "<" /* LESS_THAN */:
+            case "<=" /* LESS_THAN_OR_EQUAL */:
+                filterValue = valuesGetLowerBound(fieldFilter.value);
+                break;
+            case "==" /* EQUAL */:
+            case "in" /* IN */:
+            case ">=" /* GREATER_THAN_OR_EQUAL */:
+                filterValue = fieldFilter.value;
+                break;
+            case ">" /* GREATER_THAN */:
+                filterValue = fieldFilter.value;
+                filterInclusive = false;
+                break;
+            case "!=" /* NOT_EQUAL */:
+            case "not-in" /* NOT_IN */:
+                filterValue = MIN_VALUE;
+                break;
+            // Remaining filters cannot be used as lower bounds.
+        }
+        if (valuesMax(value, filterValue) === filterValue) {
+            value = filterValue;
+            inclusive = filterInclusive;
+        }
+    }
+    // If there is an additional bound, compare the values against the existing
+    // range to see if we can narrow the scope.
+    if (bound !== null) {
+        for (let i = 0; i < target.orderBy.length; ++i) {
+            const orderBy = target.orderBy[i];
+            if (orderBy.field.isEqual(fieldPath)) {
+                const cursorValue = bound.position[i];
+                if (valuesMax(value, cursorValue) === cursorValue) {
+                    value = cursorValue;
+                    inclusive = bound.inclusive;
+                }
+                break;
+            }
+        }
+    }
+    return { value, inclusive };
+}
+/**
+ * Returns the value to use as the upper bound for ascending index segment at
+ * the provided `fieldPath` (or the lower bound for an descending segment).
+ */
+function targetGetUpperBoundForField(target, fieldPath, bound) {
+    let value = undefined;
+    let inclusive = true;
+    // Process all filters to find a value for the current field segment
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
+        let filterValue = undefined;
+        let filterInclusive = true;
+        switch (fieldFilter.op) {
+            case ">=" /* GREATER_THAN_OR_EQUAL */:
+            case ">" /* GREATER_THAN */:
+                filterValue = valuesGetUpperBound(fieldFilter.value);
+                filterInclusive = false;
+                break;
+            case "==" /* EQUAL */:
+            case "in" /* IN */:
+            case "<=" /* LESS_THAN_OR_EQUAL */:
+                filterValue = fieldFilter.value;
+                break;
+            case "<" /* LESS_THAN */:
+                filterValue = fieldFilter.value;
+                filterInclusive = false;
+                break;
+            case "!=" /* NOT_EQUAL */:
+            case "not-in" /* NOT_IN */:
+                filterValue = MAX_VALUE;
+                break;
+            // Remaining filters cannot be used as upper bounds.
+        }
+        if (valuesMin(value, filterValue) === filterValue) {
+            value = filterValue;
+            inclusive = filterInclusive;
+        }
+    }
+    // If there is an additional bound, compare the values against the existing
+    // range to see if we can narrow the scope.
+    if (bound !== null) {
+        for (let i = 0; i < target.orderBy.length; ++i) {
+            const orderBy = target.orderBy[i];
+            if (orderBy.field.isEqual(fieldPath)) {
+                const cursorValue = bound.position[i];
+                if (valuesMin(value, cursorValue) === cursorValue) {
+                    value = cursorValue;
+                    inclusive = bound.inclusive;
+                }
+                break;
+            }
+        }
+    }
+    return { value, inclusive };
+}
 class Filter {
 }
 class FieldFilter extends Filter {
@@ -5101,6 +5218,18 @@ function queryMatchesBounds(query, doc) {
     }
     return true;
 }
+/**
+ * Returns the collection group that this query targets.
+ *
+ * PORTING NOTE: This is only used in the Web SDK to facilitate multi-tab
+ * synchronization for query results.
+ */
+function queryCollectionGroup(query) {
+    return (query.collectionGroup ||
+        (query.path.length % 2 === 1
+            ? query.path.lastSegment()
+            : query.path.get(query.path.length - 2)));
+}
 /**
  * Returns a new comparator function that can be used to compare two documents
  * based on the Query's ordering constraint.
@@ -8634,40 +8763,33 @@ function fromDbRemoteDocument(localSerializer, remoteDoc) {
 }
 /** Encodes a document for storage locally. */
 function toDbRemoteDocument(localSerializer, document) {
-    const parentPath = document.key.path.popLast().toArray();
-    const readTime = toDbTimestampKey(document.readTime);
+    const key = document.key;
+    const remoteDoc = {
+        prefixPath: key.getCollectionPath().popLast().toArray(),
+        collectionGroup: key.collectionGroup,
+        documentId: key.path.lastSegment(),
+        readTime: toDbTimestampKey(document.readTime),
+        hasCommittedMutations: document.hasCommittedMutations
+    };
     if (document.isFoundDocument()) {
-        const doc = toDocument(localSerializer.remoteSerializer, document);
-        const hasCommittedMutations = document.hasCommittedMutations;
-        return {
-            document: doc,
-            hasCommittedMutations,
-            readTime,
-            parentPath
-        };
+        remoteDoc.document = toDocument(localSerializer.remoteSerializer, document);
     }
     else if (document.isNoDocument()) {
-        const path = document.key.path.toArray();
-        const hasCommittedMutations = document.hasCommittedMutations;
-        return {
-            noDocument: { path, readTime: toDbTimestamp(document.version) },
-            hasCommittedMutations,
-            readTime,
-            parentPath
+        remoteDoc.noDocument = {
+            path: key.path.toArray(),
+            readTime: toDbTimestamp(document.version)
         };
     }
     else if (document.isUnknownDocument()) {
-        const path = document.key.path.toArray();
-        return {
-            unknownDocument: { path, version: toDbTimestamp(document.version) },
-            hasCommittedMutations: true,
-            readTime,
-            parentPath
+        remoteDoc.unknownDocument = {
+            path: key.path.toArray(),
+            version: toDbTimestamp(document.version)
         };
     }
     else {
         return fail();
     }
+    return remoteDoc;
 }
 function toDbTimestampKey(snapshotVersion) {
     const timestamp = snapshotVersion.toTimestamp();
@@ -9929,8 +10051,9 @@ const EMPTY_VALUE = new Uint8Array(0);
  * data as it supports multi-tab access.
  */
 class IndexedDbIndexManager {
-    constructor(user) {
+    constructor(user, databaseId) {
         this.user = user;
+        this.databaseId = databaseId;
         /**
          * 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.
@@ -10026,7 +10149,8 @@ class IndexedDbIndexManager {
                 return PersistencePromise.resolve(null);
             }
             else {
-                let result = documentKeySet();
+                let existingKeys = documentKeySet();
+                const result = [];
                 return PersistencePromise.forEach(indexes, (index, subTarget) => {
                     logDebug(LOG_TAG$f, `Using index ${fieldIndexToString(index)} to execute ${canonifyTarget(target)}`);
                     const arrayValues = targetGetArrayValues(subTarget, index);
@@ -10042,7 +10166,11 @@ class IndexedDbIndexManager {
                             .loadFirst(indexRange, target.limit)
                             .next(entries => {
                             entries.forEach(entry => {
-                                result = result.add(new DocumentKey(decodeResourcePath(entry.documentKey)));
+                                const documentKey = DocumentKey.fromSegments(entry.documentKey);
+                                if (!existingKeys.has(documentKey)) {
+                                    existingKeys = existingKeys.add(documentKey);
+                                    result.push(documentKey);
+                                }
                             });
                         });
                     });
@@ -10141,6 +10269,15 @@ class IndexedDbIndexManager {
         FirestoreIndexValueWriter.INSTANCE.writeIndexValue(value, encoder.forKind(0 /* ASCENDING */));
         return encoder.encodedBytes();
     }
+    /**
+     * Returns an encoded form of the document key that sorts based on the key
+     * ordering of the field index.
+     */
+    encodeDirectionalKey(fieldIndex, documentKey) {
+        const encoder = new IndexByteEncoder();
+        FirestoreIndexValueWriter.INSTANCE.writeIndexValue(refValue(this.databaseId, documentKey), encoder.forKind(fieldIndexGetKeyOrder(fieldIndex)));
+        return encoder.encodedBytes();
+    }
     /**
      * Encodes the given field values according to the specification in `target`.
      * For IN queries, a list of possible values is returned.
@@ -10264,7 +10401,7 @@ class IndexedDbIndexManager {
                     return this.getExistingIndexEntries(transaction, key, fieldIndex).next(existingEntries => {
                         const newEntries = this.computeIndexEntries(doc, fieldIndex);
                         if (!existingEntries.isEqual(newEntries)) {
-                            return this.updateEntries(transaction, doc, existingEntries, newEntries);
+                            return this.updateEntries(transaction, doc, fieldIndex, existingEntries, newEntries);
                         }
                         return PersistencePromise.resolve();
                     });
@@ -10272,24 +10409,26 @@ class IndexedDbIndexManager {
             });
         });
     }
-    addIndexEntry(transaction, document, indexEntry) {
+    addIndexEntry(transaction, document, fieldIndex, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
         return indexEntries.put({
             indexId: indexEntry.indexId,
             uid: this.uid,
             arrayValue: indexEntry.arrayValue,
             directionalValue: indexEntry.directionalValue,
-            documentKey: encodeResourcePath(document.key.path)
+            orderedDocumentKey: this.encodeDirectionalKey(fieldIndex, document.key),
+            documentKey: document.key.path.toArray()
         });
     }
-    deleteIndexEntry(transaction, document, indexEntry) {
+    deleteIndexEntry(transaction, document, fieldIndex, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
         return indexEntries.delete([
             indexEntry.indexId,
             this.uid,
             indexEntry.arrayValue,
             indexEntry.directionalValue,
-            encodeResourcePath(document.key.path)
+            this.encodeDirectionalKey(fieldIndex, document.key),
+            document.key.path.toArray()
         ]);
     }
     getExistingIndexEntries(transaction, documentKey, fieldIndex) {
@@ -10301,7 +10440,7 @@ class IndexedDbIndexManager {
             range: IDBKeyRange.only([
                 fieldIndex.indexId,
                 this.uid,
-                encodeResourcePath(documentKey.path)
+                this.encodeDirectionalKey(fieldIndex, documentKey)
             ])
         }, (_, entry) => {
             results = results.add(new IndexEntry(fieldIndex.indexId, documentKey, entry.arrayValue, entry.directionalValue));
@@ -10334,15 +10473,15 @@ class IndexedDbIndexManager {
      * that are no longer referenced in `newEntries` and adding all newly added
      * entries.
      */
-    updateEntries(transaction, document, existingEntries, newEntries) {
+    updateEntries(transaction, document, fieldIndex, existingEntries, newEntries) {
         logDebug(LOG_TAG$f, "Updating index entries for document '%s'", document.key);
         const promises = [];
         diffSortedSets(existingEntries, newEntries, indexEntryComparator, 
         /* onAdd= */ entry => {
-            promises.push(this.addIndexEntry(transaction, document, entry));
+            promises.push(this.addIndexEntry(transaction, document, fieldIndex, entry));
         }, 
         /* onRemove= */ entry => {
-            promises.push(this.deleteIndexEntry(transaction, document, entry));
+            promises.push(this.deleteIndexEntry(transaction, document, fieldIndex, entry));
         });
         return PersistencePromise.waitFor(promises);
     }
@@ -10399,13 +10538,15 @@ class IndexedDbIndexManager {
                 this.uid,
                 bounds[i].arrayValue,
                 bounds[i].directionalValue,
-                ''
+                EMPTY_VALUE,
+                []
             ], [
                 bounds[i + 1].indexId,
                 this.uid,
                 bounds[i + 1].arrayValue,
                 bounds[i + 1].directionalValue,
-                ''
+                EMPTY_VALUE,
+                []
             ]));
         }
         return ranges;
@@ -11819,7 +11960,7 @@ class IndexedDbRemoteDocumentCacheImpl {
      */
     addEntry(transaction, key, doc) {
         const documentStore = remoteDocumentsStore(transaction);
-        return documentStore.put(dbKey(key), doc);
+        return documentStore.put(doc);
     }
     /**
      * Removes a document from the cache.
@@ -11827,10 +11968,9 @@ class IndexedDbRemoteDocumentCacheImpl {
      * All calls of `removeEntry`  are required to go through the RemoteDocumentChangeBuffer
      * returned by `newChangeBuffer()` to ensure proper accounting of metadata.
      */
-    removeEntry(transaction, documentKey) {
+    removeEntry(transaction, documentKey, readTime) {
         const store = remoteDocumentsStore(transaction);
-        const key = dbKey(documentKey);
-        return store.delete(key);
+        return store.delete(dbReadTimeKey(documentKey, readTime));
     }
     /**
      * Updates the current cache size.
@@ -11845,11 +11985,15 @@ class IndexedDbRemoteDocumentCacheImpl {
         });
     }
     getEntry(transaction, documentKey) {
+        let doc = MutableDocument.newInvalidDocument(documentKey);
         return remoteDocumentsStore(transaction)
-            .get(dbKey(documentKey))
-            .next(dbRemoteDoc => {
-            return this.maybeDecodeDocument(documentKey, dbRemoteDoc);
-        });
+            .iterate({
+            index: DbRemoteDocumentDocumentKeyIndex,
+            range: IDBKeyRange.only(dbKey(documentKey))
+        }, (_, dbRemoteDoc) => {
+            doc = this.maybeDecodeDocument(documentKey, dbRemoteDoc);
+        })
+            .next(() => doc);
     }
     /**
      * Looks up an entry in the cache.
@@ -11858,15 +12002,21 @@ class IndexedDbRemoteDocumentCacheImpl {
      * @returns The cached document entry and its size.
      */
     getSizedEntry(transaction, documentKey) {
+        let result = {
+            size: 0,
+            document: MutableDocument.newInvalidDocument(documentKey)
+        };
         return remoteDocumentsStore(transaction)
-            .get(dbKey(documentKey))
-            .next(dbRemoteDoc => {
-            const doc = this.maybeDecodeDocument(documentKey, dbRemoteDoc);
-            return {
-                document: doc,
+            .iterate({
+            index: DbRemoteDocumentDocumentKeyIndex,
+            range: IDBKeyRange.only(dbKey(documentKey))
+        }, (_, dbRemoteDoc) => {
+            result = {
+                document: this.maybeDecodeDocument(documentKey, dbRemoteDoc),
                 size: dbDocumentSize(dbRemoteDoc)
             };
-        });
+        })
+            .next(() => result);
     }
     getEntries(transaction, documentKeys) {
         let results = mutableDocumentMap();
@@ -11897,14 +12047,20 @@ class IndexedDbRemoteDocumentCacheImpl {
         if (documentKeys.isEmpty()) {
             return PersistencePromise.resolve();
         }
-        const range = IDBKeyRange.bound(documentKeys.first().path.toArray(), documentKeys.last().path.toArray());
-        const keyIter = documentKeys.getIterator();
+        let sortedKeys = new SortedSet(dbKeyComparator);
+        documentKeys.forEach(e => (sortedKeys = sortedKeys.add(e)));
+        const range = IDBKeyRange.bound(dbKey(sortedKeys.first()), dbKey(sortedKeys.last()));
+        const keyIter = sortedKeys.getIterator();
         let nextKey = keyIter.getNext();
         return remoteDocumentsStore(transaction)
-            .iterate({ range }, (potentialKeyRaw, dbRemoteDoc, control) => {
-            const potentialKey = DocumentKey.fromSegments(potentialKeyRaw);
+            .iterate({ index: DbRemoteDocumentDocumentKeyIndex, range }, (_, dbRemoteDoc, control) => {
+            const potentialKey = DocumentKey.fromSegments([
+                ...dbRemoteDoc.prefixPath,
+                dbRemoteDoc.collectionGroup,
+                dbRemoteDoc.documentId
+            ]);
             // Go through keys not found in cache.
-            while (nextKey && DocumentKey.comparator(nextKey, potentialKey) < 0) {
+            while (nextKey && dbKeyComparator(nextKey, potentialKey) < 0) {
                 callback(nextKey, null);
                 nextKey = keyIter.getNext();
             }
@@ -11915,7 +12071,7 @@ class IndexedDbRemoteDocumentCacheImpl {
             }
             // Skip to the next key (if there is one).
             if (nextKey) {
-                control.skip(nextKey.path.toArray());
+                control.skip(dbKey(nextKey));
             }
             else {
                 control.done();
@@ -11930,41 +12086,44 @@ class IndexedDbRemoteDocumentCacheImpl {
             }
         });
     }
-    getAll(transaction, collection, sinceReadTime) {
-        let results = mutableDocumentMap();
-        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 = 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 = collection.toArray();
-            const readTimeKey = toDbTimestampKey(sinceReadTime);
-            iterationOptions.range = IDBKeyRange.lowerBound([collectionKey, readTimeKey], 
-            /* open= */ true);
-            iterationOptions.index = DbRemoteDocumentCollectionReadTimeIndex;
-        }
+    getAllFromCollection(transaction, collection, offset) {
+        const startKey = [
+            collection.popLast().toArray(),
+            collection.lastSegment(),
+            toDbTimestampKey(offset.readTime),
+            offset.documentKey.path.isEmpty()
+                ? ''
+                : offset.documentKey.path.lastSegment()
+        ];
+        const endKey = [
+            collection.popLast().toArray(),
+            collection.lastSegment(),
+            [Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+            ''
+        ];
         return remoteDocumentsStore(transaction)
-            .iterate(iterationOptions, (key, dbRemoteDoc, control) => {
-            // The query is actually returning any path that starts with the query
-            // path prefix which may include documents in subcollections. For
-            // example, a query on 'rooms' will return rooms/abc/messages/xyx but we
-            // shouldn't match it. Fix this by discarding rows with document keys
-            // more than one segment longer than the query path.
-            if (key.length !== immediateChildrenPathLength) {
-                return;
-            }
-            const document = this.maybeDecodeDocument(DocumentKey.fromSegments(key), dbRemoteDoc);
-            if (collection.isPrefixOf(document.key.path)) {
+            .loadAll(IDBKeyRange.bound(startKey, endKey, true))
+            .next(dbRemoteDocs => {
+            let results = mutableDocumentMap();
+            for (const dbRemoteDoc of dbRemoteDocs) {
+                const document = this.maybeDecodeDocument(DocumentKey.fromSegments(dbRemoteDoc.prefixPath.concat(dbRemoteDoc.collectionGroup, dbRemoteDoc.documentId)), dbRemoteDoc);
                 results = results.insert(document.key, document);
             }
-            else {
+            return results;
+        });
+    }
+    getAllFromCollectionGroup(transaction, collectionGroup, offset, limit) {
+        let results = mutableDocumentMap();
+        const startKey = dbCollectionGroupKey(collectionGroup, offset);
+        const endKey = dbCollectionGroupKey(collectionGroup, IndexOffset.max());
+        return remoteDocumentsStore(transaction)
+            .iterate({
+            index: DbRemoteDocumentCollectionGroupIndex,
+            range: IDBKeyRange.bound(startKey, endKey, true)
+        }, (_, dbRemoteDoc, control) => {
+            const document = this.maybeDecodeDocument(DocumentKey.fromSegments(dbRemoteDoc.prefixPath.concat(dbRemoteDoc.collectionGroup, dbRemoteDoc.documentId)), dbRemoteDoc);
+            results = results.insert(document.key, document);
+            if (results.size === limit) {
                 control.done();
             }
         })
@@ -12008,50 +12167,6 @@ class IndexedDbRemoteDocumentCacheImpl {
 function newIndexedDbRemoteDocumentCache(serializer) {
     return new IndexedDbRemoteDocumentCacheImpl(serializer);
 }
-/**
- * Returns the set of documents that have changed since the specified read
- * time.
- */
-// PORTING NOTE: This is only used for multi-tab synchronization.
-function remoteDocumentCacheGetNewDocumentChanges(remoteDocumentCache, transaction, sinceReadTime) {
-    const remoteDocumentCacheImpl = debugCast(remoteDocumentCache);
-    let changedDocs = mutableDocumentMap();
-    let lastReadTime = toDbTimestampKey(sinceReadTime);
-    const documentsStore = remoteDocumentsStore(transaction);
-    const range = IDBKeyRange.lowerBound(lastReadTime, true);
-    return documentsStore
-        .iterate({ index: DbRemoteDocumentReadTimeIndex, range }, (_, dbRemoteDoc) => {
-        // Unlike `getEntry()` and others, `getNewDocumentChanges()` parses
-        // the documents directly since we want to keep sentinel deletes.
-        const doc = fromDbRemoteDocument(remoteDocumentCacheImpl.serializer, dbRemoteDoc);
-        changedDocs = changedDocs.insert(doc.key, doc);
-        lastReadTime = dbRemoteDoc.readTime;
-    })
-        .next(() => {
-        return {
-            changedDocs,
-            readTime: fromDbTimestampKey(lastReadTime)
-        };
-    });
-}
-/**
- * Returns the read time of the most recently read document in the cache, or
- * SnapshotVersion.min() if not available.
- */
-// PORTING NOTE: This is only used for multi-tab synchronization.
-function remoteDocumentCacheGetLastReadTime(transaction) {
-    const documentsStore = remoteDocumentsStore(transaction);
-    // If there are no existing entries, we return SnapshotVersion.min().
-    let readTime = SnapshotVersion.min();
-    return documentsStore
-        .iterate({ index: DbRemoteDocumentReadTimeIndex, reverse: true }, (key, dbRemoteDoc, control) => {
-        if (dbRemoteDoc.readTime) {
-            readTime = fromDbTimestampKey(dbRemoteDoc.readTime);
-        }
-        control.done();
-    })
-        .next(() => readTime);
-}
 /**
  * Handles the details of adding and updating documents in the IndexedDbRemoteDocumentCache.
  *
@@ -12069,24 +12184,26 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
         super();
         this.documentCache = documentCache;
         this.trackRemovals = trackRemovals;
-        // A map of document sizes prior to applying the changes in this buffer.
-        this.documentSizes = new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
+        // A map of document sizes and read times prior to applying the changes in
+        // this buffer.
+        this.documentStates = new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
     }
     applyChanges(transaction) {
         const promises = [];
         let sizeDelta = 0;
         let collectionParents = new SortedSet((l, r) => primitiveComparator(l.canonicalString(), r.canonicalString()));
         this.changes.forEach((key, documentChange) => {
-            const previousSize = this.documentSizes.get(key);
+            const previousDoc = this.documentStates.get(key);
+            promises.push(this.documentCache.removeEntry(transaction, key, previousDoc.readTime));
             if (documentChange.isValidDocument()) {
                 const doc = toDbRemoteDocument(this.documentCache.serializer, documentChange);
                 collectionParents = collectionParents.add(key.path.popLast());
                 const size = dbDocumentSize(doc);
-                sizeDelta += size - previousSize;
+                sizeDelta += size - previousDoc.size;
                 promises.push(this.documentCache.addEntry(transaction, key, doc));
             }
             else {
-                sizeDelta -= previousSize;
+                sizeDelta -= previousDoc.size;
                 if (this.trackRemovals) {
                     // In order to track removals, we store a "sentinel delete" in the
                     // RemoteDocumentCache. This entry is represented by a NoDocument
@@ -12095,9 +12212,6 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
                     const deletedDoc = toDbRemoteDocument(this.documentCache.serializer, documentChange.convertToNoDocument(SnapshotVersion.min()));
                     promises.push(this.documentCache.addEntry(transaction, key, deletedDoc));
                 }
-                else {
-                    promises.push(this.documentCache.removeEntry(transaction, key));
-                }
             }
         });
         collectionParents.forEach(parent => {
@@ -12111,7 +12225,10 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
         return this.documentCache
             .getSizedEntry(transaction, documentKey)
             .next(getResult => {
-            this.documentSizes.set(documentKey, getResult.size);
+            this.documentStates.set(documentKey, {
+                size: getResult.size,
+                readTime: getResult.document.readTime
+            });
             return getResult.document;
         });
     }
@@ -12125,7 +12242,10 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
             // keys to `DocumentSizeEntry`s. This is to allow returning the
             // `MutableDocumentMap` directly, without a conversion.
             sizeMap.forEach((documentKey, size) => {
-                this.documentSizes.set(documentKey, size);
+                this.documentStates.set(documentKey, {
+                    size,
+                    readTime: documents.get(documentKey).readTime
+                });
             });
             return documents;
         });
@@ -12140,8 +12260,71 @@ function documentGlobalStore(txn) {
 function remoteDocumentsStore(txn) {
     return getStore(txn, DbRemoteDocumentStore);
 }
-function dbKey(docKey) {
-    return docKey.path.toArray();
+/**
+ * Returns a key that can be used for document lookups on the
+ * `DbRemoteDocumentDocumentKeyIndex` index.
+ */
+function dbKey(documentKey) {
+    const path = documentKey.path.toArray();
+    return [
+        /* prefix path */ path.slice(0, path.length - 2),
+        /* collection id */ path[path.length - 2],
+        /* document id */ path[path.length - 1]
+    ];
+}
+/**
+ * Returns a key that can be used for document lookups via the primary key of
+ * the DbRemoteDocument object store.
+ */
+function dbReadTimeKey(documentKey, readTime) {
+    const path = documentKey.path.toArray();
+    return [
+        /* prefix path */ path.slice(0, path.length - 2),
+        /* collection id */ path[path.length - 2],
+        toDbTimestampKey(readTime),
+        /* document id */ path[path.length - 1]
+    ];
+}
+/**
+ * Returns a key that can be used for document lookups on the
+ * `DbRemoteDocumentDocumentCollectionGroupIndex` index.
+ */
+function dbCollectionGroupKey(collectionGroup, offset) {
+    const path = offset.documentKey.path.toArray();
+    return [
+        /* collection id */ collectionGroup,
+        toDbTimestampKey(offset.readTime),
+        /* prefix path */ path.slice(0, path.length - 2),
+        /* document id */ path.length > 0 ? path[path.length - 1] : ''
+    ];
+}
+/**
+ * Comparator that compares document keys according to the primary key sorting
+ * used by the `DbRemoteDocumentDocument` store (by prefix path, collection id
+ * and then document ID).
+ *
+ * Visible for testing.
+ */
+function dbKeyComparator(l, r) {
+    const left = l.path.toArray();
+    const right = r.path.toArray();
+    // The ordering is based on https://chromium.googlesource.com/chromium/blink/+/fe5c21fef94dae71c1c3344775b8d8a7f7e6d9ec/Source/modules/indexeddb/IDBKey.cpp#74
+    let cmp = 0;
+    for (let i = 0; i < left.length - 2 && i < right.length - 2; ++i) {
+        cmp = primitiveComparator(left[i], right[i]);
+        if (cmp) {
+            return cmp;
+        }
+    }
+    cmp = primitiveComparator(left.length, right.length);
+    if (cmp) {
+        return cmp;
+    }
+    cmp = primitiveComparator(left[left.length - 2], right[right.length - 2]);
+    if (cmp) {
+        return cmp;
+    }
+    return primitiveComparator(left[left.length - 1], right[right.length - 1]);
 }
 /**
  * Schema Version for the Web client:
@@ -12162,9 +12345,11 @@ function dbKey(docKey) {
  * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
  * 11. Add bundles and named_queries for bundle support.
  * 12. Add document overlays.
- * 13. Add indexing support.
+ * 13. Rewrite the keys of the remote document cache to allow for efficient
+ *     document lookup via `getAll()`.
+ * 14. Add indexing support.
  */
-const SCHEMA_VERSION = 12;
+const SCHEMA_VERSION = 13;
 
 /**
  * @license
@@ -12200,7 +12385,7 @@ class SchemaConverter {
             createPrimaryClientStore(db);
             createMutationQueue(db);
             createQueryCache(db);
-            createRemoteDocumentCache(db);
+            createLegacyRemoteDocumentCache(db);
         }
         // Migration 2 to populate the targetGlobal object no longer needed since
         // migration 3 unconditionally clears it.
@@ -12249,7 +12434,8 @@ class SchemaConverter {
                 // to the DbRemoteDocument object store itself. Since the previous change
                 // log only contained transient data, we can drop its object store.
                 dropRemoteDocumentChangesStore(db);
-                createRemoteDocumentReadTimeIndex(txn);
+                // Note: Schema version 9 used to create a read time index for the
+                // RemoteDocumentCache. This is now done with schema version 13.
             });
         }
         if (fromVersion < 10 && toVersion >= 10) {
@@ -12267,6 +12453,12 @@ class SchemaConverter {
             });
         }
         if (fromVersion < 13 && toVersion >= 13) {
+            p = p
+                .next(() => createRemoteDocumentCache(db))
+                .next(() => this.rewriteRemoteDocumentCache(db, simpleDbTransaction))
+                .next(() => db.deleteObjectStore(DbRemoteDocumentStore$1));
+        }
+        if (fromVersion < 14 && toVersion >= 14) {
             p = p.next(() => {
                 createFieldIndex(db);
             });
@@ -12276,7 +12468,7 @@ class SchemaConverter {
     addDocumentGlobal(txn) {
         let byteSize = 0;
         return txn
-            .store(DbRemoteDocumentStore)
+            .store(DbRemoteDocumentStore$1)
             .iterate((_, doc) => {
             byteSize += dbDocumentSize(doc);
         })
@@ -12311,7 +12503,7 @@ class SchemaConverter {
      */
     ensureSequenceNumbers(txn) {
         const documentTargetStore = txn.store(DbTargetDocumentStore);
-        const documentsStore = txn.store(DbRemoteDocumentStore);
+        const documentsStore = txn.store(DbRemoteDocumentStore$1);
         const globalTargetStore = txn.store(DbTargetGlobalStore);
         return globalTargetStore.get(DbTargetGlobalKey).next(metadata => {
             const writeSentinelKey = (path) => {
@@ -12358,7 +12550,7 @@ class SchemaConverter {
         };
         // Index existing remote documents.
         return txn
-            .store(DbRemoteDocumentStore)
+            .store(DbRemoteDocumentStore$1)
             .iterate({ keysOnly: true }, (pathSegments, _) => {
             const path = new ResourcePath(pathSegments);
             return addEntry(path.popLast());
@@ -12381,6 +12573,27 @@ class SchemaConverter {
             return targetStore.put(updatedDbTarget);
         });
     }
+    rewriteRemoteDocumentCache(db, transaction) {
+        const legacyRemoteDocumentStore = transaction.store(DbRemoteDocumentStore$1);
+        const writes = [];
+        return legacyRemoteDocumentStore
+            .iterate((_, legacyDocument) => {
+            const remoteDocumentStore = transaction.store(DbRemoteDocumentStore);
+            const path = extractKey(legacyDocument).path.toArray();
+            const dbRemoteDocument = {
+                prefixPath: path.slice(0, path.length - 2),
+                collectionGroup: path[path.length - 2],
+                documentId: path[path.length - 1],
+                readTime: legacyDocument.readTime || [0, 0],
+                unknownDocument: legacyDocument.unknownDocument,
+                noDocument: legacyDocument.noDocument,
+                document: legacyDocument.document,
+                hasCommittedMutations: !!legacyDocument.hasCommittedMutations
+            };
+            writes.push(remoteDocumentStore.put(dbRemoteDocument));
+        })
+            .next(() => PersistencePromise.waitFor(writes));
+    }
 }
 function sentinelKey(path) {
     return [0, encodeResourcePath(path)];
@@ -12417,8 +12630,15 @@ function upgradeMutationBatchSchemaAndMigrateData(db, txn) {
         return PersistencePromise.waitFor(writeAll);
     });
 }
+function createLegacyRemoteDocumentCache(db) {
+    db.createObjectStore(DbRemoteDocumentStore$1);
+}
 function createRemoteDocumentCache(db) {
-    db.createObjectStore(DbRemoteDocumentStore);
+    const remoteDocumentStore = db.createObjectStore(DbRemoteDocumentStore, {
+        keyPath: DbRemoteDocumentKeyPath
+    });
+    remoteDocumentStore.createIndex(DbRemoteDocumentDocumentKeyIndex, DbRemoteDocumentDocumentKeyIndexPath);
+    remoteDocumentStore.createIndex(DbRemoteDocumentCollectionGroupIndex, DbRemoteDocumentCollectionGroupIndexPath);
 }
 function createDocumentGlobalStore(db) {
     db.createObjectStore(DbRemoteDocumentGlobalStore);
@@ -12460,15 +12680,6 @@ function writeEmptyTargetGlobalEntry(txn) {
     };
     return globalStore.put(DbTargetGlobalKey, metadata);
 }
-/**
- * Creates indices on the RemoteDocuments store used for both multi-tab
- * and Index-Free queries.
- */
-function createRemoteDocumentReadTimeIndex(txn) {
-    const remoteDocumentStore = txn.objectStore(DbRemoteDocumentStore);
-    remoteDocumentStore.createIndex(DbRemoteDocumentReadTimeIndex, DbRemoteDocumentReadTimeIndexPath, { unique: false });
-    remoteDocumentStore.createIndex(DbRemoteDocumentCollectionReadTimeIndex, DbRemoteDocumentCollectionReadTimeIndexPath, { unique: false });
-}
 function createClientMetadataStore(db) {
     db.createObjectStore(DbClientMetadataStore, {
         keyPath: DbClientMetadataKeyPath
@@ -12485,11 +12696,11 @@ function createNamedQueriesStore(db) {
     });
 }
 function createFieldIndex(db) {
-    const indexConfiguratioStore = db.createObjectStore(DbIndexConfigurationStore, {
+    const indexConfigurationStore = db.createObjectStore(DbIndexConfigurationStore, {
         keyPath: DbIndexConfigurationKeyPath,
         autoIncrement: true
     });
-    indexConfiguratioStore.createIndex(DbIndexConfigurationCollectionGroupIndex, DbIndexConfigurationCollectionGroupIndexPath, { unique: false });
+    indexConfigurationStore.createIndex(DbIndexConfigurationCollectionGroupIndex, DbIndexConfigurationCollectionGroupIndexPath, { unique: false });
     const indexStateStore = db.createObjectStore(DbIndexStateStore, {
         keyPath: DbIndexStateKeyPath
     });
@@ -12505,6 +12716,20 @@ function createDocumentOverlayStore(db) {
     });
     documentOverlayStore.createIndex(DbDocumentOverlayCollectionPathOverlayIndex, DbDocumentOverlayCollectionPathOverlayIndexPath, { unique: false });
     documentOverlayStore.createIndex(DbDocumentOverlayCollectionGroupOverlayIndex, DbDocumentOverlayCollectionGroupOverlayIndexPath, { unique: false });
+}
+function extractKey(remoteDoc) {
+    if (remoteDoc.document) {
+        return new DocumentKey(ResourcePath.fromString(remoteDoc.document.name).popFirst(5));
+    }
+    else if (remoteDoc.noDocument) {
+        return DocumentKey.fromSegments(remoteDoc.noDocument.path);
+    }
+    else if (remoteDoc.unknownDocument) {
+        return DocumentKey.fromSegments(remoteDoc.unknownDocument.path);
+    }
+    else {
+        return fail();
+    }
 }
 
 /**
@@ -13000,7 +13225,7 @@ class IndexedDbPersistence {
         return this.remoteDocumentCache;
     }
     getIndexManager(user) {
-        return new IndexedDbIndexManager(user);
+        return new IndexedDbIndexManager(user, this.serializer.remoteSerializer.databaseId);
     }
     getDocumentOverlayCache(user) {
         return IndexedDbDocumentOverlayCache.forUser(this.serializer, user);
@@ -13347,18 +13572,17 @@ class LocalDocumentsView {
      *
      * @param transaction - The persistence transaction.
      * @param query - The query to match documents against.
-     * @param sinceReadTime - If not set to SnapshotVersion.min(), return only
-     *     documents that have been read since this snapshot version (exclusive).
+     * @param offset - Read time and key to start scanning by (exclusive).
      */
-    getDocumentsMatchingQuery(transaction, query, sinceReadTime) {
+    getDocumentsMatchingQuery(transaction, query, offset) {
         if (isDocumentQuery$1(query)) {
             return this.getDocumentsMatchingDocumentQuery(transaction, query.path);
         }
         else if (isCollectionGroupQuery(query)) {
-            return this.getDocumentsMatchingCollectionGroupQuery(transaction, query, sinceReadTime);
+            return this.getDocumentsMatchingCollectionGroupQuery(transaction, query, offset);
         }
         else {
-            return this.getDocumentsMatchingCollectionQuery(transaction, query, sinceReadTime);
+            return this.getDocumentsMatchingCollectionQuery(transaction, query, offset);
         }
     }
     getDocumentsMatchingDocumentQuery(transaction, docPath) {
@@ -13371,7 +13595,7 @@ class LocalDocumentsView {
             return result;
         });
     }
-    getDocumentsMatchingCollectionGroupQuery(transaction, query, sinceReadTime) {
+    getDocumentsMatchingCollectionGroupQuery(transaction, query, offset) {
         const collectionId = query.collectionGroup;
         let results = documentMap();
         return this.indexManager
@@ -13381,7 +13605,7 @@ class LocalDocumentsView {
             // collectionId and aggregate the results.
             return PersistencePromise.forEach(parents, (parent) => {
                 const collectionQuery = asCollectionQueryAtPath(query, parent.child(collectionId));
-                return this.getDocumentsMatchingCollectionQuery(transaction, collectionQuery, sinceReadTime).next(r => {
+                return this.getDocumentsMatchingCollectionQuery(transaction, collectionQuery, offset).next(r => {
                     r.forEach((key, doc) => {
                         results = results.insert(key, doc);
                     });
@@ -13389,11 +13613,11 @@ class LocalDocumentsView {
             }).next(() => results);
         });
     }
-    getDocumentsMatchingCollectionQuery(transaction, query, sinceReadTime) {
+    getDocumentsMatchingCollectionQuery(transaction, query, offset) {
         // Query the remote documents and overlay mutations.
         let results;
         return this.remoteDocumentCache
-            .getAll(transaction, query.path, sinceReadTime)
+            .getAllFromCollection(transaction, query.path, offset)
             .next(queryResults => {
             results = queryResults;
             return this.mutationQueue.getAllMutationBatchesAffectingQuery(transaction, query);
@@ -13479,11 +13703,12 @@ class LocalStoreImpl {
         // TODO(wuandy): Evaluate if TargetId can be part of Target.
         this.targetIdByTarget = new ObjectMap(t => canonifyTarget(t), targetEquals);
         /**
-         * The read time of the last entry processed by `getNewDocumentChanges()`.
+         * A per collection group index of the last read time processed by
+         * `getNewDocumentChanges()`.
          *
          * PORTING NOTE: This is only used for multi-tab synchronization.
          */
-        this.lastDocumentChangeReadTime = SnapshotVersion.min();
+        this.collectionGroupReadTime = new Map();
         this.remoteDocuments = persistence.getRemoteDocumentCache();
         this.targetCache = persistence.getTargetCache();
         this.bundleCache = persistence.getBundleCache();
@@ -14018,6 +14243,7 @@ function localStoreExecuteQuery(localStore, query, usePreviousResults) {
             ? lastLimboFreeSnapshotVersion
             : SnapshotVersion.min(), usePreviousResults ? remoteKeys : documentKeySet()))
             .next(documents => {
+            setMaxReadTime(localStoreImpl, queryCollectionGroup(query), documents);
             return { documents, remoteKeys };
         });
     });
@@ -14095,28 +14321,32 @@ function localStoreGetCachedTarget(localStore, targetId) {
  * since the prior call.
  */
 // PORTING NOTE: Multi-Tab only.
-function localStoreGetNewDocumentChanges(localStore) {
+function localStoreGetNewDocumentChanges(localStore, collectionGroup) {
     const localStoreImpl = debugCast(localStore);
+    // Get the current maximum read time for the collection. This should always
+    // exist, but to reduce the chance for regressions we default to
+    // SnapshotVersion.Min()
+    // TODO(indexing): Consider removing the default value.
+    const readTime = localStoreImpl.collectionGroupReadTime.get(collectionGroup) ||
+        SnapshotVersion.min();
     return localStoreImpl.persistence
-        .runTransaction('Get new document changes', 'readonly', txn => remoteDocumentCacheGetNewDocumentChanges(localStoreImpl.remoteDocuments, txn, localStoreImpl.lastDocumentChangeReadTime))
-        .then(({ changedDocs, readTime }) => {
-        localStoreImpl.lastDocumentChangeReadTime = readTime;
+        .runTransaction('Get new document changes', 'readonly', txn => localStoreImpl.remoteDocuments.getAllFromCollectionGroup(txn, collectionGroup, newIndexOffsetSuccessorFromReadTime(readTime, INITIAL_LARGEST_BATCH_ID), 
+    /* limit= */ Number.MAX_SAFE_INTEGER))
+        .then(changedDocs => {
+        setMaxReadTime(localStoreImpl, collectionGroup, changedDocs);
         return changedDocs;
     });
 }
-/**
- * Reads the newest document change from persistence and moves the internal
- * synchronization marker forward so that calls to `getNewDocumentChanges()`
- * only return changes that happened after client initialization.
- */
+/** Sets the collection group's maximum read time from the given documents. */
 // PORTING NOTE: Multi-Tab only.
-async function localStoreSynchronizeLastDocumentChangeReadTime(localStore) {
-    const localStoreImpl = debugCast(localStore);
-    return localStoreImpl.persistence
-        .runTransaction('Synchronize last document change read time', 'readonly', txn => remoteDocumentCacheGetLastReadTime(txn))
-        .then(readTime => {
-        localStoreImpl.lastDocumentChangeReadTime = readTime;
+function setMaxReadTime(localStoreImpl, collectionGroup, changedDocs) {
+    let readTime = SnapshotVersion.min();
+    changedDocs.forEach((_, doc) => {
+        if (doc.readTime.compareTo(readTime) > 0) {
+            readTime = doc.readTime;
+        }
     });
+    localStoreImpl.collectionGroupReadTime.set(collectionGroup, readTime);
 }
 /**
  * Creates a new target using the given bundle name, which will be used to
@@ -14799,7 +15029,7 @@ class MemoryRemoteDocumentCacheImpl {
         });
         return PersistencePromise.resolve(results);
     }
-    getAll(transaction, collectionPath, sinceReadTime) {
+    getAllFromCollection(transaction, collectionPath, offset) {
         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.
@@ -14814,13 +15044,19 @@ class MemoryRemoteDocumentCacheImpl {
                 // Exclude entries from subcollections.
                 continue;
             }
-            if (document.readTime.compareTo(sinceReadTime) <= 0) {
+            if (indexOffsetComparator(newIndexOffsetFromDocument(document), offset) <= 0) {
+                // The document sorts before the offset.
                 continue;
             }
             results = results.insert(document.key, document.mutableCopy());
         }
         return PersistencePromise.resolve(results);
     }
+    getAllFromCollectionGroup(transaction, collectionGroup, offset, limti) {
+        // This method should only be called from the IndexBackfiller if persistence
+        // is enabled.
+        fail();
+    }
     forEachDocumentKey(transaction, f) {
         return PersistencePromise.forEach(this.docs, (key) => f(key));
     }
@@ -15273,7 +15509,7 @@ class QueryEngine {
             }
             // Retrieve all results for documents that were updated since the last
             // limbo-document free remote snapshot.
-            return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, lastLimboFreeSnapshotVersion).next(updatedResults => {
+            return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, newIndexOffsetSuccessorFromReadTime(lastLimboFreeSnapshotVersion, INITIAL_LARGEST_BATCH_ID)).next(updatedResults => {
                 // We merge `previousResults` into `updateResults`, since
                 // `updateResults` is already a DocumentMap. If a document is
                 // contained in both lists, then its contents are the same.
@@ -15335,7 +15571,7 @@ class QueryEngine {
         if (getLogLevel() <= LogLevel.DEBUG) {
             logDebug('QueryEngine', 'Using full collection scan to execute query:', stringifyQuery(query));
         }
-        return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, SnapshotVersion.min());
+        return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, IndexOffset.min());
     }
 }
 
@@ -15396,8 +15632,9 @@ function createWebStorageOnlineStateKey(persistenceKey) {
 // The WebStorage prefix that plays as a event to indicate the remote documents
 // might have changed due to some secondary tabs loading a bundle.
 // format of the key is:
-//     firestore_bundle_loaded_<persistenceKey>
-const BUNDLE_LOADED_KEY_PREFIX = 'firestore_bundle_loaded';
+//     firestore_bundle_loaded_v2_<persistenceKey>
+// The version ending with "v2" stores the list of modified collection groups.
+const BUNDLE_LOADED_KEY_PREFIX = 'firestore_bundle_loaded_v2';
 function createBundleLoadedKey(persistenceKey) {
     return `${BUNDLE_LOADED_KEY_PREFIX}_${persistenceKey}`;
 }
@@ -15775,8 +16012,8 @@ class WebStorageSharedClientState {
     setOnlineState(onlineState) {
         this.persistOnlineState(onlineState);
     }
-    notifyBundleLoaded() {
-        this.persistBundleLoadedState();
+    notifyBundleLoaded(collectionGroups) {
+        this.persistBundleLoadedState(collectionGroups);
     }
     shutdown() {
         if (this.started) {
@@ -15860,7 +16097,8 @@ class WebStorageSharedClientState {
                     }
                 }
                 else if (storageEvent.key === this.bundleLoadedKey) {
-                    return this.syncEngine.synchronizeWithChangedDocuments();
+                    const collectionGroups = this.fromWebStoreBundleLoadedState(storageEvent.newValue);
+                    await Promise.all(collectionGroups.map(cg => this.syncEngine.synchronizeWithChangedDocuments(cg)));
                 }
             });
         }
@@ -15892,8 +16130,9 @@ class WebStorageSharedClientState {
         const targetMetadata = new QueryTargetMetadata(targetId, state, error);
         this.setItem(targetKey, targetMetadata.toWebStorageJSON());
     }
-    persistBundleLoadedState() {
-        this.setItem(this.bundleLoadedKey, 'value-not-used');
+    persistBundleLoadedState(collectionGroups) {
+        const json = JSON.stringify(Array.from(collectionGroups));
+        this.setItem(this.bundleLoadedKey, json);
     }
     /**
      * Parses a client state key in WebStorage. Returns null if the key does not
@@ -15937,6 +16176,9 @@ class WebStorageSharedClientState {
     fromWebStorageOnlineState(value) {
         return SharedOnlineState.fromWebStorageEntry(value);
     }
+    fromWebStoreBundleLoadedState(value) {
+        return JSON.parse(value);
+    }
     async handleMutationBatchEvent(mutationBatch) {
         if (mutationBatch.user.uid !== this.currentUser.uid) {
             logDebug(LOG_TAG$a, `Ignoring mutation for non-active user ${mutationBatch.user.uid}`);
@@ -16053,7 +16295,7 @@ class MemorySharedClientState {
     }
     shutdown() { }
     writeSequenceNumber(sequenceNumber) { }
-    notifyBundleLoaded() {
+    notifyBundleLoaded(collectionGroups) {
         // No op.
     }
 }
@@ -21353,29 +21595,6 @@ class LocalViewChanges {
     }
 }
 
-/**
- * @license
- * Copyright 2020 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.
- */
-class BundleLoadResult {
-    constructor(progress, changedDocs) {
-        this.progress = progress;
-        this.changedDocs = changedDocs;
-    }
-}
-
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -21430,6 +21649,8 @@ class BundleLoader {
         this.queries = [];
         /** Batched documents to be saved into storage */
         this.documents = [];
+        /** The collection groups affected by this bundle. */
+        this.collectionGroups = new Set();
         this.progress = bundleInitialProgress(bundleMetadata);
     }
     /**
@@ -21449,6 +21670,8 @@ class BundleLoader {
             if (!element.payload.documentMetadata.exists) {
                 ++documentsLoaded;
             }
+            const path = ResourcePath.fromString(element.payload.documentMetadata.name);
+            this.collectionGroups.add(path.get(path.length - 2));
         }
         else if (element.payload.document) {
             this.documents[this.documents.length - 1].document =
@@ -21479,13 +21702,17 @@ class BundleLoader {
      * Update the progress to 'Success' and return the updated progress.
      */
     async complete() {
-        const changedDocuments = await localStoreApplyBundledDocuments(this.localStore, new BundleConverterImpl(this.serializer), this.documents, this.bundleMetadata.id);
+        const changedDocs = await localStoreApplyBundledDocuments(this.localStore, new BundleConverterImpl(this.serializer), this.documents, this.bundleMetadata.id);
         const queryDocumentMap = this.getQueryDocumentMapping(this.documents);
         for (const q of this.queries) {
             await localStoreSaveNamedQuery(this.localStore, q, queryDocumentMap.get(q.name));
         }
         this.progress.taskState = 'Success';
-        return new BundleLoadResult(Object.assign({}, this.progress), changedDocuments);
+        return {
+            progress: this.progress,
+            changedCollectionGroups: this.collectionGroups,
+            changedDocs
+        };
     }
 }
 /**
@@ -22564,9 +22791,9 @@ async function synchronizeViewAndComputeSnapshot(syncEngine, queryView) {
  * snapshots if needed.
  */
 // PORTING NOTE: Multi-Tab only.
-async function syncEngineSynchronizeWithChangedDocuments(syncEngine) {
+async function syncEngineSynchronizeWithChangedDocuments(syncEngine, collectionGroup) {
     const syncEngineImpl = debugCast(syncEngine);
-    return localStoreGetNewDocumentChanges(syncEngineImpl.localStore).then(changes => syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngineImpl, changes));
+    return localStoreGetNewDocumentChanges(syncEngineImpl.localStore, collectionGroup).then(changes => syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngineImpl, changes));
 }
 /** Applies a mutation state to an existing batch.  */
 // PORTING NOTE: Multi-Tab only.
@@ -22731,11 +22958,12 @@ async function syncEngineApplyTargetState(syncEngine, targetId, state, error) {
         logDebug(LOG_TAG$3, 'Ignoring unexpected query state notification.');
         return;
     }
-    if (syncEngineImpl.queriesByTarget.has(targetId)) {
+    const query = syncEngineImpl.queriesByTarget.get(targetId);
+    if (query && query.length > 0) {
         switch (state) {
             case 'current':
             case 'not-current': {
-                const changes = await localStoreGetNewDocumentChanges(syncEngineImpl.localStore);
+                const changes = await localStoreGetNewDocumentChanges(syncEngineImpl.localStore, queryCollectionGroup(query[0]));
                 const synthesizedRemoteEvent = RemoteEvent.createSynthesizedRemoteEventForCurrentChange(targetId, state === 'current');
                 await syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngineImpl, changes, synthesizedRemoteEvent);
                 break;
@@ -22818,10 +23046,11 @@ function syncEngineEnsureWriteCallbacks(syncEngine) {
 function syncEngineLoadBundle(syncEngine, bundleReader, task) {
     const syncEngineImpl = debugCast(syncEngine);
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    loadBundleImpl(syncEngineImpl, bundleReader, task).then(() => {
-        syncEngineImpl.sharedClientState.notifyBundleLoaded();
+    loadBundleImpl(syncEngineImpl, bundleReader, task).then(collectionGroups => {
+        syncEngineImpl.sharedClientState.notifyBundleLoaded(collectionGroups);
     });
 }
+/** Loads a bundle and returns the list of affected collection groups. */
 async function loadBundleImpl(syncEngine, reader, task) {
     try {
         const metadata = await reader.getMetadata();
@@ -22829,7 +23058,7 @@ async function loadBundleImpl(syncEngine, reader, task) {
         if (skip) {
             await reader.close();
             task._completeWith(bundleSuccessProgress(metadata));
-            return;
+            return Promise.resolve(new Set());
         }
         task._updateProgress(bundleInitialProgress(metadata));
         const loader = new BundleLoader(metadata, syncEngine.localStore, reader.serializer);
@@ -22843,18 +23072,17 @@ async function loadBundleImpl(syncEngine, reader, task) {
             element = await reader.nextElement();
         }
         const result = await loader.complete();
-        // TODO(b/160876443): This currently raises snapshots with
-        // `fromCache=false` if users already listen to some queries and bundles
-        // has newer version.
         await syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngine, result.changedDocs, 
         /* remoteEvent */ undefined);
         // Save metadata, so loading the same bundle will skip.
         await localStoreSaveBundle(syncEngine.localStore, metadata);
         task._completeWith(result.progress);
+        return Promise.resolve(result.changedCollectionGroups);
     }
     catch (e) {
         logWarn(LOG_TAG$3, `Loading bundle failed with ${e}`);
         task._failWith(e);
+        return Promise.resolve(new Set());
     }
 }
 
@@ -22923,7 +23151,6 @@ class IndexedDbOfflineComponentProvider extends MemoryOfflineComponentProvider {
     }
     async initialize(cfg) {
         await super.initialize(cfg);
-        await localStoreSynchronizeLastDocumentChangeReadTime(this.localStore);
         await this.onlineComponentProvider.initialize(this, cfg);
         // Enqueue writes from a previous session
         await syncEngineEnsureWriteCallbacks(this.onlineComponentProvider.syncEngine);