@firebase/firestore 3.4.5 → 3.4.6-canary.3198d58dc

package/dist/index.node.cjs.js

@@ -33,7 +33,7 @@ var grpc__namespace = /*#__PURE__*/_interopNamespace(grpc);
 var protoLoader__namespace = /*#__PURE__*/_interopNamespace(protoLoader);
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.5";
+const version$1 = "3.4.6-canary.3198d58dc";
 
 /**
  * @license
@@ -86,7 +86,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.7";
+const version = "9.6.9-canary.3198d58dc";
 
 /**
  * @license
@@ -1224,55 +1224,41 @@ function decodeResourcePath(path) {
     }
     return new ResourcePath(segments);
 }
+
 /**
- * Schema Version for the Web client:
- * 1.  Initial version including Mutation Queue, Query Cache, and Remote
- *     Document Cache
- * 2.  Used to ensure a targetGlobal object exists and add targetCount to it. No
- *     longer required because migration 3 unconditionally clears it.
- * 3.  Dropped and re-created Query Cache to deal with cache corruption related
- *     to limbo resolution. Addresses
- *     https://github.com/firebase/firebase-ios-sdk/issues/1548
- * 4.  Multi-Tab Support.
- * 5.  Removal of held write acks.
- * 6.  Create document global for tracking document cache size.
- * 7.  Ensure every cached document has a sentinel row with a sequence number.
- * 8.  Add collection-parent index for Collection Group queries.
- * 9.  Change RemoteDocumentChanges store to be keyed by readTime rather than
- *     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 = 12;
-/**
- * Wrapper class to store timestamps (seconds and nanos) in IndexedDb objects.
+ * @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.
  */
-class DbTimestamp {
-    constructor(seconds, nanoseconds) {
-        this.seconds = seconds;
-        this.nanoseconds = nanoseconds;
-    }
-}
+const DbRemoteDocumentStore$1 = 'remoteDocuments';
+
 /**
- * A singleton object to be stored in the 'owner' store in IndexedDb.
+ * @license
+ * Copyright 2022 Google LLC
  *
- * A given database can have a single primary tab assigned at a given time. That
- * tab must validate that it is still holding the primary lease before every
- * operation that requires locked access. The primary tab should regularly
- * write an updated timestamp to this lease to prevent other tabs from
- * "stealing" the primary lease
+ * 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 DbPrimaryClient {
-    constructor(ownerId, 
-    /** Whether to allow shared access from multiple tabs. */
-    allowTabSynchronization, leaseTimestampMs) {
-        this.ownerId = ownerId;
-        this.allowTabSynchronization = allowTabSynchronization;
-        this.leaseTimestampMs = leaseTimestampMs;
-    }
-}
 /**
  * Name of the IndexedDb object store.
  *
@@ -1280,550 +1266,128 @@ class DbPrimaryClient {
  * older clients that only supported single locked access to the persistence
  * layer.
  */
-DbPrimaryClient.store = 'owner';
+const DbPrimaryClientStore = 'owner';
 /**
  * The key string used for the single object that exists in the
  * DbPrimaryClient store.
  */
-DbPrimaryClient.key = 'owner';
-/**
- * An object to be stored in the 'mutationQueues' store in IndexedDb.
- *
- * Each user gets a single queue of MutationBatches to apply to the server.
- * DbMutationQueue tracks the metadata about the queue.
- */
-class DbMutationQueue {
-    constructor(
-    /**
-     * The normalized user ID to which this queue belongs.
-     */
-    userId, 
-    /**
-     * An identifier for the highest numbered batch that has been acknowledged
-     * by the server. All MutationBatches in this queue with batchIds less
-     * than or equal to this value are considered to have been acknowledged by
-     * the server.
-     *
-     * NOTE: this is deprecated and no longer used by the code.
-     */
-    lastAcknowledgedBatchId, 
-    /**
-     * A stream token that was previously sent by the server.
-     *
-     * See StreamingWriteRequest in datastore.proto for more details about
-     * usage.
-     *
-     * After sending this token, earlier tokens may not be used anymore so
-     * only a single stream token is retained.
-     *
-     * NOTE: this is deprecated and no longer used by the code.
-     */
-    lastStreamToken) {
-        this.userId = userId;
-        this.lastAcknowledgedBatchId = lastAcknowledgedBatchId;
-        this.lastStreamToken = lastStreamToken;
-    }
-}
+const DbPrimaryClientKey = 'owner';
 /** Name of the IndexedDb object store.  */
-DbMutationQueue.store = 'mutationQueues';
+const DbMutationQueueStore = 'mutationQueues';
 /** Keys are automatically assigned via the userId property. */
-DbMutationQueue.keyPath = 'userId';
-/**
- * An object to be stored in the 'mutations' store in IndexedDb.
- *
- * Represents a batch of user-level mutations intended to be sent to the server
- * in a single write. Each user-level batch gets a separate DbMutationBatch
- * with a new batchId.
- */
-class DbMutationBatch {
-    constructor(
-    /**
-     * The normalized user ID to which this batch belongs.
-     */
-    userId, 
-    /**
-     * An identifier for this batch, allocated using an auto-generated key.
-     */
-    batchId, 
-    /**
-     * The local write time of the batch, stored as milliseconds since the
-     * epoch.
-     */
-    localWriteTimeMs, 
-    /**
-     * A list of "mutations" that represent a partial base state from when this
-     * write batch was initially created. During local application of the write
-     * batch, these baseMutations are applied prior to the real writes in order
-     * to override certain document fields from the remote document cache. This
-     * is necessary in the case of non-idempotent writes (e.g. `increment()`
-     * transforms) to make sure that the local view of the modified documents
-     * doesn't flicker if the remote document cache receives the result of the
-     * non-idempotent write before the write is removed from the queue.
-     *
-     * These mutations are never sent to the backend.
-     */
-    baseMutations, 
-    /**
-     * A list of mutations to apply. All mutations will be applied atomically.
-     *
-     * Mutations are serialized via toMutation().
-     */
-    mutations) {
-        this.userId = userId;
-        this.batchId = batchId;
-        this.localWriteTimeMs = localWriteTimeMs;
-        this.baseMutations = baseMutations;
-        this.mutations = mutations;
-    }
-}
+const DbMutationQueueKeyPath = 'userId';
 /** Name of the IndexedDb object store.  */
-DbMutationBatch.store = 'mutations';
+const DbMutationBatchStore = 'mutations';
 /** Keys are automatically assigned via the userId, batchId properties. */
-DbMutationBatch.keyPath = 'batchId';
+const DbMutationBatchKeyPath = 'batchId';
 /** The index name for lookup of mutations by user. */
-DbMutationBatch.userMutationsIndex = 'userMutationsIndex';
+const DbMutationBatchUserMutationsIndex = 'userMutationsIndex';
 /** The user mutations index is keyed by [userId, batchId] pairs. */
-DbMutationBatch.userMutationsKeyPath = ['userId', 'batchId'];
+const DbMutationBatchUserMutationsKeyPath = ['userId', 'batchId'];
 /**
- * An object to be stored in the 'documentMutations' store in IndexedDb.
- *
- * A manually maintained index of all the mutation batches that affect a given
- * document key. The rows in this table are references based on the contents of
- * DbMutationBatch.mutations.
+ * Creates a [userId] key for use in the DbDocumentMutations index to iterate
+ * over all of a user's document mutations.
  */
