@firebase/firestore 3.4.4 → 3.4.5-canary.8ac8fb099

package/dist/index.node.mjs

@@ -4,11 +4,11 @@ import { Logger, LogLevel } from '@firebase/logger';
 import { inspect, TextEncoder, TextDecoder } from 'util';
 import { FirebaseError, createMockUserToken, getModularInstance, deepEqual, getUA, isIndexedDBAvailable, isSafari } from '@firebase/util';
 import { randomBytes as randomBytes$1 } from 'crypto';
-import { credentials, loadPackageDefinition, Metadata } from '@grpc/grpc-js';
-import { fromJSON } from '@grpc/proto-loader';
+import * as grpc from '@grpc/grpc-js';
+import * as protoLoader from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.4";
+const version$1 = "3.4.5-canary.8ac8fb099";
 
 /**
  * @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";
+const version = "9.6.7-canary.8ac8fb099";
 
 /**
  * @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,52 @@ 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;
+            });
+        }
+    }
+    /**
+     * Loads the first `count` elements from the provided index range. Loads all
+     * elements if no limit is provided.
+     */
+    loadFirst(range, count) {
+        const request = this.store.getAll(range, count === null ? undefined : count);
+        return new PersistencePromise((resolve, reject) => {
+            request.onerror = (event) => {
+                reject(event.target.error);
+            };
+            request.onsuccess = (event) => {
+                resolve(event.target.result);
+            };
         });
     }
     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);
