@firebase/firestore 3.4.4-canary.2dd99ae2d → 3.4.4-canary.3a8d4c1d1

package/dist/index.node.mjs

@@ -8,7 +8,7 @@ import { credentials, loadPackageDefinition, Metadata } from '@grpc/grpc-js';
 import { fromJSON } from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.4-canary.2dd99ae2d";
+const version$1 = "3.4.4-canary.3a8d4c1d1";
 
 /**
  * @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.5-canary.2dd99ae2d";
+const version = "9.6.6-canary.3a8d4c1d1";
 
 /**
  * @license
@@ -666,13 +666,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));
@@ -707,6 +713,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 {
@@ -1192,23 +1199,6 @@ function decodeResourcePath(path) {
     }
     return new ResourcePath(segments);
 }
-
-/**
- * @license
- * Copyright 2017 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.
- */
 /**
  * Schema Version for the Web client:
  * 1.  Initial version including Mutation Queue, Query Cache, and Remote
@@ -1227,8 +1217,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 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.
  */
@@ -1753,9 +1745,7 @@ class DbClientMetadata {
 DbClientMetadata.store = 'clientMetadata';
 /** Keys are automatically assigned via the clientId properties. */
 DbClientMetadata.keyPath = 'clientId';
-/**
- * A object representing a bundle loaded by the SDK.
- */
+/** An object representing a bundle loaded by the SDK. */
 class DbBundle {
     constructor(
     /** The ID of the loaded bundle. */
@@ -1772,9 +1762,7 @@ class DbBundle {
 /** Name of the IndexedDb object store. */
 DbBundle.store = 'bundles';
 DbBundle.keyPath = 'bundleId';
-/**
- * A object representing a named query loaded by the SDK via a bundle.
- */
+/** An object representing a named query loaded by the SDK via a bundle. */
 class DbNamedQuery {
     constructor(
     /** The name of the query. */
@@ -1791,6 +1779,158 @@ class DbNamedQuery {
 /** Name of the IndexedDb object store. */
 DbNamedQuery.store = 'namedQueries';
 DbNamedQuery.keyPath = 'name';
+/** An object representing the global configuration for a field index. */
+class DbIndexConfiguration {
+    constructor(
+    /**
+     * The index id for this entry. Undefined for indexes that are not yet
+     * persisted.
+     */
+    indexId, 
+    /** The collection group this index belongs to. */
+    collectionGroup, 
+    /** The fields to index for this index. */
+    fields) {
+        this.indexId = indexId;
+        this.collectionGroup = collectionGroup;
+        this.fields = fields;
+    }
+}
+/** 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.
+ */
+class DbIndexState {
+    constructor(
+    /** The index id for this entry. */
+    indexId, 
+    /** The user id for this entry. */
+    uid, 
+    /**
+     * A number that indicates when the index was last updated (relative to
+     * other indexes).
+     */
+    sequenceNumber, 
+    /**
+     * The latest read time that has been indexed by Firestore for this field
+     * index. Set to `{seconds: 0, nanos: 0}` if no documents have been indexed.
+     */
+    readTime, 
+    /**
+     * The last document that has been indexed for this field index. Empty if
+     * no documents have been indexed.
+     */
+    documentKey, 
+    /**
+     * The largest mutation batch id that has been processed for this index. -1
+     * if no mutations have been indexed.
+     */
+    largestBatchId) {
+        this.indexId = indexId;
+        this.uid = uid;
+        this.sequenceNumber = sequenceNumber;
+        this.readTime = readTime;
+        this.documentKey = documentKey;
+        this.largestBatchId = largestBatchId;
+    }
+}
+/** 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 DbIndexEntry {
+    constructor(
+    /** The index id for this entry. */
+    indexId, 
+    /** The user id for this entry. */
+    uid, 
+    /** The encoded array index value for this entry. */
+    arrayValue, 
+    /** The encoded directional value for equality and inequality filters. */
+    directionalValue, 
+    /** The document key this entry points to. */
+    documentKey) {
+        this.indexId = indexId;
+        this.uid = uid;
+        this.arrayValue = arrayValue;
+        this.directionalValue = directionalValue;
+        this.documentKey = documentKey;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbIndexEntry.store = 'indexEntries';
+DbIndexEntry.keyPath = [
+    'indexId',
+    'uid',
+    'arrayValue',
+    'directionalValue',
+    'documentKey'
+];
+DbIndexEntry.documentKeyIndex = 'documentKeyIndex';
+DbIndexEntry.documentKeyIndexPath = ['indexId', 'uid', '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,
@@ -1805,7 +1945,6 @@ const V1_STORES = [
 // V2 is no longer usable (see comment at top of file)
 // Visible for testing
 const V3_STORES = V1_STORES;
-// Visible for testing
 // Note: DbRemoteDocumentChanges is no longer used and dropped with v9.
 const V4_STORES = [...V3_STORES, DbClientMetadata.store];
 // V5 does not change the set of stores.
@@ -1815,12 +1954,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];
-/**
- * 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;
+const V12_STORES = [...V11_STORES, DbDocumentOverlay.store];
+const V13_STORES = [
+    ...V12_STORES,
+    DbIndexConfiguration.store,
+    DbIndexState.store,
+    DbIndexEntry.store
+];
+/** 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
@@ -2061,7 +2216,7 @@ class PersistencePromise {
  */
 // References to `window` are guarded by SimpleDb.isAvailable()
 /* eslint-disable no-restricted-globals */
-const LOG_TAG$g = 'SimpleDb';
+const LOG_TAG$h = 'SimpleDb';
 /**
  * The maximum number of retry attempts for an IndexedDb transaction that fails
  * with a DOMException.
@@ -2112,11 +2267,20 @@ class SimpleDbTransaction {
             this.completionDeferred.reject(error);
         }
         if (!this.aborted) {
-            logDebug(LOG_TAG$g, 'Aborting transaction:', error ? error.message : 'Client-initiated abort');
+            logDebug(LOG_TAG$h, 'Aborting transaction:', error ? error.message : 'Client-initiated abort');
             this.aborted = true;
             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
@@ -2166,7 +2330,7 @@ class SimpleDb {
     }
     /** Deletes the specified database. */
     static delete(name) {
-        logDebug(LOG_TAG$g, 'Removing database:', name);
+        logDebug(LOG_TAG$h, 'Removing database:', name);
         return wrapRequest(window.indexedDB.deleteDatabase(name)).toPromise();
     }
     /** Returns true if IndexedDB is available in the current environment. */
@@ -2245,7 +2409,7 @@ class SimpleDb {
      */
     async ensureDb(action) {
         if (!this.db) {
-            logDebug(LOG_TAG$g, 'Opening database:', this.name);
+            logDebug(LOG_TAG$h, 'Opening database:', this.name);
             this.db = await new Promise((resolve, reject) => {
                 // TODO(mikelehen): Investigate browser compatibility.
                 // https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB
@@ -2281,12 +2445,12 @@ class SimpleDb {
                     }
                 };
                 request.onupgradeneeded = (event) => {
-                    logDebug(LOG_TAG$g, 'Database "' + this.name + '" requires upgrade from version:', event.oldVersion);
+                    logDebug(LOG_TAG$h, 'Database "' + this.name + '" requires upgrade from version:', event.oldVersion);
                     const db = event.target.result;
                     this.schemaConverter
                         .createOrUpgrade(db, request.transaction, event.oldVersion, this.version)
                         .next(() => {
-                        logDebug(LOG_TAG$g, 'Database upgrade to version ' + this.version + ' complete');
+                        logDebug(LOG_TAG$h, 'Database upgrade to version ' + this.version + ' complete');
                     });
                 };
             });
@@ -2313,6 +2477,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);
@@ -2340,7 +2508,7 @@ class SimpleDb {
                 // exception is wrapped in a generic error by our async/await handling.
                 const retryable = error.name !== 'FirebaseError' &&
                     attemptNumber < TRANSACTION_RETRY_COUNT;
-                logDebug(LOG_TAG$g, 'Transaction failed with error:', error.message, 'Retrying:', retryable);
+                logDebug(LOG_TAG$h, 'Transaction failed with error:', error.message, 'Retrying:', retryable);
                 this.close();
                 if (!retryable) {
                     return Promise.reject(error);
@@ -2427,11 +2595,11 @@ class SimpleDbStore {
     put(keyOrValue, value) {
         let request;
         if (value !== undefined) {
-            logDebug(LOG_TAG$g, 'PUT', this.store.name, keyOrValue, value);
+            logDebug(LOG_TAG$h, 'PUT', this.store.name, keyOrValue, value);
             request = this.store.put(value, keyOrValue);
         }
         else {
-            logDebug(LOG_TAG$g, 'PUT', this.store.name, '<auto-key>', keyOrValue);
+            logDebug(LOG_TAG$h, 'PUT', this.store.name, '<auto-key>', keyOrValue);
             request = this.store.put(keyOrValue);
         }
         return wrapRequest(request);
@@ -2444,7 +2612,7 @@ class SimpleDbStore {
      * @returns The key of the value to add.
      */
     add(value) {
-        logDebug(LOG_TAG$g, 'ADD', this.store.name, value, value);
+        logDebug(LOG_TAG$h, 'ADD', this.store.name, value, value);
         const request = this.store.add(value);
         return wrapRequest(request);
     }
@@ -2464,12 +2632,12 @@ class SimpleDbStore {
             if (result === undefined) {
                 result = null;
             }
-            logDebug(LOG_TAG$g, 'GET', this.store.name, key, result);
+            logDebug(LOG_TAG$h, 'GET', this.store.name, key, result);
             return result;
         });
     }
     delete(key) {
-        logDebug(LOG_TAG$g, 'DELETE', this.store.name, key);
+        logDebug(LOG_TAG$h, 'DELETE', this.store.name, key);
         const request = this.store.delete(key);
         return wrapRequest(request);
     }
@@ -2480,21 +2648,37 @@ class SimpleDbStore {
      * Returns the number of rows in the store.
      */
     count() {
-        logDebug(LOG_TAG$g, 'COUNT', this.store.name);
+        logDebug(LOG_TAG$h, 'COUNT', this.store.name);
         const request = this.store.count();
         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);
+        logDebug(LOG_TAG$h, 'DELETE ALL', this.store.name);
         const options = this.options(indexOrRange, range);
         options.keysOnly = false;
         const cursor = this.cursor(options);
@@ -3517,11 +3701,22 @@ class DocumentKey {
     static empty() {
         return new DocumentKey(ResourcePath.emptyPath());
     }
+    get collectionGroup() {
+        return this.path.popLast().lastSegment();
+    }
     /** Returns true if the document is in the specified collectionId. */
     hasCollectionId(collectionId) {
         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);
     }
@@ -3561,6 +3756,13 @@ class DocumentKey {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const MAX_VALUE = {
+    mapValue: {
+        fields: {
+            '__type__': { stringValue: '__max___' }
+        }
+    }
+};
 /** Extracts the backend's type order for the provided value. */
 function typeOrder(value) {
     if ('nullValue' in value) {
@@ -3970,6 +4172,10 @@ function deepClone(source) {
     else {
         return Object.assign({}, source);
     }
+}
+/** Returns true if the Value represents the canonical {@link #MAX_VALUE} . */
+function isMaxValue(value) {
+    return valueEquals(value, MAX_VALUE);
 }
 
 /**
@@ -4345,17 +4551,25 @@ 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;
     }
 }
 /** An ID for an index that has not yet been added to persistence.  */
 FieldIndex.UNKNOWN_ID = -1;
+/** Returns the ArrayContains/ArrayContainsAny segment for this index. */
+function fieldIndexGetArraySegment(fieldIndex) {
+    return fieldIndex.fields.find(s => s.kind === 2 /* CONTAINS */);
+}
+/** Returns all directional (ascending/descending) segments for this index. */
+function fieldIndexGetDirectionalSegments(fieldIndex) {
+    return fieldIndex.fields.filter(s => s.kind !== 2 /* CONTAINS */);
+}
 /** An index component consisting of field path and index type.  */
 class IndexSegment {
     constructor(
@@ -4460,27 +4674,29 @@ function newTarget(path, collectionGroup = null, orderBy = [], filters = [], lim
 function canonifyTarget(target) {
     const targetImpl = debugCast(target);
     if (targetImpl.memoizedCanonicalId === null) {
-        let canonicalId = targetImpl.path.canonicalString();
+        let str = targetImpl.path.canonicalString();
         if (targetImpl.collectionGroup !== null) {
-            canonicalId += '|cg:' + targetImpl.collectionGroup;
+            str += '|cg:' + targetImpl.collectionGroup;
         }
-        canonicalId += '|f:';
-        canonicalId += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
-        canonicalId += '|ob:';
-        canonicalId += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
+        str += '|f:';
+        str += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
+        str += '|ob:';
+        str += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
         if (!isNullOrUndefined(targetImpl.limit)) {
-            canonicalId += '|l:';
-            canonicalId += targetImpl.limit;
+            str += '|l:';
+            str += targetImpl.limit;
         }
         if (targetImpl.startAt) {
-            canonicalId += '|lb:';
-            canonicalId += canonifyBound(targetImpl.startAt);
+            str += '|lb:';
+            str += targetImpl.startAt.inclusive ? 'b:' : 'a:';
+            str += targetImpl.startAt.position.map(p => canonicalId(p)).join(',');
         }
         if (targetImpl.endAt) {
-            canonicalId += '|ub:';
-            canonicalId += canonifyBound(targetImpl.endAt);
+            str += '|ub:';
+            str += targetImpl.endAt.inclusive ? 'a:' : 'b:';
+            str += targetImpl.endAt.position.map(p => canonicalId(p)).join(',');
         }
-        targetImpl.memoizedCanonicalId = canonicalId;
+        targetImpl.memoizedCanonicalId = str;
     }
     return targetImpl.memoizedCanonicalId;
 }
@@ -4503,10 +4719,14 @@ function stringifyTarget(target) {
             .join(', ')}]`;
     }
     if (target.startAt) {
-        str += ', startAt: ' + canonifyBound(target.startAt);
+        str += ', startAt: ';
+        str += target.startAt.inclusive ? 'b:' : 'a:';
+        str += target.startAt.position.map(p => canonicalId(p)).join(',');
     }
     if (target.endAt) {
-        str += ', endAt: ' + canonifyBound(target.endAt);
+        str += ', endAt: ';
+        str += target.endAt.inclusive ? 'a:' : 'b:';
+        str += target.endAt.position.map(p => canonicalId(p)).join(',');
     }
     return `Target(${str})`;
 }
@@ -4729,7 +4949,6 @@ class ArrayContainsAnyFilter extends FieldFilter {
         return other.arrayValue.values.some(val => arrayValueContains(this.value.arrayValue, val));
     }
 }
-// TODO(indexing): Change Bound.before to "inclusive"
 /**
  * Represents a bound of a query.
  *
@@ -4745,17 +4964,11 @@ class ArrayContainsAnyFilter extends FieldFilter {
  * just after the provided values.
  */
 class Bound {
-    constructor(position, before) {
+    constructor(position, inclusive) {
         this.position = position;
-        this.before = before;
+        this.inclusive = inclusive;
     }
 }
-function canonifyBound(bound) {
-    // TODO(b/29183165): Make this collision robust.
-    return `${bound.before ? 'b' : 'a'}:${bound.position
-        .map(p => canonicalId(p))
-        .join(',')}`;
-}
 /**
  * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
  */
@@ -4775,11 +4988,7 @@ function stringifyOrderBy(orderBy) {
 function orderByEquals(left, right) {
     return left.dir === right.dir && left.field.isEqual(right.field);
 }
-/**
- * Returns true if a document sorts before a bound using the provided sort
- * order.
- */
-function sortsBeforeDocument(bound, orderBy, doc) {
+function boundCompareToDocument(bound, orderBy, doc) {
     let comparison = 0;
     for (let i = 0; i < bound.position.length; i++) {
         const orderByComponent = orderBy[i];
@@ -4798,7 +5007,23 @@ function sortsBeforeDocument(bound, orderBy, doc) {
             break;
         }
     }
-    return bound.before ? comparison <= 0 : comparison < 0;
+    return comparison;
+}
+/**
+ * Returns true if a document sorts after a bound using the provided sort
+ * order.
+ */
+function boundSortsAfterDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison >= 0 : comparison > 0;
+}
+/**
+ * Returns true if a document sorts before a bound using the provided sort
+ * order.
+ */
+function boundSortsBeforeDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison <= 0 : comparison < 0;
 }
 function boundEquals(left, right) {
     if (left === null) {
@@ -4807,7 +5032,7 @@ function boundEquals(left, right) {
     else if (right === null) {
         return false;
     }
-    if (left.before !== right.before ||
+    if (left.inclusive !== right.inclusive ||
         left.position.length !== right.position.length) {
         return false;
     }
@@ -5011,10 +5236,10 @@ function queryToTarget(query) {
             }
             // We need to swap the cursors to match the now-flipped query ordering.
             const startAt = queryImpl.endAt
-                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.before)
+                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.inclusive)
                 : null;
             const endAt = queryImpl.startAt
-                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.before)
+                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.inclusive)
                 : null;
             // Now return as a LimitType.First query.
             queryImpl.memoizedTarget = newTarget(queryImpl.path, queryImpl.collectionGroup, orderBys, queryImpl.filters, queryImpl.limit, startAt, endAt);
@@ -5102,11 +5327,11 @@ function queryMatchesFilters(query, doc) {
 /** Makes sure a document is within the bounds, if provided. */
 function queryMatchesBounds(query, doc) {
     if (query.startAt &&
-        !sortsBeforeDocument(query.startAt, queryOrderBy(query), doc)) {
+        !boundSortsBeforeDocument(query.startAt, queryOrderBy(query), doc)) {
         return false;
     }
     if (query.endAt &&
-        sortsBeforeDocument(query.endAt, queryOrderBy(query), doc)) {
+        !boundSortsAfterDocument(query.endAt, queryOrderBy(query), doc)) {
         return false;
     }
     return true;
@@ -5761,6 +5986,72 @@ class SortedSetIterator {
     hasNext() {
         return this.iter.hasNext();
     }
+}
+/**
+ * Compares two sorted sets for equality using their natural ordering. The
+ * method computes the intersection and invokes `onAdd` for every element that
+ * is in `after` but not `before`. `onRemove` is invoked for every element in
+ * `before` but missing from `after`.
+ *
+ * The method creates a copy of both `before` and `after` and runs in O(n log
+ * n), where n is the size of the two lists.
+ *
+ * @param before - The elements that exist in the original set.
+ * @param after - The elements to diff against the original set.
+ * @param comparator - The comparator for the elements in before and after.
+ * @param onAdd - A function to invoke for every element that is part of `
+ * after` but not `before`.
+ * @param onRemove - A function to invoke for every element that is part of
+ * `before` but not `after`.
+ */
+function diffSortedSets(before, after, comparator, onAdd, onRemove) {
+    const beforeIt = before.getIterator();
+    const afterIt = after.getIterator();
+    let beforeValue = advanceIterator(beforeIt);
+    let afterValue = advanceIterator(afterIt);
+    // Walk through the two sets at the same time, using the ordering defined by
+    // `comparator`.
+    while (beforeValue || afterValue) {
+        let added = false;
+        let removed = false;
+        if (beforeValue && afterValue) {
+            const cmp = comparator(beforeValue, afterValue);
+            if (cmp < 0) {
+                // The element was removed if the next element in our ordered
+                // walkthrough is only in `before`.
+                removed = true;
+            }
+            else if (cmp > 0) {
+                // The element was added if the next element in our ordered walkthrough
+                // is only in `after`.
+                added = true;
+            }
+        }
+        else if (beforeValue != null) {
+            removed = true;
+        }
+        else {
+            added = true;
+        }
+        if (added) {
+            onAdd(afterValue);
+            afterValue = advanceIterator(afterIt);
+        }
+        else if (removed) {
+            onRemove(beforeValue);
+            beforeValue = advanceIterator(beforeIt);
+        }
+        else {
+            beforeValue = advanceIterator(beforeIt);
+            afterValue = advanceIterator(afterIt);
+        }
+    }
+}
+/**
+ * Returns the next element from the iterator or `undefined` if none available.
+ */
+function advanceIterator(it) {
+    return it.hasNext() ? it.getNext() : undefined;
 }
 
 /**
@@ -6599,6 +6890,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
@@ -7071,7 +7403,7 @@ class TargetState {
         this._current = true;
     }
 }
-const LOG_TAG$f = 'WatchChangeAggregator';
+const LOG_TAG$g = 'WatchChangeAggregator';
 /**
  * A helper class to accumulate watch changes into a RemoteEvent.
  */
@@ -7366,7 +7698,7 @@ class WatchChangeAggregator {
     isActiveTarget(targetId) {
         const targetActive = this.targetDataForActiveTarget(targetId) !== null;
         if (!targetActive) {
-            logDebug(LOG_TAG$f, 'Detected inactive target', targetId);
+            logDebug(LOG_TAG$g, 'Detected inactive target', targetId);
         }
         return targetActive;
     }
@@ -7985,10 +8317,10 @@ function toQueryTarget(serializer, target) {
         result.structuredQuery.limit = limit;
     }
     if (target.startAt) {
-        result.structuredQuery.startAt = toCursor(target.startAt);
+        result.structuredQuery.startAt = toStartAtCursor(target.startAt);
     }
     if (target.endAt) {
-        result.structuredQuery.endAt = toCursor(target.endAt);
+        result.structuredQuery.endAt = toEndAtCursor(target.endAt);
     }
     return result;
 }
@@ -8021,11 +8353,11 @@ function convertQueryTargetToQuery(target) {
     }
     let startAt = null;
     if (query.startAt) {
-        startAt = fromCursor(query.startAt);
+        startAt = fromStartAtCursor(query.startAt);
     }
     let endAt = null;
     if (query.endAt) {
-        endAt = fromCursor(query.endAt);
+        endAt = fromEndAtCursor(query.endAt);
     }
     return newQuery(path, collectionGroup, orderBy, filterBy, limit, "F" /* First */, startAt, endAt);
 }
@@ -8116,16 +8448,27 @@ function toOrder(orderBys) {
 function fromOrder(orderBys) {
     return orderBys.map(order => fromPropertyOrder(order));
 }
-function toCursor(cursor) {
+function toStartAtCursor(cursor) {
+    return {
+        before: cursor.inclusive,
+        values: cursor.position
+    };
+}
+function toEndAtCursor(cursor) {
     return {
-        before: cursor.before,
+        before: !cursor.inclusive,
         values: cursor.position
     };
 }
-function fromCursor(cursor) {
-    const before = !!cursor.before;
+function fromStartAtCursor(cursor) {
+    const inclusive = !!cursor.before;
     const position = cursor.values || [];
-    return new Bound(position, before);
+    return new Bound(position, inclusive);
+}
+function fromEndAtCursor(cursor) {
+    const inclusive = !cursor.before;
+    const position = cursor.values || [];
+    return new Bound(position, inclusive);
 }
 // visible for testing
 function toDirection(dir) {
@@ -8572,28 +8915,764 @@ function fromBundledQuery(bundledQuery) {
     if (bundledQuery.limitType === 'LAST') {
         return queryWithLimit(query, query.limit, "L" /* Last */);
     }
-    return query;
+    return query;
+}
+/** Encodes a NamedQuery proto object to a NamedQuery model object. */
+function fromProtoNamedQuery(namedQuery) {
+    return {
+        name: namedQuery.name,
+        query: fromBundledQuery(namedQuery.bundledQuery),
+        readTime: fromVersion(namedQuery.readTime)
+    };
+}
+/** Decodes a BundleMetadata proto into a BundleMetadata object. */
+function fromBundleMetadata(metadata) {
+    return {
+        id: metadata.id,
+        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);
+}
+
+/**
+ * @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 IndexedDbBundleCache {
+    getBundleMetadata(transaction, bundleId) {
+        return bundlesStore(transaction)
+            .get(bundleId)
+            .next(bundle => {
+            if (bundle) {
+                return fromDbBundle(bundle);
+            }
+            return undefined;
+        });
+    }
+    saveBundleMetadata(transaction, bundleMetadata) {
+        return bundlesStore(transaction).put(toDbBundle(bundleMetadata));
+    }
+    getNamedQuery(transaction, queryName) {
+        return namedQueriesStore(transaction)
+            .get(queryName)
+            .next(query => {
+            if (query) {
+                return fromDbNamedQuery(query);
+            }
+            return undefined;
+        });
+    }
+    saveNamedQuery(transaction, query) {
+        return namedQueriesStore(transaction).put(toDbNamedQuery(query));
+    }
+}
+/**
+ * Helper to get a typed SimpleDbStore for the bundles object store.
+ */
+function bundlesStore(txn) {
+    return getStore(txn, DbBundle.store);
+}
+/**
+ * Helper to get a typed SimpleDbStore for the namedQueries object store.
+ */
+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 2021 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.
+ */
+// Note: This code is copied from the backend. Code that is not used by
+// Firestore was removed.
+const INDEX_TYPE_NULL = 5;
+const INDEX_TYPE_BOOLEAN = 10;
+const INDEX_TYPE_NAN = 13;
+const INDEX_TYPE_NUMBER = 15;
+const INDEX_TYPE_TIMESTAMP = 20;
+const INDEX_TYPE_STRING = 25;
+const INDEX_TYPE_BLOB = 30;
+const INDEX_TYPE_REFERENCE = 37;
+const INDEX_TYPE_GEOPOINT = 45;
+const INDEX_TYPE_ARRAY = 50;
+const INDEX_TYPE_MAP = 55;
+const INDEX_TYPE_REFERENCE_SEGMENT = 60;
+// A terminator that indicates that a truncatable value was not truncated.
+// This must be smaller than all other type labels.
+const NOT_TRUNCATED = 2;
+/** Firestore index value writer.  */
+class FirestoreIndexValueWriter {
+    constructor() { }
+    // The write methods below short-circuit writing terminators for values
+    // containing a (terminating) truncated value.
+    //
+    // As an example, consider the resulting encoding for:
+    //
+    // ["bar", [2, "foo"]] -> (STRING, "bar", TERM, ARRAY, NUMBER, 2, STRING, "foo", TERM, TERM, TERM)
+    // ["bar", [2, truncated("foo")]] -> (STRING, "bar", TERM, ARRAY, NUMBER, 2, STRING, "foo", TRUNC)
+    // ["bar", truncated(["foo"])] -> (STRING, "bar", TERM, ARRAY. STRING, "foo", TERM, TRUNC)
+    /** Writes an index value.  */
+    writeIndexValue(value, encoder) {
+        this.writeIndexValueAux(value, encoder);
+        // Write separator to split index values
+        // (see go/firestore-storage-format#encodings).
+        encoder.writeInfinity();
+    }
+    writeIndexValueAux(indexValue, encoder) {
+        if ('nullValue' in indexValue) {
+            this.writeValueTypeLabel(encoder, INDEX_TYPE_NULL);
+        }
+        else if ('booleanValue' in indexValue) {
+            this.writeValueTypeLabel(encoder, INDEX_TYPE_BOOLEAN);
+            encoder.writeNumber(indexValue.booleanValue ? 1 : 0);
+        }
+        else if ('integerValue' in indexValue) {
+            this.writeValueTypeLabel(encoder, INDEX_TYPE_NUMBER);
+            encoder.writeNumber(normalizeNumber(indexValue.integerValue));
+        }
+        else if ('doubleValue' in indexValue) {
+            const n = normalizeNumber(indexValue.doubleValue);
+            if (isNaN(n)) {
+                this.writeValueTypeLabel(encoder, INDEX_TYPE_NAN);
+            }
+            else {
+                this.writeValueTypeLabel(encoder, INDEX_TYPE_NUMBER);
+                if (isNegativeZero(n)) {
+                    // -0.0, 0 and 0.0 are all considered the same
+                    encoder.writeNumber(0.0);
+                }
+                else {
+                    encoder.writeNumber(n);
+                }
+            }
+        }
+        else if ('timestampValue' in indexValue) {
+            const timestamp = indexValue.timestampValue;
+            this.writeValueTypeLabel(encoder, INDEX_TYPE_TIMESTAMP);
+            if (typeof timestamp === 'string') {
+                encoder.writeString(timestamp);
+            }
+            else {
+                encoder.writeString(`${timestamp.seconds || ''}`);
+                encoder.writeNumber(timestamp.nanos || 0);
+            }
+        }
+        else if ('stringValue' in indexValue) {
+            this.writeIndexString(indexValue.stringValue, encoder);
+            this.writeTruncationMarker(encoder);
+        }
+        else if ('bytesValue' in indexValue) {
+            this.writeValueTypeLabel(encoder, INDEX_TYPE_BLOB);
+            encoder.writeBytes(normalizeByteString(indexValue.bytesValue));
+            this.writeTruncationMarker(encoder);
+        }
+        else if ('referenceValue' in indexValue) {
+            this.writeIndexEntityRef(indexValue.referenceValue, encoder);
+        }
+        else if ('geoPointValue' in indexValue) {
+            const geoPoint = indexValue.geoPointValue;
+            this.writeValueTypeLabel(encoder, INDEX_TYPE_GEOPOINT);
+            encoder.writeNumber(geoPoint.latitude || 0);
+            encoder.writeNumber(geoPoint.longitude || 0);
+        }
+        else if ('mapValue' in indexValue) {
+            if (isMaxValue(indexValue)) {
+                this.writeValueTypeLabel(encoder, Number.MAX_SAFE_INTEGER);
+            }
+            else {
+                this.writeIndexMap(indexValue.mapValue, encoder);
+                this.writeTruncationMarker(encoder);
+            }
+        }
+        else if ('arrayValue' in indexValue) {
+            this.writeIndexArray(indexValue.arrayValue, encoder);
+            this.writeTruncationMarker(encoder);
+        }
+        else {
+            fail();
+        }
+    }
+    writeIndexString(stringIndexValue, encoder) {
+        this.writeValueTypeLabel(encoder, INDEX_TYPE_STRING);
+        this.writeUnlabeledIndexString(stringIndexValue, encoder);
+    }
+    writeUnlabeledIndexString(stringIndexValue, encoder) {
+        encoder.writeString(stringIndexValue);
+    }
+    writeIndexMap(mapIndexValue, encoder) {
+        const map = mapIndexValue.fields || {};
+        this.writeValueTypeLabel(encoder, INDEX_TYPE_MAP);
+        for (const key of Object.keys(map)) {
+            this.writeIndexString(key, encoder);
+            this.writeIndexValueAux(map[key], encoder);
+        }
+    }
+    writeIndexArray(arrayIndexValue, encoder) {
+        const values = arrayIndexValue.values || [];
+        this.writeValueTypeLabel(encoder, INDEX_TYPE_ARRAY);
+        for (const element of values) {
+            this.writeIndexValueAux(element, encoder);
+        }
+    }
+    writeIndexEntityRef(referenceValue, encoder) {
+        this.writeValueTypeLabel(encoder, INDEX_TYPE_REFERENCE);
+        const path = DocumentKey.fromName(referenceValue).path;
+        path.forEach(segment => {
+            this.writeValueTypeLabel(encoder, INDEX_TYPE_REFERENCE_SEGMENT);
+            this.writeUnlabeledIndexString(segment, encoder);
+        });
+    }
+    writeValueTypeLabel(encoder, typeOrder) {
+        encoder.writeNumber(typeOrder);
+    }
+    writeTruncationMarker(encoder) {
+        // While the SDK does not implement truncation, the truncation marker is
+        // used to terminate all variable length values (which are strings, bytes,
+        // references, arrays and maps).
+        encoder.writeNumber(NOT_TRUNCATED);
+    }
+}
+FirestoreIndexValueWriter.INSTANCE = new FirestoreIndexValueWriter();
+
+/**
+ * @license
+ * Copyright 2021 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 | agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES | CONDITIONS OF ANY KIND, either express | implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** These constants are taken from the backend. */
+const MIN_SURROGATE = '\uD800';
+const MAX_SURROGATE = '\uDBFF';
+const ESCAPE1 = 0x00;
+const NULL_BYTE = 0xff; // Combined with ESCAPE1
+const SEPARATOR = 0x01; // Combined with ESCAPE1
+const ESCAPE2 = 0xff;
+const INFINITY = 0xff; // Combined with ESCAPE2
+const FF_BYTE = 0x00; // Combined with ESCAPE2
+const LONG_SIZE = 64;
+const BYTE_SIZE = 8;
+/**
+ * The default size of the buffer. This is arbitrary, but likely larger than
+ * most index values so that less copies of the underlying buffer will be made.
+ * For large values, a single copy will made to double the buffer length.
+ */
+const DEFAULT_BUFFER_SIZE = 1024;
+/** Converts a JavaScript number to a byte array (using big endian encoding). */
+function doubleToLongBits(value) {
+    const dv = new DataView(new ArrayBuffer(8));
+    dv.setFloat64(0, value, /* littleEndian= */ false);
+    return new Uint8Array(dv.buffer);
+}
+/**
+ * Counts the number of zeros in a byte.
+ *
+ * Visible for testing.
+ */
+function numberOfLeadingZerosInByte(x) {
+    if (x === 0) {
+        return 8;
+    }
+    let zeros = 0;
+    if (x >> 4 === 0) {
+        // Test if the first four bits are zero.
+        zeros += 4;
+        x = x << 4;
+    }
+    if (x >> 6 === 0) {
+        // Test if the first two (or next two) bits are zero.
+        zeros += 2;
+        x = x << 2;
+    }
+    if (x >> 7 === 0) {
+        // Test if the remaining bit is zero.
+        zeros += 1;
+    }
+    return zeros;
+}
+/** Counts the number of leading zeros in the given byte array. */
+function numberOfLeadingZeros(bytes) {
+    let leadingZeros = 0;
+    for (let i = 0; i < 8; ++i) {
+        const zeros = numberOfLeadingZerosInByte(bytes[i] & 0xff);
+        leadingZeros += zeros;
+        if (zeros !== 8) {
+            break;
+        }
+    }
+    return leadingZeros;
+}
+/**
+ * Returns the number of bytes required to store "value". Leading zero bytes
+ * are skipped.
+ */
+function unsignedNumLength(value) {
+    // This is just the number of bytes for the unsigned representation of the number.
+    const numBits = LONG_SIZE - numberOfLeadingZeros(value);
+    return Math.ceil(numBits / BYTE_SIZE);
+}
+/**
+ * OrderedCodeWriter is a minimal-allocation implementation of the writing
+ * behavior defined by the backend.
+ *
+ * The code is ported from its Java counterpart.
+ */
+class OrderedCodeWriter {
+    constructor() {
+        this.buffer = new Uint8Array(DEFAULT_BUFFER_SIZE);
+        this.position = 0;
+    }
+    writeBytesAscending(value) {
+        const it = value[Symbol.iterator]();
+        let byte = it.next();
+        while (!byte.done) {
+            this.writeByteAscending(byte.value);
+            byte = it.next();
+        }
+        this.writeSeparatorAscending();
+    }
+    writeBytesDescending(value) {
+        const it = value[Symbol.iterator]();
+        let byte = it.next();
+        while (!byte.done) {
+            this.writeByteDescending(byte.value);
+            byte = it.next();
+        }
+        this.writeSeparatorDescending();
+    }
+    /** Writes utf8 bytes into this byte sequence, ascending. */
+    writeUtf8Ascending(sequence) {
+        for (const c of sequence) {
+            const charCode = c.charCodeAt(0);
+            if (charCode < 0x80) {
+                this.writeByteAscending(charCode);
+            }
+            else if (charCode < 0x800) {
+                this.writeByteAscending((0x0f << 6) | (charCode >>> 6));
+                this.writeByteAscending(0x80 | (0x3f & charCode));
+            }
+            else if (c < MIN_SURROGATE || MAX_SURROGATE < c) {
+                this.writeByteAscending((0x0f << 5) | (charCode >>> 12));
+                this.writeByteAscending(0x80 | (0x3f & (charCode >>> 6)));
+                this.writeByteAscending(0x80 | (0x3f & charCode));
+            }
+            else {
+                const codePoint = c.codePointAt(0);
+                this.writeByteAscending((0x0f << 4) | (codePoint >>> 18));
+                this.writeByteAscending(0x80 | (0x3f & (codePoint >>> 12)));
+                this.writeByteAscending(0x80 | (0x3f & (codePoint >>> 6)));
+                this.writeByteAscending(0x80 | (0x3f & codePoint));
+            }
+        }
+        this.writeSeparatorAscending();
+    }
+    /** Writes utf8 bytes into this byte sequence, descending */
+    writeUtf8Descending(sequence) {
+        for (const c of sequence) {
+            const charCode = c.charCodeAt(0);
+            if (charCode < 0x80) {
+                this.writeByteDescending(charCode);
+            }
+            else if (charCode < 0x800) {
+                this.writeByteDescending((0x0f << 6) | (charCode >>> 6));
+                this.writeByteDescending(0x80 | (0x3f & charCode));
+            }
+            else if (c < MIN_SURROGATE || MAX_SURROGATE < c) {
+                this.writeByteDescending((0x0f << 5) | (charCode >>> 12));
+                this.writeByteDescending(0x80 | (0x3f & (charCode >>> 6)));
+                this.writeByteDescending(0x80 | (0x3f & charCode));
+            }
+            else {
+                const codePoint = c.codePointAt(0);
+                this.writeByteDescending((0x0f << 4) | (codePoint >>> 18));
+                this.writeByteDescending(0x80 | (0x3f & (codePoint >>> 12)));
+                this.writeByteDescending(0x80 | (0x3f & (codePoint >>> 6)));
+                this.writeByteDescending(0x80 | (0x3f & codePoint));
+            }
+        }
+        this.writeSeparatorDescending();
+    }
+    writeNumberAscending(val) {
+        // Values are encoded with a single byte length prefix, followed by the
+        // actual value in big-endian format with leading 0 bytes dropped.
+        const value = this.toOrderedBits(val);
+        const len = unsignedNumLength(value);
+        this.ensureAvailable(1 + len);
+        this.buffer[this.position++] = len & 0xff; // Write the length
+        for (let i = value.length - len; i < value.length; ++i) {
+            this.buffer[this.position++] = value[i] & 0xff;
+        }
+    }
+    writeNumberDescending(val) {
+        // Values are encoded with a single byte length prefix, followed by the
+        // inverted value in big-endian format with leading 0 bytes dropped.
+        const value = this.toOrderedBits(val);
+        const len = unsignedNumLength(value);
+        this.ensureAvailable(1 + len);
+        this.buffer[this.position++] = ~(len & 0xff); // Write the length
+        for (let i = value.length - len; i < value.length; ++i) {
+            this.buffer[this.position++] = ~(value[i] & 0xff);
+        }
+    }
+    /**
+     * Writes the "infinity" byte sequence that sorts after all other byte
+     * sequences written in ascending order.
+     */
+    writeInfinityAscending() {
+        this.writeEscapedByteAscending(ESCAPE2);
+        this.writeEscapedByteAscending(INFINITY);
+    }
+    /**
+     * Writes the "infinity" byte sequence that sorts before all other byte
+     * sequences written in descending order.
+     */
+    writeInfinityDescending() {
+        this.writeEscapedByteDescending(ESCAPE2);
+        this.writeEscapedByteDescending(INFINITY);
+    }
+    /**
+     * Resets the buffer such that it is the same as when it was newly
+     * constructed.
+     */
+    reset() {
+        this.position = 0;
+    }
+    seed(encodedBytes) {
+        this.ensureAvailable(encodedBytes.length);
+        this.buffer.set(encodedBytes, this.position);
+        this.position += encodedBytes.length;
+    }
+    /** Makes a copy of the encoded bytes in this buffer.  */
+    encodedBytes() {
+        return this.buffer.slice(0, this.position);
+    }
+    /**
+     * Encodes `val` into an encoding so that the order matches the IEEE 754
+     * floating-point comparison results with the following exceptions:
+     *   -0.0 < 0.0
+     *   all non-NaN < NaN
+     *   NaN = NaN
+     */
+    toOrderedBits(val) {
+        const value = doubleToLongBits(val);
+        // Check if the first bit is set. We use a bit mask since value[0] is
+        // encoded as a number from 0 to 255.
+        const isNegative = (value[0] & 0x80) !== 0;
+        // Revert the two complement to get natural ordering
+        value[0] ^= isNegative ? 0xff : 0x80;
+        for (let i = 1; i < value.length; ++i) {
+            value[i] ^= isNegative ? 0xff : 0x00;
+        }
+        return value;
+    }
+    /** Writes a single byte ascending to the buffer. */
+    writeByteAscending(b) {
+        const masked = b & 0xff;
+        if (masked === ESCAPE1) {
+            this.writeEscapedByteAscending(ESCAPE1);
+            this.writeEscapedByteAscending(NULL_BYTE);
+        }
+        else if (masked === ESCAPE2) {
+            this.writeEscapedByteAscending(ESCAPE2);
+            this.writeEscapedByteAscending(FF_BYTE);
+        }
+        else {
+            this.writeEscapedByteAscending(masked);
+        }
+    }
+    /** Writes a single byte descending to the buffer.  */
+    writeByteDescending(b) {
+        const masked = b & 0xff;
+        if (masked === ESCAPE1) {
+            this.writeEscapedByteDescending(ESCAPE1);
+            this.writeEscapedByteDescending(NULL_BYTE);
+        }
+        else if (masked === ESCAPE2) {
+            this.writeEscapedByteDescending(ESCAPE2);
+            this.writeEscapedByteDescending(FF_BYTE);
+        }
+        else {
+            this.writeEscapedByteDescending(b);
+        }
+    }
+    writeSeparatorAscending() {
+        this.writeEscapedByteAscending(ESCAPE1);
+        this.writeEscapedByteAscending(SEPARATOR);
+    }
+    writeSeparatorDescending() {
+        this.writeEscapedByteDescending(ESCAPE1);
+        this.writeEscapedByteDescending(SEPARATOR);
+    }
+    writeEscapedByteAscending(b) {
+        this.ensureAvailable(1);
+        this.buffer[this.position++] = b;
+    }
+    writeEscapedByteDescending(b) {
+        this.ensureAvailable(1);
+        this.buffer[this.position++] = ~b;
+    }
+    ensureAvailable(bytes) {
+        const minCapacity = bytes + this.position;
+        if (minCapacity <= this.buffer.length) {
+            return;
+        }
+        // Try doubling.
+        let newLength = this.buffer.length * 2;
+        // Still not big enough? Just allocate the right size.
+        if (newLength < minCapacity) {
+            newLength = minCapacity;
+        }
+        // Create the new buffer.
+        const newBuffer = new Uint8Array(newLength);
+        newBuffer.set(this.buffer); // copy old data
+        this.buffer = newBuffer;
+    }
+}
+
+class AscendingIndexByteEncoder {
+    constructor(orderedCode) {
+        this.orderedCode = orderedCode;
+    }
+    writeBytes(value) {
+        this.orderedCode.writeBytesAscending(value);
+    }
+    writeString(value) {
+        this.orderedCode.writeUtf8Ascending(value);
+    }
+    writeNumber(value) {
+        this.orderedCode.writeNumberAscending(value);
+    }
+    writeInfinity() {
+        this.orderedCode.writeInfinityAscending();
+    }
 }
-/** Encodes a NamedQuery proto object to a NamedQuery model object. */
-function fromProtoNamedQuery(namedQuery) {
-    return {
-        name: namedQuery.name,
-        query: fromBundledQuery(namedQuery.bundledQuery),
-        readTime: fromVersion(namedQuery.readTime)
-    };
+class DescendingIndexByteEncoder {
+    constructor(orderedCode) {
+        this.orderedCode = orderedCode;
+    }
+    writeBytes(value) {
+        this.orderedCode.writeBytesDescending(value);
+    }
+    writeString(value) {
+        this.orderedCode.writeUtf8Descending(value);
+    }
+    writeNumber(value) {
+        this.orderedCode.writeNumberDescending(value);
+    }
+    writeInfinity() {
+        this.orderedCode.writeInfinityDescending();
+    }
 }
-/** Decodes a BundleMetadata proto into a BundleMetadata object. */
-function fromBundleMetadata(metadata) {
-    return {
-        id: metadata.id,
-        version: metadata.version,
-        createTime: fromVersion(metadata.createTime)
-    };
+/**
+ * Implements `DirectionalIndexByteEncoder` using `OrderedCodeWriter` for the
+ * actual encoding.
+ */
+class IndexByteEncoder {
+    constructor() {
+        this.orderedCode = new OrderedCodeWriter();
+        this.ascending = new AscendingIndexByteEncoder(this.orderedCode);
+        this.descending = new DescendingIndexByteEncoder(this.orderedCode);
+    }
+    seed(encodedBytes) {
+        this.orderedCode.seed(encodedBytes);
+    }
+    forKind(kind) {
+        return kind === 0 /* ASCENDING */ ? this.ascending : this.descending;
+    }
+    encodedBytes() {
+        return this.orderedCode.encodedBytes();
+    }
+    reset() {
+        this.orderedCode.reset();
+    }
 }
 
 /**
  * @license
- * Copyright 2020 Google LLC
+ * 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.
@@ -8607,45 +9686,38 @@ function fromBundleMetadata(metadata) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class IndexedDbBundleCache {
-    getBundleMetadata(transaction, bundleId) {
-        return bundlesStore(transaction)
-            .get(bundleId)
-            .next(bundle => {
-            if (bundle) {
-                return fromDbBundle(bundle);
-            }
-            return undefined;
-        });
+/** Represents an index entry saved by the SDK in persisted storage. */
+class IndexEntry {
+    constructor(indexId, documentKey, arrayValue, directionalValue) {
+        this.indexId = indexId;
+        this.documentKey = documentKey;
+        this.arrayValue = arrayValue;
+        this.directionalValue = directionalValue;
     }
-    saveBundleMetadata(transaction, bundleMetadata) {
-        return bundlesStore(transaction).put(toDbBundle(bundleMetadata));
+}
+function indexEntryComparator(left, right) {
+    let cmp = left.indexId - right.indexId;
+    if (cmp !== 0) {
+        return cmp;
     }
-    getNamedQuery(transaction, queryName) {
-        return namedQueriesStore(transaction)
-            .get(queryName)
-            .next(query => {
-            if (query) {
-                return fromDbNamedQuery(query);
-            }
-            return undefined;
-        });
+    cmp = DocumentKey.comparator(left.documentKey, right.documentKey);
+    if (cmp !== 0) {
+        return cmp;
     }
-    saveNamedQuery(transaction, query) {
-        return namedQueriesStore(transaction).put(toDbNamedQuery(query));
+    cmp = compareByteArrays(left.arrayValue, right.arrayValue);
+    if (cmp !== 0) {
+        return cmp;
     }
+    return compareByteArrays(left.directionalValue, right.directionalValue);
 }
-/**
- * Helper to get a typed SimpleDbStore for the bundles object store.
- */
-function bundlesStore(txn) {
-    return getStore(txn, DbBundle.store);
-}
-/**
- * Helper to get a typed SimpleDbStore for the namedQueries object store.
- */
-function namedQueriesStore(txn) {
-    return getStore(txn, DbNamedQuery.store);
+function compareByteArrays(left, right) {
+    for (let i = 0; i < left.length && i < right.length; ++i) {
+        const compare = left[i] - right[i];
+        if (compare !== 0) {
+            return compare;
+        }
+    }
+    return left.length - right.length;
 }
 
 /**
@@ -8678,6 +9750,38 @@ class MemoryIndexManager {
     getCollectionParents(transaction, collectionId) {
         return PersistencePromise.resolve(this.collectionParentIndex.getEntries(collectionId));
     }
+    addFieldIndex(transaction, index) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
+    deleteFieldIndex(transaction, index) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
+    getDocumentsMatchingTarget(transaction, fieldIndex, target) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve(documentKeySet());
+    }
+    getFieldIndex(transaction, target) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve(null);
+    }
+    getFieldIndexes(transaction, collectionGroup) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve([]);
+    }
+    getNextCollectionGroupToUpdate(transaction) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve(null);
+    }
+    updateCollectionGroup(transaction, collectionGroup, offset) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
+    updateIndexEntries(transaction, documents) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
 }
 /**
  * Internal implementation of the collection-parent index exposed by MemoryIndexManager.
@@ -8727,19 +9831,25 @@ class MemoryCollectionParentIndex {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const LOG_TAG$f = 'IndexedDbIndexManager';
 /**
  * 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.
@@ -8786,6 +9896,198 @@ class IndexedDbIndexManager {
             return parentPaths;
         });
     }
+    addFieldIndex(transaction, index) {
+        // 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) {
+        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
+        return PersistencePromise.resolve(documentKeySet());
+    }
+    getFieldIndex(transaction, target) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve(null);
+    }
+    /**
+     * Returns the byte encoded form of the directional values in the field index.
+     * Returns `null` if the document does not have all fields specified in the
+     * index.
+     */
+    encodeDirectionalElements(fieldIndex, document) {
+        const encoder = new IndexByteEncoder();
+        for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+            const field = document.data.field(segment.fieldPath);
+            if (field == null) {
+                return null;
+            }
+            const directionalEncoder = encoder.forKind(segment.kind);
+            FirestoreIndexValueWriter.INSTANCE.writeIndexValue(field, directionalEncoder);
+        }
+        return encoder.encodedBytes();
+    }
+    /** Encodes a single value to the ascending index format. */
+    encodeSingleElement(value) {
+        const encoder = new IndexByteEncoder();
+        FirestoreIndexValueWriter.INSTANCE.writeIndexValue(value, encoder.forKind(0 /* ASCENDING */));
+        return encoder.encodedBytes();
+    }
+    getFieldIndexes(transaction, collectionGroup) {
+        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) {
+        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) {
+        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) {
+        // Porting Note: `getFieldIndexes()` on Web does not cache index lookups as
+        // it could be used across different IndexedDB transactions. As any cached
+        // data might be invalidated by other multi-tab clients, we can only trust
+        // data within a single IndexedDB transaction. We therefore add a cache
+        // here.
+        const memoizedIndexes = new Map();
+        return PersistencePromise.forEach(documents, (key, doc) => {
+            const memoizedCollectionIndexes = memoizedIndexes.get(key.collectionGroup);
+            const fieldIndexes = memoizedCollectionIndexes
+                ? PersistencePromise.resolve(memoizedCollectionIndexes)
+                : this.getFieldIndexes(transaction, key.collectionGroup);
+            return fieldIndexes.next(fieldIndexes => {
+                memoizedIndexes.set(key.collectionGroup, fieldIndexes);
+                return PersistencePromise.forEach(fieldIndexes, (fieldIndex) => {
+                    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 PersistencePromise.resolve();
+                    });
+                });
+            });
+        });
+    }
+    addIndexEntry(transaction, document, indexEntry) {
+        const indexEntries = indexEntriesStore(transaction);
+        return indexEntries.put(new DbIndexEntry(indexEntry.indexId, this.uid, indexEntry.arrayValue, indexEntry.directionalValue, encodeResourcePath(document.key.path)));
+    }
+    deleteIndexEntry(transaction, document, indexEntry) {
+        const indexEntries = indexEntriesStore(transaction);
+        return indexEntries.delete([
+            indexEntry.indexId,
+            this.uid,
+            indexEntry.arrayValue,
+            indexEntry.directionalValue,
+            encodeResourcePath(document.key.path)
+        ]);
+    }
+    getExistingIndexEntries(transaction, documentKey, fieldIndex) {
+        const indexEntries = indexEntriesStore(transaction);
+        let results = new SortedSet(indexEntryComparator);
+        return indexEntries
+            .iterate({
+            index: DbIndexEntry.documentKeyIndex,
+            range: IDBKeyRange.only([
+                fieldIndex.indexId,
+                this.uid,
+                encodeResourcePath(documentKey.path)
+            ])
+        }, (_, entry) => {
+            results = results.add(new IndexEntry(fieldIndex.indexId, documentKey, entry.arrayValue, entry.directionalValue));
+        })
+            .next(() => results);
+    }
+    /** Creates the index entries for the given document. */
+    computeIndexEntries(document, fieldIndex) {
+        let results = new SortedSet(indexEntryComparator);
+        const directionalValue = this.encodeDirectionalElements(fieldIndex, document);
+        if (directionalValue == null) {
+            return results;
+        }
+        const arraySegment = fieldIndexGetArraySegment(fieldIndex);
+        if (arraySegment != null) {
+            const value = document.data.field(arraySegment.fieldPath);
+            if (isArray(value)) {
+                for (const arrayValue of value.arrayValue.values || []) {
+                    results = results.add(new IndexEntry(fieldIndex.indexId, document.key, this.encodeSingleElement(arrayValue), directionalValue));
+                }
+            }
+        }
+        else {
+            results = results.add(new IndexEntry(fieldIndex.indexId, document.key, new Uint8Array(), directionalValue));
+        }
+        return results;
+    }
+    /**
+     * Updates the index entries for the provided document by deleting entries
+     * that are no longer referenced in `newEntries` and adding all newly added
+     * entries.
+     */
+    updateEntries(transaction, document, 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));
+        }, 
+        /* onRemove= */ entry => {
+            promises.push(this.deleteIndexEntry(transaction, document, entry));
+        });
+        return PersistencePromise.waitFor(promises);
+    }
+    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
@@ -8793,6 +10095,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);
 }
 
 /**
@@ -10262,12 +11582,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;
     }
     /**
@@ -10389,21 +11707,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);
@@ -10420,12 +11738,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);
     }
@@ -10463,14 +11781,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
@@ -10637,9 +11950,6 @@ class SchemaConverter {
      * and local feature development.
      */
     createOrUpgrade(db, txn, fromVersion, toVersion) {
-        hardAssert(fromVersion < toVersion &&
-            fromVersion >= 0 &&
-            toVersion <= SCHEMA_VERSION);
         const simpleDbTransaction = new SimpleDbTransaction('createOrUpgrade', txn);
         if (fromVersion < 1 && toVersion >= 1) {
             createPrimaryClientStore(db);
@@ -10706,6 +12016,16 @@ class SchemaConverter {
                 createNamedQueriesStore(db);
             });
         }
+        if (fromVersion < 12 && toVersion >= 12) {
+            p = p.next(() => {
+                createDocumentOverlayStore(db);
+            });
+        }
+        if (fromVersion < 13 && toVersion >= 13) {
+            p = p.next(() => {
+                createFieldIndex(db);
+            });
+        }
         return p;
     }
     addDocumentGlobal(txn) {
@@ -10912,6 +12232,28 @@ function createNamedQueriesStore(db) {
     db.createObjectStore(DbNamedQuery.store, {
         keyPath: DbNamedQuery.keyPath
     });
+}
+function createFieldIndex(db) {
+    const indexConfiguratioStore = db.createObjectStore(DbIndexConfiguration.store, {
+        keyPath: DbIndexConfiguration.keyPath,
+        autoIncrement: true
+    });
+    indexConfiguratioStore.createIndex(DbIndexConfiguration.collectionGroupIndex, DbIndexConfiguration.collectionGroupIndexPath, { unique: false });
+    const indexStateStore = db.createObjectStore(DbIndexState.store, {
+        keyPath: DbIndexState.keyPath
+    });
+    indexStateStore.createIndex(DbIndexState.sequenceNumberIndex, DbIndexState.sequenceNumberIndexPath, { unique: false });
+    const indexEntryStore = db.createObjectStore(DbIndexEntry.store, {
+        keyPath: DbIndexEntry.keyPath
+    });
+    indexEntryStore.createIndex(DbIndexEntry.documentKeyIndex, DbIndexEntry.documentKeyIndexPath, { unique: false });
+}
+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 });
 }
 
 /**
@@ -11023,7 +12365,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;
@@ -11032,6 +12374,7 @@ class IndexedDbPersistence {
         this.document = document;
         this.sequenceNumberSyncer = sequenceNumberSyncer;
         this.forceOwningTab = forceOwningTab;
+        this.schemaVersion = schemaVersion;
         this.listenSequence = null;
         this._started = false;
         this.isPrimary = false;
@@ -11053,10 +12396,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;
@@ -11392,8 +12734,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;
@@ -11401,8 +12743,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;
@@ -11410,11 +12755,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);
@@ -11786,39 +13132,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
@@ -11831,29 +13166,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;
-        });
-    }
 }
 
 /**
@@ -11912,11 +13224,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) {
@@ -11938,8 +13257,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.
@@ -11948,11 +13265,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 = [];
@@ -11973,7 +13287,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 {
@@ -11984,9 +13298,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. */
@@ -12699,6 +14010,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
@@ -13052,14 +14479,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.
      *
@@ -13107,21 +14536,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());
@@ -13143,13 +14573,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.
@@ -13343,6 +14772,7 @@ class MemoryPersistence {
      */
     constructor(referenceDelegateFactory, serializer) {
         this.mutationQueues = {};
+        this.overlays = {};
         this.listenSequence = new ListenSequence(0);
         this._started = false;
         this._started = true;
@@ -13350,7 +14780,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);
     }
@@ -13371,13 +14801,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;
@@ -20340,12 +21780,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;
 }
@@ -24853,8 +26293,7 @@ class DocumentSnapshot extends DocumentSnapshot$1 {
         this.metadata = metadata;
     }
     /**
-     * Property of the `DocumentSnapshot` that signals whether or not the data
-     * exists. True if the document exists.
+     * Returns whether or not the data exists. True if the document exists.
      */
     exists() {
         return super.exists();
@@ -25228,51 +26667,53 @@ function limitToLast(limit) {
     return new QueryLimitConstraint('limitToLast', limit, "L" /* Last */);
 }
 class QueryStartAtConstraint extends QueryConstraint {
-    constructor(type, _docOrFields, _before) {
+    constructor(type, _docOrFields, _inclusive) {
         super();
         this.type = type;
         this._docOrFields = _docOrFields;
-        this._before = _before;
+        this._inclusive = _inclusive;
     }
     _apply(query) {
-        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._before);
+        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._inclusive);
         return new Query(query.firestore, query.converter, queryWithStartAt(query._query, bound));
     }
 }
 function startAt(...docOrFields) {
-    return new QueryStartAtConstraint('startAt', docOrFields, /*before=*/ true);
+    return new QueryStartAtConstraint('startAt', docOrFields, 
+    /*inclusive=*/ true);
 }
 function startAfter(...docOrFields) {
     return new QueryStartAtConstraint('startAfter', docOrFields, 
-    /*before=*/ false);
+    /*inclusive=*/ false);
 }
 class QueryEndAtConstraint extends QueryConstraint {
-    constructor(type, _docOrFields, _before) {
+    constructor(type, _docOrFields, _inclusive) {
         super();
         this.type = type;
         this._docOrFields = _docOrFields;
-        this._before = _before;
+        this._inclusive = _inclusive;
     }
     _apply(query) {
-        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._before);
+        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._inclusive);
         return new Query(query.firestore, query.converter, queryWithEndAt(query._query, bound));
     }
 }
 function endBefore(...docOrFields) {
-    return new QueryEndAtConstraint('endBefore', docOrFields, /*before=*/ true);
+    return new QueryEndAtConstraint('endBefore', docOrFields, 
+    /*inclusive=*/ false);
 }
 function endAt(...docOrFields) {
-    return new QueryEndAtConstraint('endAt', docOrFields, /*before=*/ false);
+    return new QueryEndAtConstraint('endAt', docOrFields, /*inclusive=*/ true);
 }
 /** Helper function to create a bound from a document or fields */
-function newQueryBoundFromDocOrFields(query, methodName, docOrFields, before) {
+function newQueryBoundFromDocOrFields(query, methodName, docOrFields, inclusive) {
     docOrFields[0] = getModularInstance(docOrFields[0]);
     if (docOrFields[0] instanceof DocumentSnapshot$1) {
-        return newQueryBoundFromDocument(query._query, query.firestore._databaseId, methodName, docOrFields[0]._document, before);
+        return newQueryBoundFromDocument(query._query, query.firestore._databaseId, methodName, docOrFields[0]._document, inclusive);
     }
     else {
         const reader = newUserDataReader(query.firestore);
-        return newQueryBoundFromFields(query._query, query.firestore._databaseId, reader, methodName, docOrFields, before);
+        return newQueryBoundFromFields(query._query, query.firestore._databaseId, reader, methodName, docOrFields, inclusive);
     }
 }
 function newQueryFilter(query, methodName, dataReader, databaseId, fieldPath, op, value) {
@@ -25330,7 +26771,7 @@ function newQueryOrderBy(query, fieldPath, direction) {
  * of the query or if any of the fields in the order by are an uncommitted
  * server timestamp.
  */
-function newQueryBoundFromDocument(query, databaseId, methodName, doc, before) {
+function newQueryBoundFromDocument(query, databaseId, methodName, doc, inclusive) {
     if (!doc) {
         throw new FirestoreError(Code.NOT_FOUND, `Can't use a DocumentSnapshot that doesn't exist for ` +
             `${methodName}().`);
@@ -25367,12 +26808,12 @@ function newQueryBoundFromDocument(query, databaseId, methodName, doc, before) {
             }
         }
     }
-    return new Bound(components, before);
+    return new Bound(components, inclusive);
 }
 /**
  * Converts a list of field values to a `Bound` for the given query.
  */
-function newQueryBoundFromFields(query, databaseId, dataReader, methodName, values, before) {
+function newQueryBoundFromFields(query, databaseId, dataReader, methodName, values, inclusive) {
     // Use explicit order by's because it has to match the query the user made
     const orderBy = query.explicitOrderBy;
     if (values.length > orderBy.length) {
@@ -25409,7 +26850,7 @@ function newQueryBoundFromFields(query, databaseId, dataReader, methodName, valu
             components.push(wrapped);
         }
     }
-    return new Bound(components, before);
+    return new Bound(components, inclusive);
 }
 /**
  * Parses the given `documentIdValue` into a `ReferenceValue`, throwing