-class DbDocumentMutation {
-    constructor() { }
-    /**
-     * Creates a [userId] key for use in the DbDocumentMutations index to iterate
-     * over all of a user's document mutations.
-     */
-    static prefixForUser(userId) {
-        return [userId];
-    }
-    /**
-     * Creates a [userId, encodedPath] key for use in the DbDocumentMutations
-     * index to iterate over all at document mutations for a given path or lower.
-     */
-    static prefixForPath(userId, path) {
-        return [userId, encodeResourcePath(path)];
-    }
-    /**
-     * Creates a full index key of [userId, encodedPath, batchId] for inserting
-     * and deleting into the DbDocumentMutations index.
-     */
-    static key(userId, path, batchId) {
-        return [userId, encodeResourcePath(path), batchId];
-    }
+function newDbDocumentMutationPrefixForUser(userId) {
+    return [userId];
 }
-DbDocumentMutation.store = 'documentMutations';
-/**
- * Because we store all the useful information for this store in the key,
- * there is no useful information to store as the value. The raw (unencoded)
- * path cannot be stored because IndexedDb doesn't store prototype
- * information.
- */
-DbDocumentMutation.PLACEHOLDER = new DbDocumentMutation();
 /**
- * Represents the known absence of a document at a particular version.
- * Stored in IndexedDb as part of a DbRemoteDocument object.
+ * Creates a [userId, encodedPath] key for use in the DbDocumentMutations
+ * index to iterate over all at document mutations for a given path or lower.
  */
-class DbNoDocument {
-    constructor(path, readTime) {
-        this.path = path;
-        this.readTime = readTime;
-    }
+function newDbDocumentMutationPrefixForPath(userId, path) {
+    return [userId, encodeResourcePath(path)];
 }
 /**
- * Represents a document that is known to exist but whose data is unknown.
- * Stored in IndexedDb as part of a DbRemoteDocument object.
+ * Creates a full index key of [userId, encodedPath, batchId] for inserting
+ * and deleting into the DbDocumentMutations index.
  */
-class DbUnknownDocument {
-    constructor(path, version) {
-        this.path = path;
-        this.version = version;
-    }
+function newDbDocumentMutationKey(userId, path, batchId) {
+    return [userId, encodeResourcePath(path), batchId];
 }
 /**
- * An object to be stored in the 'remoteDocuments' store in IndexedDb.
- * It represents either:
- *
- * - A complete document.
- * - A "no document" representing a document that is known not to exist (at
- * some version).
- * - An "unknown document" representing a document that is known to exist (at
- * some version) but whose contents are unknown.
- *
- * Note: This is the persisted equivalent of a MaybeDocument and could perhaps
- * be made more general if necessary.
+ * Because we store all the useful information for this store in the key,
+ * there is no useful information to store as the value. The raw (unencoded)
+ * path cannot be stored because IndexedDb doesn't store prototype
+ * information.
  */
-class DbRemoteDocument {
-    // TODO: We are currently storing full document keys almost three times
-    // (once as part of the primary key, once - partly - as `parentPath` and once
-    // inside the encoded documents). During our next migration, we should
-    // rewrite the primary key as parentPath + document ID which would allow us
-    // to drop one value.
-    constructor(
-    /**
-     * Set to an instance of DbUnknownDocument if the data for a document is
-     * not known, but it is known that a document exists at the specified
-     * version (e.g. it had a successful update applied to it)
-     */
-    unknownDocument, 
-    /**
-     * Set to an instance of a DbNoDocument if it is known that no document
-     * exists.
-     */
-    noDocument, 
-    /**
-     * Set to an instance of a Document if there's a cached version of the
-     * document.
-     */
-    document, 
-    /**
-     * Documents that were written to the remote document store based on
-     * a write acknowledgment are marked with `hasCommittedMutations`. These
-     * documents are potentially inconsistent with the backend's copy and use
-     * the write's commit version as their document version.
-     */
-    hasCommittedMutations, 
-    /**
-     * When the document was read from the backend. Undefined for data written
-     * prior to schema version 9.
-     */
-    readTime, 
-    /**
-     * The path of the collection this document is part of. Undefined for data
-     * written prior to schema version 9.
-     */
-    parentPath) {
-        this.unknownDocument = unknownDocument;
-        this.noDocument = noDocument;
-        this.document = document;
-        this.hasCommittedMutations = hasCommittedMutations;
-        this.readTime = readTime;
-        this.parentPath = parentPath;
-    }
-}
-DbRemoteDocument.store = 'remoteDocuments';
+const DbDocumentMutationPlaceholder = {};
+const DbDocumentMutationStore = 'documentMutations';
+const DbRemoteDocumentStore = 'remoteDocumentsV14';
 /**
- * An index that provides access to all entries sorted by read time (which
- * corresponds to the last modification time of each row).
- *
- * This index is used to provide a changelog for Multi-Tab.
+ * The primary key of the remote documents store, which allows for efficient
+ * access by collection path and read time.
  */
-DbRemoteDocument.readTimeIndex = 'readTimeIndex';
-DbRemoteDocument.readTimeIndexPath = 'readTime';
+const DbRemoteDocumentKeyPath = [
+    'prefixPath',
+    'collectionGroup',
+    'readTime',
+    'documentId'
+];
+/** An index that provides access to documents by key. */
+const DbRemoteDocumentDocumentKeyIndex = 'documentKeyIndex';
+const DbRemoteDocumentDocumentKeyIndexPath = [
+    'prefixPath',
+    'collectionGroup',
+    'documentId'
+];
 /**
- * An index that provides access to documents in a collection sorted by read
+ * An index that provides access to documents by collection group and read
  * time.
  *
- * This index is used to allow the RemoteDocumentCache to fetch newly changed
- * documents in a collection.
- */
-DbRemoteDocument.collectionReadTimeIndex = 'collectionReadTimeIndex';
-DbRemoteDocument.collectionReadTimeIndexPath = ['parentPath', 'readTime'];
-/**
- * Contains a single entry that has metadata about the remote document cache.
+ * This index is used by the index backfiller.
  */
-class DbRemoteDocumentGlobal {
-    /**
-     * @param byteSize - Approximately the total size in bytes of all the
-     * documents in the document cache.
-     */
-    constructor(byteSize) {
-        this.byteSize = byteSize;
-    }
-}
-DbRemoteDocumentGlobal.store = 'remoteDocumentGlobal';
-DbRemoteDocumentGlobal.key = 'remoteDocumentGlobalKey';
-/**
- * An object to be stored in the 'targets' store in IndexedDb.
- *
- * This is based on and should be kept in sync with the proto used in the iOS
- * client.
- *
- * Each query the client listens to against the server is tracked on disk so
- * that the query can be efficiently resumed on restart.
- */
-class DbTarget {
-    constructor(
-    /**
-     * An auto-generated sequential numeric identifier for the query.
-     *
-     * Queries are stored using their canonicalId as the key, but these
-     * canonicalIds can be quite long so we additionally assign a unique
-     * queryId which can be used by referenced data structures (e.g.
-     * indexes) to minimize the on-disk cost.
-     */
-    targetId, 
-    /**
-     * The canonical string representing this query. This is not unique.
-     */
-    canonicalId, 
-    /**
-     * The last readTime received from the Watch Service for this query.
-     *
-     * This is the same value as TargetChange.read_time in the protos.
-     */
-    readTime, 
-    /**
-     * An opaque, server-assigned token that allows watching a query to be
-     * resumed after disconnecting without retransmitting all the data
-     * that matches the query. The resume token essentially identifies a
-     * point in time from which the server should resume sending results.
-     *
-     * This is related to the snapshotVersion in that the resumeToken
-     * effectively also encodes that value, but the resumeToken is opaque
-     * and sometimes encodes additional information.
-     *
-     * A consequence of this is that the resumeToken should be used when
-     * asking the server to reason about where this client is in the watch
-     * stream, but the client should use the snapshotVersion for its own
-     * purposes.
-     *
-     * This is the same value as TargetChange.resume_token in the protos.
-     */
-    resumeToken, 
-    /**
-     * A sequence number representing the last time this query was
-     * listened to, used for garbage collection purposes.
-     *
-     * Conventionally this would be a timestamp value, but device-local
-     * clocks are unreliable and they must be able to create new listens
-     * even while disconnected. Instead this should be a monotonically
-     * increasing number that's incremented on each listen call.
-     *
-     * This is different from the queryId since the queryId is an
-     * immutable identifier assigned to the Query on first use while
-     * lastListenSequenceNumber is updated every time the query is
-     * listened to.
-     */
-    lastListenSequenceNumber, 
-    /**
-     * Denotes the maximum snapshot version at which the associated query view
-     * contained no limbo documents.  Undefined for data written prior to
-     * schema version 9.
-     */
-    lastLimboFreeSnapshotVersion, 
-    /**
-     * The query for this target.
-     *
-     * Because canonical ids are not unique we must store the actual query. We
-     * use the proto to have an object we can persist without having to
-     * duplicate translation logic to and from a `Query` object.
-     */
-    query) {
-        this.targetId = targetId;
-        this.canonicalId = canonicalId;
-        this.readTime = readTime;
-        this.resumeToken = resumeToken;
-        this.lastListenSequenceNumber = lastListenSequenceNumber;
-        this.lastLimboFreeSnapshotVersion = lastLimboFreeSnapshotVersion;
-        this.query = query;
-    }
-}
-DbTarget.store = 'targets';
+const DbRemoteDocumentCollectionGroupIndex = 'collectionGroupIndex';
+const DbRemoteDocumentCollectionGroupIndexPath = [
+    'collectionGroup',
+    'readTime',
+    'prefixPath',
+    'documentId'
+];
+const DbRemoteDocumentGlobalStore = 'remoteDocumentGlobal';
+const DbRemoteDocumentGlobalKey = 'remoteDocumentGlobalKey';
+const DbTargetStore = 'targets';
 /** Keys are automatically assigned via the targetId property. */
-DbTarget.keyPath = 'targetId';
+const DbTargetKeyPath = 'targetId';
 /** The name of the queryTargets index. */
-DbTarget.queryTargetsIndexName = 'queryTargetsIndex';
+const DbTargetQueryTargetsIndexName = 'queryTargetsIndex';
 /**
  * The index of all canonicalIds to the targets that they match. This is not
  * a unique mapping because canonicalId does not promise a unique name for all
  * possible queries, so we append the targetId to make the mapping unique.
  */
-DbTarget.queryTargetsKeyPath = ['canonicalId', 'targetId'];
-/**
- * An object representing an association between a target and a document, or a
- * sentinel row marking the last sequence number at which a document was used.
- * Each document cached must have a corresponding sentinel row before lru
- * garbage collection is enabled.
- *
- * The target associations and sentinel rows are co-located so that orphaned
- * documents and their sequence numbers can be identified efficiently via a scan
- * of this store.
- */
-class DbTargetDocument {
-    constructor(
-    /**
-     * The targetId identifying a target or 0 for a sentinel row.
-     */
-    targetId, 
-    /**
-     * The path to the document, as encoded in the key.
-     */
-    path, 
-    /**
-     * If this is a sentinel row, this should be the sequence number of the last
-     * time the document specified by `path` was used. Otherwise, it should be
-     * `undefined`.
-     */
-    sequenceNumber) {
-        this.targetId = targetId;
-        this.path = path;
-        this.sequenceNumber = sequenceNumber;
-    }
-}
+const DbTargetQueryTargetsKeyPath = ['canonicalId', 'targetId'];
 /** Name of the IndexedDb object store.  */
-DbTargetDocument.store = 'targetDocuments';
+const DbTargetDocumentStore = 'targetDocuments';
 /** Keys are automatically assigned via the targetId, path properties. */
-DbTargetDocument.keyPath = ['targetId', 'path'];
+const DbTargetDocumentKeyPath = ['targetId', 'path'];
 /** The index name for the reverse index. */
-DbTargetDocument.documentTargetsIndex = 'documentTargetsIndex';
+const DbTargetDocumentDocumentTargetsIndex = 'documentTargetsIndex';
 /** We also need to create the reverse index for these properties. */
-DbTargetDocument.documentTargetsKeyPath = ['path', 'targetId'];
-/**
- * A record of global state tracked across all Targets, tracked separately
- * to avoid the need for extra indexes.
- *
- * This should be kept in-sync with the proto used in the iOS client.
- */
-class DbTargetGlobal {
-    constructor(
-    /**
-     * The highest numbered target id across all targets.
-     *
-     * See DbTarget.targetId.
-     */
-    highestTargetId, 
-    /**
-     * The highest numbered lastListenSequenceNumber across all targets.
-     *
-     * See DbTarget.lastListenSequenceNumber.
-     */
-    highestListenSequenceNumber, 
-    /**
-     * A global snapshot version representing the last consistent snapshot we
-     * received from the backend. This is monotonically increasing and any
-     * snapshots received from the backend prior to this version (e.g. for
-     * targets resumed with a resumeToken) should be suppressed (buffered)
-     * until the backend has caught up to this snapshot version again. This
-     * prevents our cache from ever going backwards in time.
-     */
-    lastRemoteSnapshotVersion, 
-    /**
-     * The number of targets persisted.
-     */
-    targetCount) {
-        this.highestTargetId = highestTargetId;
-        this.highestListenSequenceNumber = highestListenSequenceNumber;
-        this.lastRemoteSnapshotVersion = lastRemoteSnapshotVersion;
-        this.targetCount = targetCount;
-    }
-}
+const DbTargetDocumentDocumentTargetsKeyPath = ['path', 'targetId'];
 /**
  * The key string used for the single object that exists in the
  * DbTargetGlobal store.
  */
-DbTargetGlobal.key = 'targetGlobalKey';
-DbTargetGlobal.store = 'targetGlobal';
-/**
- * An object representing an association between a Collection id (e.g. 'messages')
- * to a parent path (e.g. '/chats/123') that contains it as a (sub)collection.
- * This is used to efficiently find all collections to query when performing
- * a Collection Group query.
- */
-class DbCollectionParent {
-    constructor(
-    /**
-     * The collectionId (e.g. 'messages')
-     */
-    collectionId, 
-    /**
-     * The path to the parent (either a document location or an empty path for
-     * a root-level collection).
-     */
-    parent) {
-        this.collectionId = collectionId;
-        this.parent = parent;
-    }
-}
+const DbTargetGlobalKey = 'targetGlobalKey';
+const DbTargetGlobalStore = 'targetGlobal';
 /** Name of the IndexedDb object store. */
-DbCollectionParent.store = 'collectionParents';
+const DbCollectionParentStore = 'collectionParents';
 /** Keys are automatically assigned via the collectionId, parent properties. */
-DbCollectionParent.keyPath = ['collectionId', 'parent'];
-/**
- * A record of the metadata state of each client.
- *
- * PORTING NOTE: This is used to synchronize multi-tab state and does not need
- * to be ported to iOS or Android.
- */
-class DbClientMetadata {
-    constructor(
-    // Note: Previous schema versions included a field
-    // "lastProcessedDocumentChangeId". Don't use anymore.
-    /** The auto-generated client id assigned at client startup. */
-    clientId, 
-    /** The last time this state was updated. */
-    updateTimeMs, 
-    /** Whether the client's network connection is enabled. */
-    networkEnabled, 
-    /** Whether this client is running in a foreground tab. */
-    inForeground) {
-        this.clientId = clientId;
-        this.updateTimeMs = updateTimeMs;
-        this.networkEnabled = networkEnabled;
-        this.inForeground = inForeground;
-    }
-}
+const DbCollectionParentKeyPath = ['collectionId', 'parent'];
 /** Name of the IndexedDb object store. */
-DbClientMetadata.store = 'clientMetadata';
+const DbClientMetadataStore = 'clientMetadata';
 /** Keys are automatically assigned via the clientId properties. */
-DbClientMetadata.keyPath = 'clientId';
-/** An object representing a bundle loaded by the SDK. */
-class DbBundle {
-    constructor(
-    /** The ID of the loaded bundle. */
-    bundleId, 
-    /** The create time of the loaded bundle. */
-    createTime, 
-    /** The schema version of the loaded bundle. */
-    version) {
-        this.bundleId = bundleId;
-        this.createTime = createTime;
-        this.version = version;
-    }
-}
+const DbClientMetadataKeyPath = 'clientId';
 /** Name of the IndexedDb object store. */
-DbBundle.store = 'bundles';
-DbBundle.keyPath = 'bundleId';
-/** An object representing a named query loaded by the SDK via a bundle. */
-class DbNamedQuery {
-    constructor(
-    /** The name of the query. */
-    name, 
-    /** The read time of the results saved in the bundle from the named query. */
-    readTime, 
-    /** The query saved in the bundle. */
-    bundledQuery) {
-        this.name = name;
-        this.readTime = readTime;
-        this.bundledQuery = bundledQuery;
-    }
-}
+const DbBundleStore = 'bundles';
+const DbBundleKeyPath = 'bundleId';
 /** 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;
-    }
-}
+const DbNamedQueryStore = 'namedQueries';
+const DbNamedQueryKeyPath = 'name';
 /** Name of the IndexedDb object store. */
-DbIndexConfiguration.store = 'indexConfiguration';
-DbIndexConfiguration.keyPath = 'indexId';
+const DbIndexConfigurationStore = 'indexConfiguration';
+const DbIndexConfigurationKeyPath = 'indexId';
 /**
  * An index that provides access to the index configurations by collection
  * group.
@@ -1832,49 +1396,11 @@ DbIndexConfiguration.keyPath = 'indexId';
  * 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;
-    }
-}
+const DbIndexConfigurationCollectionGroupIndex = 'collectionGroupIndex';
+const DbIndexConfigurationCollectionGroupIndexPath = 'collectionGroup';
 /** Name of the IndexedDb object store. */
-DbIndexState.store = 'indexState';
-DbIndexState.keyPath = ['indexId', 'uid'];
+const DbIndexStateStore = 'indexState';
+const DbIndexStateKeyPath = ['indexId', 'uid'];
 /**
  * An index that provides access to documents in a collection sorted by last
  * update time. Used by the backfiller.
@@ -1883,112 +1409,89 @@ DbIndexState.keyPath = ['indexId', 'uid'];
  * 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;
-    }
-}
+const DbIndexStateSequenceNumberIndex = 'sequenceNumberIndex';
+const DbIndexStateSequenceNumberIndexPath = ['uid', 'sequenceNumber'];
 /** Name of the IndexedDb object store. */
-DbIndexEntry.store = 'indexEntries';
-DbIndexEntry.keyPath = [
+const DbIndexEntryStore = 'indexEntries';
+const DbIndexEntryKeyPath = [
     '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;
-    }
-}
+const DbIndexEntryDocumentKeyIndex = 'documentKeyIndex';
+const DbIndexEntryDocumentKeyIndexPath = [
+    'indexId',
+    'uid',
+    'documentKey'
+];
 /** Name of the IndexedDb object store. */
-DbDocumentOverlay.store = 'documentOverlays';
-DbDocumentOverlay.keyPath = ['userId', 'collectionPath', 'documentId'];
-DbDocumentOverlay.collectionPathOverlayIndex = 'collectionPathOverlayIndex';
-DbDocumentOverlay.collectionPathOverlayIndexPath = [
+const DbDocumentOverlayStore = 'documentOverlays';
+const DbDocumentOverlayKeyPath = [
+    'userId',
+    'collectionPath',
+    'documentId'
+];
+const DbDocumentOverlayCollectionPathOverlayIndex = 'collectionPathOverlayIndex';
+const DbDocumentOverlayCollectionPathOverlayIndexPath = [
     'userId',
     'collectionPath',
     'largestBatchId'
 ];
-DbDocumentOverlay.collectionGroupOverlayIndex = 'collectionGroupOverlayIndex';
-DbDocumentOverlay.collectionGroupOverlayIndexPath = [
+const DbDocumentOverlayCollectionGroupOverlayIndex = 'collectionGroupOverlayIndex';
+const DbDocumentOverlayCollectionGroupOverlayIndexPath = [
     'userId',
     'collectionGroup',
     'largestBatchId'
 ];
 // Visible for testing
 const V1_STORES = [
-    DbMutationQueue.store,
-    DbMutationBatch.store,
-    DbDocumentMutation.store,
-    DbRemoteDocument.store,
-    DbTarget.store,
-    DbPrimaryClient.store,
-    DbTargetGlobal.store,
-    DbTargetDocument.store
+    DbMutationQueueStore,
+    DbMutationBatchStore,
+    DbDocumentMutationStore,
+    DbRemoteDocumentStore$1,
+    DbTargetStore,
+    DbPrimaryClientStore,
+    DbTargetGlobalStore,
+    DbTargetDocumentStore
 ];
-// V2 is no longer usable (see comment at top of file)
 // Visible for testing
 const V3_STORES = V1_STORES;
 // 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.
-const V6_STORES = [...V4_STORES, DbRemoteDocumentGlobal.store];
-// V7 does not change the set of stores.
-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];
-const V12_STORES = [...V11_STORES, DbDocumentOverlay.store];
+const V4_STORES = [...V3_STORES, DbClientMetadataStore];
+const V6_STORES = [...V4_STORES, DbRemoteDocumentGlobalStore];
+const V8_STORES = [...V6_STORES, DbCollectionParentStore];
+const V11_STORES = [...V8_STORES, DbBundleStore, DbNamedQueryStore];
+const V12_STORES = [...V11_STORES, DbDocumentOverlayStore];
 const V13_STORES = [
-    ...V12_STORES,
-    DbIndexConfiguration.store,
-    DbIndexState.store,
-    DbIndexEntry.store
+    DbMutationQueueStore,
+    DbMutationBatchStore,
+    DbDocumentMutationStore,
+    DbRemoteDocumentStore,
+    DbTargetStore,
+    DbPrimaryClientStore,
+    DbTargetGlobalStore,
+    DbTargetDocumentStore,
+    DbClientMetadataStore,
+    DbRemoteDocumentGlobalStore,
+    DbCollectionParentStore,
+    DbBundleStore,
+    DbNamedQueryStore,
+    DbDocumentOverlayStore
+];
+const V14_STORES = [
+    ...V13_STORES,
+    DbIndexConfigurationStore,
+    DbIndexStateStore,
+    DbIndexEntryStore
 ];
 /** Returns the object stores for the provided schema. */
 function getObjectStores(schemaVersion) {
-    if (schemaVersion === 13) {
+    if (schemaVersion === 14) {
+        return V14_STORES;
+    }
+    else if (schemaVersion === 13) {
         return V13_STORES;
     }
     else if (schemaVersion === 12) {
@@ -2702,6 +2205,21 @@ class SimpleDbStore {
             });
         }
     }
+    /**
+     * 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$h, 'DELETE ALL', this.store.name);
         const options = this.options(indexOrRange, range);
@@ -3184,6 +2702,9 @@ class SnapshotVersion {
     static min() {
         return new SnapshotVersion(new Timestamp(0, 0));
     }
+    static max() {
+        return new SnapshotVersion(new Timestamp(253402300799, 1e9 - 1));
+    }
     compareTo(other) {
         return this.timestamp._compareTo(other.timestamp);
     }
@@ -3312,17 +2833,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() {
@@ -3363,6 +2882,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);
     }
@@ -3781,13 +3302,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___' }
+            '__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) {
@@ -3821,6 +3346,9 @@ function typeOrder(value) {
         if (isServerTimestamp(value)) {
             return 4 /* ServerTimestampValue */;
         }
+        else if (isMaxValue(value)) {
+            return 9 /* ArrayValue */;
+        }
         return 10 /* ObjectValue */;
     }
     else {
@@ -3860,6 +3388,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();
     }
@@ -3932,6 +3462,7 @@ function valueCompare(left, right) {
     }
     switch (leftType) {
         case 0 /* NullValue */:
+        case 9007199254740991 /* MaxValue */:
             return 0;
         case 1 /* BooleanValue */:
             return primitiveComparator(left.booleanValue, right.booleanValue);
@@ -4200,7 +3731,102 @@ function deepClone(source) {
 }
 /** Returns true if the Value represents the canonical {@link #MAX_VALUE} . */
 function isMaxValue(value) {
-    return valueEquals(value, MAX_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;
+    }
 }
 
 /**
@@ -4595,6 +4221,10 @@ function fieldIndexGetArraySegment(fieldIndex) {
 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(
@@ -4626,6 +4256,28 @@ class IndexState {
         return new IndexState(INITIAL_SEQUENCE_NUMBER, IndexOffset.min());
     }
 }
+/**
+ * Creates an offset that matches all documents with a read time higher than
+ * `readTime`.
+ */
+function newIndexOffsetSuccessorFromReadTime(readTime, largestBatchId) {
+    // We want to create an offset that matches all documents with a read time
+    // greater than the provided read time. To do so, we technically need to
+    // create an offset for `(readTime, MAX_DOCUMENT_KEY)`. While we could use
+    // Unicode codepoints to generate MAX_DOCUMENT_KEY, it is much easier to use
+    // `(readTime + 1, DocumentKey.empty())` since `> DocumentKey.empty()` matches
+    // all valid document IDs.
+    const successorSeconds = readTime.toTimestamp().seconds;
+    const successorNanos = readTime.toTimestamp().nanoseconds + 1;
+    const successor = SnapshotVersion.fromTimestamp(successorNanos === 1e9
+        ? new Timestamp(successorSeconds + 1, 0)
+        : new Timestamp(successorSeconds, successorNanos));
+    return new IndexOffset(successor, DocumentKey.empty(), largestBatchId);
+}
+/** Creates a new offset based on the provided document. */
+function newIndexOffsetFromDocument(document) {
+    return new IndexOffset(document.readTime, document.key, INITIAL_LARGEST_BATCH_ID);
+}
 /**
  * Stores the latest read time, document and batch ID that were processed for an
  * index.
@@ -4650,10 +4302,25 @@ class IndexOffset {
         this.documentKey = documentKey;
         this.largestBatchId = largestBatchId;
     }
-    /** The state of an index that has not yet been backfilled. */
+    /** Returns an offset that sorts before all regular offsets. */
     static min() {
         return new IndexOffset(SnapshotVersion.min(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
     }
+    /** Returns an offset that sorts after all regular offsets. */
+    static max() {
+        return new IndexOffset(SnapshotVersion.max(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
+    }
+}
+function indexOffsetComparator(left, right) {
+    let cmp = left.readTime.compareTo(right.readTime);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    cmp = DocumentKey.comparator(left.documentKey, right.documentKey);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    return primitiveComparator(left.largestBatchId, right.largestBatchId);
 }
 
 /**
@@ -4766,30 +4433,215 @@ function targetEquals(left, right) {
         if (!orderByEquals(left.orderBy[i], right.orderBy[i])) {
             return false;
         }
-    }
-    if (left.filters.length !== right.filters.length) {
-        return false;
-    }
-    for (let i = 0; i < left.filters.length; i++) {
-        if (!filterEquals(left.filters[i], right.filters[i])) {
-            return false;
+    }
+    if (left.filters.length !== right.filters.length) {
+        return false;
+    }
+    for (let i = 0; i < left.filters.length; i++) {
+        if (!filterEquals(left.filters[i], right.filters[i])) {
+            return false;
+        }
+    }
+    if (left.collectionGroup !== right.collectionGroup) {
+        return false;
+    }
+    if (!left.path.isEqual(right.path)) {
+        return false;
+    }
+    if (!boundEquals(left.startAt, right.startAt)) {
+        return false;
+    }
+    return boundEquals(left.endAt, right.endAt);
+}
+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);
     }
-    if (left.collectionGroup !== right.collectionGroup) {
-        return false;
-    }
-    if (!left.path.isEqual(right.path)) {
-        return false;
-    }
-    if (!boundEquals(left.startAt, right.startAt)) {
-        return false;
-    }
-    return boundEquals(left.endAt, right.endAt);
-}
-function targetIsDocumentTarget(target) {
-    return (DocumentKey.isDocumentKey(target.path) &&
-        target.collectionGroup === null &&
-        target.filters.length === 0);
+    return new Bound(values, inclusive);
 }
 class Filter {
 }
@@ -5361,6 +5213,18 @@ function queryMatchesBounds(query, doc) {
     }
     return true;
 }
+/**
+ * Returns the collection group that this query targets.
+ *
+ * PORTING NOTE: This is only used in the Web SDK to facilitate multi-tab
+ * synchronization for query results.
+ */
+function queryCollectionGroup(query) {
+    return (query.collectionGroup ||
+        (query.path.length % 2 === 1
+            ? query.path.lastSegment()
+            : query.path.get(query.path.length - 2)));
+}
 /**
  * Returns a new comparator function that can be used to compare two documents
  * based on the Query's ordering constraint.
@@ -5392,6 +5256,116 @@ function compareDocs(orderBy, d1, d2) {
     }
 }
 
+/**
+ * @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 = {};
+        /** The number of entries stored in the map */
+        this.innerSize = 0;
+    }
+    /** 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]];
+            this.innerSize++;
+            return;
+        }
+        for (let i = 0; i < matches.length; i++) {
+            if (this.equalsFn(matches[i][0], key)) {
+                // This is updating an existing entry and does not increase `innerSize`.
+                matches[i] = [key, value];
+                return;
+            }
+        }
+        matches.push([key, value]);
+        this.innerSize++;
+    }
+    /**
+     * 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);
+                }
+                this.innerSize--;
+                return true;
+            }
+        }
+        return false;
+    }
+    forEach(fn) {
+        forEach(this.inner, (_, entries) => {
+            for (const [k, v] of entries) {
+                fn(k, v);
+            }
+        });
+    }
+    isEmpty() {
+        return isEmpty(this.inner);
+    }
+    size() {
+        return this.innerSize;
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -5534,7 +5508,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) {
@@ -6103,6 +6077,9 @@ const EMPTY_DOCUMENT_MAP = new SortedMap(DocumentKey.comparator);
 function documentMap() {
     return EMPTY_DOCUMENT_MAP;
 }
+function newOverlayMap() {
+    return new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
+}
 const EMPTY_DOCUMENT_VERSION_MAP = new SortedMap(DocumentKey.comparator);
 function documentVersionMap() {
     return EMPTY_DOCUMENT_VERSION_MAP;
@@ -8781,34 +8758,33 @@ function fromDbRemoteDocument(localSerializer, remoteDoc) {
 }
 /** Encodes a document for storage locally. */
 function toDbRemoteDocument(localSerializer, document) {
-    const dbReadTime = toDbTimestampKey(document.readTime);
-    const parentPath = document.key.path.popLast().toArray();
+    const key = document.key;
+    const remoteDoc = {
+        prefixPath: key.getCollectionPath().popLast().toArray(),
+        collectionGroup: key.collectionGroup,
+        documentId: key.path.lastSegment(),
+        readTime: toDbTimestampKey(document.readTime),
+        hasCommittedMutations: document.hasCommittedMutations
+    };
     if (document.isFoundDocument()) {
-        const doc = toDocument(localSerializer.remoteSerializer, document);
-        const hasCommittedMutations = document.hasCommittedMutations;
-        return new DbRemoteDocument(
-        /* unknownDocument= */ null, 
-        /* noDocument= */ null, doc, hasCommittedMutations, dbReadTime, parentPath);
+        remoteDoc.document = toDocument(localSerializer.remoteSerializer, document);
     }
     else if (document.isNoDocument()) {
-        const path = document.key.path.toArray();
-        const version = toDbTimestamp(document.version);
-        const hasCommittedMutations = document.hasCommittedMutations;
-        return new DbRemoteDocument(
-        /* unknownDocument= */ null, new DbNoDocument(path, version), 
-        /* document= */ null, hasCommittedMutations, dbReadTime, parentPath);
+        remoteDoc.noDocument = {
+            path: key.path.toArray(),
+            readTime: toDbTimestamp(document.version)
+        };
     }
     else if (document.isUnknownDocument()) {
-        const path = document.key.path.toArray();
-        const readTime = toDbTimestamp(document.version);
-        return new DbRemoteDocument(new DbUnknownDocument(path, readTime), 
-        /* noDocument= */ null, 
-        /* document= */ null, 
-        /* hasCommittedMutations= */ true, dbReadTime, parentPath);
+        remoteDoc.unknownDocument = {
+            path: key.path.toArray(),
+            version: toDbTimestamp(document.version)
+        };
     }
     else {
         return fail();
     }
+    return remoteDoc;
 }
 function toDbTimestampKey(snapshotVersion) {
     const timestamp = snapshotVersion.toTimestamp();
@@ -8820,7 +8796,7 @@ function fromDbTimestampKey(dbTimestampKey) {
 }
 function toDbTimestamp(snapshotVersion) {
     const timestamp = snapshotVersion.toTimestamp();
-    return new DbTimestamp(timestamp.seconds, timestamp.nanoseconds);
+    return { seconds: timestamp.seconds, nanoseconds: timestamp.nanoseconds };
 }
 function fromDbTimestamp(dbTimestamp) {
     const timestamp = new Timestamp(dbTimestamp.seconds, dbTimestamp.nanoseconds);
@@ -8830,7 +8806,13 @@ function fromDbTimestamp(dbTimestamp) {
 function toDbMutationBatch(localSerializer, userId, batch) {
     const serializedBaseMutations = batch.baseMutations.map(m => toMutation(localSerializer.remoteSerializer, m));
     const serializedMutations = batch.mutations.map(m => toMutation(localSerializer.remoteSerializer, m));
-    return new DbMutationBatch(userId, batch.batchId, batch.localWriteTime.toMillis(), serializedBaseMutations, serializedMutations);
+    return {
+        userId,
+        batchId: batch.batchId,
+        localWriteTimeMs: batch.localWriteTime.toMillis(),
+        baseMutations: serializedBaseMutations,
+        mutations: serializedMutations
+    };
 }
 /** Decodes a DbMutationBatch into a MutationBatch */
 function fromDbMutationBatch(localSerializer, dbBatch) {
@@ -8886,7 +8868,15 @@ function toDbTarget(localSerializer, targetData) {
     // convert it to a base64 string for storage.
     const resumeToken = targetData.resumeToken.toBase64();
     // lastListenSequenceNumber is always 0 until we do real GC.
-    return new DbTarget(targetData.targetId, canonifyTarget(targetData.target), dbTimestamp, resumeToken, targetData.sequenceNumber, dbLastLimboFreeTimestamp, queryProto);
+    return {
+        targetId: targetData.targetId,
+        canonicalId: canonifyTarget(targetData.target),
+        readTime: dbTimestamp,
+        resumeToken,
+        lastListenSequenceNumber: targetData.sequenceNumber,
+        lastLimboFreeSnapshotVersion: dbLastLimboFreeTimestamp,
+        query: queryProto
+    };
 }
 /**
  * A helper function for figuring out what kind of query has been stored.
@@ -8965,7 +8955,14 @@ function fromDbDocumentOverlay(localSerializer, dbDocumentOverlay) {
 /** 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));
+    return {
+        userId,
+        collectionPath,
+        documentId,
+        collectionGroup: overlay.mutation.key.getCollectionGroup(),
+        largestBatchId: overlay.largestBatchId,
+        overlayMutation: toMutation(localSerializer.remoteSerializer, overlay.mutation)
+    };
 }
 /**
  * Returns the DbDocumentOverlayKey corresponding to the given user and
@@ -8977,7 +8974,11 @@ function toDbDocumentOverlayKey(userId, docKey) {
     return [userId, collectionPath, docId];
 }
 function toDbIndexConfiguration(index) {
-    return new DbIndexConfiguration(index.indexId, index.collectionGroup, index.fields.map(s => [s.fieldPath.canonicalString(), s.kind]));
+    return {
+        indexId: index.indexId,
+        collectionGroup: index.collectionGroup,
+        fields: index.fields.map(s => [s.fieldPath.canonicalString(), s.kind])
+    };
 }
 function fromDbIndexConfiguration(index, state) {
     const decodedState = state
@@ -8987,7 +8988,14 @@ function fromDbIndexConfiguration(index, state) {
     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);
+    return {
+        indexId,
+        uid: user.uid || '',
+        sequenceNumber,
+        readTime: toDbTimestamp(offset.readTime),
+        documentKey: encodeResourcePath(offset.documentKey.path),
+        largestBatchId: offset.largestBatchId
+    };
 }
 
 /**
@@ -9038,13 +9046,13 @@ class IndexedDbBundleCache {
  * Helper to get a typed SimpleDbStore for the bundles object store.
  */
 function bundlesStore(txn) {
-    return getStore(txn, DbBundle.store);
+    return getStore(txn, DbBundleStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the namedQueries object store.
  */
 function namedQueriesStore(txn) {
-    return getStore(txn, DbNamedQuery.store);
+    return getStore(txn, DbNamedQueryStore);
 }
 
 /**
@@ -9091,7 +9099,7 @@ class IndexedDbDocumentOverlayCache {
     }
     saveOverlays(transaction, largestBatchId, overlays) {
         const promises = [];
-        overlays.forEach(mutation => {
+        overlays.forEach((_, mutation) => {
             const overlay = new Overlay(largestBatchId, mutation);
             promises.push(this.saveOverlay(transaction, overlay));
         });
@@ -9106,19 +9114,19 @@ class IndexedDbDocumentOverlayCache {
             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));
+            promises.push(documentOverlayStore(transaction).deleteAll(DbDocumentOverlayCollectionPathOverlayIndex, range));
         });
         return PersistencePromise.waitFor(promises);
     }
     getOverlaysForCollection(transaction, collection, sinceBatchId) {
-        const result = new Map();
+        const result = newOverlayMap();
         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)
+            .loadAll(DbDocumentOverlayCollectionPathOverlayIndex, range)
             .next(dbOverlays => {
             for (const dbOverlay of dbOverlays) {
                 const overlay = fromDbDocumentOverlay(this.serializer, dbOverlay);
@@ -9128,7 +9136,7 @@ class IndexedDbDocumentOverlayCache {
         });
     }
     getOverlaysForCollectionGroup(transaction, collectionGroup, sinceBatchId, count) {
-        const result = new Map();
+        const result = newOverlayMap();
         let currentBatchId = undefined;
         // We want batch IDs larger than `sinceBatchId`, and so the lower bound
         // is not inclusive.
@@ -9136,7 +9144,7 @@ class IndexedDbDocumentOverlayCache {
         /*lowerOpen=*/ true);
         return documentOverlayStore(transaction)
             .iterate({
-            index: DbDocumentOverlay.collectionGroupOverlayIndex,
+            index: DbDocumentOverlayCollectionGroupOverlayIndex,
             range
         }, (_, dbOverlay, control) => {
             // We do not want to return partial batch overlays, even if the size
@@ -9144,7 +9152,7 @@ class IndexedDbDocumentOverlayCache {
             // 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 ||
+            if (result.size() < count ||
                 overlay.largestBatchId === currentBatchId) {
                 result.set(overlay.getKey(), overlay);
                 currentBatchId = overlay.largestBatchId;
@@ -9163,7 +9171,7 @@ class IndexedDbDocumentOverlayCache {
  * Helper to get a typed SimpleDbStore for the document overlay object store.
  */
 function documentOverlayStore(txn) {
-    return getStore(txn, DbDocumentOverlay.store);
+    return getStore(txn, DbDocumentOverlayStore);
 }
 
 /**
@@ -9719,21 +9727,40 @@ class IndexEntry {
         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 = DocumentKey.comparator(left.documentKey, right.documentKey);
+    cmp = compareByteArrays(left.arrayValue, right.arrayValue);
     if (cmp !== 0) {
         return cmp;
     }
-    cmp = compareByteArrays(left.arrayValue, right.arrayValue);
+    cmp = compareByteArrays(left.directionalValue, right.directionalValue);
     if (cmp !== 0) {
         return cmp;
     }
-    return compareByteArrays(left.directionalValue, right.directionalValue);
+    return DocumentKey.comparator(left.documentKey, right.documentKey);
 }
 function compareByteArrays(left, right) {
     for (let i = 0; i < left.length && i < right.length; ++i) {
@@ -9745,6 +9772,160 @@ function compareByteArrays(left, right) {
     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 2019 Google LLC
@@ -9783,9 +9964,9 @@ class MemoryIndexManager {
         // Field indices are not supported with memory persistence.
         return PersistencePromise.resolve();
     }
-    getDocumentsMatchingTarget(transaction, fieldIndex, target) {
+    getDocumentsMatchingTarget(transaction, target) {
         // Field indices are not supported with memory persistence.
-        return PersistencePromise.resolve(documentKeySet());
+        return PersistencePromise.resolve(null);
     }
     getFieldIndex(transaction, target) {
         // Field indices are not supported with memory persistence.
@@ -9857,6 +10038,7 @@ class MemoryCollectionParentIndex {
  * limitations under the License.
  */
 const LOG_TAG$f = 'IndexedDbIndexManager';
+const EMPTY_VALUE = new Uint8Array(0);
 /**
  * A persisted implementation of IndexManager.
  *
@@ -9874,6 +10056,11 @@ class IndexedDbIndexManager {
          * 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 || '';
     }
     /**
@@ -9942,13 +10129,111 @@ class IndexedDbIndexManager {
         /*lowerOpen=*/ false, 
         /*upperOpen=*/ true)));
     }
-    getDocumentsMatchingTarget(transaction, fieldIndex, target) {
-        // TODO(indexing): Implement
-        return PersistencePromise.resolve(documentKeySet());
+    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 `DbIndexEntryStore` 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) {
-        // TODO(indexing): Implement
-        return PersistencePromise.resolve(null);
+        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.
@@ -9962,22 +10247,90 @@ class IndexedDbIndexManager {
             if (field == null) {
                 return null;
             }
-            const directionalEncoder = encoder.forKind(segment.kind);
-            FirestoreIndexValueWriter.INSTANCE.writeIndexValue(field, directionalEncoder);
+            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 encoder.encodedBytes();
+        return results;
     }
-    /** 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();
+    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(DbIndexConfigurationCollectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
             : indexes.loadAll()).next(indexConfigs => {
             const result = [];
             return PersistencePromise.forEach(indexConfigs, (indexConfig) => {
@@ -9994,7 +10347,12 @@ class IndexedDbIndexManager {
             if (indexes.length === 0) {
                 return null;
             }
-            indexes.sort((l, r) => l.indexState.sequenceNumber - r.indexState.sequenceNumber);
+            indexes.sort((l, r) => {
+                const cmp = l.indexState.sequenceNumber - r.indexState.sequenceNumber;
+                return cmp !== 0
+                    ? cmp
+                    : primitiveComparator(l.collectionGroup, r.collectionGroup);
+            });
             return indexes[0].collectionGroup;
         });
     }
@@ -10002,7 +10360,7 @@ class IndexedDbIndexManager {
         const indexes = indexConfigurationStore(transaction);
         const states = indexStateStore(transaction);
         return this.getNextSequenceNumber(transaction).next(nextSequenceNumber => indexes
-            .loadAll(DbIndexConfiguration.collectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
+            .loadAll(DbIndexConfigurationCollectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
             .next(configs => PersistencePromise.forEach(configs, (config) => states.put(toDbIndexState(config.indexId, this.user, nextSequenceNumber, offset)))));
     }
     updateIndexEntries(transaction, documents) {
@@ -10033,7 +10391,13 @@ class IndexedDbIndexManager {
     }
     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)));
+        return indexEntries.put({
+            indexId: indexEntry.indexId,
+            uid: this.uid,
+            arrayValue: indexEntry.arrayValue,
+            directionalValue: indexEntry.directionalValue,
+            documentKey: encodeResourcePath(document.key.path)
+        });
     }
     deleteIndexEntry(transaction, document, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
@@ -10050,7 +10414,7 @@ class IndexedDbIndexManager {
         let results = new SortedSet(indexEntryComparator);
         return indexEntries
             .iterate({
-            index: DbIndexEntry.documentKeyIndex,
+            index: DbIndexEntryDocumentKeyIndex,
             range: IDBKeyRange.only([
                 fieldIndex.indexId,
                 this.uid,
@@ -10078,7 +10442,7 @@ class IndexedDbIndexManager {
             }
         }
         else {
-            results = results.add(new IndexEntry(fieldIndex.indexId, document.key, new Uint8Array(), directionalValue));
+            results = results.add(new IndexEntry(fieldIndex.indexId, document.key, EMPTY_VALUE, directionalValue));
         }
         return results;
     }
@@ -10104,7 +10468,7 @@ class IndexedDbIndexManager {
         const states = indexStateStore(transaction);
         return states
             .iterate({
-            index: DbIndexState.sequenceNumberIndex,
+            index: DbIndexStateSequenceNumberIndex,
             reverse: true,
             range: IDBKeyRange.upperBound([this.uid, Number.MAX_SAFE_INTEGER])
         }, (_, state, controller) => {
@@ -10113,31 +10477,81 @@ class IndexedDbIndexManager {
         })
             .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
  * document store.
  */
 function collectionParentsStore(txn) {
-    return getStore(txn, DbCollectionParent.store);
+    return getStore(txn, DbCollectionParentStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the index entry object store.
  */
 function indexEntriesStore(txn) {
-    return getStore(txn, DbIndexEntry.store);
+    return getStore(txn, DbIndexEntryStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the index configuration object store.
  */
 function indexConfigurationStore(txn) {
-    return getStore(txn, DbIndexConfiguration.store);
+    return getStore(txn, DbIndexConfigurationStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the index state object store.
  */
 function indexStateStore(txn) {
-    return getStore(txn, DbIndexState.store);
+    return getStore(txn, DbIndexStateStore);
 }
 
 /**
@@ -10161,8 +10575,8 @@ function indexStateStore(txn) {
  * @returns A PersistencePromise of the document mutations that were removed.
  */
 function removeMutationBatch(txn, userId, batch) {
-    const mutationStore = txn.store(DbMutationBatch.store);
-    const indexTxn = txn.store(DbDocumentMutation.store);
+    const mutationStore = txn.store(DbMutationBatchStore);
+    const indexTxn = txn.store(DbDocumentMutationStore);
     const promises = [];
     const range = IDBKeyRange.only(batch.batchId);
     let numDeleted = 0;
@@ -10175,7 +10589,7 @@ function removeMutationBatch(txn, userId, batch) {
     }));
     const removedDocuments = [];
     for (const mutation of batch.mutations) {
-        const indexKey = DbDocumentMutation.key(userId, mutation.key.path, batch.batchId);
+        const indexKey = newDbDocumentMutationKey(userId, mutation.key.path, batch.batchId);
         promises.push(indexTxn.delete(indexKey));
         removedDocuments.push(mutation.key);
     }
@@ -10264,7 +10678,7 @@ class IndexedDbMutationQueue {
         let empty = true;
         const range = IDBKeyRange.bound([this.userId, Number.NEGATIVE_INFINITY], [this.userId, Number.POSITIVE_INFINITY]);
         return mutationsStore(transaction)
-            .iterate({ index: DbMutationBatch.userMutationsIndex, range }, (key, value, control) => {
+            .iterate({ index: DbMutationBatchUserMutationsIndex, range }, (key, value, control) => {
             empty = false;
             control.done();
         })
@@ -10289,10 +10703,10 @@ class IndexedDbMutationQueue {
             const promises = [];
             let collectionParents = new SortedSet((l, r) => primitiveComparator(l.canonicalString(), r.canonicalString()));
             for (const mutation of mutations) {
-                const indexKey = DbDocumentMutation.key(this.userId, mutation.key.path, batchId);
+                const indexKey = newDbDocumentMutationKey(this.userId, mutation.key.path, batchId);
                 collectionParents = collectionParents.add(mutation.key.path.popLast());
                 promises.push(mutationStore.put(dbBatch));
-                promises.push(documentStore.put(indexKey, DbDocumentMutation.PLACEHOLDER));
+                promises.push(documentStore.put(indexKey, DbDocumentMutationPlaceholder));
             }
             collectionParents.forEach(parent => {
                 promises.push(this.indexManager.addToCollectionParentIndex(transaction, parent));
@@ -10343,7 +10757,7 @@ class IndexedDbMutationQueue {
         const range = IDBKeyRange.lowerBound([this.userId, nextBatchId]);
         let foundBatch = null;
         return mutationsStore(transaction)
-            .iterate({ index: DbMutationBatch.userMutationsIndex, range }, (key, dbBatch, control) => {
+            .iterate({ index: DbMutationBatchUserMutationsIndex, range }, (key, dbBatch, control) => {
             if (dbBatch.userId === this.userId) {
                 hardAssert(dbBatch.batchId >= nextBatchId);
                 foundBatch = fromDbMutationBatch(this.serializer, dbBatch);
@@ -10359,7 +10773,7 @@ class IndexedDbMutationQueue {
         ]);
         let batchId = BATCHID_UNKNOWN;
         return mutationsStore(transaction)
-            .iterate({ index: DbMutationBatch.userMutationsIndex, range, reverse: true }, (key, dbBatch, control) => {
+            .iterate({ index: DbMutationBatchUserMutationsIndex, range, reverse: true }, (key, dbBatch, control) => {
             batchId = dbBatch.batchId;
             control.done();
         })
@@ -10368,13 +10782,13 @@ class IndexedDbMutationQueue {
     getAllMutationBatches(transaction) {
         const range = IDBKeyRange.bound([this.userId, BATCHID_UNKNOWN], [this.userId, Number.POSITIVE_INFINITY]);
         return mutationsStore(transaction)
-            .loadAll(DbMutationBatch.userMutationsIndex, range)
+            .loadAll(DbMutationBatchUserMutationsIndex, range)
             .next(dbBatches => dbBatches.map(dbBatch => fromDbMutationBatch(this.serializer, dbBatch)));
     }
     getAllMutationBatchesAffectingDocumentKey(transaction, documentKey) {
         // Scan the document-mutation index starting with a prefix starting with
         // the given documentKey.
-        const indexPrefix = DbDocumentMutation.prefixForPath(this.userId, documentKey.path);
+        const indexPrefix = newDbDocumentMutationPrefixForPath(this.userId, documentKey.path);
         const indexStart = IDBKeyRange.lowerBound(indexPrefix);
         const results = [];
         return documentMutationsStore(transaction)
@@ -10409,7 +10823,7 @@ class IndexedDbMutationQueue {
         let uniqueBatchIDs = new SortedSet(primitiveComparator);
         const promises = [];
         documentKeys.forEach(documentKey => {
-            const indexStart = DbDocumentMutation.prefixForPath(this.userId, documentKey.path);
+            const indexStart = newDbDocumentMutationPrefixForPath(this.userId, documentKey.path);
             const range = IDBKeyRange.lowerBound(indexStart);
             const promise = documentMutationsStore(transaction).iterate({ range }, (indexKey, _, control) => {
                 const [userID, encodedPath, batchID] = indexKey;
@@ -10445,7 +10859,7 @@ class IndexedDbMutationQueue {
         // Since we don't yet index the actual properties in the mutations, our
         // current approach is to just return all mutation batches that affect
         // documents in the collection being queried.
-        const indexPrefix = DbDocumentMutation.prefixForPath(this.userId, queryPath);
+        const indexPrefix = newDbDocumentMutationPrefixForPath(this.userId, queryPath);
         const indexStart = IDBKeyRange.lowerBound(indexPrefix);
         // Collect up unique batchIDs encountered during a scan of the index. Use a
         // SortedSet to accumulate batch IDs so they can be traversed in order in a
@@ -10517,7 +10931,7 @@ class IndexedDbMutationQueue {
             }
             // Verify that there are no entries in the documentMutations index if
             // the queue is empty.
-            const startRange = IDBKeyRange.lowerBound(DbDocumentMutation.prefixForUser(this.userId));
+            const startRange = IDBKeyRange.lowerBound(newDbDocumentMutationPrefixForUser(this.userId));
             const danglingMutationReferences = [];
             return documentMutationsStore(txn)
                 .iterate({ range: startRange }, (key, _, control) => {
@@ -10545,9 +10959,11 @@ class IndexedDbMutationQueue {
         return mutationQueuesStore(transaction)
             .get(this.userId)
             .next((metadata) => {
-            return (metadata ||
-                new DbMutationQueue(this.userId, BATCHID_UNKNOWN, 
-                /*lastStreamToken=*/ ''));
+            return (metadata || {
+                userId: this.userId,
+                lastAcknowledgedBatchId: BATCHID_UNKNOWN,
+                lastStreamToken: ''
+            });
         });
     }
 }
@@ -10556,7 +10972,7 @@ class IndexedDbMutationQueue {
  *         mutation for the given key.
  */
 function mutationQueueContainsKey(txn, userId, key) {
-    const indexKey = DbDocumentMutation.prefixForPath(userId, key.path);
+    const indexKey = newDbDocumentMutationPrefixForPath(userId, key.path);
     const encodedPath = indexKey[1];
     const startRange = IDBKeyRange.lowerBound(indexKey);
     let containsKey = false;
@@ -10588,19 +11004,19 @@ function mutationQueuesContainKey(txn, docKey) {
  * Helper to get a typed SimpleDbStore for the mutations object store.
  */
 function mutationsStore(txn) {
-    return getStore(txn, DbMutationBatch.store);
+    return getStore(txn, DbMutationBatchStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the mutationQueues object store.
  */
 function documentMutationsStore(txn) {
-    return getStore(txn, DbDocumentMutation.store);
+    return getStore(txn, DbDocumentMutationStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the mutationQueues object store.
  */
 function mutationQueuesStore(txn) {
-    return getStore(txn, DbMutationQueue.store);
+    return getStore(txn, DbMutationQueueStore);
 }
 
 /**
@@ -10764,14 +11180,14 @@ class IndexedDbTargetCache {
     }
     retrieveMetadata(transaction) {
         return globalTargetStore(transaction)
-            .get(DbTargetGlobal.key)
+            .get(DbTargetGlobalKey)
             .next(metadata => {
             hardAssert(metadata !== null);
             return metadata;
         });
     }
     saveMetadata(transaction, metadata) {
-        return globalTargetStore(transaction).put(DbTargetGlobal.key, metadata);
+        return globalTargetStore(transaction).put(DbTargetGlobalKey, metadata);
     }
     saveTargetData(transaction, targetData) {
         return targetsStore(transaction).put(toDbTarget(this.serializer, targetData));
@@ -10804,7 +11220,7 @@ class IndexedDbTargetCache {
         const range = IDBKeyRange.bound([canonicalId, Number.NEGATIVE_INFINITY], [canonicalId, Number.POSITIVE_INFINITY]);
         let result = null;
         return targetsStore(transaction)
-            .iterate({ range, index: DbTarget.queryTargetsIndexName }, (key, value, control) => {
+            .iterate({ range, index: DbTargetQueryTargetsIndexName }, (key, value, control) => {
             const found = fromDbTarget(value);
             // After finding a potential match, check that the target is
             // actually equal to the requested target.
@@ -10822,7 +11238,7 @@ class IndexedDbTargetCache {
         const store = documentTargetStore(txn);
         keys.forEach(key => {
             const path = encodeResourcePath(key.path);
-            promises.push(store.put(new DbTargetDocument(targetId, path)));
+            promises.push(store.put({ targetId, path }));
             promises.push(this.referenceDelegate.addReference(txn, targetId, key));
         });
         return PersistencePromise.waitFor(promises);
@@ -10868,7 +11284,7 @@ class IndexedDbTargetCache {
         let count = 0;
         return documentTargetStore(txn)
             .iterate({
-            index: DbTargetDocument.documentTargetsIndex,
+            index: DbTargetDocumentDocumentTargetsIndex,
             keysOnly: true,
             range
         }, ([targetId, path], _, control) => {
@@ -10907,19 +11323,19 @@ class IndexedDbTargetCache {
  * Helper to get a typed SimpleDbStore for the queries object store.
  */
 function targetsStore(txn) {
-    return getStore(txn, DbTarget.store);
+    return getStore(txn, DbTargetStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the target globals object store.
  */
 function globalTargetStore(txn) {
-    return getStore(txn, DbTargetGlobal.store);
+    return getStore(txn, DbTargetGlobalStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the document target object store.
  */
 function documentTargetStore(txn) {
-    return getStore(txn, DbTargetDocument.store);
+    return getStore(txn, DbTargetDocumentStore);
 }
 
 /**
@@ -11333,7 +11749,7 @@ class IndexedDbLruDelegateImpl {
         let nextPath;
         return store
             .iterate({
-            index: DbTargetDocument.documentTargetsIndex
+            index: DbTargetDocumentDocumentTargetsIndex
         }, ([targetId, docKey], { path, sequenceNumber }) => {
             if (targetId === 0) {
                 // if nextToReport is valid, report it, this is a new key so the
@@ -11375,113 +11791,12 @@ function sentinelKey$1(key) {
  * store.
  */
 function sentinelRow(key, sequenceNumber) {
-    return new DbTargetDocument(0, encodeResourcePath(key.path), sequenceNumber);
+    return { targetId: 0, path: 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);
-                }
-                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 2017 Google LLC
@@ -11621,7 +11936,7 @@ class IndexedDbRemoteDocumentCacheImpl {
      */
     addEntry(transaction, key, doc) {
         const documentStore = remoteDocumentsStore(transaction);
-        return documentStore.put(dbKey(key), doc);
+        return documentStore.put(doc);
     }
     /**
      * Removes a document from the cache.
@@ -11629,10 +11944,9 @@ class IndexedDbRemoteDocumentCacheImpl {
      * All calls of `removeEntry`  are required to go through the RemoteDocumentChangeBuffer
      * returned by `newChangeBuffer()` to ensure proper accounting of metadata.
      */
-    removeEntry(transaction, documentKey) {
+    removeEntry(transaction, documentKey, readTime) {
         const store = remoteDocumentsStore(transaction);
-        const key = dbKey(documentKey);
-        return store.delete(key);
+        return store.delete(dbReadTimeKey(documentKey, readTime));
     }
     /**
      * Updates the current cache size.
@@ -11647,11 +11961,15 @@ class IndexedDbRemoteDocumentCacheImpl {
         });
     }
     getEntry(transaction, documentKey) {
+        let doc = MutableDocument.newInvalidDocument(documentKey);
         return remoteDocumentsStore(transaction)
-            .get(dbKey(documentKey))
-            .next(dbRemoteDoc => {
-            return this.maybeDecodeDocument(documentKey, dbRemoteDoc);
-        });
+            .iterate({
+            index: DbRemoteDocumentDocumentKeyIndex,
+            range: IDBKeyRange.only(dbKey(documentKey))
+        }, (_, dbRemoteDoc) => {
+            doc = this.maybeDecodeDocument(documentKey, dbRemoteDoc);
+        })
+            .next(() => doc);
     }
     /**
      * Looks up an entry in the cache.
@@ -11660,15 +11978,21 @@ class IndexedDbRemoteDocumentCacheImpl {
      * @returns The cached document entry and its size.
      */
     getSizedEntry(transaction, documentKey) {
+        let result = {
+            size: 0,
+            document: MutableDocument.newInvalidDocument(documentKey)
+        };
         return remoteDocumentsStore(transaction)
-            .get(dbKey(documentKey))
-            .next(dbRemoteDoc => {
-            const doc = this.maybeDecodeDocument(documentKey, dbRemoteDoc);
-            return {
-                document: doc,
+            .iterate({
+            index: DbRemoteDocumentDocumentKeyIndex,
+            range: IDBKeyRange.only(dbKey(documentKey))
+        }, (_, dbRemoteDoc) => {
+            result = {
+                document: this.maybeDecodeDocument(documentKey, dbRemoteDoc),
                 size: dbDocumentSize(dbRemoteDoc)
             };
-        });
+        })
+            .next(() => result);
     }
     getEntries(transaction, documentKeys) {
         let results = mutableDocumentMap();
@@ -11699,14 +12023,20 @@ class IndexedDbRemoteDocumentCacheImpl {
         if (documentKeys.isEmpty()) {
             return PersistencePromise.resolve();
         }
-        const range = IDBKeyRange.bound(documentKeys.first().path.toArray(), documentKeys.last().path.toArray());
-        const keyIter = documentKeys.getIterator();
+        let sortedKeys = new SortedSet(dbKeyComparator);
+        documentKeys.forEach(e => (sortedKeys = sortedKeys.add(e)));
+        const range = IDBKeyRange.bound(dbKey(sortedKeys.first()), dbKey(sortedKeys.last()));
+        const keyIter = sortedKeys.getIterator();
         let nextKey = keyIter.getNext();
         return remoteDocumentsStore(transaction)
-            .iterate({ range }, (potentialKeyRaw, dbRemoteDoc, control) => {
-            const potentialKey = DocumentKey.fromSegments(potentialKeyRaw);
+            .iterate({ index: DbRemoteDocumentDocumentKeyIndex, range }, (_, dbRemoteDoc, control) => {
+            const potentialKey = DocumentKey.fromSegments([
+                ...dbRemoteDoc.prefixPath,
+                dbRemoteDoc.collectionGroup,
+                dbRemoteDoc.documentId
+            ]);
             // Go through keys not found in cache.
-            while (nextKey && DocumentKey.comparator(nextKey, potentialKey) < 0) {
+            while (nextKey && dbKeyComparator(nextKey, potentialKey) < 0) {
                 callback(nextKey, null);
                 nextKey = keyIter.getNext();
             }
@@ -11717,7 +12047,7 @@ class IndexedDbRemoteDocumentCacheImpl {
             }
             // Skip to the next key (if there is one).
             if (nextKey) {
-                control.skip(nextKey.path.toArray());
+                control.skip(dbKey(nextKey));
             }
             else {
                 control.done();
@@ -11732,41 +12062,44 @@ class IndexedDbRemoteDocumentCacheImpl {
             }
         });
     }
-    getAll(transaction, collection, sinceReadTime) {
-        let results = mutableDocumentMap();
-        const immediateChildrenPathLength = collection.length + 1;
-        const iterationOptions = {};
-        if (sinceReadTime.isEqual(SnapshotVersion.min())) {
-            // Documents are ordered by key, so we can use a prefix scan to narrow
-            // down the documents we need to match the query against.
-            const startKey = collection.toArray();
-            iterationOptions.range = IDBKeyRange.lowerBound(startKey);
-        }
-        else {
-            // Execute an index-free query and filter by read time. This is safe
-            // since all document changes to queries that have a
-            // lastLimboFreeSnapshotVersion (`sinceReadTime`) have a read time set.
-            const collectionKey = collection.toArray();
-            const readTimeKey = toDbTimestampKey(sinceReadTime);
-            iterationOptions.range = IDBKeyRange.lowerBound([collectionKey, readTimeKey], 
-            /* open= */ true);
-            iterationOptions.index = DbRemoteDocument.collectionReadTimeIndex;
-        }
+    getAllFromCollection(transaction, collection, offset) {
+        const startKey = [
+            collection.popLast().toArray(),
+            collection.lastSegment(),
+            toDbTimestampKey(offset.readTime),
+            offset.documentKey.path.isEmpty()
+                ? ''
+                : offset.documentKey.path.lastSegment()
+        ];
+        const endKey = [
+            collection.popLast().toArray(),
+            collection.lastSegment(),
+            [Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+            ''
+        ];
         return remoteDocumentsStore(transaction)
-            .iterate(iterationOptions, (key, dbRemoteDoc, control) => {
-            // The query is actually returning any path that starts with the query
-            // path prefix which may include documents in subcollections. For
-            // example, a query on 'rooms' will return rooms/abc/messages/xyx but we
-            // shouldn't match it. Fix this by discarding rows with document keys
-            // more than one segment longer than the query path.
-            if (key.length !== immediateChildrenPathLength) {
-                return;
-            }
-            const document = this.maybeDecodeDocument(DocumentKey.fromSegments(key), dbRemoteDoc);
-            if (collection.isPrefixOf(document.key.path)) {
+            .loadAll(IDBKeyRange.bound(startKey, endKey, true))
+            .next(dbRemoteDocs => {
+            let results = mutableDocumentMap();
+            for (const dbRemoteDoc of dbRemoteDocs) {
+                const document = this.maybeDecodeDocument(DocumentKey.fromSegments(dbRemoteDoc.prefixPath.concat(dbRemoteDoc.collectionGroup, dbRemoteDoc.documentId)), dbRemoteDoc);
                 results = results.insert(document.key, document);
             }
-            else {
+            return results;
+        });
+    }
+    getAllFromCollectionGroup(transaction, collectionGroup, offset, limit) {
+        let results = mutableDocumentMap();
+        const startKey = dbCollectionGroupKey(collectionGroup, offset);
+        const endKey = dbCollectionGroupKey(collectionGroup, IndexOffset.max());
+        return remoteDocumentsStore(transaction)
+            .iterate({
+            index: DbRemoteDocumentCollectionGroupIndex,
+            range: IDBKeyRange.bound(startKey, endKey, true)
+        }, (_, dbRemoteDoc, control) => {
+            const document = this.maybeDecodeDocument(DocumentKey.fromSegments(dbRemoteDoc.prefixPath.concat(dbRemoteDoc.collectionGroup, dbRemoteDoc.documentId)), dbRemoteDoc);
+            results = results.insert(document.key, document);
+            if (results.size === limit) {
                 control.done();
             }
         })
@@ -11780,14 +12113,14 @@ class IndexedDbRemoteDocumentCacheImpl {
     }
     getMetadata(txn) {
         return documentGlobalStore(txn)
-            .get(DbRemoteDocumentGlobal.key)
+            .get(DbRemoteDocumentGlobalKey)
             .next(metadata => {
             hardAssert(!!metadata);
             return metadata;
         });
     }
     setMetadata(txn, metadata) {
-        return documentGlobalStore(txn).put(DbRemoteDocumentGlobal.key, metadata);
+        return documentGlobalStore(txn).put(DbRemoteDocumentGlobalKey, metadata);
     }
     /**
      * Decodes `dbRemoteDoc` and returns the document (or an invalid document if
@@ -11810,50 +12143,6 @@ class IndexedDbRemoteDocumentCacheImpl {
 function newIndexedDbRemoteDocumentCache(serializer) {
     return new IndexedDbRemoteDocumentCacheImpl(serializer);
 }
-/**
- * Returns the set of documents that have changed since the specified read
- * time.
- */
-// PORTING NOTE: This is only used for multi-tab synchronization.
-function remoteDocumentCacheGetNewDocumentChanges(remoteDocumentCache, transaction, sinceReadTime) {
-    const remoteDocumentCacheImpl = debugCast(remoteDocumentCache);
-    let changedDocs = mutableDocumentMap();
-    let lastReadTime = toDbTimestampKey(sinceReadTime);
-    const documentsStore = remoteDocumentsStore(transaction);
-    const range = IDBKeyRange.lowerBound(lastReadTime, true);
-    return documentsStore
-        .iterate({ index: DbRemoteDocument.readTimeIndex, range }, (_, dbRemoteDoc) => {
-        // Unlike `getEntry()` and others, `getNewDocumentChanges()` parses
-        // the documents directly since we want to keep sentinel deletes.
-        const doc = fromDbRemoteDocument(remoteDocumentCacheImpl.serializer, dbRemoteDoc);
-        changedDocs = changedDocs.insert(doc.key, doc);
-        lastReadTime = dbRemoteDoc.readTime;
-    })
-        .next(() => {
-        return {
-            changedDocs,
-            readTime: fromDbTimestampKey(lastReadTime)
-        };
-    });
-}
-/**
- * Returns the read time of the most recently read document in the cache, or
- * SnapshotVersion.min() if not available.
- */
-// PORTING NOTE: This is only used for multi-tab synchronization.
-function remoteDocumentCacheGetLastReadTime(transaction) {
-    const documentsStore = remoteDocumentsStore(transaction);
-    // If there are no existing entries, we return SnapshotVersion.min().
-    let readTime = SnapshotVersion.min();
-    return documentsStore
-        .iterate({ index: DbRemoteDocument.readTimeIndex, reverse: true }, (key, dbRemoteDoc, control) => {
-        if (dbRemoteDoc.readTime) {
-            readTime = fromDbTimestampKey(dbRemoteDoc.readTime);
-        }
-        control.done();
-    })
-        .next(() => readTime);
-}
 /**
  * Handles the details of adding and updating documents in the IndexedDbRemoteDocumentCache.
  *
@@ -11871,24 +12160,26 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
         super();
         this.documentCache = documentCache;
         this.trackRemovals = trackRemovals;
-        // A map of document sizes prior to applying the changes in this buffer.
-        this.documentSizes = new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
+        // A map of document sizes and read times prior to applying the changes in
+        // this buffer.
+        this.documentStates = new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
     }
     applyChanges(transaction) {
         const promises = [];
         let sizeDelta = 0;
         let collectionParents = new SortedSet((l, r) => primitiveComparator(l.canonicalString(), r.canonicalString()));
         this.changes.forEach((key, documentChange) => {
-            const previousSize = this.documentSizes.get(key);
+            const previousDoc = this.documentStates.get(key);
+            promises.push(this.documentCache.removeEntry(transaction, key, previousDoc.readTime));
             if (documentChange.isValidDocument()) {
                 const doc = toDbRemoteDocument(this.documentCache.serializer, documentChange);
                 collectionParents = collectionParents.add(key.path.popLast());
                 const size = dbDocumentSize(doc);
-                sizeDelta += size - previousSize;
+                sizeDelta += size - previousDoc.size;
                 promises.push(this.documentCache.addEntry(transaction, key, doc));
             }
             else {
-                sizeDelta -= previousSize;
+                sizeDelta -= previousDoc.size;
                 if (this.trackRemovals) {
                     // In order to track removals, we store a "sentinel delete" in the
                     // RemoteDocumentCache. This entry is represented by a NoDocument
@@ -11897,9 +12188,6 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
                     const deletedDoc = toDbRemoteDocument(this.documentCache.serializer, documentChange.convertToNoDocument(SnapshotVersion.min()));
                     promises.push(this.documentCache.addEntry(transaction, key, deletedDoc));
                 }
-                else {
-                    promises.push(this.documentCache.removeEntry(transaction, key));
-                }
             }
         });
         collectionParents.forEach(parent => {
@@ -11913,7 +12201,10 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
         return this.documentCache
             .getSizedEntry(transaction, documentKey)
             .next(getResult => {
-            this.documentSizes.set(documentKey, getResult.size);
+            this.documentStates.set(documentKey, {
+                size: getResult.size,
+                readTime: getResult.document.readTime
+            });
             return getResult.document;
         });
     }
@@ -11927,24 +12218,95 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
             // keys to `DocumentSizeEntry`s. This is to allow returning the
             // `MutableDocumentMap` directly, without a conversion.
             sizeMap.forEach((documentKey, size) => {
-                this.documentSizes.set(documentKey, size);
+                this.documentStates.set(documentKey, {
+                    size,
+                    readTime: documents.get(documentKey).readTime
+                });
             });
             return documents;
         });
     }
 }
 function documentGlobalStore(txn) {
-    return getStore(txn, DbRemoteDocumentGlobal.store);
+    return getStore(txn, DbRemoteDocumentGlobalStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the remoteDocuments object store.
  */
 function remoteDocumentsStore(txn) {
-    return getStore(txn, DbRemoteDocument.store);
+    return getStore(txn, DbRemoteDocumentStore);
+}
+/**
+ * Returns a key that can be used for document lookups on the
+ * `DbRemoteDocumentDocumentKeyIndex` index.
+ */
+function dbKey(documentKey) {
+    const path = documentKey.path.toArray();
+    return [
+        /* prefix path */ path.slice(0, path.length - 2),
+        /* collection id */ path[path.length - 2],
+        /* document id */ path[path.length - 1]
+    ];
+}
+/**
+ * Returns a key that can be used for document lookups via the primary key of
+ * the DbRemoteDocument object store.
+ */
+function dbReadTimeKey(documentKey, readTime) {
+    const path = documentKey.path.toArray();
+    return [
+        /* prefix path */ path.slice(0, path.length - 2),
+        /* collection id */ path[path.length - 2],
+        toDbTimestampKey(readTime),
+        /* document id */ path[path.length - 1]
+    ];
+}
+/**
+ * Returns a key that can be used for document lookups on the
+ * `DbRemoteDocumentDocumentCollectionGroupIndex` index.
+ */
+function dbCollectionGroupKey(collectionGroup, offset) {
+    const path = offset.documentKey.path.toArray();
+    return [
+        /* collection id */ collectionGroup,
+        toDbTimestampKey(offset.readTime),
+        /* prefix path */ path.slice(0, path.length - 2),
+        /* document id */ path.length > 0 ? path[path.length - 1] : ''
+    ];
 }
-function dbKey(docKey) {
-    return docKey.path.toArray();
+/**
+ * Comparator that compares document keys according to the primary key sorting
+ * used by the `DbRemoteDocumentDocument` store (by collection path and then
+ * document ID).
+ */
+function dbKeyComparator(l, r) {
+    const cmp = l.path.length - r.path.length;
+    return cmp !== 0 ? cmp : DocumentKey.comparator(l, r);
 }
+/**
+ * Schema Version for the Web client:
+ * 1.  Initial version including Mutation Queue, Query Cache, and Remote
+ *     Document Cache
+ * 2.  Used to ensure a targetGlobal object exists and add targetCount to it. No
+ *     longer required because migration 3 unconditionally clears it.
+ * 3.  Dropped and re-created Query Cache to deal with cache corruption related
+ *     to limbo resolution. Addresses
+ *     https://github.com/firebase/firebase-ios-sdk/issues/1548
+ * 4.  Multi-Tab Support.
+ * 5.  Removal of held write acks.
+ * 6.  Create document global for tracking document cache size.
+ * 7.  Ensure every cached document has a sentinel row with a sequence number.
+ * 8.  Add collection-parent index for Collection Group queries.
+ * 9.  Change RemoteDocumentChanges store to be keyed by readTime rather than
+ *     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. Rewrite the keys of the remote document cache to allow for efficient
+ *     document lookup via `getAll()`.
+ * 14. Add indexing support.
+ */
+const SCHEMA_VERSION = 13;
 
 /**
  * @license
@@ -11980,7 +12342,7 @@ class SchemaConverter {
             createPrimaryClientStore(db);
             createMutationQueue(db);
             createQueryCache(db);
-            createRemoteDocumentCache(db);
+            createLegacyRemoteDocumentCache(db);
         }
         // Migration 2 to populate the targetGlobal object no longer needed since
         // migration 3 unconditionally clears it.
@@ -12029,7 +12391,8 @@ class SchemaConverter {
                 // to the DbRemoteDocument object store itself. Since the previous change
                 // log only contained transient data, we can drop its object store.
                 dropRemoteDocumentChangesStore(db);
-                createRemoteDocumentReadTimeIndex(txn);
+                // Note: Schema version 9 used to create a read time index for the
+                // RemoteDocumentCache. This is now done with schema version 13.
             });
         }
         if (fromVersion < 10 && toVersion >= 10) {
@@ -12047,6 +12410,12 @@ class SchemaConverter {
             });
         }
         if (fromVersion < 13 && toVersion >= 13) {
+            p = p
+                .next(() => createRemoteDocumentCache(db))
+                .next(() => this.rewriteRemoteDocumentCache(db, simpleDbTransaction))
+                .next(() => db.deleteObjectStore(DbRemoteDocumentStore$1));
+        }
+        if (fromVersion < 14 && toVersion >= 14) {
             p = p.next(() => {
                 createFieldIndex(db);
             });
@@ -12054,27 +12423,27 @@ class SchemaConverter {
         return p;
     }
     addDocumentGlobal(txn) {
-        let byteCount = 0;
+        let byteSize = 0;
         return txn
-            .store(DbRemoteDocument.store)
+            .store(DbRemoteDocumentStore$1)
             .iterate((_, doc) => {
-            byteCount += dbDocumentSize(doc);
+            byteSize += dbDocumentSize(doc);
         })
             .next(() => {
-            const metadata = new DbRemoteDocumentGlobal(byteCount);
+            const metadata = { byteSize };
             return txn
-                .store(DbRemoteDocumentGlobal.store)
-                .put(DbRemoteDocumentGlobal.key, metadata);
+                .store(DbRemoteDocumentGlobalStore)
+                .put(DbRemoteDocumentGlobalKey, metadata);
         });
     }
     removeAcknowledgedMutations(txn) {
-        const queuesStore = txn.store(DbMutationQueue.store);
-        const mutationsStore = txn.store(DbMutationBatch.store);
+        const queuesStore = txn.store(DbMutationQueueStore);
+        const mutationsStore = txn.store(DbMutationBatchStore);
         return queuesStore.loadAll().next(queues => {
             return PersistencePromise.forEach(queues, (queue) => {
                 const range = IDBKeyRange.bound([queue.userId, BATCHID_UNKNOWN], [queue.userId, queue.lastAcknowledgedBatchId]);
                 return mutationsStore
-                    .loadAll(DbMutationBatch.userMutationsIndex, range)
+                    .loadAll(DbMutationBatchUserMutationsIndex, range)
                     .next(dbBatches => {
                     return PersistencePromise.forEach(dbBatches, (dbBatch) => {
                         hardAssert(dbBatch.userId === queue.userId);
@@ -12090,12 +12459,16 @@ class SchemaConverter {
      * with a sequence number. Missing rows are given the most recently used sequence number.
      */
     ensureSequenceNumbers(txn) {
-        const documentTargetStore = txn.store(DbTargetDocument.store);
-        const documentsStore = txn.store(DbRemoteDocument.store);
-        const globalTargetStore = txn.store(DbTargetGlobal.store);
-        return globalTargetStore.get(DbTargetGlobal.key).next(metadata => {
+        const documentTargetStore = txn.store(DbTargetDocumentStore);
+        const documentsStore = txn.store(DbRemoteDocumentStore$1);
+        const globalTargetStore = txn.store(DbTargetGlobalStore);
+        return globalTargetStore.get(DbTargetGlobalKey).next(metadata => {
             const writeSentinelKey = (path) => {
-                return documentTargetStore.put(new DbTargetDocument(0, encodeResourcePath(path), metadata.highestListenSequenceNumber));
+                return documentTargetStore.put({
+                    targetId: 0,
+                    path: encodeResourcePath(path),
+                    sequenceNumber: metadata.highestListenSequenceNumber
+                });
             };
             const promises = [];
             return documentsStore
@@ -12116,10 +12489,10 @@ class SchemaConverter {
     }
     createCollectionParentIndex(db, txn) {
         // Create the index.
-        db.createObjectStore(DbCollectionParent.store, {
-            keyPath: DbCollectionParent.keyPath
+        db.createObjectStore(DbCollectionParentStore, {
+            keyPath: DbCollectionParentKeyPath
         });
-        const collectionParentsStore = txn.store(DbCollectionParent.store);
+        const collectionParentsStore = txn.store(DbCollectionParentStore);
         // Helper to add an index entry iff we haven't already written it.
         const cache = new MemoryCollectionParentIndex();
         const addEntry = (collectionPath) => {
@@ -12134,7 +12507,7 @@ class SchemaConverter {
         };
         // Index existing remote documents.
         return txn
-            .store(DbRemoteDocument.store)
+            .store(DbRemoteDocumentStore$1)
             .iterate({ keysOnly: true }, (pathSegments, _) => {
             const path = new ResourcePath(pathSegments);
             return addEntry(path.popLast());
@@ -12142,7 +12515,7 @@ class SchemaConverter {
             .next(() => {
             // Index existing mutations.
             return txn
-                .store(DbDocumentMutation.store)
+                .store(DbDocumentMutationStore)
                 .iterate({ keysOnly: true }, ([userID, encodedPath, batchId], _) => {
                 const path = decodeResourcePath(encodedPath);
                 return addEntry(path.popLast());
@@ -12150,71 +12523,99 @@ class SchemaConverter {
         });
     }
     rewriteCanonicalIds(txn) {
-        const targetStore = txn.store(DbTarget.store);
+        const targetStore = txn.store(DbTargetStore);
         return targetStore.iterate((key, originalDbTarget) => {
             const originalTargetData = fromDbTarget(originalDbTarget);
             const updatedDbTarget = toDbTarget(this.serializer, originalTargetData);
             return targetStore.put(updatedDbTarget);
         });
     }
+    rewriteRemoteDocumentCache(db, transaction) {
+        const legacyRemoteDocumentStore = transaction.store(DbRemoteDocumentStore$1);
+        const writes = [];
+        return legacyRemoteDocumentStore
+            .iterate((_, legacyDocument) => {
+            const remoteDocumentStore = transaction.store(DbRemoteDocumentStore);
+            const path = extractKey(legacyDocument).path.toArray();
+            const dbRemoteDocument = {
+                prefixPath: path.slice(0, path.length - 2),
+                collectionGroup: path[path.length - 2],
+                documentId: path[path.length - 1],
+                readTime: legacyDocument.readTime || [0, 0],
+                unknownDocument: legacyDocument.unknownDocument,
+                noDocument: legacyDocument.noDocument,
+                document: legacyDocument.document,
+                hasCommittedMutations: !!legacyDocument.hasCommittedMutations
+            };
+            writes.push(remoteDocumentStore.put(dbRemoteDocument));
+        })
+            .next(() => PersistencePromise.waitFor(writes));
+    }
 }
 function sentinelKey(path) {
     return [0, encodeResourcePath(path)];
 }
 function createPrimaryClientStore(db) {
-    db.createObjectStore(DbPrimaryClient.store);
+    db.createObjectStore(DbPrimaryClientStore);
 }
 function createMutationQueue(db) {
-    db.createObjectStore(DbMutationQueue.store, {
-        keyPath: DbMutationQueue.keyPath
+    db.createObjectStore(DbMutationQueueStore, {
+        keyPath: DbMutationQueueKeyPath
     });
-    const mutationBatchesStore = db.createObjectStore(DbMutationBatch.store, {
-        keyPath: DbMutationBatch.keyPath,
+    const mutationBatchesStore = db.createObjectStore(DbMutationBatchStore, {
+        keyPath: DbMutationBatchKeyPath,
         autoIncrement: true
     });
-    mutationBatchesStore.createIndex(DbMutationBatch.userMutationsIndex, DbMutationBatch.userMutationsKeyPath, { unique: true });
-    db.createObjectStore(DbDocumentMutation.store);
+    mutationBatchesStore.createIndex(DbMutationBatchUserMutationsIndex, DbMutationBatchUserMutationsKeyPath, { unique: true });
+    db.createObjectStore(DbDocumentMutationStore);
 }
 /**
  * Upgrade function to migrate the 'mutations' store from V1 to V3. Loads
  * and rewrites all data.
  */
 function upgradeMutationBatchSchemaAndMigrateData(db, txn) {
-    const v1MutationsStore = txn.store(DbMutationBatch.store);
+    const v1MutationsStore = txn.store(DbMutationBatchStore);
     return v1MutationsStore.loadAll().next(existingMutations => {
-        db.deleteObjectStore(DbMutationBatch.store);
-        const mutationsStore = db.createObjectStore(DbMutationBatch.store, {
-            keyPath: DbMutationBatch.keyPath,
+        db.deleteObjectStore(DbMutationBatchStore);
+        const mutationsStore = db.createObjectStore(DbMutationBatchStore, {
+            keyPath: DbMutationBatchKeyPath,
             autoIncrement: true
         });
-        mutationsStore.createIndex(DbMutationBatch.userMutationsIndex, DbMutationBatch.userMutationsKeyPath, { unique: true });
-        const v3MutationsStore = txn.store(DbMutationBatch.store);
+        mutationsStore.createIndex(DbMutationBatchUserMutationsIndex, DbMutationBatchUserMutationsKeyPath, { unique: true });
+        const v3MutationsStore = txn.store(DbMutationBatchStore);
         const writeAll = existingMutations.map(mutation => v3MutationsStore.put(mutation));
         return PersistencePromise.waitFor(writeAll);
     });
 }
+function createLegacyRemoteDocumentCache(db) {
+    db.createObjectStore(DbRemoteDocumentStore$1);
+}
 function createRemoteDocumentCache(db) {
-    db.createObjectStore(DbRemoteDocument.store);
+    const remoteDocumentStore = db.createObjectStore(DbRemoteDocumentStore, {
+        keyPath: DbRemoteDocumentKeyPath
+    });
+    remoteDocumentStore.createIndex(DbRemoteDocumentDocumentKeyIndex, DbRemoteDocumentDocumentKeyIndexPath);
+    remoteDocumentStore.createIndex(DbRemoteDocumentCollectionGroupIndex, DbRemoteDocumentCollectionGroupIndexPath);
 }
 function createDocumentGlobalStore(db) {
-    db.createObjectStore(DbRemoteDocumentGlobal.store);
+    db.createObjectStore(DbRemoteDocumentGlobalStore);
 }
 function createQueryCache(db) {
-    const targetDocumentsStore = db.createObjectStore(DbTargetDocument.store, {
-        keyPath: DbTargetDocument.keyPath
+    const targetDocumentsStore = db.createObjectStore(DbTargetDocumentStore, {
+        keyPath: DbTargetDocumentKeyPath
     });
-    targetDocumentsStore.createIndex(DbTargetDocument.documentTargetsIndex, DbTargetDocument.documentTargetsKeyPath, { unique: true });
-    const targetStore = db.createObjectStore(DbTarget.store, {
-        keyPath: DbTarget.keyPath
+    targetDocumentsStore.createIndex(DbTargetDocumentDocumentTargetsIndex, DbTargetDocumentDocumentTargetsKeyPath, { unique: true });
+    const targetStore = db.createObjectStore(DbTargetStore, {
+        keyPath: DbTargetKeyPath
     });
     // NOTE: This is unique only because the TargetId is the suffix.
-    targetStore.createIndex(DbTarget.queryTargetsIndexName, DbTarget.queryTargetsKeyPath, { unique: true });
-    db.createObjectStore(DbTargetGlobal.store);
+    targetStore.createIndex(DbTargetQueryTargetsIndexName, DbTargetQueryTargetsKeyPath, { unique: true });
+    db.createObjectStore(DbTargetGlobalStore);
 }
 function dropQueryCache(db) {
-    db.deleteObjectStore(DbTargetDocument.store);
-    db.deleteObjectStore(DbTarget.store);
-    db.deleteObjectStore(DbTargetGlobal.store);
+    db.deleteObjectStore(DbTargetDocumentStore);
+    db.deleteObjectStore(DbTargetStore);
+    db.deleteObjectStore(DbTargetGlobalStore);
 }
 function dropRemoteDocumentChangesStore(db) {
     if (db.objectStoreNames.contains('remoteDocumentChanges')) {
@@ -12227,58 +12628,65 @@ function dropRemoteDocumentChangesStore(db) {
  * @param txn - The version upgrade transaction for indexeddb
  */
 function writeEmptyTargetGlobalEntry(txn) {
-    const globalStore = txn.store(DbTargetGlobal.store);
-    const metadata = new DbTargetGlobal(
-    /*highestTargetId=*/ 0, 
-    /*lastListenSequenceNumber=*/ 0, SnapshotVersion.min().toTimestamp(), 
-    /*targetCount=*/ 0);
-    return globalStore.put(DbTargetGlobal.key, metadata);
-}
-/**
- * Creates indices on the RemoteDocuments store used for both multi-tab
- * and Index-Free queries.
- */
-function createRemoteDocumentReadTimeIndex(txn) {
-    const remoteDocumentStore = txn.objectStore(DbRemoteDocument.store);
-    remoteDocumentStore.createIndex(DbRemoteDocument.readTimeIndex, DbRemoteDocument.readTimeIndexPath, { unique: false });
-    remoteDocumentStore.createIndex(DbRemoteDocument.collectionReadTimeIndex, DbRemoteDocument.collectionReadTimeIndexPath, { unique: false });
+    const globalStore = txn.store(DbTargetGlobalStore);
+    const metadata = {
+        highestTargetId: 0,
+        highestListenSequenceNumber: 0,
+        lastRemoteSnapshotVersion: SnapshotVersion.min().toTimestamp(),
+        targetCount: 0
+    };
+    return globalStore.put(DbTargetGlobalKey, metadata);
 }
 function createClientMetadataStore(db) {
-    db.createObjectStore(DbClientMetadata.store, {
-        keyPath: DbClientMetadata.keyPath
+    db.createObjectStore(DbClientMetadataStore, {
+        keyPath: DbClientMetadataKeyPath
     });
 }
 function createBundlesStore(db) {
-    db.createObjectStore(DbBundle.store, {
-        keyPath: DbBundle.keyPath
+    db.createObjectStore(DbBundleStore, {
+        keyPath: DbBundleKeyPath
     });
 }
 function createNamedQueriesStore(db) {
-    db.createObjectStore(DbNamedQuery.store, {
-        keyPath: DbNamedQuery.keyPath
+    db.createObjectStore(DbNamedQueryStore, {
+        keyPath: DbNamedQueryKeyPath
     });
 }
 function createFieldIndex(db) {
-    const indexConfiguratioStore = db.createObjectStore(DbIndexConfiguration.store, {
-        keyPath: DbIndexConfiguration.keyPath,
+    const indexConfigurationStore = db.createObjectStore(DbIndexConfigurationStore, {
+        keyPath: DbIndexConfigurationKeyPath,
         autoIncrement: true
     });
-    indexConfiguratioStore.createIndex(DbIndexConfiguration.collectionGroupIndex, DbIndexConfiguration.collectionGroupIndexPath, { unique: false });
-    const indexStateStore = db.createObjectStore(DbIndexState.store, {
-        keyPath: DbIndexState.keyPath
+    indexConfigurationStore.createIndex(DbIndexConfigurationCollectionGroupIndex, DbIndexConfigurationCollectionGroupIndexPath, { unique: false });
+    const indexStateStore = db.createObjectStore(DbIndexStateStore, {
+        keyPath: DbIndexStateKeyPath
     });
-    indexStateStore.createIndex(DbIndexState.sequenceNumberIndex, DbIndexState.sequenceNumberIndexPath, { unique: false });
-    const indexEntryStore = db.createObjectStore(DbIndexEntry.store, {
-        keyPath: DbIndexEntry.keyPath
+    indexStateStore.createIndex(DbIndexStateSequenceNumberIndex, DbIndexStateSequenceNumberIndexPath, { unique: false });
+    const indexEntryStore = db.createObjectStore(DbIndexEntryStore, {
+        keyPath: DbIndexEntryKeyPath
     });
-    indexEntryStore.createIndex(DbIndexEntry.documentKeyIndex, DbIndexEntry.documentKeyIndexPath, { unique: false });
+    indexEntryStore.createIndex(DbIndexEntryDocumentKeyIndex, DbIndexEntryDocumentKeyIndexPath, { unique: false });
 }
 function createDocumentOverlayStore(db) {
-    const documentOverlayStore = db.createObjectStore(DbDocumentOverlay.store, {
-        keyPath: DbDocumentOverlay.keyPath
+    const documentOverlayStore = db.createObjectStore(DbDocumentOverlayStore, {
+        keyPath: DbDocumentOverlayKeyPath
     });
-    documentOverlayStore.createIndex(DbDocumentOverlay.collectionPathOverlayIndex, DbDocumentOverlay.collectionPathOverlayIndexPath, { unique: false });
-    documentOverlayStore.createIndex(DbDocumentOverlay.collectionGroupOverlayIndex, DbDocumentOverlay.collectionGroupOverlayIndexPath, { unique: false });
+    documentOverlayStore.createIndex(DbDocumentOverlayCollectionPathOverlayIndex, DbDocumentOverlayCollectionPathOverlayIndexPath, { unique: false });
+    documentOverlayStore.createIndex(DbDocumentOverlayCollectionGroupOverlayIndex, DbDocumentOverlayCollectionGroupOverlayIndexPath, { unique: false });
+}
+function extractKey(remoteDoc) {
+    if (remoteDoc.document) {
+        return new DocumentKey(ResourcePath.fromString(remoteDoc.document.name).popFirst(5));
+    }
+    else if (remoteDoc.noDocument) {
+        return DocumentKey.fromSegments(remoteDoc.noDocument.path);
+    }
+    else if (remoteDoc.unknownDocument) {
+        return DocumentKey.fromSegments(remoteDoc.unknownDocument.path);
+    }
+    else {
+        return fail();
+    }
 }
 
 /**
@@ -12526,7 +12934,12 @@ class IndexedDbPersistence {
         return this.runTransaction('updateClientMetadataAndTryBecomePrimary', 'readwrite', txn => {
             const metadataStore = clientMetadataStore(txn);
             return metadataStore
-                .put(new DbClientMetadata(this.clientId, Date.now(), this.networkEnabled, this.inForeground))
+                .put({
+                clientId: this.clientId,
+                updateTimeMs: Date.now(),
+                networkEnabled: this.networkEnabled,
+                inForeground: this.inForeground
+            })
                 .next(() => {
                 if (this.isPrimary) {
                     return this.verifyPrimaryLease(txn).next(success => {
@@ -12572,7 +12985,7 @@ class IndexedDbPersistence {
     }
     verifyPrimaryLease(txn) {
         const store = primaryClientStore(txn);
-        return store.get(DbPrimaryClient.key).next(primaryClient => {
+        return store.get(DbPrimaryClientKey).next(primaryClient => {
             return PersistencePromise.resolve(this.isLocalClient(primaryClient));
         });
     }
@@ -12590,7 +13003,7 @@ class IndexedDbPersistence {
             !this.isWithinAge(this.lastGarbageCollectionTime, MAX_CLIENT_AGE_MS)) {
             this.lastGarbageCollectionTime = Date.now();
             const inactiveClients = await this.runTransaction('maybeGarbageCollectMultiClientState', 'readwrite-primary', txn => {
-                const metadataStore = getStore(txn, DbClientMetadata.store);
+                const metadataStore = getStore(txn, DbClientMetadataStore);
                 return metadataStore.loadAll().next(existingClients => {
                     const active = this.filterActiveClients(existingClients, MAX_CLIENT_AGE_MS);
                     const inactive = existingClients.filter(client => active.indexOf(client) === -1);
@@ -12644,7 +13057,7 @@ class IndexedDbPersistence {
         }
         const store = primaryClientStore(txn);
         return store
-            .get(DbPrimaryClient.key)
+            .get(DbPrimaryClientKey)
             .next(currentPrimary => {
             const currentLeaseIsValid = currentPrimary !== null &&
                 this.isWithinAge(currentPrimary.leaseTimestampMs, MAX_PRIMARY_ELIGIBLE_AGE_MS) &&
@@ -12725,7 +13138,7 @@ class IndexedDbPersistence {
         this.detachWindowUnloadHook();
         // Use `SimpleDb.runTransaction` directly to avoid failing if another tab
         // has obtained the primary lease.
-        await this.simpleDb.runTransaction('shutdown', 'readwrite', [DbPrimaryClient.store, DbClientMetadata.store], simpleDbTxn => {
+        await this.simpleDb.runTransaction('shutdown', 'readwrite', [DbPrimaryClientStore, DbClientMetadataStore], simpleDbTxn => {
             const persistenceTransaction = new IndexedDbTransaction(simpleDbTxn, ListenSequence.INVALID);
             return this.releasePrimaryLeaseIfHeld(persistenceTransaction).next(() => this.removeClientMetadata(persistenceTransaction));
         });
@@ -12832,7 +13245,7 @@ class IndexedDbPersistence {
     // be turned off.
     verifyAllowTabSynchronization(txn) {
         const store = primaryClientStore(txn);
-        return store.get(DbPrimaryClient.key).next(currentPrimary => {
+        return store.get(DbPrimaryClientKey).next(currentPrimary => {
             const currentLeaseIsValid = currentPrimary !== null &&
                 this.isWithinAge(currentPrimary.leaseTimestampMs, MAX_PRIMARY_ELIGIBLE_AGE_MS) &&
                 !this.isClientZombied(currentPrimary.ownerId);
@@ -12850,8 +13263,12 @@ class IndexedDbPersistence {
      * method does not verify that the client is eligible for this lease.
      */
     acquireOrExtendPrimaryLease(txn) {
-        const newPrimary = new DbPrimaryClient(this.clientId, this.allowTabSynchronization, Date.now());
-        return primaryClientStore(txn).put(DbPrimaryClient.key, newPrimary);
+        const newPrimary = {
+            ownerId: this.clientId,
+            allowTabSynchronization: this.allowTabSynchronization,
+            leaseTimestampMs: Date.now()
+        };
+        return primaryClientStore(txn).put(DbPrimaryClientKey, newPrimary);
     }
     static isAvailable() {
         return SimpleDb.isAvailable();
@@ -12859,10 +13276,10 @@ class IndexedDbPersistence {
     /** Checks the primary lease and removes it if we are the current primary. */
     releasePrimaryLeaseIfHeld(txn) {
         const store = primaryClientStore(txn);
-        return store.get(DbPrimaryClient.key).next(primaryClient => {
+        return store.get(DbPrimaryClientKey).next(primaryClient => {
             if (this.isLocalClient(primaryClient)) {
                 logDebug(LOG_TAG$d, 'Releasing primary lease.');
-                return store.delete(DbPrimaryClient.key);
+                return store.delete(DbPrimaryClientKey);
             }
             else {
                 return PersistencePromise.resolve();
@@ -12996,13 +13413,13 @@ class IndexedDbPersistence {
  * Helper to get a typed SimpleDbStore for the primary client object store.
  */
 function primaryClientStore(txn) {
-    return getStore(txn, DbPrimaryClient.store);
+    return getStore(txn, DbPrimaryClientStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the client metadata object store.
  */
 function clientMetadataStore(txn) {
-    return getStore(txn, DbClientMetadata.store);
+    return getStore(txn, DbClientMetadataStore);
 }
 /**
  * Generates a string used as a prefix when storing data in IndexedDB and
@@ -13112,18 +13529,17 @@ class LocalDocumentsView {
      *
      * @param transaction - The persistence transaction.
      * @param query - The query to match documents against.
-     * @param sinceReadTime - If not set to SnapshotVersion.min(), return only
-     *     documents that have been read since this snapshot version (exclusive).
+     * @param offset - Read time and key to start scanning by (exclusive).
      */
-    getDocumentsMatchingQuery(transaction, query, sinceReadTime) {
+    getDocumentsMatchingQuery(transaction, query, offset) {
         if (isDocumentQuery$1(query)) {
             return this.getDocumentsMatchingDocumentQuery(transaction, query.path);
         }
         else if (isCollectionGroupQuery(query)) {
-            return this.getDocumentsMatchingCollectionGroupQuery(transaction, query, sinceReadTime);
+            return this.getDocumentsMatchingCollectionGroupQuery(transaction, query, offset);
         }
         else {
-            return this.getDocumentsMatchingCollectionQuery(transaction, query, sinceReadTime);
+            return this.getDocumentsMatchingCollectionQuery(transaction, query, offset);
         }
     }
     getDocumentsMatchingDocumentQuery(transaction, docPath) {
@@ -13136,7 +13552,7 @@ class LocalDocumentsView {
             return result;
         });
     }
-    getDocumentsMatchingCollectionGroupQuery(transaction, query, sinceReadTime) {
+    getDocumentsMatchingCollectionGroupQuery(transaction, query, offset) {
         const collectionId = query.collectionGroup;
         let results = documentMap();
         return this.indexManager
@@ -13146,7 +13562,7 @@ class LocalDocumentsView {
             // collectionId and aggregate the results.
             return PersistencePromise.forEach(parents, (parent) => {
                 const collectionQuery = asCollectionQueryAtPath(query, parent.child(collectionId));
-                return this.getDocumentsMatchingCollectionQuery(transaction, collectionQuery, sinceReadTime).next(r => {
+                return this.getDocumentsMatchingCollectionQuery(transaction, collectionQuery, offset).next(r => {
                     r.forEach((key, doc) => {
                         results = results.insert(key, doc);
                     });
@@ -13154,11 +13570,11 @@ class LocalDocumentsView {
             }).next(() => results);
         });
     }
-    getDocumentsMatchingCollectionQuery(transaction, query, sinceReadTime) {
+    getDocumentsMatchingCollectionQuery(transaction, query, offset) {
         // Query the remote documents and overlay mutations.
         let results;
         return this.remoteDocumentCache
-            .getAll(transaction, query.path, sinceReadTime)
+            .getAllFromCollection(transaction, query.path, offset)
             .next(queryResults => {
             results = queryResults;
             return this.mutationQueue.getAllMutationBatchesAffectingQuery(transaction, query);
@@ -13244,11 +13660,12 @@ class LocalStoreImpl {
         // TODO(wuandy): Evaluate if TargetId can be part of Target.
         this.targetIdByTarget = new ObjectMap(t => canonifyTarget(t), targetEquals);
         /**
-         * The read time of the last entry processed by `getNewDocumentChanges()`.
+         * A per collection group index of the last read time processed by
+         * `getNewDocumentChanges()`.
          *
          * PORTING NOTE: This is only used for multi-tab synchronization.
          */
-        this.lastDocumentChangeReadTime = SnapshotVersion.min();
+        this.collectionGroupReadTime = new Map();
         this.remoteDocuments = persistence.getRemoteDocumentCache();
         this.targetCache = persistence.getTargetCache();
         this.bundleCache = persistence.getBundleCache();
@@ -13783,6 +14200,7 @@ function localStoreExecuteQuery(localStore, query, usePreviousResults) {
             ? lastLimboFreeSnapshotVersion
             : SnapshotVersion.min(), usePreviousResults ? remoteKeys : documentKeySet()))
             .next(documents => {
+            setMaxReadTime(localStoreImpl, queryCollectionGroup(query), documents);
             return { documents, remoteKeys };
         });
     });
@@ -13860,28 +14278,32 @@ function localStoreGetCachedTarget(localStore, targetId) {
  * since the prior call.
  */
 // PORTING NOTE: Multi-Tab only.
-function localStoreGetNewDocumentChanges(localStore) {
+function localStoreGetNewDocumentChanges(localStore, collectionGroup) {
     const localStoreImpl = debugCast(localStore);
+    // Get the current maximum read time for the collection. This should always
+    // exist, but to reduce the chance for regressions we default to
+    // SnapshotVersion.Min()
+    // TODO(indexing): Consider removing the default value.
+    const readTime = localStoreImpl.collectionGroupReadTime.get(collectionGroup) ||
+        SnapshotVersion.min();
     return localStoreImpl.persistence
-        .runTransaction('Get new document changes', 'readonly', txn => remoteDocumentCacheGetNewDocumentChanges(localStoreImpl.remoteDocuments, txn, localStoreImpl.lastDocumentChangeReadTime))
-        .then(({ changedDocs, readTime }) => {
-        localStoreImpl.lastDocumentChangeReadTime = readTime;
+        .runTransaction('Get new document changes', 'readonly', txn => localStoreImpl.remoteDocuments.getAllFromCollectionGroup(txn, collectionGroup, newIndexOffsetSuccessorFromReadTime(readTime, INITIAL_LARGEST_BATCH_ID), 
+    /* limit= */ Number.MAX_SAFE_INTEGER))
+        .then(changedDocs => {
+        setMaxReadTime(localStoreImpl, collectionGroup, changedDocs);
         return changedDocs;
     });
 }
-/**
- * Reads the newest document change from persistence and moves the internal
- * synchronization marker forward so that calls to `getNewDocumentChanges()`
- * only return changes that happened after client initialization.
- */
+/** Sets the collection group's maximum read time from the given documents. */
 // PORTING NOTE: Multi-Tab only.
-async function localStoreSynchronizeLastDocumentChangeReadTime(localStore) {
-    const localStoreImpl = debugCast(localStore);
-    return localStoreImpl.persistence
-        .runTransaction('Synchronize last document change read time', 'readonly', txn => remoteDocumentCacheGetLastReadTime(txn))
-        .then(readTime => {
-        localStoreImpl.lastDocumentChangeReadTime = readTime;
+function setMaxReadTime(localStoreImpl, collectionGroup, changedDocs) {
+    let readTime = SnapshotVersion.min();
+    changedDocs.forEach((_, doc) => {
+        if (doc.readTime.compareTo(readTime) > 0) {
+            readTime = doc.readTime;
+        }
     });
+    localStoreImpl.collectionGroupReadTime.set(collectionGroup, readTime);
 }
 /**
  * Creates a new target using the given bundle name, which will be used to
@@ -14065,7 +14487,7 @@ class MemoryDocumentOverlayCache {
         return PersistencePromise.resolve(this.overlays.get(key));
     }
     saveOverlays(transaction, largestBatchId, overlays) {
-        overlays.forEach(mutation => {
+        overlays.forEach((_, mutation) => {
             this.saveOverlay(transaction, largestBatchId, mutation);
         });
         return PersistencePromise.resolve();
@@ -14079,7 +14501,7 @@ class MemoryDocumentOverlayCache {
         return PersistencePromise.resolve();
     }
     getOverlaysForCollection(transaction, collection, sinceBatchId) {
-        const result = new Map();
+        const result = newOverlayMap();
         const immediateChildrenPathLength = collection.length + 1;
         const prefix = new DocumentKey(collection.child(''));
         const iter = this.overlays.getIteratorFrom(prefix);
@@ -14113,19 +14535,19 @@ class MemoryDocumentOverlayCache {
             if (overlay.largestBatchId > sinceBatchId) {
                 let overlaysForBatchId = batchIdToOverlays.get(overlay.largestBatchId);
                 if (overlaysForBatchId === null) {
-                    overlaysForBatchId = new Map();
+                    overlaysForBatchId = newOverlayMap();
                     batchIdToOverlays = batchIdToOverlays.insert(overlay.largestBatchId, overlaysForBatchId);
                 }
                 overlaysForBatchId.set(overlay.getKey(), overlay);
             }
         }
-        const result = new Map();
+        const result = newOverlayMap();
         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) {
+            overlays.forEach((key, overlay) => result.set(key, overlay));
+            if (result.size() >= count) {
                 break;
             }
         }
@@ -14138,16 +14560,19 @@ class MemoryDocumentOverlayCache {
         // 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);
+            const newSet = this.overlayByBatchId
+                .get(existing.largestBatchId)
+                .delete(mutation.key);
+            this.overlayByBatchId.set(existing.largestBatchId, newSet);
         }
         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();
+            batch = documentKeySet();
             this.overlayByBatchId.set(largestBatchId, batch);
         }
-        batch.add(mutation.key);
+        this.overlayByBatchId.set(largestBatchId, batch.add(mutation.key));
     }
 }
 
@@ -14561,7 +14986,7 @@ class MemoryRemoteDocumentCacheImpl {
         });
         return PersistencePromise.resolve(results);
     }
-    getAll(transaction, collectionPath, sinceReadTime) {
+    getAllFromCollection(transaction, collectionPath, offset) {
         let results = mutableDocumentMap();
         // Documents are ordered by key, so we can use a prefix scan to narrow down
         // the documents we need to match the query against.
@@ -14576,13 +15001,19 @@ class MemoryRemoteDocumentCacheImpl {
                 // Exclude entries from subcollections.
                 continue;
             }
-            if (document.readTime.compareTo(sinceReadTime) <= 0) {
+            if (indexOffsetComparator(newIndexOffsetFromDocument(document), offset) <= 0) {
+                // The document sorts before the offset.
                 continue;
             }
             results = results.insert(document.key, document.mutableCopy());
         }
         return PersistencePromise.resolve(results);
     }
+    getAllFromCollectionGroup(transaction, collectionGroup, offset, limti) {
+        // This method should only be called from the IndexBackfiller if persistence
+        // is enabled.
+        fail();
+    }
     forEachDocumentKey(transaction, f) {
         return PersistencePromise.forEach(this.docs, (key) => f(key));
     }
@@ -15035,7 +15466,7 @@ class QueryEngine {
             }
             // Retrieve all results for documents that were updated since the last
             // limbo-document free remote snapshot.
-            return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, lastLimboFreeSnapshotVersion).next(updatedResults => {
+            return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, newIndexOffsetSuccessorFromReadTime(lastLimboFreeSnapshotVersion, INITIAL_LARGEST_BATCH_ID)).next(updatedResults => {
                 // We merge `previousResults` into `updateResults`, since
                 // `updateResults` is already a DocumentMap. If a document is
                 // contained in both lists, then its contents are the same.
@@ -15097,7 +15528,7 @@ class QueryEngine {
         if (getLogLevel() <= logger.LogLevel.DEBUG) {
             logDebug('QueryEngine', 'Using full collection scan to execute query:', stringifyQuery(query));
         }
-        return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, SnapshotVersion.min());
+        return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, IndexOffset.min());
     }
 }
 
@@ -15158,8 +15589,9 @@ function createWebStorageOnlineStateKey(persistenceKey) {
 // The WebStorage prefix that plays as a event to indicate the remote documents
 // might have changed due to some secondary tabs loading a bundle.
 // format of the key is:
-//     firestore_bundle_loaded_<persistenceKey>
-const BUNDLE_LOADED_KEY_PREFIX = 'firestore_bundle_loaded';
+//     firestore_bundle_loaded_v2_<persistenceKey>
+// The version ending with "v2" stores the list of modified collection groups.
+const BUNDLE_LOADED_KEY_PREFIX = 'firestore_bundle_loaded_v2';
 function createBundleLoadedKey(persistenceKey) {
     return `${BUNDLE_LOADED_KEY_PREFIX}_${persistenceKey}`;
 }
@@ -15537,8 +15969,8 @@ class WebStorageSharedClientState {
     setOnlineState(onlineState) {
         this.persistOnlineState(onlineState);
     }
-    notifyBundleLoaded() {
-        this.persistBundleLoadedState();
+    notifyBundleLoaded(collectionGroups) {
+        this.persistBundleLoadedState(collectionGroups);
     }
     shutdown() {
         if (this.started) {
@@ -15622,7 +16054,8 @@ class WebStorageSharedClientState {
                     }
                 }
                 else if (storageEvent.key === this.bundleLoadedKey) {
-                    return this.syncEngine.synchronizeWithChangedDocuments();
+                    const collectionGroups = this.fromWebStoreBundleLoadedState(storageEvent.newValue);
+                    await Promise.all(collectionGroups.map(cg => this.syncEngine.synchronizeWithChangedDocuments(cg)));
                 }
             });
         }
@@ -15654,8 +16087,9 @@ class WebStorageSharedClientState {
         const targetMetadata = new QueryTargetMetadata(targetId, state, error);
         this.setItem(targetKey, targetMetadata.toWebStorageJSON());
     }
-    persistBundleLoadedState() {
-        this.setItem(this.bundleLoadedKey, 'value-not-used');
+    persistBundleLoadedState(collectionGroups) {
+        const json = JSON.stringify(Array.from(collectionGroups));
+        this.setItem(this.bundleLoadedKey, json);
     }
     /**
      * Parses a client state key in WebStorage. Returns null if the key does not
@@ -15699,6 +16133,9 @@ class WebStorageSharedClientState {
     fromWebStorageOnlineState(value) {
         return SharedOnlineState.fromWebStorageEntry(value);
     }
+    fromWebStoreBundleLoadedState(value) {
+        return JSON.parse(value);
+    }
     async handleMutationBatchEvent(mutationBatch) {
         if (mutationBatch.user.uid !== this.currentUser.uid) {
             logDebug(LOG_TAG$a, `Ignoring mutation for non-active user ${mutationBatch.user.uid}`);
@@ -15815,7 +16252,7 @@ class MemorySharedClientState {
     }
     shutdown() { }
     writeSequenceNumber(sequenceNumber) { }
-    notifyBundleLoaded() {
+    notifyBundleLoaded(collectionGroups) {
         // No op.
     }
 }
@@ -15998,9 +16435,13 @@ function createMetadata(databasePath, authToken, appCheckToken, appId) {
         metadata.set('X-Firebase-GMPID', appId);
     }
     metadata.set('X-Goog-Api-Client', X_GOOG_API_CLIENT_VALUE);
-    // This header is used to improve routing and project isolation by the
+    // These headers are used to improve routing and project isolation by the
     // backend.
+    // TODO(b/199767712): We are keeping 'Google-Cloud-Resource-Prefix' until Emulators can be
+    // released with cl/428820046. Currently blocked because Emulators are now built with Java
+    // 11 from Google3.
     metadata.set('Google-Cloud-Resource-Prefix', databasePath);
+    metadata.set('x-goog-request-params', databasePath);
     return metadata;
 }
 /**
@@ -21111,29 +21552,6 @@ class LocalViewChanges {
     }
 }
 
-/**
- * @license
- * Copyright 2020 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class BundleLoadResult {
-    constructor(progress, changedDocs) {
-        this.progress = progress;
-        this.changedDocs = changedDocs;
-    }
-}
-
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -21188,6 +21606,8 @@ class BundleLoader {
         this.queries = [];
         /** Batched documents to be saved into storage */
         this.documents = [];
+        /** The collection groups affected by this bundle. */
+        this.collectionGroups = new Set();
         this.progress = bundleInitialProgress(bundleMetadata);
     }
     /**
@@ -21207,6 +21627,8 @@ class BundleLoader {
             if (!element.payload.documentMetadata.exists) {
                 ++documentsLoaded;
             }
+            const path = ResourcePath.fromString(element.payload.documentMetadata.name);
+            this.collectionGroups.add(path.get(path.length - 2));
         }
         else if (element.payload.document) {
             this.documents[this.documents.length - 1].document =
@@ -21237,13 +21659,17 @@ class BundleLoader {
      * Update the progress to 'Success' and return the updated progress.
      */
     async complete() {
-        const changedDocuments = await localStoreApplyBundledDocuments(this.localStore, new BundleConverterImpl(this.serializer), this.documents, this.bundleMetadata.id);
+        const changedDocs = await localStoreApplyBundledDocuments(this.localStore, new BundleConverterImpl(this.serializer), this.documents, this.bundleMetadata.id);
         const queryDocumentMap = this.getQueryDocumentMapping(this.documents);
         for (const q of this.queries) {
             await localStoreSaveNamedQuery(this.localStore, q, queryDocumentMap.get(q.name));
         }
         this.progress.taskState = 'Success';
-        return new BundleLoadResult(Object.assign({}, this.progress), changedDocuments);
+        return {
+            progress: this.progress,
+            changedCollectionGroups: this.collectionGroups,
+            changedDocs
+        };
     }
 }
 /**
@@ -22322,9 +22748,9 @@ async function synchronizeViewAndComputeSnapshot(syncEngine, queryView) {
  * snapshots if needed.
  */
 // PORTING NOTE: Multi-Tab only.
-async function syncEngineSynchronizeWithChangedDocuments(syncEngine) {
+async function syncEngineSynchronizeWithChangedDocuments(syncEngine, collectionGroup) {
     const syncEngineImpl = debugCast(syncEngine);
-    return localStoreGetNewDocumentChanges(syncEngineImpl.localStore).then(changes => syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngineImpl, changes));
+    return localStoreGetNewDocumentChanges(syncEngineImpl.localStore, collectionGroup).then(changes => syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngineImpl, changes));
 }
 /** Applies a mutation state to an existing batch.  */
 // PORTING NOTE: Multi-Tab only.
@@ -22489,11 +22915,12 @@ async function syncEngineApplyTargetState(syncEngine, targetId, state, error) {
         logDebug(LOG_TAG$3, 'Ignoring unexpected query state notification.');
         return;
     }
-    if (syncEngineImpl.queriesByTarget.has(targetId)) {
+    const query = syncEngineImpl.queriesByTarget.get(targetId);
+    if (query && query.length > 0) {
         switch (state) {
             case 'current':
             case 'not-current': {
-                const changes = await localStoreGetNewDocumentChanges(syncEngineImpl.localStore);
+                const changes = await localStoreGetNewDocumentChanges(syncEngineImpl.localStore, queryCollectionGroup(query[0]));
                 const synthesizedRemoteEvent = RemoteEvent.createSynthesizedRemoteEventForCurrentChange(targetId, state === 'current');
                 await syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngineImpl, changes, synthesizedRemoteEvent);
                 break;
@@ -22576,10 +23003,11 @@ function syncEngineEnsureWriteCallbacks(syncEngine) {
 function syncEngineLoadBundle(syncEngine, bundleReader, task) {
     const syncEngineImpl = debugCast(syncEngine);
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    loadBundleImpl(syncEngineImpl, bundleReader, task).then(() => {
-        syncEngineImpl.sharedClientState.notifyBundleLoaded();
+    loadBundleImpl(syncEngineImpl, bundleReader, task).then(collectionGroups => {
+        syncEngineImpl.sharedClientState.notifyBundleLoaded(collectionGroups);
     });
 }
+/** Loads a bundle and returns the list of affected collection groups. */
 async function loadBundleImpl(syncEngine, reader, task) {
     try {
         const metadata = await reader.getMetadata();
@@ -22587,7 +23015,7 @@ async function loadBundleImpl(syncEngine, reader, task) {
         if (skip) {
             await reader.close();
             task._completeWith(bundleSuccessProgress(metadata));
-            return;
+            return Promise.resolve(new Set());
         }
         task._updateProgress(bundleInitialProgress(metadata));
         const loader = new BundleLoader(metadata, syncEngine.localStore, reader.serializer);
@@ -22601,18 +23029,17 @@ async function loadBundleImpl(syncEngine, reader, task) {
             element = await reader.nextElement();
         }
         const result = await loader.complete();
-        // TODO(b/160876443): This currently raises snapshots with
-        // `fromCache=false` if users already listen to some queries and bundles
-        // has newer version.
         await syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngine, result.changedDocs, 
         /* remoteEvent */ undefined);
         // Save metadata, so loading the same bundle will skip.
         await localStoreSaveBundle(syncEngine.localStore, metadata);
         task._completeWith(result.progress);
+        return Promise.resolve(result.changedCollectionGroups);
     }
     catch (e) {
         logWarn(LOG_TAG$3, `Loading bundle failed with ${e}`);
         task._failWith(e);
+        return Promise.resolve(new Set());
     }
 }
 
@@ -22681,7 +23108,6 @@ class IndexedDbOfflineComponentProvider extends MemoryOfflineComponentProvider {
     }
     async initialize(cfg) {
         await super.initialize(cfg);
-        await localStoreSynchronizeLastDocumentChangeReadTime(this.localStore);
         await this.onlineComponentProvider.initialize(this, cfg);
         // Enqueue writes from a previous session
         await syncEngineEnsureWriteCallbacks(this.onlineComponentProvider.syncEngine);