@@ -3103,17 +3302,15 @@ class FieldMask {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/** Converts a Base64 encoded string to a binary string. */
 function decodeBase64(encoded) {
-    // Node actually doesn't validate base64 strings.
-    // A quick sanity check that is not a fool-proof validation
-    if (/[^-A-Za-z0-9+/=]/.test(encoded)) {
-        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Not a valid Base64 string: ' + encoded);
-    }
-    return new Buffer(encoded, 'base64').toString('binary');
+    // Note: We used to validate the base64 string here via a regular expression.
+    // This was removed to improve the performance of indexing.
+    return Buffer.from(encoded, 'base64').toString('binary');
 }
 /** Converts a binary string to a Base64 encoded string. */
 function encodeBase64(raw) {
-    return new Buffer(raw, 'binary').toString('base64');
+    return Buffer.from(raw, 'binary').toString('base64');
 }
 /** True if and only if the Base64 conversion functions are available. */
 function isBase64Available() {
@@ -3154,6 +3351,8 @@ class ByteString {
         return new ByteString(binaryString);
     }
     static fromUint8Array(array) {
+        // TODO(indexing); Remove the copy of the byte string here as this method
+        // is frequently called during indexing.
         const binaryString = binaryStringFromUint8Array(array);
         return new ByteString(binaryString);
     }
@@ -3374,6 +3573,75 @@ function getLocalWriteTime(value) {
     return new Timestamp(localWriteTime.seconds, localWriteTime.nanos);
 }
 
+/**
+ * @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.
+ */
+class DatabaseInfo {
+    /**
+     * Constructs a DatabaseInfo using the provided host, databaseId and
+     * persistenceKey.
+     *
+     * @param databaseId - The database to use.
+     * @param appId - The Firebase App Id.
+     * @param persistenceKey - A unique identifier for this Firestore's local
+     * storage (used in conjunction with the databaseId).
+     * @param host - The Firestore backend host to connect to.
+     * @param ssl - Whether to use SSL when connecting.
+     * @param forceLongPolling - Whether to use the forceLongPolling option
+     * when using WebChannel as the network transport.
+     * @param autoDetectLongPolling - Whether to use the detectBufferingProxy
+     * option when using WebChannel as the network transport.
+     * @param useFetchStreams Whether to use the Fetch API instead of
+     * XMLHTTPRequest
+     */
+    constructor(databaseId, appId, persistenceKey, host, ssl, forceLongPolling, autoDetectLongPolling, useFetchStreams) {
+        this.databaseId = databaseId;
+        this.appId = appId;
+        this.persistenceKey = persistenceKey;
+        this.host = host;
+        this.ssl = ssl;
+        this.forceLongPolling = forceLongPolling;
+        this.autoDetectLongPolling = autoDetectLongPolling;
+        this.useFetchStreams = useFetchStreams;
+    }
+}
+/** The default database name for a project. */
+const DEFAULT_DATABASE_NAME = '(default)';
+/**
+ * Represents the database ID a Firestore client is associated with.
+ * @internal
+ */
+class DatabaseId {
+    constructor(projectId, database) {
+        this.projectId = projectId;
+        this.database = database ? database : DEFAULT_DATABASE_NAME;
+    }
+    static empty() {
+        return new DatabaseId('', '');
+    }
+    get isDefaultDatabase() {
+        return this.database === DEFAULT_DATABASE_NAME;
+    }
+    isEqual(other) {
+        return (other instanceof DatabaseId &&
+            other.projectId === this.projectId &&
+            other.database === this.database);
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -3445,11 +3713,25 @@ class DocumentKey {
     static fromName(name) {
         return new DocumentKey(ResourcePath.fromString(name).popFirst(5));
     }
+    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);
     }
@@ -3489,6 +3771,17 @@ class DocumentKey {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const MAX_VALUE_TYPE = '__max__';
+const MAX_VALUE = {
+    mapValue: {
+        fields: {
+            '__type__': { stringValue: MAX_VALUE_TYPE }
+        }
+    }
+};
+const MIN_VALUE = {
+    nullValue: 'NULL_VALUE'
+};
 /** Extracts the backend's type order for the provided value. */
 function typeOrder(value) {
     if ('nullValue' in value) {
@@ -3522,6 +3815,9 @@ function typeOrder(value) {
         if (isServerTimestamp(value)) {
             return 4 /* ServerTimestampValue */;
         }
+        else if (isMaxValue(value)) {
+            return 9 /* ArrayValue */;
+        }
         return 10 /* ObjectValue */;
     }
     else {
@@ -3561,6 +3857,8 @@ function valueEquals(left, right) {
             return arrayEquals(left.arrayValue.values || [], right.arrayValue.values || [], valueEquals);
         case 10 /* ObjectValue */:
             return objectEquals(left, right);
+        case 9007199254740991 /* MaxValue */:
+            return true;
         default:
             return fail();
     }
@@ -3633,6 +3931,7 @@ function valueCompare(left, right) {
     }
     switch (leftType) {
         case 0 /* NullValue */:
+        case 9007199254740991 /* MaxValue */:
             return 0;
         case 1 /* BooleanValue */:
             return primitiveComparator(left.booleanValue, right.booleanValue);
@@ -3898,6 +4197,105 @@ function deepClone(source) {
     else {
         return Object.assign({}, source);
     }
+}
+/** Returns true if the Value represents the canonical {@link #MAX_VALUE} . */
+function isMaxValue(value) {
+    return ((((value.mapValue || {}).fields || {})['__type__'] || {}).stringValue ===
+        MAX_VALUE_TYPE);
+}
+/** Returns the lowest value for the given value type (inclusive). */
+function valuesGetLowerBound(value) {
+    if ('nullValue' in value) {
+        return MIN_VALUE;
+    }
+    else if ('booleanValue' in value) {
+        return { booleanValue: false };
+    }
+    else if ('integerValue' in value || 'doubleValue' in value) {
+        return { doubleValue: NaN };
+    }
+    else if ('timestampValue' in value) {
+        return { timestampValue: { seconds: Number.MIN_SAFE_INTEGER } };
+    }
+    else if ('stringValue' in value) {
+        return { stringValue: '' };
+    }
+    else if ('bytesValue' in value) {
+        return { bytesValue: '' };
+    }
+    else if ('referenceValue' in value) {
+        return refValue(DatabaseId.empty(), DocumentKey.empty());
+    }
+    else if ('geoPointValue' in value) {
+        return { geoPointValue: { latitude: -90, longitude: -180 } };
+    }
+    else if ('arrayValue' in value) {
+        return { arrayValue: {} };
+    }
+    else if ('mapValue' in value) {
+        return { mapValue: {} };
+    }
+    else {
+        return fail();
+    }
+}
+/** Returns the largest value for the given value type (exclusive). */
+function valuesGetUpperBound(value) {
+    if ('nullValue' in value) {
+        return { booleanValue: false };
+    }
+    else if ('booleanValue' in value) {
+        return { doubleValue: NaN };
+    }
+    else if ('integerValue' in value || 'doubleValue' in value) {
+        return { timestampValue: { seconds: Number.MIN_SAFE_INTEGER } };
+    }
+    else if ('timestampValue' in value) {
+        return { stringValue: '' };
+    }
+    else if ('stringValue' in value) {
+        return { bytesValue: '' };
+    }
+    else if ('bytesValue' in value) {
+        return refValue(DatabaseId.empty(), DocumentKey.empty());
+    }
+    else if ('referenceValue' in value) {
+        return { geoPointValue: { latitude: -90, longitude: -180 } };
+    }
+    else if ('geoPointValue' in value) {
+        return { arrayValue: {} };
+    }
+    else if ('arrayValue' in value) {
+        return { mapValue: {} };
+    }
+    else if ('mapValue' in value) {
+        return MAX_VALUE;
+    }
+    else {
+        return fail();
+    }
+}
+function valuesMax(left, right) {
+    if (left === undefined) {
+        return right;
+    }
+    else if (right === undefined) {
+        return left;
+    }
+    else {
+        return valueCompare(left, right) > 0 ? left : right;
+    }
+}
+function valuesMin(left, right) {
+    if (left === undefined) {
+        return right;
+    }
+    else if (right === undefined) {
+        return left;
+    }
+    else {
+        return valueCompare(left, right) < 0 ? left : right;
+    }
 }
 
 /**
@@ -4093,10 +4491,11 @@ function extractFieldMask(value) {
  * from all views.
  */
 class MutableDocument {
-    constructor(key, documentType, version, data, documentState) {
+    constructor(key, documentType, version, readTime, data, documentState) {
         this.key = key;
         this.documentType = documentType;
         this.version = version;
+        this.readTime = readTime;
         this.data = data;
         this.documentState = documentState;
     }
@@ -4105,18 +4504,18 @@ class MutableDocument {
      * base document for mutations.
      */
     static newInvalidDocument(documentKey) {
-        return new MutableDocument(documentKey, 0 /* INVALID */, SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 0 /* INVALID */, SnapshotVersion.min(), SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
     }
     /**
      * Creates a new document that is known to exist with the given data at the
      * given version.
      */
     static newFoundDocument(documentKey, version, value) {
-        return new MutableDocument(documentKey, 1 /* FOUND_DOCUMENT */, version, value, 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 1 /* FOUND_DOCUMENT */, version, SnapshotVersion.min(), value, 0 /* SYNCED */);
     }
     /** Creates a new document that is known to not exist at the given version. */
     static newNoDocument(documentKey, version) {
-        return new MutableDocument(documentKey, 2 /* NO_DOCUMENT */, version, ObjectValue.empty(), 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 2 /* NO_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
     }
     /**
      * Creates a new document that is known to exist at the given version but
@@ -4124,7 +4523,7 @@ class MutableDocument {
      * base document).
      */
     static newUnknownDocument(documentKey, version) {
-        return new MutableDocument(documentKey, 3 /* UNKNOWN_DOCUMENT */, version, ObjectValue.empty(), 2 /* HAS_COMMITTED_MUTATIONS */);
+        return new MutableDocument(documentKey, 3 /* UNKNOWN_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 2 /* HAS_COMMITTED_MUTATIONS */);
     }
     /**
      * Changes the document type to indicate that it exists and that its version
@@ -4168,6 +4567,10 @@ class MutableDocument {
         this.documentState = 1 /* HAS_LOCAL_MUTATIONS */;
         return this;
     }
+    setReadTime(readTime) {
+        this.readTime = readTime;
+        return this;
+    }
     get hasLocalMutations() {
         return this.documentState === 1 /* HAS_LOCAL_MUTATIONS */;
     }
@@ -4198,7 +4601,7 @@ class MutableDocument {
             this.data.isEqual(other.data));
     }
     mutableCopy() {
-        return new MutableDocument(this.key, this.documentType, this.version, this.data.clone(), this.documentState);
+        return new MutableDocument(this.key, this.documentType, this.version, this.readTime, this.data.clone(), this.documentState);
     }
     toString() {
         return (`Document(${this.key}, ${this.version}, ${JSON.stringify(this.data.value)}, ` +
@@ -4223,7 +4626,7 @@ function compareDocumentsByField(field, d1, d2) {
 
 /**
  * @license
- * Copyright 2019 Google LLC
+ * 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.
@@ -4237,9 +4640,140 @@ function compareDocumentsByField(field, d1, d2) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// Visible for testing
-class TargetImpl {
-    constructor(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
+/**
+ * The initial mutation batch id for each index. Gets updated during index
+ * backfill.
+ */
+const INITIAL_LARGEST_BATCH_ID = -1;
+/**
+ * The initial sequence number for each index. Gets updated during index
+ * backfill.
+ */
+const INITIAL_SEQUENCE_NUMBER = 0;
+/**
+ * An index definition for field indexes in Firestore.
+ *
+ * Every index is associated with a collection. The definition contains a list
+ * of fields and their index kind (which can be `ASCENDING`, `DESCENDING` or
+ * `CONTAINS` for ArrayContains/ArrayContainsAny queries).
+ *
+ * Unlike the backend, the SDK does not differentiate between collection or
+ * collection group-scoped indices. Every index can be used for both single
+ * collection and collection group queries.
+ */
+class FieldIndex {
+    constructor(
+    /**
+     * The index ID. Returns -1 if the index ID is not available (e.g. the index
+     * has not yet been persisted).
+     */
+    indexId, 
+    /** The collection ID this index applies to. */
+    collectionGroup, 
+    /** The field segments for this index. */
+    fields, 
+    /** Shows how up-to-date the index is for the current user. */
+    indexState) {
+        this.indexId = indexId;
+        this.collectionGroup = collectionGroup;
+        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 */);
+}
+/** Returns a debug representation of the field index */
+function fieldIndexToString(fieldIndex) {
+    return `id=${fieldIndex.indexId}|cg=${fieldIndex.collectionGroup}|f=${fieldIndex.fields.map(f => `${f.fieldPath}:${f.kind}`).join(',')}`;
+}
+/** An index component consisting of field path and index type.  */
+class IndexSegment {
+    constructor(
+    /** The field path of the component. */
+    fieldPath, 
+    /** The fields sorting order. */
+    kind) {
+        this.fieldPath = fieldPath;
+        this.kind = kind;
+    }
+}
+/**
+ * Stores the "high water mark" that indicates how updated the Index is for the
+ * current user.
+ */
+class IndexState {
+    constructor(
+    /**
+     * Indicates when the index was last updated (relative to other indexes).
+     */
+    sequenceNumber, 
+    /** The the latest indexed read time, document and batch id. */
+    offset) {
+        this.sequenceNumber = sequenceNumber;
+        this.offset = offset;
+    }
+    /** The state of an index that has not yet been backfilled. */
+    static empty() {
+        return new IndexState(INITIAL_SEQUENCE_NUMBER, IndexOffset.min());
+    }
+}
+/**
+ * Stores the latest read time, document and batch ID that were processed for an
+ * index.
+ */
+class IndexOffset {
+    constructor(
+    /**
+     * The latest read time version that has been indexed by Firestore for this
+     * field index.
+     */
+    readTime, 
+    /**
+     * The key of the last document that was indexed for this query. Use
+     * `DocumentKey.empty()` if no document has been indexed.
+     */
+    documentKey, 
+    /*
+     * The largest mutation batch id that's been processed by Firestore.
+     */
+    largestBatchId) {
+        this.readTime = readTime;
+        this.documentKey = documentKey;
+        this.largestBatchId = largestBatchId;
+    }
+    /** The state of an index that has not yet been backfilled. */
+    static min() {
+        return new IndexOffset(SnapshotVersion.min(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
+    }
+}
+
+/**
+ * @license
+ * Copyright 2019 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.
+ */
+// Visible for testing
+class TargetImpl {
+    constructor(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
         this.path = path;
         this.collectionGroup = collectionGroup;
         this.orderBy = orderBy;
@@ -4264,27 +4798,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;
 }
@@ -4307,10 +4843,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})`;
 }
@@ -4345,11 +4885,196 @@ function targetEquals(left, right) {
     }
     return boundEquals(left.endAt, right.endAt);
 }
-function isDocumentTarget(target) {
+function targetIsDocumentTarget(target) {
     return (DocumentKey.isDocumentKey(target.path) &&
         target.collectionGroup === null &&
         target.filters.length === 0);
 }
+/** Returns the field filters that target the given field path. */
+function targetGetFieldFiltersForPath(target, path) {
+    return target.filters.filter(f => f instanceof FieldFilter && f.field.isEqual(path));
+}
+/**
+ * Returns the values that are used in ARRAY_CONTAINS or ARRAY_CONTAINS_ANY
+ * filters. Returns `null` if there are no such filters.
+ */
+function targetGetArrayValues(target, fieldIndex) {
+    const segment = fieldIndexGetArraySegment(fieldIndex);
+    if (segment === undefined) {
+        return null;
+    }
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
+        switch (fieldFilter.op) {
+            case "array-contains-any" /* ARRAY_CONTAINS_ANY */:
+                return fieldFilter.value.arrayValue.values || [];
+            case "array-contains" /* ARRAY_CONTAINS */:
+                return [fieldFilter.value];
+            // Remaining filters are not array filters.
+        }
+    }
+    return null;
+}
+/**
+ * Returns the list of values that are used in != or NOT_IN filters. Returns
+ * `null` if there are no such filters.
+ */
+function targetGetNotInValues(target, fieldIndex) {
+    const values = new Map();
+    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
+            switch (fieldFilter.op) {
+                case "==" /* EQUAL */:
+                case "in" /* IN */:
+                    // Encode equality prefix, which is encoded in the index value before
+                    // the inequality (e.g. `a == 'a' && b != 'b'` is encoded to
+                    // `value != 'ab'`).
+                    values.set(segment.fieldPath.canonicalString(), fieldFilter.value);
+                    break;
+                case "not-in" /* NOT_IN */:
+                case "!=" /* NOT_EQUAL */:
+                    // NotIn/NotEqual is always a suffix. There cannot be any remaining
+                    // segments and hence we can return early here.
+                    values.set(segment.fieldPath.canonicalString(), fieldFilter.value);
+                    return Array.from(values.values());
+                // Remaining filters cannot be used as notIn bounds.
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Returns a lower bound of field values that can be used as a starting point to
+ * scan the index defined by `fieldIndex`. Returns `null` if no lower bound
+ * exists.
+ */
+function targetGetLowerBound(target, fieldIndex) {
+    const values = [];
+    let inclusive = true;
+    // For each segment, retrieve a lower bound if there is a suitable filter or
+    // startAt.
+    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+        let segmentValue = undefined;
+        let segmentInclusive = true;
+        // Process all filters to find a value for the current field segment
+        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
+            let filterValue = undefined;
+            let filterInclusive = true;
+            switch (fieldFilter.op) {
+                case "<" /* LESS_THAN */:
+                case "<=" /* LESS_THAN_OR_EQUAL */:
+                    filterValue = valuesGetLowerBound(fieldFilter.value);
+                    break;
+                case "==" /* EQUAL */:
+                case "in" /* IN */:
+                case ">=" /* GREATER_THAN_OR_EQUAL */:
+                    filterValue = fieldFilter.value;
+                    break;
+                case ">" /* GREATER_THAN */:
+                    filterValue = fieldFilter.value;
+                    filterInclusive = false;
+                    break;
+                case "!=" /* NOT_EQUAL */:
+                case "not-in" /* NOT_IN */:
+                    filterValue = MIN_VALUE;
+                    break;
+                // Remaining filters cannot be used as lower bounds.
+            }
+            if (valuesMax(segmentValue, filterValue) === filterValue) {
+                segmentValue = filterValue;
+                segmentInclusive = filterInclusive;
+            }
+        }
+        // If there is a startAt bound, compare the values against the existing
+        // boundary to see if we can narrow the scope.
+        if (target.startAt !== null) {
+            for (let i = 0; i < target.orderBy.length; ++i) {
+                const orderBy = target.orderBy[i];
+                if (orderBy.field.isEqual(segment.fieldPath)) {
+                    const cursorValue = target.startAt.position[i];
+                    if (valuesMax(segmentValue, cursorValue) === cursorValue) {
+                        segmentValue = cursorValue;
+                        segmentInclusive = target.startAt.inclusive;
+                    }
+                    break;
+                }
+            }
+        }
+        if (segmentValue === undefined) {
+            // No lower bound exists
+            return null;
+        }
+        values.push(segmentValue);
+        inclusive && (inclusive = segmentInclusive);
+    }
+    return new Bound(values, inclusive);
+}
+/**
+ * Returns an upper bound of field values that can be used as an ending point
+ * when scanning the index defined by `fieldIndex`. Returns `null` if no
+ * upper bound exists.
+ */
+function targetGetUpperBound(target, fieldIndex) {
+    const values = [];
+    let inclusive = true;
+    // For each segment, retrieve an upper bound if there is a suitable filter or
+    // endAt.
+    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+        let segmentValue = undefined;
+        let segmentInclusive = true;
+        // Process all filters to find a value for the current field segment
+        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
+            let filterValue = undefined;
+            let filterInclusive = true;
+            switch (fieldFilter.op) {
+                case ">=" /* GREATER_THAN_OR_EQUAL */:
+                case ">" /* GREATER_THAN */:
+                    filterValue = valuesGetUpperBound(fieldFilter.value);
+                    filterInclusive = false;
+                    break;
+                case "==" /* EQUAL */:
+                case "in" /* IN */:
+                case "<=" /* LESS_THAN_OR_EQUAL */:
+                    filterValue = fieldFilter.value;
+                    break;
+                case "<" /* LESS_THAN */:
+                    filterValue = fieldFilter.value;
+                    filterInclusive = false;
+                    break;
+                case "!=" /* NOT_EQUAL */:
+                case "not-in" /* NOT_IN */:
+                    filterValue = MAX_VALUE;
+                    break;
+                // Remaining filters cannot be used as upper bounds.
+            }
+            if (valuesMin(segmentValue, filterValue) === filterValue) {
+                segmentValue = filterValue;
+                segmentInclusive = filterInclusive;
+            }
+        }
+        // If there is a endAt bound, compare the values against the existing
+        // boundary to see if we can narrow the scope.
+        if (target.endAt !== null) {
+            for (let i = 0; i < target.orderBy.length; ++i) {
+                const orderBy = target.orderBy[i];
+                if (orderBy.field.isEqual(segment.fieldPath)) {
+                    const cursorValue = target.endAt.position[i];
+                    if (valuesMin(segmentValue, cursorValue) === cursorValue) {
+                        segmentValue = cursorValue;
+                        segmentInclusive = target.endAt.inclusive;
+                    }
+                    break;
+                }
+            }
+        }
+        if (segmentValue === undefined) {
+            // No upper bound exists
+            return null;
+        }
+        values.push(segmentValue);
+        inclusive && (inclusive = segmentInclusive);
+    }
+    return new Bound(values, inclusive);
+}
 class Filter {
 }
 class FieldFilter extends Filter {
@@ -4548,17 +5273,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.
  */
@@ -4578,11 +5297,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];
@@ -4601,7 +5316,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) {
@@ -4610,7 +5341,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;
     }
@@ -4814,10 +5545,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);
@@ -4905,11 +5636,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;
@@ -5087,7 +5818,7 @@ class SortedMapIterator {
         while (!node.isEmpty()) {
             cmp = startKey ? comparator(node.key, startKey) : 1;
             // flip the comparison if we're going in reverse
-            if (isReverse) {
+            if (startKey && isReverse) {
                 cmp *= -1;
             }
             if (cmp < 0) {
@@ -5564,6 +6295,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;
 }
 
 /**
@@ -6402,6 +7199,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
@@ -6874,7 +7712,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.
  */
@@ -6990,7 +7828,7 @@ class WatchChangeAggregator {
         const targetData = this.targetDataForActiveTarget(targetId);
         if (targetData) {
             const target = targetData.target;
-            if (isDocumentTarget(target)) {
+            if (targetIsDocumentTarget(target)) {
                 if (expectedCount === 0) {
                     // The existence filter told us the document does not exist. We deduce
                     // that this document does not exist and apply a deleted document to
@@ -7025,7 +7863,7 @@ class WatchChangeAggregator {
         this.targetStates.forEach((targetState, targetId) => {
             const targetData = this.targetDataForActiveTarget(targetId);
             if (targetData) {
-                if (targetState.current && isDocumentTarget(targetData.target)) {
+                if (targetState.current && targetIsDocumentTarget(targetData.target)) {
                     // Document queries for document that don't exist can produce an empty
                     // result set. To update our local cache, we synthesize a document
                     // delete if we have not previously received the document. This
@@ -7068,6 +7906,7 @@ class WatchChangeAggregator {
                 resolvedLimboDocuments = resolvedLimboDocuments.add(key);
             }
         });
+        this.pendingDocumentUpdates.forEach((_, doc) => doc.setReadTime(snapshotVersion));
         const remoteEvent = new RemoteEvent(snapshotVersion, targetChanges, this.pendingTargetResets, this.pendingDocumentUpdates, resolvedLimboDocuments);
         this.pendingDocumentUpdates = mutableDocumentMap();
         this.pendingDocumentTargetMapping = documentTargetMap();
@@ -7168,7 +8007,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;
     }
@@ -7787,10 +8626,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;
 }
@@ -7823,11 +8662,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);
 }
@@ -7860,7 +8699,7 @@ function toLabel(serializer, purpose) {
 function toTarget(serializer, targetData) {
     let result;
     const target = targetData.target;
-    if (isDocumentTarget(target)) {
+    if (targetIsDocumentTarget(target)) {
         result = { documents: toDocumentsTarget(serializer, target) };
     }
     else {
@@ -7918,16 +8757,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, inclusive);
+}
+function fromEndAtCursor(cursor) {
+    const inclusive = !cursor.before;
     const position = cursor.values || [];
-    return new Bound(position, before);
+    return new Bound(position, inclusive);
 }
 // visible for testing
 function toDirection(dir) {
@@ -8188,29 +9038,34 @@ class LocalSerializer {
 }
 /** Decodes a remote document from storage locally to a Document. */
 function fromDbRemoteDocument(localSerializer, remoteDoc) {
+    let doc;
     if (remoteDoc.document) {
-        return fromDocument(localSerializer.remoteSerializer, remoteDoc.document, !!remoteDoc.hasCommittedMutations);
+        doc = fromDocument(localSerializer.remoteSerializer, remoteDoc.document, !!remoteDoc.hasCommittedMutations);
     }
     else if (remoteDoc.noDocument) {
         const key = DocumentKey.fromSegments(remoteDoc.noDocument.path);
         const version = fromDbTimestamp(remoteDoc.noDocument.readTime);
-        const document = MutableDocument.newNoDocument(key, version);
-        return remoteDoc.hasCommittedMutations
-            ? document.setHasCommittedMutations()
-            : document;
+        doc = MutableDocument.newNoDocument(key, version);
+        if (remoteDoc.hasCommittedMutations) {
+            doc.setHasCommittedMutations();
+        }
     }
     else if (remoteDoc.unknownDocument) {
         const key = DocumentKey.fromSegments(remoteDoc.unknownDocument.path);
         const version = fromDbTimestamp(remoteDoc.unknownDocument.version);
-        return MutableDocument.newUnknownDocument(key, version);
+        doc = MutableDocument.newUnknownDocument(key, version);
     }
     else {
         return fail();
     }
+    if (remoteDoc.readTime) {
+        doc.setReadTime(fromDbTimestampKey(remoteDoc.readTime));
+    }
+    return doc;
 }
 /** Encodes a document for storage locally. */
-function toDbRemoteDocument(localSerializer, document, readTime) {
-    const dbReadTime = toDbTimestampKey(readTime);
+function toDbRemoteDocument(localSerializer, document) {
+    const dbReadTime = toDbTimestampKey(document.readTime);
     const parentPath = document.key.path.popLast().toArray();
     if (document.isFoundDocument()) {
         const doc = toDocument(localSerializer.remoteSerializer, document);
@@ -8221,10 +9076,10 @@ function toDbRemoteDocument(localSerializer, document, readTime) {
     }
     else if (document.isNoDocument()) {
         const path = document.key.path.toArray();
-        const readTime = toDbTimestamp(document.version);
+        const version = toDbTimestamp(document.version);
         const hasCommittedMutations = document.hasCommittedMutations;
         return new DbRemoteDocument(
-        /* unknownDocument= */ null, new DbNoDocument(path, readTime), 
+        /* unknownDocument= */ null, new DbNoDocument(path, version), 
         /* document= */ null, hasCommittedMutations, dbReadTime, parentPath);
     }
     else if (document.isUnknownDocument()) {
@@ -8305,7 +9160,7 @@ function toDbTarget(localSerializer, targetData) {
     const dbTimestamp = toDbTimestamp(targetData.snapshotVersion);
     const dbLastLimboFreeTimestamp = toDbTimestamp(targetData.lastLimboFreeSnapshotVersion);
     let queryProto;
-    if (isDocumentTarget(targetData.target)) {
+    if (targetIsDocumentTarget(targetData.target)) {
         queryProto = toDocumentsTarget(localSerializer.remoteSerializer, targetData.target);
     }
     else {
@@ -8386,6 +9241,37 @@ function fromBundleMetadata(metadata) {
         version: metadata.version,
         createTime: fromVersion(metadata.createTime)
     };
+}
+/** Encodes a DbDocumentOverlay object to an Overlay model object. */
+function fromDbDocumentOverlay(localSerializer, dbDocumentOverlay) {
+    return new Overlay(dbDocumentOverlay.largestBatchId, fromMutation(localSerializer.remoteSerializer, dbDocumentOverlay.overlayMutation));
+}
+/** Decodes an Overlay model object into a DbDocumentOverlay object. */
+function toDbDocumentOverlay(localSerializer, userId, overlay) {
+    const [_, collectionPath, documentId] = toDbDocumentOverlayKey(userId, overlay.mutation.key);
+    return new DbDocumentOverlay(userId, collectionPath, documentId, overlay.mutation.key.getCollectionGroup(), overlay.largestBatchId, toMutation(localSerializer.remoteSerializer, overlay.mutation));
+}
+/**
+ * Returns the DbDocumentOverlayKey corresponding to the given user and
+ * document key.
+ */
+function toDbDocumentOverlayKey(userId, docKey) {
+    const docId = docKey.path.lastSegment();
+    const collectionPath = encodeResourcePath(docKey.path.popLast());
+    return [userId, collectionPath, docId];
+}
+function toDbIndexConfiguration(index) {
+    return new DbIndexConfiguration(index.indexId, index.collectionGroup, index.fields.map(s => [s.fieldPath.canonicalString(), s.kind]));
+}
+function fromDbIndexConfiguration(index, state) {
+    const decodedState = state
+        ? new IndexState(state.sequenceNumber, new IndexOffset(fromDbTimestamp(state.readTime), new DocumentKey(decodeResourcePath(state.documentKey)), state.largestBatchId))
+        : IndexState.empty();
+    const decodedSegments = index.fields.map(([fieldPath, kind]) => new IndexSegment(FieldPath$1.fromServerFormat(fieldPath), kind));
+    return new FieldIndex(index.indexId, index.collectionGroup, decodedSegments, decodedState);
+}
+function toDbIndexState(indexId, user, sequenceNumber, offset) {
+    return new DbIndexState(indexId, user.uid || '', sequenceNumber, toDbTimestamp(offset.readTime), encodeResourcePath(offset.documentKey.path), offset.largestBatchId);
 }
 
 /**
@@ -8447,7 +9333,7 @@ function namedQueriesStore(txn) {
 
 /**
  * @license
- * Copyright 2019 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.
@@ -8462,53 +9348,1057 @@ function namedQueriesStore(txn) {
  * limitations under the License.
  */
 /**
- * An in-memory implementation of IndexManager.
+ * Implementation of DocumentOverlayCache using IndexedDb.
  */
-class MemoryIndexManager {
-    constructor() {
-        this.collectionParentIndex = new MemoryCollectionParentIndex();
-    }
-    addToCollectionParentIndex(transaction, collectionPath) {
-        this.collectionParentIndex.add(collectionPath);
-        return PersistencePromise.resolve();
+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;
     }
-    getCollectionParents(transaction, collectionId) {
-        return PersistencePromise.resolve(this.collectionParentIndex.getEntries(collectionId));
+    static forUser(serializer, user) {
+        const userId = user.uid || '';
+        return new IndexedDbDocumentOverlayCache(serializer, userId);
     }
-}
-/**
- * Internal implementation of the collection-parent index exposed by MemoryIndexManager.
- * Also used for in-memory caching by IndexedDbIndexManager and initial index population
- * in indexeddb_schema.ts
- */
-class MemoryCollectionParentIndex {
-    constructor() {
-        this.index = {};
+    getOverlay(transaction, key) {
+        return documentOverlayStore(transaction)
+            .get(toDbDocumentOverlayKey(this.userId, key))
+            .next(dbOverlay => {
+            if (dbOverlay) {
+                return fromDbDocumentOverlay(this.serializer, dbOverlay);
+            }
+            return null;
+        });
     }
-    // Returns false if the entry already existed.
-    add(collectionPath) {
-        const collectionId = collectionPath.lastSegment();
-        const parentPath = collectionPath.popLast();
-        const existingParents = this.index[collectionId] ||
-            new SortedSet(ResourcePath.comparator);
-        const added = !existingParents.has(parentPath);
-        this.index[collectionId] = existingParents.add(parentPath);
-        return added;
+    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);
     }
-    has(collectionPath) {
-        const collectionId = collectionPath.lastSegment();
-        const parentPath = collectionPath.popLast();
-        const existingParents = this.index[collectionId];
-        return existingParents && existingParents.has(parentPath);
+    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);
     }
-    getEntries(collectionId) {
-        const parentPaths = this.index[collectionId] ||
-            new SortedSet(ResourcePath.comparator);
-        return parentPaths.toArray();
+    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();
+    }
+}
+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();
+    }
+}
+/**
+ * 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 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.
+ */
+/** 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;
+    }
+    /**
+     * Returns an IndexEntry entry that sorts immediately after the current
+     * directional value.
+     */
+    successor() {
+        const currentLength = this.directionalValue.length;
+        const newLength = currentLength === 0 || this.directionalValue[currentLength - 1] === 255
+            ? currentLength + 1
+            : currentLength;
+        const successor = new Uint8Array(newLength);
+        successor.set(this.directionalValue, 0);
+        if (newLength !== currentLength) {
+            successor.set([0], this.directionalValue.length);
+        }
+        else {
+            ++successor[successor.length - 1];
+        }
+        return new IndexEntry(this.indexId, this.documentKey, this.arrayValue, successor);
+    }
+}
+function indexEntryComparator(left, right) {
+    let cmp = left.indexId - right.indexId;
+    if (cmp !== 0) {
+        return cmp;
+    }
+    cmp = compareByteArrays(left.arrayValue, right.arrayValue);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    cmp = compareByteArrays(left.directionalValue, right.directionalValue);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    return DocumentKey.comparator(left.documentKey, right.documentKey);
+}
+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;
+}
+
+/**
+ * @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.
+ */
+/**
+ * A light query planner for Firestore.
+ *
+ * This class matches a `FieldIndex` against a Firestore Query `Target`. It
+ * determines whether a given index can be used to serve the specified target.
+ *
+ * The following table showcases some possible index configurations:
+ *
+ * Query                                               | Index
+ * -----------------------------------------------------------------------------
+ * where('a', '==', 'a').where('b', '==', 'b')         | a ASC, b DESC
+ * where('a', '==', 'a').where('b', '==', 'b')         | a ASC
+ * where('a', '==', 'a').where('b', '==', 'b')         | b DESC
+ * where('a', '>=', 'a').orderBy('a')                  | a ASC
+ * where('a', '>=', 'a').orderBy('a', 'desc')          | a DESC
+ * where('a', '>=', 'a').orderBy('a').orderBy('b')     | a ASC, b ASC
+ * where('a', '>=', 'a').orderBy('a').orderBy('b')     | a ASC
+ * where('a', 'array-contains', 'a').orderBy('b')      | a CONTAINS, b ASCENDING
+ * where('a', 'array-contains', 'a').orderBy('b')      | a CONTAINS
+ */
+class TargetIndexMatcher {
+    constructor(target) {
+        this.collectionId =
+            target.collectionGroup != null
+                ? target.collectionGroup
+                : target.path.lastSegment();
+        this.orderBys = target.orderBy;
+        this.equalityFilters = [];
+        for (const filter of target.filters) {
+            const fieldFilter = filter;
+            if (fieldFilter.isInequality()) {
+                this.inequalityFilter = fieldFilter;
+            }
+            else {
+                this.equalityFilters.push(fieldFilter);
+            }
+        }
+    }
+    /**
+     * Returns whether the index can be used to serve the TargetIndexMatcher's
+     * target.
+     *
+     * An index is considered capable of serving the target when:
+     * - The target uses all index segments for its filters and orderBy clauses.
+     *   The target can have additional filter and orderBy clauses, but not
+     *   fewer.
+     * - If an ArrayContains/ArrayContainsAnyfilter is used, the index must also
+     *   have a corresponding `CONTAINS` segment.
+     * - All directional index segments can be mapped to the target as a series of
+     *   equality filters, a single inequality filter and a series of orderBy
+     *   clauses.
+     * - The segments that represent the equality filters may appear out of order.
+     * - The optional segment for the inequality filter must appear after all
+     *   equality segments.
+     * - The segments that represent that orderBy clause of the target must appear
+     *   in order after all equality and inequality segments. Single orderBy
+     *   clauses cannot be skipped, but a continuous orderBy suffix may be
+     *   omitted.
+     */
+    servedByIndex(index) {
+        // If there is an array element, find a matching filter.
+        const arraySegment = fieldIndexGetArraySegment(index);
+        if (arraySegment !== undefined &&
+            !this.hasMatchingEqualityFilter(arraySegment)) {
+            return false;
+        }
+        const segments = fieldIndexGetDirectionalSegments(index);
+        let segmentIndex = 0;
+        let orderBysIndex = 0;
+        // Process all equalities first. Equalities can appear out of order.
+        for (; segmentIndex < segments.length; ++segmentIndex) {
+            // We attempt to greedily match all segments to equality filters. If a
+            // filter matches an index segment, we can mark the segment as used.
+            // Since it is not possible to use the same field path in both an equality
+            // and inequality/oderBy clause, we do not have to consider the possibility
+            // that a matching equality segment should instead be used to map to an
+            // inequality filter or orderBy clause.
+            if (!this.hasMatchingEqualityFilter(segments[segmentIndex])) {
+                // If we cannot find a matching filter, we need to verify whether the
+                // remaining segments map to the target's inequality and its orderBy
+                // clauses.
+                break;
+            }
+        }
+        // If we already have processed all segments, all segments are used to serve
+        // the equality filters and we do not need to map any segments to the
+        // target's inequality and orderBy clauses.
+        if (segmentIndex === segments.length) {
+            return true;
+        }
+        // If there is an inequality filter, the next segment must match both the
+        // filter and the first orderBy clause.
+        if (this.inequalityFilter !== undefined) {
+            const segment = segments[segmentIndex];
+            if (!this.matchesFilter(this.inequalityFilter, segment) ||
+                !this.matchesOrderBy(this.orderBys[orderBysIndex++], segment)) {
+                return false;
+            }
+            ++segmentIndex;
+        }
+        // All remaining segments need to represent the prefix of the target's
+        // orderBy.
+        for (; segmentIndex < segments.length; ++segmentIndex) {
+            const segment = segments[segmentIndex];
+            if (orderBysIndex >= this.orderBys.length ||
+                !this.matchesOrderBy(this.orderBys[orderBysIndex++], segment)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasMatchingEqualityFilter(segment) {
+        for (const filter of this.equalityFilters) {
+            if (this.matchesFilter(filter, segment)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    matchesFilter(filter, segment) {
+        if (filter === undefined || !filter.field.isEqual(segment.fieldPath)) {
+            return false;
+        }
+        const isArrayOperator = filter.op === "array-contains" /* ARRAY_CONTAINS */ ||
+            filter.op === "array-contains-any" /* ARRAY_CONTAINS_ANY */;
+        return (segment.kind === 2 /* CONTAINS */) === isArrayOperator;
+    }
+    matchesOrderBy(orderBy, segment) {
+        if (!orderBy.field.isEqual(segment.fieldPath)) {
+            return false;
+        }
+        return ((segment.kind === 0 /* ASCENDING */ &&
+            orderBy.dir === "asc" /* ASCENDING */) ||
+            (segment.kind === 1 /* DESCENDING */ &&
+                orderBy.dir === "desc" /* DESCENDING */));
+    }
+}
+
+/**
+ * @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.
+ */
+/**
+ * A map implementation that uses objects as keys. Objects must have an
+ * associated equals function and must be immutable. Entries in the map are
+ * stored together with the key being produced from the mapKeyFn. This map
+ * automatically handles collisions of keys.
+ */
+class ObjectMap {
+    constructor(mapKeyFn, equalsFn) {
+        this.mapKeyFn = mapKeyFn;
+        this.equalsFn = equalsFn;
+        /**
+         * The inner map for a key/value pair. Due to the possibility of collisions we
+         * keep a list of entries that we do a linear search through to find an actual
+         * match. Note that collisions should be rare, so we still expect near
+         * constant time lookups in practice.
+         */
+        this.inner = {};
+    }
+    /** Get a value for this key, or undefined if it does not exist. */
+    get(key) {
+        const id = this.mapKeyFn(key);
+        const matches = this.inner[id];
+        if (matches === undefined) {
+            return undefined;
+        }
+        for (const [otherKey, value] of matches) {
+            if (this.equalsFn(otherKey, key)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    /** Put this key and value in the map. */
+    set(key, value) {
+        const id = this.mapKeyFn(key);
+        const matches = this.inner[id];
+        if (matches === undefined) {
+            this.inner[id] = [[key, value]];
+            return;
+        }
+        for (let i = 0; i < matches.length; i++) {
+            if (this.equalsFn(matches[i][0], key)) {
+                matches[i] = [key, value];
+                return;
+            }
+        }
+        matches.push([key, value]);
+    }
+    /**
+     * Remove this key from the map. Returns a boolean if anything was deleted.
+     */
+    delete(key) {
+        const id = this.mapKeyFn(key);
+        const matches = this.inner[id];
+        if (matches === undefined) {
+            return false;
+        }
+        for (let i = 0; i < matches.length; i++) {
+            if (this.equalsFn(matches[i][0], key)) {
+                if (matches.length === 1) {
+                    delete this.inner[id];
+                }
+                else {
+                    matches.splice(i, 1);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    forEach(fn) {
+        forEach(this.inner, (_, entries) => {
+            for (const [k, v] of entries) {
+                fn(k, v);
+            }
+        });
+    }
+    isEmpty() {
+        return isEmpty(this.inner);
+    }
+}
+
+/**
+ * @license
+ * Copyright 2019 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 IndexManager.
+ */
+class MemoryIndexManager {
+    constructor() {
+        this.collectionParentIndex = new MemoryCollectionParentIndex();
+    }
+    addToCollectionParentIndex(transaction, collectionPath) {
+        this.collectionParentIndex.add(collectionPath);
+        return PersistencePromise.resolve();
+    }
+    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, target) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve(null);
+    }
+    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.
+ * Also used for in-memory caching by IndexedDbIndexManager and initial index population
+ * in indexeddb_schema.ts
+ */
+class MemoryCollectionParentIndex {
+    constructor() {
+        this.index = {};
+    }
+    // Returns false if the entry already existed.
+    add(collectionPath) {
+        const collectionId = collectionPath.lastSegment();
+        const parentPath = collectionPath.popLast();
+        const existingParents = this.index[collectionId] ||
+            new SortedSet(ResourcePath.comparator);
+        const added = !existingParents.has(parentPath);
+        this.index[collectionId] = existingParents.add(parentPath);
+        return added;
+    }
+    has(collectionPath) {
+        const collectionId = collectionPath.lastSegment();
+        const parentPath = collectionPath.popLast();
+        const existingParents = this.index[collectionId];
+        return existingParents && existingParents.has(parentPath);
+    }
+    getEntries(collectionId) {
+        const parentPaths = this.index[collectionId] ||
+            new SortedSet(ResourcePath.comparator);
+        return parentPaths.toArray();
+    }
+}
+
+/**
  * @license
  * Copyright 2019 Google LLC
  *
@@ -8524,19 +10414,31 @@ class MemoryCollectionParentIndex {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const LOG_TAG$f = 'IndexedDbIndexManager';
+const EMPTY_VALUE = new Uint8Array(0);
 /**
  * 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();
+        /**
+         * Maps from a target to its equivalent list of sub-targets. Each sub-target
+         * contains only one term from the target's disjunctive normal form (DNF).
+         */
+        this.targetToDnfSubTargets = new ObjectMap(t => canonifyTarget(t), (l, r) => targetEquals(l, r));
+        this.uid = user.uid || '';
     }
     /**
      * Adds a new entry to the collection parent index.
@@ -8583,6 +10485,414 @@ 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, target) {
+        const indexEntries = indexEntriesStore(transaction);
+        let canServeTarget = true;
+        const indexes = new Map();
+        return PersistencePromise.forEach(this.getSubTargets(target), (subTarget) => {
+            return this.getFieldIndex(transaction, subTarget).next(index => {
+                canServeTarget && (canServeTarget = !!index);
+                indexes.set(subTarget, index);
+            });
+        }).next(() => {
+            if (!canServeTarget) {
+                return PersistencePromise.resolve(null);
+            }
+            else {
+                let result = documentKeySet();
+                return PersistencePromise.forEach(indexes, (index, subTarget) => {
+                    logDebug(LOG_TAG$f, `Using index ${fieldIndexToString(index)} to execute ${canonifyTarget(target)}`);
+                    const arrayValues = targetGetArrayValues(subTarget, index);
+                    const notInValues = targetGetNotInValues(subTarget, index);
+                    const lowerBound = targetGetLowerBound(subTarget, index);
+                    const upperBound = targetGetUpperBound(subTarget, index);
+                    const lowerBoundEncoded = this.encodeBound(index, subTarget, lowerBound);
+                    const upperBoundEncoded = this.encodeBound(index, subTarget, upperBound);
+                    const notInEncoded = this.encodeValues(index, subTarget, notInValues);
+                    const indexRanges = this.generateIndexRanges(index.indexId, arrayValues, lowerBoundEncoded, !!lowerBound && lowerBound.inclusive, upperBoundEncoded, !!upperBound && upperBound.inclusive, notInEncoded);
+                    return PersistencePromise.forEach(indexRanges, (indexRange) => {
+                        return indexEntries
+                            .loadFirst(indexRange, target.limit)
+                            .next(entries => {
+                            entries.forEach(entry => {
+                                result = result.add(new DocumentKey(decodeResourcePath(entry.documentKey)));
+                            });
+                        });
+                    });
+                }).next(() => result);
+            }
+        });
+    }
+    getSubTargets(target) {
+        let subTargets = this.targetToDnfSubTargets.get(target);
+        if (subTargets) {
+            return subTargets;
+        }
+        // TODO(orquery): Implement DNF transform
+        subTargets = [target];
+        this.targetToDnfSubTargets.set(target, subTargets);
+        return subTargets;
+    }
+    /**
+     * Constructs a key range query on `DbIndexEntry.store` that unions all
+     * bounds.
+     */
+    generateIndexRanges(indexId, arrayValues, lowerBounds, lowerBoundInclusive, upperBounds, upperBoundInclusive, notInValues) {
+        // The number of total index scans we union together. This is similar to a
+        // distributed normal form, but adapted for array values. We create a single
+        // index range per value in an ARRAY_CONTAINS or ARRAY_CONTAINS_ANY filter
+        // combined with the values from the query bounds.
+        const totalScans = (arrayValues != null ? arrayValues.length : 1) *
+            Math.max(lowerBounds != null ? lowerBounds.length : 1, upperBounds != null ? upperBounds.length : 1);
+        const scansPerArrayElement = totalScans / (arrayValues != null ? arrayValues.length : 1);
+        const indexRanges = [];
+        for (let i = 0; i < totalScans; ++i) {
+            const arrayValue = arrayValues
+                ? this.encodeSingleElement(arrayValues[i / scansPerArrayElement])
+                : EMPTY_VALUE;
+            const lowerBound = lowerBounds
+                ? this.generateLowerBound(indexId, arrayValue, lowerBounds[i % scansPerArrayElement], lowerBoundInclusive)
+                : this.generateEmptyBound(indexId);
+            const upperBound = upperBounds
+                ? this.generateUpperBound(indexId, arrayValue, upperBounds[i % scansPerArrayElement], upperBoundInclusive)
+                : this.generateEmptyBound(indexId + 1);
+            indexRanges.push(...this.createRange(lowerBound, upperBound, notInValues.map((notIn // make non-nullable
+            ) => this.generateLowerBound(indexId, arrayValue, notIn, 
+            /* inclusive= */ true))));
+        }
+        return indexRanges;
+    }
+    /** Generates the lower bound for `arrayValue` and `directionalValue`. */
+    generateLowerBound(indexId, arrayValue, directionalValue, inclusive) {
+        const entry = new IndexEntry(indexId, DocumentKey.empty(), arrayValue, directionalValue);
+        return inclusive ? entry : entry.successor();
+    }
+    /** Generates the upper bound for `arrayValue` and `directionalValue`. */
+    generateUpperBound(indexId, arrayValue, directionalValue, inclusive) {
+        const entry = new IndexEntry(indexId, DocumentKey.empty(), arrayValue, directionalValue);
+        return inclusive ? entry.successor() : entry;
+    }
+    /**
+     * Generates an empty bound that scopes the index scan to the current index
+     * and user.
+     */
+    generateEmptyBound(indexId) {
+        return new IndexEntry(indexId, DocumentKey.empty(), EMPTY_VALUE, EMPTY_VALUE);
+    }
+    getFieldIndex(transaction, target) {
+        const targetIndexMatcher = new TargetIndexMatcher(target);
+        const collectionGroup = target.collectionGroup != null
+            ? target.collectionGroup
+            : target.path.lastSegment();
+        return this.getFieldIndexes(transaction, collectionGroup).next(indexes => {
+            const matchingIndexes = indexes.filter(i => targetIndexMatcher.servedByIndex(i));
+            // Return the index that matches the most number of segments.
+            matchingIndexes.sort((l, r) => r.fields.length - l.fields.length);
+            return matchingIndexes.length > 0 ? matchingIndexes[0] : 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();
+    }
+    /**
+     * Encodes the given field values according to the specification in `target`.
+     * For IN queries, a list of possible values is returned.
+     */
+    encodeValues(fieldIndex, target, bound) {
+        if (bound === null) {
+            return [];
+        }
+        let encoders = [];
+        encoders.push(new IndexByteEncoder());
+        let boundIdx = 0;
+        for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+            const value = bound[boundIdx++];
+            for (const encoder of encoders) {
+                if (this.isInFilter(target, segment.fieldPath) && isArray(value)) {
+                    encoders = this.expandIndexValues(encoders, segment, value);
+                }
+                else {
+                    const directionalEncoder = encoder.forKind(segment.kind);
+                    FirestoreIndexValueWriter.INSTANCE.writeIndexValue(value, directionalEncoder);
+                }
+            }
+        }
+        return this.getEncodedBytes(encoders);
+    }
+    /**
+     * Encodes the given bounds according to the specification in `target`. For IN
+     * queries, a list of possible values is returned.
+     */
+    encodeBound(fieldIndex, target, bound) {
+        if (bound == null) {
+            return null;
+        }
+        return this.encodeValues(fieldIndex, target, bound.position);
+    }
+    /** Returns the byte representation for the provided encoders. */
+    getEncodedBytes(encoders) {
+        const result = [];
+        for (let i = 0; i < encoders.length; ++i) {
+            result[i] = encoders[i].encodedBytes();
+        }
+        return result;
+    }
+    /**
+     * Creates a separate encoder for each element of an array.
+     *
+     * The method appends each value to all existing encoders (e.g. filter("a",
+     * "==", "a1").filter("b", "in", ["b1", "b2"]) becomes ["a1,b1", "a1,b2"]). A
+     * list of new encoders is returned.
+     */
+    expandIndexValues(encoders, segment, value) {
+        const prefixes = [...encoders];
+        const results = [];
+        for (const arrayElement of value.arrayValue.values || []) {
+            for (const prefix of prefixes) {
+                const clonedEncoder = new IndexByteEncoder();
+                clonedEncoder.seed(prefix.encodedBytes());
+                FirestoreIndexValueWriter.INSTANCE.writeIndexValue(arrayElement, clonedEncoder.forKind(segment.kind));
+                results.push(clonedEncoder);
+            }
+        }
+        return results;
+    }
+    isInFilter(target, fieldPath) {
+        return !!target.filters.find(f => f instanceof FieldFilter &&
+            f.field.isEqual(fieldPath) &&
+            (f.op === "in" /* IN */ || f.op === "not-in" /* NOT_IN */));
+    }
+    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, EMPTY_VALUE, 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);
+    }
+    /**
+     * Returns a new set of IDB ranges that splits the existing range and excludes
+     * any values that match the `notInValue` from these ranges. As an example,
+     * '[foo > 2 && foo != 3]` becomes  `[foo > 2 && < 3, foo > 3]`.
+     */
+    createRange(lower, upper, notInValues) {
+        // The notIb values need to be sorted and unique so that we can return a
+        // sorted set of non-overlapping ranges.
+        notInValues = notInValues
+            .sort((l, r) => indexEntryComparator(l, r))
+            .filter((el, i, values) => !i || indexEntryComparator(el, values[i - 1]) !== 0);
+        const bounds = [];
+        bounds.push(lower);
+        for (const notInValue of notInValues) {
+            const cmpToLower = indexEntryComparator(notInValue, lower);
+            const cmpToUpper = indexEntryComparator(notInValue, upper);
+            if (cmpToLower === 0) {
+                // `notInValue` is the lower bound. We therefore need to raise the bound
+                // to the next value.
+                bounds[0] = lower.successor();
+            }
+            else if (cmpToLower > 0 && cmpToUpper < 0) {
+                // `notInValue` is in the middle of the range
+                bounds.push(notInValue);
+                bounds.push(notInValue.successor());
+            }
+            else if (cmpToUpper > 0) {
+                // `notInValue` (and all following values) are out of the range
+                break;
+            }
+        }
+        bounds.push(upper);
+        const ranges = [];
+        for (let i = 0; i < bounds.length; i += 2) {
+            ranges.push(IDBKeyRange.bound([
+                bounds[i].indexId,
+                this.uid,
+                bounds[i].arrayValue,
+                bounds[i].directionalValue,
+                ''
+            ], [
+                bounds[i + 1].indexId,
+                this.uid,
+                bounds[i + 1].arrayValue,
+                bounds[i + 1].directionalValue,
+                ''
+            ]));
+        }
+        return ranges;
+    }
 }
 /**
  * Helper to get a typed SimpleDbStore for the collectionParents
@@ -8590,6 +10900,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);
 }
 
 /**
@@ -9753,7 +12081,7 @@ class IndexedDbLruDelegateImpl {
                         // Our size accounting requires us to read all documents before
                         // removing them.
                         return changeBuffer.getEntry(txn, docKey).next(() => {
-                            changeBuffer.removeEntry(docKey);
+                            changeBuffer.removeEntry(docKey, SnapshotVersion.min());
                             return documentTargetStore(txn).delete(sentinelKey$1(docKey));
                         });
                     }
@@ -9775,163 +12103,62 @@ class IndexedDbLruDelegateImpl {
     }
     /**
      * Call provided function for each document in the cache that is 'orphaned'. Orphaned
-     * means not a part of any target, so the only entry in the target-document index for
-     * that document will be the sentinel row (targetId 0), which will also have the sequence
-     * number for the last time the document was accessed.
-     */
-    forEachOrphanedDocument(txn, f) {
-        const store = documentTargetStore(txn);
-        let nextToReport = ListenSequence.INVALID;
-        let nextPath;
-        return store
-            .iterate({
-            index: DbTargetDocument.documentTargetsIndex
-        }, ([targetId, docKey], { path, sequenceNumber }) => {
-            if (targetId === 0) {
-                // if nextToReport is valid, report it, this is a new key so the
-                // last one must not be a member of any targets.
-                if (nextToReport !== ListenSequence.INVALID) {
-                    f(new DocumentKey(decodeResourcePath(nextPath)), nextToReport);
-                }
-                // set nextToReport to be this sequence number. It's the next one we
-                // might report, if we don't find any targets for this document.
-                // Note that the sequence number must be defined when the targetId
-                // is 0.
-                nextToReport = sequenceNumber;
-                nextPath = path;
-            }
-            else {
-                // set nextToReport to be invalid, we know we don't need to report
-                // this one since we found a target for it.
-                nextToReport = ListenSequence.INVALID;
-            }
-        })
-            .next(() => {
-            // Since we report sequence numbers after getting to the next key, we
-            // need to check if the last key we iterated over was an orphaned
-            // document and report it.
-            if (nextToReport !== ListenSequence.INVALID) {
-                f(new DocumentKey(decodeResourcePath(nextPath)), nextToReport);
-            }
-        });
-    }
-    getCacheSize(txn) {
-        return this.db.getRemoteDocumentCache().getSize(txn);
-    }
-}
-function sentinelKey$1(key) {
-    return [0, encodeResourcePath(key.path)];
-}
-/**
- * @returns A value suitable for writing a sentinel row in the target-document
- * store.
- */
-function sentinelRow(key, sequenceNumber) {
-    return new DbTargetDocument(0, encodeResourcePath(key.path), sequenceNumber);
-}
-function writeSentinelKey(txn, key) {
-    return documentTargetStore(txn).put(sentinelRow(key, txn.currentSequenceNumber));
-}
-
-/**
- * @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.
- */
-/**
- * A map implementation that uses objects as keys. Objects must have an
- * associated equals function and must be immutable. Entries in the map are
- * stored together with the key being produced from the mapKeyFn. This map
- * automatically handles collisions of keys.
- */
-class ObjectMap {
-    constructor(mapKeyFn, equalsFn) {
-        this.mapKeyFn = mapKeyFn;
-        this.equalsFn = equalsFn;
-        /**
-         * The inner map for a key/value pair. Due to the possibility of collisions we
-         * keep a list of entries that we do a linear search through to find an actual
-         * match. Note that collisions should be rare, so we still expect near
-         * constant time lookups in practice.
-         */
-        this.inner = {};
-    }
-    /** Get a value for this key, or undefined if it does not exist. */
-    get(key) {
-        const id = this.mapKeyFn(key);
-        const matches = this.inner[id];
-        if (matches === undefined) {
-            return undefined;
-        }
-        for (const [otherKey, value] of matches) {
-            if (this.equalsFn(otherKey, key)) {
-                return value;
-            }
-        }
-        return undefined;
-    }
-    has(key) {
-        return this.get(key) !== undefined;
-    }
-    /** Put this key and value in the map. */
-    set(key, value) {
-        const id = this.mapKeyFn(key);
-        const matches = this.inner[id];
-        if (matches === undefined) {
-            this.inner[id] = [[key, value]];
-            return;
-        }
-        for (let i = 0; i < matches.length; i++) {
-            if (this.equalsFn(matches[i][0], key)) {
-                matches[i] = [key, value];
-                return;
-            }
-        }
-        matches.push([key, value]);
-    }
-    /**
-     * Remove this key from the map. Returns a boolean if anything was deleted.
-     */
-    delete(key) {
-        const id = this.mapKeyFn(key);
-        const matches = this.inner[id];
-        if (matches === undefined) {
-            return false;
-        }
-        for (let i = 0; i < matches.length; i++) {
-            if (this.equalsFn(matches[i][0], key)) {
-                if (matches.length === 1) {
-                    delete this.inner[id];
-                }
-                else {
-                    matches.splice(i, 1);
+     * means not a part of any target, so the only entry in the target-document index for
+     * that document will be the sentinel row (targetId 0), which will also have the sequence
+     * number for the last time the document was accessed.
+     */
+    forEachOrphanedDocument(txn, f) {
+        const store = documentTargetStore(txn);
+        let nextToReport = ListenSequence.INVALID;
+        let nextPath;
+        return store
+            .iterate({
+            index: DbTargetDocument.documentTargetsIndex
+        }, ([targetId, docKey], { path, sequenceNumber }) => {
+            if (targetId === 0) {
+                // if nextToReport is valid, report it, this is a new key so the
+                // last one must not be a member of any targets.
+                if (nextToReport !== ListenSequence.INVALID) {
+                    f(new DocumentKey(decodeResourcePath(nextPath)), nextToReport);
                 }
-                return true;
+                // set nextToReport to be this sequence number. It's the next one we
+                // might report, if we don't find any targets for this document.
+                // Note that the sequence number must be defined when the targetId
+                // is 0.
+                nextToReport = sequenceNumber;
+                nextPath = path;
             }
-        }
-        return false;
-    }
-    forEach(fn) {
-        forEach(this.inner, (_, entries) => {
-            for (const [k, v] of entries) {
-                fn(k, v);
+            else {
+                // set nextToReport to be invalid, we know we don't need to report
+                // this one since we found a target for it.
+                nextToReport = ListenSequence.INVALID;
+            }
+        })
+            .next(() => {
+            // Since we report sequence numbers after getting to the next key, we
+            // need to check if the last key we iterated over was an orphaned
+            // document and report it.
+            if (nextToReport !== ListenSequence.INVALID) {
+                f(new DocumentKey(decodeResourcePath(nextPath)), nextToReport);
             }
         });
     }
-    isEmpty() {
-        return isEmpty(this.inner);
+    getCacheSize(txn) {
+        return this.db.getRemoteDocumentCache().getSize(txn);
     }
+}
+function sentinelKey$1(key) {
+    return [0, encodeResourcePath(key.path)];
+}
+/**
+ * @returns A value suitable for writing a sentinel row in the target-document
+ * store.
+ */
+function sentinelRow(key, sequenceNumber) {
+    return new DbTargetDocument(0, encodeResourcePath(key.path), sequenceNumber);
+}
+function writeSentinelKey(txn, key) {
+    return documentTargetStore(txn).put(sentinelRow(key, txn.currentSequenceNumber));
 }
 
 /**
@@ -9966,27 +12193,19 @@ class ObjectMap {
  */
 class RemoteDocumentChangeBuffer {
     constructor() {
-        // A mapping of document key to the new cache entry that should be written (or null if any
-        // existing cache entry should be removed).
+        // A mapping of document key to the new cache entry that should be written.
         this.changes = new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
         this.changesApplied = false;
     }
-    getReadTime(key) {
-        const change = this.changes.get(key);
-        if (change) {
-            return change.readTime;
-        }
-        return SnapshotVersion.min();
-    }
     /**
      * Buffers a `RemoteDocumentCache.addEntry()` call.
      *
      * You can only modify documents that have already been retrieved via
      * `getEntry()/getEntries()` (enforced via IndexedDbs `apply()`).
      */
-    addEntry(document, readTime) {
+    addEntry(document) {
         this.assertNotApplied();
-        this.changes.set(document.key, { document, readTime });
+        this.changes.set(document.key, document);
     }
     /**
      * Buffers a `RemoteDocumentCache.removeEntry()` call.
@@ -9994,12 +12213,9 @@ class RemoteDocumentChangeBuffer {
      * You can only remove documents that have already been retrieved via
      * `getEntry()/getEntries()` (enforced via IndexedDbs `apply()`).
      */
-    removeEntry(key, readTime = null) {
+    removeEntry(key, readTime) {
         this.assertNotApplied();
-        this.changes.set(key, {
-            document: MutableDocument.newInvalidDocument(key),
-            readTime
-        });
+        this.changes.set(key, MutableDocument.newInvalidDocument(key).setReadTime(readTime));
     }
     /**
      * Looks up an entry in the cache. The buffered changes will first be checked,
@@ -10016,7 +12232,7 @@ class RemoteDocumentChangeBuffer {
         this.assertNotApplied();
         const bufferedEntry = this.changes.get(documentKey);
         if (bufferedEntry !== undefined) {
-            return PersistencePromise.resolve(bufferedEntry.document);
+            return PersistencePromise.resolve(bufferedEntry);
         }
         else {
             return this.getFromCache(transaction, documentKey);
@@ -10070,12 +12286,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;
     }
     /**
@@ -10197,21 +12411,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);
@@ -10227,13 +12441,13 @@ class IndexedDbRemoteDocumentCacheImpl {
             if (key.length !== immediateChildrenPathLength) {
                 return;
             }
-            const document = fromDbRemoteDocument(this.serializer, dbRemoteDoc);
-            if (!query.path.isPrefixOf(document.key.path)) {
-                control.done();
-            }
-            else if (queryMatches(query, document)) {
+            const document = this.maybeDecodeDocument(DocumentKey.fromSegments(key), dbRemoteDoc);
+            if (collection.isPrefixOf(document.key.path)) {
                 results = results.insert(document.key, document);
             }
+            else {
+                control.done();
+            }
         })
             .next(() => results);
     }
@@ -10255,8 +12469,8 @@ class IndexedDbRemoteDocumentCacheImpl {
         return documentGlobalStore(txn).put(DbRemoteDocumentGlobal.key, metadata);
     }
     /**
-     * Decodes `remoteDoc` and returns the document (or null, if the document
-     * corresponds to the format used for sentinel deletes).
+     * Decodes `dbRemoteDoc` and returns the document (or an invalid document if
+     * the document corresponds to the format used for sentinel deletes).
      */
     maybeDecodeDocument(documentKey, dbRemoteDoc) {
         if (dbRemoteDoc) {
@@ -10271,14 +12485,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
@@ -10350,8 +12559,8 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
         let collectionParents = new SortedSet((l, r) => primitiveComparator(l.canonicalString(), r.canonicalString()));
         this.changes.forEach((key, documentChange) => {
             const previousSize = this.documentSizes.get(key);
-            if (documentChange.document.isValidDocument()) {
-                const doc = toDbRemoteDocument(this.documentCache.serializer, documentChange.document, this.getReadTime(key));
+            if (documentChange.isValidDocument()) {
+                const doc = toDbRemoteDocument(this.documentCache.serializer, documentChange);
                 collectionParents = collectionParents.add(key.path.popLast());
                 const size = dbDocumentSize(doc);
                 sizeDelta += size - previousSize;
@@ -10364,7 +12573,7 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
                     // RemoteDocumentCache. This entry is represented by a NoDocument
                     // with a version of 0 and ignored by `maybeDecodeDocument()` but
                     // preserved in `getNewDocumentChanges()`.
-                    const deletedDoc = toDbRemoteDocument(this.documentCache.serializer, MutableDocument.newNoDocument(key, SnapshotVersion.min()), this.getReadTime(key));
+                    const deletedDoc = toDbRemoteDocument(this.documentCache.serializer, documentChange.convertToNoDocument(SnapshotVersion.min()));
                     promises.push(this.documentCache.addEntry(transaction, key, deletedDoc));
                 }
                 else {
@@ -10445,9 +12654,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);
@@ -10514,6 +12720,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) {
@@ -10720,6 +12936,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 });
 }
 
 /**
@@ -10831,7 +13069,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;
@@ -10840,6 +13078,7 @@ class IndexedDbPersistence {
         this.document = document;
         this.sequenceNumberSyncer = sequenceNumberSyncer;
         this.forceOwningTab = forceOwningTab;
+        this.schemaVersion = schemaVersion;
         this.listenSequence = null;
         this._started = false;
         this.isPrimary = false;
@@ -10861,10 +13100,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;
@@ -11200,8 +13438,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;
@@ -11209,8 +13447,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;
@@ -11218,11 +13459,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);
@@ -11594,39 +13836,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
@@ -11639,29 +13870,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;
-        });
-    }
 }
 
 /**
@@ -11720,11 +13928,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) {
@@ -11746,8 +13961,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.
@@ -11756,11 +13969,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 = [];
@@ -11781,7 +13991,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 {
@@ -11792,9 +14002,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. */
@@ -11951,14 +14158,14 @@ function localStoreApplyRemoteEventToLocalCache(localStore, remoteEvent) {
             }
         });
         let changedDocs = mutableDocumentMap();
-        remoteEvent.documentUpdates.forEach((key, doc) => {
+        remoteEvent.documentUpdates.forEach(key => {
             if (remoteEvent.resolvedLimboDocuments.has(key)) {
                 promises.push(localStoreImpl.persistence.referenceDelegate.updateLimboDocument(txn, key));
             }
         });
         // Each loop iteration only affects its "own" doc, so it's safe to get all the remote
         // documents in advance in a single call.
-        promises.push(populateDocumentChangeBuffer(txn, documentBuffer, remoteEvent.documentUpdates, remoteVersion, undefined).next(result => {
+        promises.push(populateDocumentChangeBuffer(txn, documentBuffer, remoteEvent.documentUpdates).next(result => {
             changedDocs = result;
         }));
         // HACK: The only reason we allow a null snapshot version is so that we
@@ -11999,17 +14206,13 @@ function localStoreApplyRemoteEventToLocalCache(localStore, remoteEvent) {
  * Note: this function will use `documentVersions` if it is defined;
  * when it is not defined, resorts to `globalVersion`.
  */
-function populateDocumentChangeBuffer(txn, documentBuffer, documents, globalVersion, 
-// TODO(wuandy): We could add `readTime` to MaybeDocument instead to remove
-// this parameter.
-documentVersions) {
+function populateDocumentChangeBuffer(txn, documentBuffer, documents) {
     let updatedKeys = documentKeySet();
     documents.forEach(k => (updatedKeys = updatedKeys.add(k)));
     return documentBuffer.getEntries(txn, updatedKeys).next(existingDocs => {
         let changedDocs = mutableDocumentMap();
         documents.forEach((key, doc) => {
             const existingDoc = existingDocs.get(key);
-            const docReadTime = (documentVersions === null || documentVersions === void 0 ? void 0 : documentVersions.get(key)) || globalVersion;
             // Note: The order of the steps below is important, since we want
             // to ensure that rejected limbo resolutions (which fabricate
             // NoDocuments with SnapshotVersion.min()) never add documents to
@@ -12018,14 +14221,14 @@ documentVersions) {
                 // NoDocuments with SnapshotVersion.min() are used in manufactured
                 // events. We remove these documents from cache since we lost
                 // access.
-                documentBuffer.removeEntry(key, docReadTime);
+                documentBuffer.removeEntry(key, doc.readTime);
                 changedDocs = changedDocs.insert(key, doc);
             }
             else if (!existingDoc.isValidDocument() ||
                 doc.version.compareTo(existingDoc.version) > 0 ||
                 (doc.version.compareTo(existingDoc.version) === 0 &&
                     existingDoc.hasPendingWrites)) {
-                documentBuffer.addEntry(doc, docReadTime);
+                documentBuffer.addEntry(doc);
                 changedDocs = changedDocs.insert(key, doc);
             }
             else {
@@ -12279,7 +14482,8 @@ function applyWriteToRemoteDocuments(localStoreImpl, txn, batchResult, documentB
                     // We use the commitVersion as the readTime rather than the
                     // document's updateTime since the updateTime is not advanced
                     // for updates that do not modify the underlying document.
-                    documentBuffer.addEntry(doc, batchResult.commitVersion);
+                    doc.setReadTime(batchResult.commitVersion);
+                    documentBuffer.addEntry(doc);
                 }
             }
         });
@@ -12380,14 +14584,14 @@ async function localStoreApplyBundledDocuments(localStore, bundleConverter, docu
     const localStoreImpl = debugCast(localStore);
     let documentKeys = documentKeySet();
     let documentMap = mutableDocumentMap();
-    let versionMap = documentVersionMap();
     for (const bundleDoc of documents) {
         const documentKey = bundleConverter.toDocumentKey(bundleDoc.metadata.name);
         if (bundleDoc.document) {
             documentKeys = documentKeys.add(documentKey);
         }
-        documentMap = documentMap.insert(documentKey, bundleConverter.toMutableDocument(bundleDoc));
-        versionMap = versionMap.insert(documentKey, bundleConverter.toSnapshotVersion(bundleDoc.metadata.readTime));
+        const doc = bundleConverter.toMutableDocument(bundleDoc);
+        doc.setReadTime(bundleConverter.toSnapshotVersion(bundleDoc.metadata.readTime));
+        documentMap = documentMap.insert(documentKey, doc);
     }
     const documentBuffer = localStoreImpl.remoteDocuments.newChangeBuffer({
         trackRemovals: true // Make sure document removals show up in `getNewDocumentChanges()`
@@ -12396,7 +14600,7 @@ async function localStoreApplyBundledDocuments(localStore, bundleConverter, docu
     // they will not get garbage collected right away.
     const umbrellaTargetData = await localStoreAllocateTarget(localStoreImpl, umbrellaTarget(bundleName));
     return localStoreImpl.persistence.runTransaction('Apply bundle documents', 'readwrite', txn => {
-        return populateDocumentChangeBuffer(txn, documentBuffer, documentMap, SnapshotVersion.min(), versionMap)
+        return populateDocumentChangeBuffer(txn, documentBuffer, documentMap)
             .next(changedDocs => {
             documentBuffer.apply(txn);
             return changedDocs;
@@ -12510,6 +14714,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
@@ -12863,29 +15183,30 @@ 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.
      *
      * All calls of `addEntry`  are required to go through the RemoteDocumentChangeBuffer
      * returned by `newChangeBuffer()`.
      */
-    addEntry(transaction, doc, readTime) {
+    addEntry(transaction, doc) {
         const key = doc.key;
         const entry = this.docs.get(key);
         const previousSize = entry ? entry.size : 0;
         const currentSize = this.sizer(doc);
         this.docs = this.docs.insert(key, {
             document: doc.mutableCopy(),
-            size: currentSize,
-            readTime
+            size: currentSize
         });
         this.size += currentSize - previousSize;
         return this.indexManager.addToCollectionParentIndex(transaction, key.path.popLast());
@@ -12919,21 +15240,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, readTime } } = iterator.getNext();
-            if (!query.path.isPrefixOf(key.path)) {
+            const { key, value: { document } } = iterator.getNext();
+            if (!collectionPath.isPrefixOf(key.path)) {
                 break;
             }
-            if (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());
@@ -12955,13 +15277,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.
@@ -12974,8 +15295,8 @@ class MemoryRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
     applyChanges(transaction) {
         const promises = [];
         this.changes.forEach((key, doc) => {
-            if (doc.document.isValidDocument()) {
-                promises.push(this.documentCache.addEntry(transaction, doc.document, this.getReadTime(key)));
+            if (doc.isValidDocument()) {
+                promises.push(this.documentCache.addEntry(transaction, doc));
             }
             else {
                 this.documentCache.removeEntry(key);
@@ -13155,6 +15476,7 @@ class MemoryPersistence {
      */
     constructor(referenceDelegateFactory, serializer) {
         this.mutationQueues = {};
+        this.overlays = {};
         this.listenSequence = new ListenSequence(0);
         this._started = false;
         this._started = true;
@@ -13162,7 +15484,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);
     }
@@ -13183,13 +15505,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;
@@ -13288,7 +15620,7 @@ class MemoryEagerDelegate {
             const key = DocumentKey.fromPath(path);
             return this.isReferenced(txn, key).next(isReferenced => {
                 if (!isReferenced) {
-                    changeBuffer.removeEntry(key);
+                    changeBuffer.removeEntry(key, SnapshotVersion.min());
                 }
             });
         }).next(() => {
@@ -14334,7 +16666,7 @@ const LOG_TAG$9 = 'Connection';
 const X_GOOG_API_CLIENT_VALUE = `gl-node/${process.versions.node} fire/${SDK_VERSION} grpc/${grpcVersion}`;
 function createMetadata(databasePath, authToken, appCheckToken, appId) {
     hardAssert(authToken === null || authToken.type === 'OAuth');
-    const metadata = new Metadata();
+    const metadata = new grpc.Metadata();
     if (authToken) {
         authToken.headers.forEach((value, key) => metadata.set(key, value));
     }
@@ -14365,10 +16697,10 @@ class GrpcConnection {
     ensureActiveStub() {
         if (!this.cachedStub) {
             logDebug(LOG_TAG$9, 'Creating Firestore stub.');
-            const credentials$1 = this.databaseInfo.ssl
-                ? credentials.createSsl()
-                : credentials.createInsecure();
-            this.cachedStub = new this.firestore.Firestore(this.databaseInfo.host, credentials$1);
+            const credentials = this.databaseInfo.ssl
+                ? grpc.credentials.createSsl()
+                : grpc.credentials.createInsecure();
+            this.cachedStub = new this.firestore.Firestore(this.databaseInfo.host, credentials);
         }
         return this.cachedStub;
     }
@@ -17068,6 +19400,40 @@ const nested = {
 								id: 2
 							}
 						}
+					},
+					methodSignature: {
+						rule: "repeated",
+						type: "string",
+						id: 1051,
+						extend: "google.protobuf.MethodOptions"
+					},
+					defaultHost: {
+						type: "string",
+						id: 1049,
+						extend: "google.protobuf.ServiceOptions"
+					},
+					oauthScopes: {
+						type: "string",
+						id: 1050,
+						extend: "google.protobuf.ServiceOptions"
+					},
+					fieldBehavior: {
+						rule: "repeated",
+						type: "google.api.FieldBehavior",
+						id: 1052,
+						extend: "google.protobuf.FieldOptions"
+					},
+					FieldBehavior: {
+						values: {
+							FIELD_BEHAVIOR_UNSPECIFIED: 0,
+							OPTIONAL: 1,
+							REQUIRED: 2,
+							OUTPUT_ONLY: 3,
+							INPUT_ONLY: 4,
+							IMMUTABLE: 5,
+							UNORDERED_LIST: 6,
+							NON_EMPTY_DEFAULT: 7
+						}
 					}
 				}
 			},
@@ -17166,8 +19532,8 @@ const protoLoaderOptions = {
  * @returns The GrpcObject representing our protos.
  */
 function loadProtos() {
-    const packageDefinition = fromJSON(protos$1, protoLoaderOptions);
-    return loadPackageDefinition(packageDefinition);
+    const packageDefinition = protoLoader.fromJSON(protos$1, protoLoaderOptions);
+    return grpc.loadPackageDefinition(packageDefinition);
 }
 
 /**
@@ -20118,12 +22484,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;
 }
@@ -20311,6 +22677,9 @@ async function syncEngineRejectListen(syncEngine, targetId, err) {
         // store to purge a document. However, it would be tricky to keep all of
         // the local store's invariants with another method.
         let documentUpdates = new SortedMap(DocumentKey.comparator);
+        // TODO(b/217189216): This limbo document should ideally have a read time,
+        // so that it is picked up by any read-time based scans. The backend,
+        // however, does not send a read time for target removals.
         documentUpdates = documentUpdates.insert(limboKey, MutableDocument.newNoDocument(limboKey, SnapshotVersion.min()));
         const resolvedLimboDocuments = documentKeySet().add(limboKey);
         const event = new RemoteEvent(SnapshotVersion.min(), 
@@ -22255,72 +24624,6 @@ function createBundleReader(data, serializer) {
     return newBundleReader(toByteStreamReader(content), serializer);
 }
 
-/**
- * @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.
- */
-class DatabaseInfo {
-    /**
-     * Constructs a DatabaseInfo using the provided host, databaseId and
-     * persistenceKey.
-     *
-     * @param databaseId - The database to use.
-     * @param appId - The Firebase App Id.
-     * @param persistenceKey - A unique identifier for this Firestore's local
-     * storage (used in conjunction with the databaseId).
-     * @param host - The Firestore backend host to connect to.
-     * @param ssl - Whether to use SSL when connecting.
-     * @param forceLongPolling - Whether to use the forceLongPolling option
-     * when using WebChannel as the network transport.
-     * @param autoDetectLongPolling - Whether to use the detectBufferingProxy
-     * option when using WebChannel as the network transport.
-     * @param useFetchStreams Whether to use the Fetch API instead of
-     * XMLHTTPRequest
-     */
-    constructor(databaseId, appId, persistenceKey, host, ssl, forceLongPolling, autoDetectLongPolling, useFetchStreams) {
-        this.databaseId = databaseId;
-        this.appId = appId;
-        this.persistenceKey = persistenceKey;
-        this.host = host;
-        this.ssl = ssl;
-        this.forceLongPolling = forceLongPolling;
-        this.autoDetectLongPolling = autoDetectLongPolling;
-        this.useFetchStreams = useFetchStreams;
-    }
-}
-/** The default database name for a project. */
-const DEFAULT_DATABASE_NAME = '(default)';
-/**
- * Represents the database ID a Firestore client is associated with.
- * @internal
- */
-class DatabaseId {
-    constructor(projectId, database) {
-        this.projectId = projectId;
-        this.database = database ? database : DEFAULT_DATABASE_NAME;
-    }
-    get isDefaultDatabase() {
-        return this.database === DEFAULT_DATABASE_NAME;
-    }
-    isEqual(other) {
-        return (other instanceof DatabaseId &&
-            other.projectId === this.projectId &&
-            other.database === this.database);
-    }
-}
-
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -24694,8 +26997,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();
@@ -25069,51 +27371,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) {
@@ -25171,7 +27475,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}().`);
@@ -25208,12 +27512,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) {
@@ -25250,7 +27554,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
@@ -26234,17 +28538,6 @@ function writeBatch(firestore) {
     ensureFirestoreConfigured(firestore);
     return new WriteBatch(firestore, mutations => executeWrite(firestore, mutations));
 }
-/** An index component consisting of field path and index type.  */
-class Segment {
-    constructor(
-    /** The field path of the component. */
-    fieldPath, 
-    /** The fields sorting order. */
-    kind) {
-        this.fieldPath = fieldPath;
-        this.kind = kind;
-    }
-}
 
 /**
  * @license
@@ -26268,27 +28561,29 @@ function setIndexConfiguration(firestore, jsonOrConfiguration) {
     const indexConfiguration = typeof jsonOrConfiguration === 'string'
         ? tryParseJson(jsonOrConfiguration)
         : jsonOrConfiguration;
+    const parsedIndexes = [];
     // PORTING NOTE: We don't return an error if the user has not enabled
     // persistence since `enableIndexeddbPersistence()` can fail on the Web.
     if (Array.isArray(indexConfiguration.indexes)) {
         for (const index of indexConfiguration.indexes) {
-            tryGetString(index, 'collectionGroup');
+            const collectionGroup = tryGetString(index, 'collectionGroup');
             const segments = [];
             if (Array.isArray(index.fields)) {
                 for (const field of index.fields) {
                     const fieldPathString = tryGetString(field, 'fieldPath');
                     const fieldPath = fieldPathFromDotSeparatedString('setIndexConfiguration', fieldPathString);
                     if (field.arrayConfig === 'CONTAINS') {
-                        segments.push(new Segment(fieldPath, 2 /* CONTAINS */));
+                        segments.push(new IndexSegment(fieldPath, 2 /* CONTAINS */));
                     }
                     else if (field.order === 'ASCENDING') {
-                        segments.push(new Segment(fieldPath, 0 /* ASCENDING */));
+                        segments.push(new IndexSegment(fieldPath, 0 /* ASCENDING */));
                     }
                     else if (field.order === 'DESCENDING') {
-                        segments.push(new Segment(fieldPath, 1 /* DESCENDING */));
+                        segments.push(new IndexSegment(fieldPath, 1 /* DESCENDING */));
                     }
                 }
             }
+            parsedIndexes.push(new FieldIndex(FieldIndex.UNKNOWN_ID, collectionGroup, segments, IndexState.empty()));
         }
     }
     // TODO(indexing): Configure indexes