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

package/dist/index.node.mjs

@@ -8,7 +8,7 @@ import { credentials, loadPackageDefinition, Metadata } from '@grpc/grpc-js';
 import { fromJSON } from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.4-canary.2dd99ae2d";
+const version$1 = "3.4.4-canary.3e9f3e253";
 
 /**
  * @license
@@ -61,7 +61,7 @@ User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');
 User.FIRST_PARTY = new User('first-party-uid');
 User.MOCK_USER = new User('mock-user');
 
-const version = "9.6.5-canary.2dd99ae2d";
+const version = "9.6.6-canary.3e9f3e253";
 
 /**
  * @license
@@ -666,13 +666,19 @@ class FirebaseAppCheckTokenProvider {
         this.appCheckProvider = appCheckProvider;
         this.forceRefresh = false;
         this.appCheck = null;
+        this.latestAppCheckToken = null;
     }
     start(asyncQueue, changeListener) {
         const onTokenChanged = tokenResult => {
             if (tokenResult.error != null) {
                 logDebug('FirebaseAppCheckTokenProvider', `Error getting App Check token; using placeholder token instead. Error: ${tokenResult.error.message}`);
             }
-            return changeListener(tokenResult.token);
+            const tokenUpdated = tokenResult.token !== this.latestAppCheckToken;
+            this.latestAppCheckToken = tokenResult.token;
+            logDebug('FirebaseAppCheckTokenProvider', `Received ${tokenUpdated ? 'new' : 'existing'} token.`);
+            return tokenUpdated
+                ? changeListener(tokenResult.token)
+                : Promise.resolve();
         };
         this.tokenListener = (tokenResult) => {
             asyncQueue.enqueueRetryable(() => onTokenChanged(tokenResult));
@@ -707,6 +713,7 @@ class FirebaseAppCheckTokenProvider {
         return this.appCheck.getToken(forceRefresh).then(tokenResult => {
             if (tokenResult) {
                 hardAssert(typeof tokenResult.token === 'string');
+                this.latestAppCheckToken = tokenResult.token;
                 return new AppCheckToken(tokenResult.token);
             }
             else {
@@ -1192,23 +1199,6 @@ function decodeResourcePath(path) {
     }
     return new ResourcePath(segments);
 }
-
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 /**
  * Schema Version for the Web client:
  * 1.  Initial version including Mutation Queue, Query Cache, and Remote
@@ -1227,8 +1217,10 @@ function decodeResourcePath(path) {
  *     an auto-incrementing ID. This is required for Index-Free queries.
  * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
  * 11. Add bundles and named_queries for bundle support.
+ * 12. Add document overlays.
+ * 13. Add indexing support.
  */
-const SCHEMA_VERSION = 11;
+const SCHEMA_VERSION = 12;
 /**
  * Wrapper class to store timestamps (seconds and nanos) in IndexedDb objects.
  */
@@ -1753,9 +1745,7 @@ class DbClientMetadata {
 DbClientMetadata.store = 'clientMetadata';
 /** Keys are automatically assigned via the clientId properties. */
 DbClientMetadata.keyPath = 'clientId';
-/**
- * A object representing a bundle loaded by the SDK.
- */
+/** An object representing a bundle loaded by the SDK. */
 class DbBundle {
     constructor(
     /** The ID of the loaded bundle. */
@@ -1772,9 +1762,7 @@ class DbBundle {
 /** Name of the IndexedDb object store. */
 DbBundle.store = 'bundles';
 DbBundle.keyPath = 'bundleId';
-/**
- * A object representing a named query loaded by the SDK via a bundle.
- */
+/** An object representing a named query loaded by the SDK via a bundle. */
 class DbNamedQuery {
     constructor(
     /** The name of the query. */
@@ -1791,6 +1779,156 @@ class DbNamedQuery {
 /** Name of the IndexedDb object store. */
 DbNamedQuery.store = 'namedQueries';
 DbNamedQuery.keyPath = 'name';
+/** An object representing the global configuration for a field index. */
+class DbIndexConfiguration {
+    constructor(
+    /**
+     * The index id for this entry. Undefined for indexes that are not yet
+     * persisted.
+     */
+    indexId, 
+    /** The collection group this index belongs to. */
+    collectionGroup, 
+    /** The fields to index for this index. */
+    fields) {
+        this.indexId = indexId;
+        this.collectionGroup = collectionGroup;
+        this.fields = fields;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbIndexConfiguration.store = 'indexConfiguration';
+DbIndexConfiguration.keyPath = 'indexId';
+/**
+ * An index that provides access to the index configurations by collection
+ * group.
+ *
+ * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+ * not possible here as the Web client supports concurrent access to
+ * persistence via multi-tab.
+ */
+DbIndexConfiguration.collectionGroupIndex = 'collectionGroupIndex';
+DbIndexConfiguration.collectionGroupIndexPath = 'collectionGroup';
+/**
+ * An object describing how up-to-date the index backfill is for each user and
+ * index.
+ */
+class DbIndexState {
+    constructor(
+    /** The index id for this entry. */
+    indexId, 
+    /** The user id for this entry. */
+    uid, 
+    /**
+     * A number that indicates when the index was last updated (relative to
+     * other indexes).
+     */
+    sequenceNumber, 
+    /**
+     * The latest read time that has been indexed by Firestore for this field
+     * index. Set to `{seconds: 0, nanos: 0}` if no documents have been indexed.
+     */
+    readTime, 
+    /**
+     * The last document that has been indexed for this field index. Empty if
+     * no documents have been indexed.
+     */
+    documentKey, 
+    /**
+     * The largest mutation batch id that has been processed for this index. -1
+     * if no mutations have been indexed.
+     */
+    largestBatchId) {
+        this.indexId = indexId;
+        this.uid = uid;
+        this.sequenceNumber = sequenceNumber;
+        this.readTime = readTime;
+        this.documentKey = documentKey;
+        this.largestBatchId = largestBatchId;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbIndexState.store = 'indexState';
+DbIndexState.keyPath = ['indexId', 'uid'];
+/**
+ * An index that provides access to documents in a collection sorted by last
+ * update time. Used by the backfiller.
+ *
+ * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+ * not possible here as the Web client supports concurrent access to
+ * persistence via multi-tab.
+ */
+DbIndexState.sequenceNumberIndex = 'sequenceNumberIndex';
+DbIndexState.sequenceNumberIndexPath = ['uid', 'sequenceNumber'];
+/** An object that stores the encoded entries for all documents and fields. */
+class DbIndexEntry {
+    constructor(
+    /** The index id for this entry. */
+    indexId, 
+    /** The user id for this entry. */
+    uid, 
+    /** The encoded array index value for this entry. */
+    arrayValue, 
+    /** The encoded directional value for equality and inequality filters. */
+    directionalValue, 
+    /** The document key this entry points to. */
+    documentKey) {
+        this.indexId = indexId;
+        this.uid = uid;
+        this.arrayValue = arrayValue;
+        this.directionalValue = directionalValue;
+        this.documentKey = documentKey;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbIndexEntry.store = 'indexEntries';
+DbIndexEntry.keyPath = [
+    'indexId',
+    'uid',
+    'arrayValue',
+    'directionalValue',
+    'documentKey'
+];
+/**
+ * An object representing a document overlay.
+ */
+class DbDocumentOverlay {
+    constructor(
+    /** The user ID to whom this overlay belongs. */
+    userId, 
+    /** The path to the collection that contains the document. */
+    collectionPath, 
+    /** The ID (key) of the document within the collection. */
+    documentId, 
+    /** The collection group to which the document belongs. */
+    collectionGroup, 
+    /** The largest batch ID that's been applied for this overlay. */
+    largestBatchId, 
+    /** The overlay mutation. */
+    overlayMutation) {
+        this.userId = userId;
+        this.collectionPath = collectionPath;
+        this.documentId = documentId;
+        this.collectionGroup = collectionGroup;
+        this.largestBatchId = largestBatchId;
+        this.overlayMutation = overlayMutation;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbDocumentOverlay.store = 'documentOverlays';
+DbDocumentOverlay.keyPath = ['userId', 'collectionPath', 'documentId'];
+DbDocumentOverlay.collectionPathOverlayIndex = 'collectionPathOverlayIndex';
+DbDocumentOverlay.collectionPathOverlayIndexPath = [
+    'userId',
+    'collectionPath',
+    'largestBatchId'
+];
+DbDocumentOverlay.collectionGroupOverlayIndex = 'collectionGroupOverlayIndex';
+DbDocumentOverlay.collectionGroupOverlayIndexPath = [
+    'userId',
+    'collectionGroup',
+    'largestBatchId'
+];
 // Visible for testing
 const V1_STORES = [
     DbMutationQueue.store,
@@ -1805,7 +1943,6 @@ const V1_STORES = [
 // V2 is no longer usable (see comment at top of file)
 // Visible for testing
 const V3_STORES = V1_STORES;
-// Visible for testing
 // Note: DbRemoteDocumentChanges is no longer used and dropped with v9.
 const V4_STORES = [...V3_STORES, DbClientMetadata.store];
 // V5 does not change the set of stores.
@@ -1815,12 +1952,28 @@ const V8_STORES = [...V6_STORES, DbCollectionParent.store];
 // V9 does not change the set of stores.
 // V10 does not change the set of stores.
 const V11_STORES = [...V8_STORES, DbBundle.store, DbNamedQuery.store];
-/**
- * The list of all default IndexedDB stores used throughout the SDK. This is
- * used when creating transactions so that access across all stores is done
- * atomically.
- */
-const ALL_STORES = V11_STORES;
+const V12_STORES = [...V11_STORES, DbDocumentOverlay.store];
+const V13_STORES = [
+    ...V12_STORES,
+    DbIndexConfiguration.store,
+    DbIndexState.store,
+    DbIndexEntry.store
+];
+/** Returns the object stores for the provided schema. */
+function getObjectStores(schemaVersion) {
+    if (schemaVersion === 13) {
+        return V13_STORES;
+    }
+    else if (schemaVersion === 12) {
+        return V12_STORES;
+    }
+    else if (schemaVersion === 11) {
+        return V11_STORES;
+    }
+    else {
+        fail();
+    }
+}
 
 /**
  * @license
@@ -2117,6 +2270,15 @@ class SimpleDbTransaction {
             this.transaction.abort();
         }
     }
+    maybeCommit() {
+        // If the browser supports V3 IndexedDB, we invoke commit() explicitly to
+        // speed up index DB processing if the event loop remains blocks.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const maybeV3IndexedDb = this.transaction;
+        if (!this.aborted && typeof maybeV3IndexedDb.commit === 'function') {
+            maybeV3IndexedDb.commit();
+        }
+    }
     /**
      * Returns a SimpleDbStore<KeyType, ValueType> for the specified store. All
      * operations performed on the SimpleDbStore happen within the context of this
@@ -2313,6 +2475,10 @@ class SimpleDb {
                 this.db = await this.ensureDb(action);
                 const transaction = SimpleDbTransaction.open(this.db, action, readonly ? 'readonly' : 'readwrite', objectStores);
                 const transactionFnResult = transactionFn(transaction)
+                    .next(result => {
+                    transaction.maybeCommit();
+                    return result;
+                })
                     .catch(error => {
                     // Abort the transaction if there was an error.
                     transaction.abort(error);
@@ -2485,13 +2651,29 @@ class SimpleDbStore {
         return wrapRequest(request);
     }
     loadAll(indexOrRange, range) {
-        const cursor = this.cursor(this.options(indexOrRange, range));
-        const results = [];
-        return this.iterateCursor(cursor, (key, value) => {
-            results.push(value);
-        }).next(() => {
-            return results;
-        });
+        const iterateOptions = this.options(indexOrRange, range);
+        // Use `getAll()` if the browser supports IndexedDB v3, as it is roughly
+        // 20% faster. Unfortunately, getAll() does not support custom indices.
+        if (!iterateOptions.index && typeof this.store.getAll === 'function') {
+            const request = this.store.getAll(iterateOptions.range);
+            return new PersistencePromise((resolve, reject) => {
+                request.onerror = (event) => {
+                    reject(event.target.error);
+                };
+                request.onsuccess = (event) => {
+                    resolve(event.target.result);
+                };
+            });
+        }
+        else {
+            const cursor = this.cursor(iterateOptions);
+            const results = [];
+            return this.iterateCursor(cursor, (key, value) => {
+                results.push(value);
+            }).next(() => {
+                return results;
+            });
+        }
     }
     deleteAll(indexOrRange, range) {
         logDebug(LOG_TAG$g, 'DELETE ALL', this.store.name);
@@ -3522,6 +3704,14 @@ class DocumentKey {
         return (this.path.length >= 2 &&
             this.path.get(this.path.length - 2) === collectionId);
     }
+    /** Returns the collection group (i.e. the name of the parent collection) for this key. */
+    getCollectionGroup() {
+        return this.path.get(this.path.length - 2);
+    }
+    /** Returns the fully qualified path to the parent collection. */
+    getCollectionPath() {
+        return this.path.popLast();
+    }
     isEqual(other) {
         return (other !== null && ResourcePath.comparator(this.path, other.path) === 0);
     }
@@ -4345,12 +4535,12 @@ class FieldIndex {
     /** The collection ID this index applies to. */
     collectionGroup, 
     /** The field segments for this index. */
-    segments, 
+    fields, 
     /** Shows how up-to-date the index is for the current user. */
     indexState) {
         this.indexId = indexId;
         this.collectionGroup = collectionGroup;
-        this.segments = segments;
+        this.fields = fields;
         this.indexState = indexState;
     }
 }
@@ -4460,27 +4650,29 @@ function newTarget(path, collectionGroup = null, orderBy = [], filters = [], lim
 function canonifyTarget(target) {
     const targetImpl = debugCast(target);
     if (targetImpl.memoizedCanonicalId === null) {
-        let canonicalId = targetImpl.path.canonicalString();
+        let str = targetImpl.path.canonicalString();
         if (targetImpl.collectionGroup !== null) {
-            canonicalId += '|cg:' + targetImpl.collectionGroup;
+            str += '|cg:' + targetImpl.collectionGroup;
         }
-        canonicalId += '|f:';
-        canonicalId += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
-        canonicalId += '|ob:';
-        canonicalId += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
+        str += '|f:';
+        str += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
+        str += '|ob:';
+        str += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
         if (!isNullOrUndefined(targetImpl.limit)) {
-            canonicalId += '|l:';
-            canonicalId += targetImpl.limit;
+            str += '|l:';
+            str += targetImpl.limit;
         }
         if (targetImpl.startAt) {
-            canonicalId += '|lb:';
-            canonicalId += canonifyBound(targetImpl.startAt);
+            str += '|lb:';
+            str += targetImpl.startAt.inclusive ? 'b:' : 'a:';
+            str += targetImpl.startAt.position.map(p => canonicalId(p)).join(',');
         }
         if (targetImpl.endAt) {
-            canonicalId += '|ub:';
-            canonicalId += canonifyBound(targetImpl.endAt);
+            str += '|ub:';
+            str += targetImpl.endAt.inclusive ? 'a:' : 'b:';
+            str += targetImpl.endAt.position.map(p => canonicalId(p)).join(',');
         }
-        targetImpl.memoizedCanonicalId = canonicalId;
+        targetImpl.memoizedCanonicalId = str;
     }
     return targetImpl.memoizedCanonicalId;
 }
@@ -4503,10 +4695,14 @@ function stringifyTarget(target) {
             .join(', ')}]`;
     }
     if (target.startAt) {
-        str += ', startAt: ' + canonifyBound(target.startAt);
+        str += ', startAt: ';
+        str += target.startAt.inclusive ? 'b:' : 'a:';
+        str += target.startAt.position.map(p => canonicalId(p)).join(',');
     }
     if (target.endAt) {
-        str += ', endAt: ' + canonifyBound(target.endAt);
+        str += ', endAt: ';
+        str += target.endAt.inclusive ? 'a:' : 'b:';
+        str += target.endAt.position.map(p => canonicalId(p)).join(',');
     }
     return `Target(${str})`;
 }
@@ -4729,7 +4925,6 @@ class ArrayContainsAnyFilter extends FieldFilter {
         return other.arrayValue.values.some(val => arrayValueContains(this.value.arrayValue, val));
     }
 }
-// TODO(indexing): Change Bound.before to "inclusive"
 /**
  * Represents a bound of a query.
  *
@@ -4745,17 +4940,11 @@ class ArrayContainsAnyFilter extends FieldFilter {
  * just after the provided values.
  */
 class Bound {
-    constructor(position, before) {
+    constructor(position, inclusive) {
         this.position = position;
-        this.before = before;
+        this.inclusive = inclusive;
     }
 }
-function canonifyBound(bound) {
-    // TODO(b/29183165): Make this collision robust.
-    return `${bound.before ? 'b' : 'a'}:${bound.position
-        .map(p => canonicalId(p))
-        .join(',')}`;
-}
 /**
  * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
  */
@@ -4775,11 +4964,7 @@ function stringifyOrderBy(orderBy) {
 function orderByEquals(left, right) {
     return left.dir === right.dir && left.field.isEqual(right.field);
 }
-/**
- * Returns true if a document sorts before a bound using the provided sort
- * order.
- */
-function sortsBeforeDocument(bound, orderBy, doc) {
+function boundCompareToDocument(bound, orderBy, doc) {
     let comparison = 0;
     for (let i = 0; i < bound.position.length; i++) {
         const orderByComponent = orderBy[i];
@@ -4798,7 +4983,23 @@ function sortsBeforeDocument(bound, orderBy, doc) {
             break;
         }
     }
-    return bound.before ? comparison <= 0 : comparison < 0;
+    return comparison;
+}
+/**
+ * Returns true if a document sorts after a bound using the provided sort
+ * order.
+ */
+function boundSortsAfterDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison >= 0 : comparison > 0;
+}
+/**
+ * Returns true if a document sorts before a bound using the provided sort
+ * order.
+ */
+function boundSortsBeforeDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison <= 0 : comparison < 0;
 }
 function boundEquals(left, right) {
     if (left === null) {
@@ -4807,7 +5008,7 @@ function boundEquals(left, right) {
     else if (right === null) {
         return false;
     }
-    if (left.before !== right.before ||
+    if (left.inclusive !== right.inclusive ||
         left.position.length !== right.position.length) {
         return false;
     }
@@ -5011,10 +5212,10 @@ function queryToTarget(query) {
             }
             // We need to swap the cursors to match the now-flipped query ordering.
             const startAt = queryImpl.endAt
-                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.before)
+                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.inclusive)
                 : null;
             const endAt = queryImpl.startAt
-                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.before)
+                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.inclusive)
                 : null;
             // Now return as a LimitType.First query.
             queryImpl.memoizedTarget = newTarget(queryImpl.path, queryImpl.collectionGroup, orderBys, queryImpl.filters, queryImpl.limit, startAt, endAt);
@@ -5102,11 +5303,11 @@ function queryMatchesFilters(query, doc) {
 /** Makes sure a document is within the bounds, if provided. */
 function queryMatchesBounds(query, doc) {
     if (query.startAt &&
-        !sortsBeforeDocument(query.startAt, queryOrderBy(query), doc)) {
+        !boundSortsBeforeDocument(query.startAt, queryOrderBy(query), doc)) {
         return false;
     }
     if (query.endAt &&
-        sortsBeforeDocument(query.endAt, queryOrderBy(query), doc)) {
+        !boundSortsAfterDocument(query.endAt, queryOrderBy(query), doc)) {
         return false;
     }
     return true;
@@ -6599,6 +6800,47 @@ class MutationBatchResult {
     }
 }
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Representation of an overlay computed by Firestore.
+ *
+ * Holds information about a mutation and the largest batch id in Firestore when
+ * the mutation was created.
+ */
+class Overlay {
+    constructor(largestBatchId, mutation) {
+        this.largestBatchId = largestBatchId;
+        this.mutation = mutation;
+    }
+    getKey() {
+        return this.mutation.key;
+    }
+    isEqual(other) {
+        return other !== null && this.mutation === other.mutation;
+    }
+    toString() {
+        return `Overlay{
+      largestBatchId: ${this.largestBatchId},
+      mutation: ${this.mutation.toString()}
+    }`;
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -7985,10 +8227,10 @@ function toQueryTarget(serializer, target) {
         result.structuredQuery.limit = limit;
     }
     if (target.startAt) {
-        result.structuredQuery.startAt = toCursor(target.startAt);
+        result.structuredQuery.startAt = toStartAtCursor(target.startAt);
     }
     if (target.endAt) {
-        result.structuredQuery.endAt = toCursor(target.endAt);
+        result.structuredQuery.endAt = toEndAtCursor(target.endAt);
     }
     return result;
 }
@@ -8021,11 +8263,11 @@ function convertQueryTargetToQuery(target) {
     }
     let startAt = null;
     if (query.startAt) {
-        startAt = fromCursor(query.startAt);
+        startAt = fromStartAtCursor(query.startAt);
     }
     let endAt = null;
     if (query.endAt) {
-        endAt = fromCursor(query.endAt);
+        endAt = fromEndAtCursor(query.endAt);
     }
     return newQuery(path, collectionGroup, orderBy, filterBy, limit, "F" /* First */, startAt, endAt);
 }
@@ -8116,16 +8358,27 @@ function toOrder(orderBys) {
 function fromOrder(orderBys) {
     return orderBys.map(order => fromPropertyOrder(order));
 }
-function toCursor(cursor) {
+function toStartAtCursor(cursor) {
+    return {
+        before: cursor.inclusive,
+        values: cursor.position
+    };
+}
+function toEndAtCursor(cursor) {
     return {
-        before: cursor.before,
+        before: !cursor.inclusive,
         values: cursor.position
     };
 }
-function fromCursor(cursor) {
-    const before = !!cursor.before;
+function fromStartAtCursor(cursor) {
+    const inclusive = !!cursor.before;
     const position = cursor.values || [];
-    return new Bound(position, before);
+    return new Bound(position, inclusive);
+}
+function fromEndAtCursor(cursor) {
+    const inclusive = !cursor.before;
+    const position = cursor.values || [];
+    return new Bound(position, inclusive);
 }
 // visible for testing
 function toDirection(dir) {
@@ -8589,6 +8842,37 @@ function fromBundleMetadata(metadata) {
         version: metadata.version,
         createTime: fromVersion(metadata.createTime)
     };
+}
+/** Encodes a DbDocumentOverlay object to an Overlay model object. */
+function fromDbDocumentOverlay(localSerializer, dbDocumentOverlay) {
+    return new Overlay(dbDocumentOverlay.largestBatchId, fromMutation(localSerializer.remoteSerializer, dbDocumentOverlay.overlayMutation));
+}
+/** Decodes an Overlay model object into a DbDocumentOverlay object. */
+function toDbDocumentOverlay(localSerializer, userId, overlay) {
+    const [_, collectionPath, documentId] = toDbDocumentOverlayKey(userId, overlay.mutation.key);
+    return new DbDocumentOverlay(userId, collectionPath, documentId, overlay.mutation.key.getCollectionGroup(), overlay.largestBatchId, toMutation(localSerializer.remoteSerializer, overlay.mutation));
+}
+/**
+ * Returns the DbDocumentOverlayKey corresponding to the given user and
+ * document key.
+ */
+function toDbDocumentOverlayKey(userId, docKey) {
+    const docId = docKey.path.lastSegment();
+    const collectionPath = encodeResourcePath(docKey.path.popLast());
+    return [userId, collectionPath, docId];
+}
+function toDbIndexConfiguration(index) {
+    return new DbIndexConfiguration(index.indexId, index.collectionGroup, index.fields.map(s => [s.fieldPath.canonicalString(), s.kind]));
+}
+function fromDbIndexConfiguration(index, state) {
+    const decodedState = state
+        ? new IndexState(state.sequenceNumber, new IndexOffset(fromDbTimestamp(state.readTime), new DocumentKey(decodeResourcePath(state.documentKey)), state.largestBatchId))
+        : IndexState.empty();
+    const decodedSegments = index.fields.map(([fieldPath, kind]) => new IndexSegment(FieldPath$1.fromServerFormat(fieldPath), kind));
+    return new FieldIndex(index.indexId, index.collectionGroup, decodedSegments, decodedState);
+}
+function toDbIndexState(indexId, user, sequenceNumber, offset) {
+    return new DbIndexState(indexId, user.uid || '', sequenceNumber, toDbTimestamp(offset.readTime), encodeResourcePath(offset.documentKey.path), offset.largestBatchId);
 }
 
 /**
@@ -8648,6 +8932,125 @@ function namedQueriesStore(txn) {
     return getStore(txn, DbNamedQuery.store);
 }
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Implementation of DocumentOverlayCache using IndexedDb.
+ */
+class IndexedDbDocumentOverlayCache {
+    /**
+     * @param serializer - The document serializer.
+     * @param userId - The userId for which we are accessing overlays.
+     */
+    constructor(serializer, userId) {
+        this.serializer = serializer;
+        this.userId = userId;
+    }
+    static forUser(serializer, user) {
+        const userId = user.uid || '';
+        return new IndexedDbDocumentOverlayCache(serializer, userId);
+    }
+    getOverlay(transaction, key) {
+        return documentOverlayStore(transaction)
+            .get(toDbDocumentOverlayKey(this.userId, key))
+            .next(dbOverlay => {
+            if (dbOverlay) {
+                return fromDbDocumentOverlay(this.serializer, dbOverlay);
+            }
+            return null;
+        });
+    }
+    saveOverlays(transaction, largestBatchId, overlays) {
+        const promises = [];
+        overlays.forEach(mutation => {
+            const overlay = new Overlay(largestBatchId, mutation);
+            promises.push(this.saveOverlay(transaction, overlay));
+        });
+        return PersistencePromise.waitFor(promises);
+    }
+    removeOverlaysForBatchId(transaction, documentKeys, batchId) {
+        const collectionPaths = new Set();
+        // Get the set of unique collection paths.
+        documentKeys.forEach(key => collectionPaths.add(encodeResourcePath(key.getCollectionPath())));
+        const promises = [];
+        collectionPaths.forEach(collectionPath => {
+            const range = IDBKeyRange.bound([this.userId, collectionPath, batchId], [this.userId, collectionPath, batchId + 1], 
+            /*lowerOpen=*/ false, 
+            /*upperOpen=*/ true);
+            promises.push(documentOverlayStore(transaction).deleteAll(DbDocumentOverlay.collectionPathOverlayIndex, range));
+        });
+        return PersistencePromise.waitFor(promises);
+    }
+    getOverlaysForCollection(transaction, collection, sinceBatchId) {
+        const result = new Map();
+        const collectionPath = encodeResourcePath(collection);
+        // We want batch IDs larger than `sinceBatchId`, and so the lower bound
+        // is not inclusive.
+        const range = IDBKeyRange.bound([this.userId, collectionPath, sinceBatchId], [this.userId, collectionPath, Number.POSITIVE_INFINITY], 
+        /*lowerOpen=*/ true);
+        return documentOverlayStore(transaction)
+            .loadAll(DbDocumentOverlay.collectionPathOverlayIndex, range)
+            .next(dbOverlays => {
+            for (const dbOverlay of dbOverlays) {
+                const overlay = fromDbDocumentOverlay(this.serializer, dbOverlay);
+                result.set(overlay.getKey(), overlay);
+            }
+            return result;
+        });
+    }
+    getOverlaysForCollectionGroup(transaction, collectionGroup, sinceBatchId, count) {
+        const result = new Map();
+        let currentBatchId = undefined;
+        // We want batch IDs larger than `sinceBatchId`, and so the lower bound
+        // is not inclusive.
+        const range = IDBKeyRange.bound([this.userId, collectionGroup, sinceBatchId], [this.userId, collectionGroup, Number.POSITIVE_INFINITY], 
+        /*lowerOpen=*/ true);
+        return documentOverlayStore(transaction)
+            .iterate({
+            index: DbDocumentOverlay.collectionGroupOverlayIndex,
+            range
+        }, (_, dbOverlay, control) => {
+            // We do not want to return partial batch overlays, even if the size
+            // of the result set exceeds the given `count` argument. Therefore, we
+            // continue to aggregate results even after the result size exceeds
+            // `count` if there are more overlays from the `currentBatchId`.
+            const overlay = fromDbDocumentOverlay(this.serializer, dbOverlay);
+            if (result.size < count ||
+                overlay.largestBatchId === currentBatchId) {
+                result.set(overlay.getKey(), overlay);
+                currentBatchId = overlay.largestBatchId;
+            }
+            else {
+                control.done();
+            }
+        })
+            .next(() => result);
+    }
+    saveOverlay(transaction, overlay) {
+        return documentOverlayStore(transaction).put(toDbDocumentOverlay(this.serializer, this.userId, overlay));
+    }
+}
+/**
+ * Helper to get a typed SimpleDbStore for the document overlay object store.
+ */
+function documentOverlayStore(txn) {
+    return getStore(txn, DbDocumentOverlay.store);
+}
+
 /**
  * @license
  * Copyright 2019 Google LLC
@@ -8678,6 +9081,38 @@ class MemoryIndexManager {
     getCollectionParents(transaction, collectionId) {
         return PersistencePromise.resolve(this.collectionParentIndex.getEntries(collectionId));
     }
+    addFieldIndex(transaction, index) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
+    deleteFieldIndex(transaction, index) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
+    getDocumentsMatchingTarget(transaction, fieldIndex, target) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve(documentKeySet());
+    }
+    getFieldIndex(transaction, target) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve(null);
+    }
+    getFieldIndexes(transaction, collectionGroup) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve([]);
+    }
+    getNextCollectionGroupToUpdate(transaction) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve(null);
+    }
+    updateCollectionGroup(transaction, collectionGroup, offset) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
+    updateIndexEntries(transaction, documents) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
 }
 /**
  * Internal implementation of the collection-parent index exposed by MemoryIndexManager.
@@ -8729,17 +9164,22 @@ class MemoryCollectionParentIndex {
  */
 /**
  * A persisted implementation of IndexManager.
+ *
+ * PORTING NOTE: Unlike iOS and Android, the Web SDK does not memoize index
+ * data as it supports multi-tab access.
  */
 class IndexedDbIndexManager {
-    constructor() {
+    constructor(user) {
+        this.user = user;
         /**
          * An in-memory copy of the index entries we've already written since the SDK
          * launched. Used to avoid re-writing the same entry repeatedly.
          *
-         * This is *NOT* a complete cache of what's in persistence and so can never be used to
-         * satisfy reads.
+         * This is *NOT* a complete cache of what's in persistence and so can never be
+         * used to satisfy reads.
          */
         this.collectionParentsCache = new MemoryCollectionParentIndex();
+        this.uid = user.uid || '';
     }
     /**
      * Adds a new entry to the collection parent index.
@@ -8786,6 +9226,85 @@ class IndexedDbIndexManager {
             return parentPaths;
         });
     }
+    addFieldIndex(transaction, index) {
+        // TODO(indexing): Verify that the auto-incrementing index ID works in
+        // Safari & Firefox.
+        const indexes = indexConfigurationStore(transaction);
+        const dbIndex = toDbIndexConfiguration(index);
+        delete dbIndex.indexId; // `indexId` is auto-populated by IndexedDb
+        return indexes.add(dbIndex).next();
+    }
+    deleteFieldIndex(transaction, index) {
+        const indexes = indexConfigurationStore(transaction);
+        const states = indexStateStore(transaction);
+        const entries = indexEntriesStore(transaction);
+        return indexes
+            .delete(index.indexId)
+            .next(() => states.delete(IDBKeyRange.bound([index.indexId], [index.indexId + 1], 
+        /*lowerOpen=*/ false, 
+        /*upperOpen=*/ true)))
+            .next(() => entries.delete(IDBKeyRange.bound([index.indexId], [index.indexId + 1], 
+        /*lowerOpen=*/ false, 
+        /*upperOpen=*/ true)));
+    }
+    getDocumentsMatchingTarget(transaction, fieldIndex, target) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve(documentKeySet());
+    }
+    getFieldIndex(transaction, target) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve(null);
+    }
+    getFieldIndexes(transaction, collectionGroup) {
+        const indexes = indexConfigurationStore(transaction);
+        const states = indexStateStore(transaction);
+        return (collectionGroup
+            ? indexes.loadAll(DbIndexConfiguration.collectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
+            : indexes.loadAll()).next(indexConfigs => {
+            const result = [];
+            return PersistencePromise.forEach(indexConfigs, (indexConfig) => {
+                return states
+                    .get([indexConfig.indexId, this.uid])
+                    .next(indexState => {
+                    result.push(fromDbIndexConfiguration(indexConfig, indexState));
+                });
+            }).next(() => result);
+        });
+    }
+    getNextCollectionGroupToUpdate(transaction) {
+        return this.getFieldIndexes(transaction).next(indexes => {
+            if (indexes.length === 0) {
+                return null;
+            }
+            indexes.sort((l, r) => l.indexState.sequenceNumber - r.indexState.sequenceNumber);
+            return indexes[0].collectionGroup;
+        });
+    }
+    updateCollectionGroup(transaction, collectionGroup, offset) {
+        const indexes = indexConfigurationStore(transaction);
+        const states = indexStateStore(transaction);
+        return this.getNextSequenceNumber(transaction).next(nextSequenceNumber => indexes
+            .loadAll(DbIndexConfiguration.collectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
+            .next(configs => PersistencePromise.forEach(configs, (config) => states.put(toDbIndexState(config.indexId, this.user, nextSequenceNumber, offset)))));
+    }
+    updateIndexEntries(transaction, documents) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve();
+    }
+    getNextSequenceNumber(transaction) {
+        let nextSequenceNumber = 1;
+        const states = indexStateStore(transaction);
+        return states
+            .iterate({
+            index: DbIndexState.sequenceNumberIndex,
+            reverse: true,
+            range: IDBKeyRange.upperBound([this.uid, Number.MAX_SAFE_INTEGER])
+        }, (_, state, controller) => {
+            controller.done();
+            nextSequenceNumber = state.sequenceNumber + 1;
+        })
+            .next(() => nextSequenceNumber);
+    }
 }
 /**
  * Helper to get a typed SimpleDbStore for the collectionParents
@@ -8793,6 +9312,24 @@ class IndexedDbIndexManager {
  */
 function collectionParentsStore(txn) {
     return getStore(txn, DbCollectionParent.store);
+}
+/**
+ * Helper to get a typed SimpleDbStore for the index entry object store.
+ */
+function indexEntriesStore(txn) {
+    return getStore(txn, DbIndexEntry.store);
+}
+/**
+ * Helper to get a typed SimpleDbStore for the index configuration object store.
+ */
+function indexConfigurationStore(txn) {
+    return getStore(txn, DbIndexConfiguration.store);
+}
+/**
+ * Helper to get a typed SimpleDbStore for the index state object store.
+ */
+function indexStateStore(txn) {
+    return getStore(txn, DbIndexState.store);
 }
 
 /**
@@ -10262,12 +10799,10 @@ class RemoteDocumentChangeBuffer {
  * `newIndexedDbRemoteDocumentCache()`.
  */
 class IndexedDbRemoteDocumentCacheImpl {
-    /**
-     * @param serializer - The document serializer.
-     * @param indexManager - The query indexes that need to be maintained.
-     */
-    constructor(serializer, indexManager) {
+    constructor(serializer) {
         this.serializer = serializer;
+    }
+    setIndexManager(indexManager) {
         this.indexManager = indexManager;
     }
     /**
@@ -10389,21 +10924,21 @@ class IndexedDbRemoteDocumentCacheImpl {
             }
         });
     }
-    getDocumentsMatchingQuery(transaction, query, sinceReadTime) {
+    getAll(transaction, collection, sinceReadTime) {
         let results = mutableDocumentMap();
-        const immediateChildrenPathLength = query.path.length + 1;
+        const immediateChildrenPathLength = collection.length + 1;
         const iterationOptions = {};
         if (sinceReadTime.isEqual(SnapshotVersion.min())) {
             // Documents are ordered by key, so we can use a prefix scan to narrow
             // down the documents we need to match the query against.
-            const startKey = query.path.toArray();
+            const startKey = collection.toArray();
             iterationOptions.range = IDBKeyRange.lowerBound(startKey);
         }
         else {
             // Execute an index-free query and filter by read time. This is safe
             // since all document changes to queries that have a
             // lastLimboFreeSnapshotVersion (`sinceReadTime`) have a read time set.
-            const collectionKey = query.path.toArray();
+            const collectionKey = collection.toArray();
             const readTimeKey = toDbTimestampKey(sinceReadTime);
             iterationOptions.range = IDBKeyRange.lowerBound([collectionKey, readTimeKey], 
             /* open= */ true);
@@ -10420,12 +10955,12 @@ class IndexedDbRemoteDocumentCacheImpl {
                 return;
             }
             const document = this.maybeDecodeDocument(DocumentKey.fromSegments(key), dbRemoteDoc);
-            if (!query.path.isPrefixOf(document.key.path)) {
-                control.done();
-            }
-            else if (queryMatches(query, document)) {
+            if (collection.isPrefixOf(document.key.path)) {
                 results = results.insert(document.key, document);
             }
+            else {
+                control.done();
+            }
         })
             .next(() => results);
     }
@@ -10463,14 +10998,9 @@ class IndexedDbRemoteDocumentCacheImpl {
         return MutableDocument.newInvalidDocument(documentKey);
     }
 }
-/**
- * Creates a new IndexedDbRemoteDocumentCache.
- *
- * @param serializer - The document serializer.
- * @param indexManager - The query indexes that need to be maintained.
- */
-function newIndexedDbRemoteDocumentCache(serializer, indexManager) {
-    return new IndexedDbRemoteDocumentCacheImpl(serializer, indexManager);
+/** Creates a new IndexedDbRemoteDocumentCache. */
+function newIndexedDbRemoteDocumentCache(serializer) {
+    return new IndexedDbRemoteDocumentCacheImpl(serializer);
 }
 /**
  * Returns the set of documents that have changed since the specified read
@@ -10637,9 +11167,6 @@ class SchemaConverter {
      * and local feature development.
      */
     createOrUpgrade(db, txn, fromVersion, toVersion) {
-        hardAssert(fromVersion < toVersion &&
-            fromVersion >= 0 &&
-            toVersion <= SCHEMA_VERSION);
         const simpleDbTransaction = new SimpleDbTransaction('createOrUpgrade', txn);
         if (fromVersion < 1 && toVersion >= 1) {
             createPrimaryClientStore(db);
@@ -10706,6 +11233,16 @@ class SchemaConverter {
                 createNamedQueriesStore(db);
             });
         }
+        if (fromVersion < 12 && toVersion >= 12) {
+            p = p.next(() => {
+                createDocumentOverlayStore(db);
+            });
+        }
+        if (fromVersion < 13 && toVersion >= 13) {
+            p = p.next(() => {
+                createFieldIndex(db);
+            });
+        }
         return p;
     }
     addDocumentGlobal(txn) {
@@ -10912,6 +11449,27 @@ function createNamedQueriesStore(db) {
     db.createObjectStore(DbNamedQuery.store, {
         keyPath: DbNamedQuery.keyPath
     });
+}
+function createFieldIndex(db) {
+    const indexConfiguratioStore = db.createObjectStore(DbIndexConfiguration.store, {
+        keyPath: DbIndexConfiguration.keyPath,
+        autoIncrement: true
+    });
+    indexConfiguratioStore.createIndex(DbIndexConfiguration.collectionGroupIndex, DbIndexConfiguration.collectionGroupIndexPath, { unique: false });
+    const indexStateStore = db.createObjectStore(DbIndexState.store, {
+        keyPath: DbIndexState.keyPath
+    });
+    indexStateStore.createIndex(DbIndexState.sequenceNumberIndex, DbIndexState.sequenceNumberIndexPath, { unique: false });
+    db.createObjectStore(DbIndexEntry.store, {
+        keyPath: DbIndexEntry.keyPath
+    });
+}
+function createDocumentOverlayStore(db) {
+    const documentOverlayStore = db.createObjectStore(DbDocumentOverlay.store, {
+        keyPath: DbDocumentOverlay.keyPath
+    });
+    documentOverlayStore.createIndex(DbDocumentOverlay.collectionPathOverlayIndex, DbDocumentOverlay.collectionPathOverlayIndexPath, { unique: false });
+    documentOverlayStore.createIndex(DbDocumentOverlay.collectionGroupOverlayIndex, DbDocumentOverlay.collectionGroupOverlayIndexPath, { unique: false });
 }
 
 /**
@@ -11023,7 +11581,7 @@ class IndexedDbPersistence {
      * If set to true, forcefully obtains database access. Existing tabs will
      * no longer be able to access IndexedDB.
      */
-    forceOwningTab) {
+    forceOwningTab, schemaVersion = SCHEMA_VERSION) {
         this.allowTabSynchronization = allowTabSynchronization;
         this.persistenceKey = persistenceKey;
         this.clientId = clientId;
@@ -11032,6 +11590,7 @@ class IndexedDbPersistence {
         this.document = document;
         this.sequenceNumberSyncer = sequenceNumberSyncer;
         this.forceOwningTab = forceOwningTab;
+        this.schemaVersion = schemaVersion;
         this.listenSequence = null;
         this._started = false;
         this.isPrimary = false;
@@ -11053,10 +11612,9 @@ class IndexedDbPersistence {
         this.referenceDelegate = new IndexedDbLruDelegateImpl(this, lruParams);
         this.dbName = persistenceKey + MAIN_DATABASE;
         this.serializer = new LocalSerializer(serializer);
-        this.simpleDb = new SimpleDb(this.dbName, SCHEMA_VERSION, new SchemaConverter(this.serializer));
+        this.simpleDb = new SimpleDb(this.dbName, this.schemaVersion, new SchemaConverter(this.serializer));
         this.targetCache = new IndexedDbTargetCache(this.referenceDelegate, this.serializer);
-        this.indexManager = new IndexedDbIndexManager();
-        this.remoteDocumentCache = newIndexedDbRemoteDocumentCache(this.serializer, this.indexManager);
+        this.remoteDocumentCache = newIndexedDbRemoteDocumentCache(this.serializer);
         this.bundleCache = new IndexedDbBundleCache();
         if (this.window && this.window.localStorage) {
             this.webStorage = this.window.localStorage;
@@ -11392,8 +11950,8 @@ class IndexedDbPersistence {
     get started() {
         return this._started;
     }
-    getMutationQueue(user) {
-        return IndexedDbMutationQueue.forUser(user, this.serializer, this.indexManager, this.referenceDelegate);
+    getMutationQueue(user, indexManager) {
+        return IndexedDbMutationQueue.forUser(user, this.serializer, indexManager, this.referenceDelegate);
     }
     getTargetCache() {
         return this.targetCache;
@@ -11401,8 +11959,11 @@ class IndexedDbPersistence {
     getRemoteDocumentCache() {
         return this.remoteDocumentCache;
     }
-    getIndexManager() {
-        return this.indexManager;
+    getIndexManager(user) {
+        return new IndexedDbIndexManager(user);
+    }
+    getDocumentOverlayCache(user) {
+        return IndexedDbDocumentOverlayCache.forUser(this.serializer, user);
     }
     getBundleCache() {
         return this.bundleCache;
@@ -11410,11 +11971,12 @@ class IndexedDbPersistence {
     runTransaction(action, mode, transactionOperation) {
         logDebug(LOG_TAG$d, 'Starting transaction:', action);
         const simpleDbMode = mode === 'readonly' ? 'readonly' : 'readwrite';
+        const objectStores = getObjectStores(this.schemaVersion);
         let persistenceTransaction;
         // Do all transactions as readwrite against all object stores, since we
         // are the only reader/writer.
         return this.simpleDb
-            .runTransaction(action, simpleDbMode, ALL_STORES, simpleDbTxn => {
+            .runTransaction(action, simpleDbMode, objectStores, simpleDbTxn => {
             persistenceTransaction = new IndexedDbTransaction(simpleDbTxn, this.listenSequence
                 ? this.listenSequence.next()
                 : ListenSequence.INVALID);
@@ -11786,39 +12348,28 @@ class LocalDocumentsView {
     getDocumentsMatchingCollectionQuery(transaction, query, sinceReadTime) {
         // Query the remote documents and overlay mutations.
         let results;
-        let mutationBatches;
         return this.remoteDocumentCache
-            .getDocumentsMatchingQuery(transaction, query, sinceReadTime)
+            .getAll(transaction, query.path, sinceReadTime)
             .next(queryResults => {
             results = queryResults;
             return this.mutationQueue.getAllMutationBatchesAffectingQuery(transaction, query);
         })
-            .next(matchingMutationBatches => {
-            mutationBatches = matchingMutationBatches;
-            // It is possible that a PatchMutation can make a document match a query, even if
-            // the version in the RemoteDocumentCache is not a match yet (waiting for server
-            // to ack). To handle this, we find all document keys affected by the PatchMutations
-            // that are not in `result` yet, and back fill them via `remoteDocumentCache.getEntries`,
-            // otherwise those `PatchMutations` will be ignored because no base document can be found,
-            // and lead to missing result for the query.
-            return this.addMissingBaseDocuments(transaction, mutationBatches, results).next(mergedDocuments => {
-                results = mergedDocuments;
-                for (const batch of mutationBatches) {
-                    for (const mutation of batch.mutations) {
-                        const key = mutation.key;
-                        let document = results.get(key);
-                        if (document == null) {
-                            // Create invalid document to apply mutations on top of
-                            document = MutableDocument.newInvalidDocument(key);
-                            results = results.insert(key, document);
-                        }
-                        mutationApplyToLocalView(mutation, document, batch.localWriteTime);
-                        if (!document.isFoundDocument()) {
-                            results = results.remove(key);
-                        }
+            .next(mutationBatches => {
+            for (const batch of mutationBatches) {
+                for (const mutation of batch.mutations) {
+                    const key = mutation.key;
+                    let document = results.get(key);
+                    if (document == null) {
+                        // Create invalid document to apply mutations on top of
+                        document = MutableDocument.newInvalidDocument(key);
+                        results = results.insert(key, document);
+                    }
+                    mutationApplyToLocalView(mutation, document, batch.localWriteTime);
+                    if (!document.isFoundDocument()) {
+                        results = results.remove(key);
                     }
                 }
-            });
+            }
         })
             .next(() => {
             // Finally, filter out any documents that don't actually match
@@ -11831,29 +12382,6 @@ class LocalDocumentsView {
             return results;
         });
     }
-    addMissingBaseDocuments(transaction, matchingMutationBatches, existingDocuments) {
-        let missingBaseDocEntriesForPatching = documentKeySet();
-        for (const batch of matchingMutationBatches) {
-            for (const mutation of batch.mutations) {
-                if (mutation instanceof PatchMutation &&
-                    existingDocuments.get(mutation.key) === null) {
-                    missingBaseDocEntriesForPatching =
-                        missingBaseDocEntriesForPatching.add(mutation.key);
-                }
-            }
-        }
-        let mergedDocuments = existingDocuments;
-        return this.remoteDocumentCache
-            .getEntries(transaction, missingBaseDocEntriesForPatching)
-            .next(missingBaseDocs => {
-            missingBaseDocs.forEach((key, doc) => {
-                if (doc.isFoundDocument()) {
-                    mergedDocuments = mergedDocuments.insert(key, doc);
-                }
-            });
-            return mergedDocuments;
-        });
-    }
 }
 
 /**
@@ -11912,11 +12440,18 @@ class LocalStoreImpl {
          * PORTING NOTE: This is only used for multi-tab synchronization.
          */
         this.lastDocumentChangeReadTime = SnapshotVersion.min();
-        this.mutationQueue = persistence.getMutationQueue(initialUser);
         this.remoteDocuments = persistence.getRemoteDocumentCache();
         this.targetCache = persistence.getTargetCache();
-        this.localDocuments = new LocalDocumentsView(this.remoteDocuments, this.mutationQueue, this.persistence.getIndexManager());
         this.bundleCache = persistence.getBundleCache();
+        this.initializeUserComponents(initialUser);
+    }
+    initializeUserComponents(user) {
+        // TODO(indexing): Add spec tests that test these components change after a
+        // user change
+        this.indexManager = this.persistence.getIndexManager(user);
+        this.mutationQueue = this.persistence.getMutationQueue(user, this.indexManager);
+        this.localDocuments = new LocalDocumentsView(this.remoteDocuments, this.mutationQueue, this.indexManager);
+        this.remoteDocuments.setIndexManager(this.indexManager);
         this.queryEngine.setLocalDocumentsView(this.localDocuments);
     }
     collectGarbage(garbageCollector) {
@@ -11938,8 +12473,6 @@ persistence, queryEngine, initialUser, serializer) {
 // change.
 async function localStoreHandleUserChange(localStore, user) {
     const localStoreImpl = debugCast(localStore);
-    let newMutationQueue = localStoreImpl.mutationQueue;
-    let newLocalDocuments = localStoreImpl.localDocuments;
     const result = await localStoreImpl.persistence.runTransaction('Handle user change', 'readonly', txn => {
         // Swap out the mutation queue, grabbing the pending mutation batches
         // before and after.
@@ -11948,11 +12481,8 @@ async function localStoreHandleUserChange(localStore, user) {
             .getAllMutationBatches(txn)
             .next(promisedOldBatches => {
             oldBatches = promisedOldBatches;
-            newMutationQueue = localStoreImpl.persistence.getMutationQueue(user);
-            // Recreate our LocalDocumentsView using the new
-            // MutationQueue.
-            newLocalDocuments = new LocalDocumentsView(localStoreImpl.remoteDocuments, newMutationQueue, localStoreImpl.persistence.getIndexManager());
-            return newMutationQueue.getAllMutationBatches(txn);
+            localStoreImpl.initializeUserComponents(user);
+            return localStoreImpl.mutationQueue.getAllMutationBatches(txn);
         })
             .next(newBatches => {
             const removedBatchIds = [];
@@ -11973,7 +12503,7 @@ async function localStoreHandleUserChange(localStore, user) {
             }
             // Return the set of all (potentially) changed documents and the list
             // of mutation batch IDs that were affected by change.
-            return newLocalDocuments
+            return localStoreImpl.localDocuments
                 .getDocuments(txn, changedKeys)
                 .next(affectedDocuments => {
                 return {
@@ -11984,9 +12514,6 @@ async function localStoreHandleUserChange(localStore, user) {
             });
         });
     });
-    localStoreImpl.mutationQueue = newMutationQueue;
-    localStoreImpl.localDocuments = newLocalDocuments;
-    localStoreImpl.queryEngine.setLocalDocumentsView(localStoreImpl.localDocuments);
     return result;
 }
 /* Accepts locally generated Mutations and commit them to storage. */
@@ -12699,6 +13226,122 @@ class MemoryBundleCache {
     }
 }
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * An in-memory implementation of DocumentOverlayCache.
+ */
+class MemoryDocumentOverlayCache {
+    constructor() {
+        // A map sorted by DocumentKey, whose value is a pair of the largest batch id
+        // for the overlay and the overlay itself.
+        this.overlays = new SortedMap(DocumentKey.comparator);
+        this.overlayByBatchId = new Map();
+    }
+    getOverlay(transaction, key) {
+        return PersistencePromise.resolve(this.overlays.get(key));
+    }
+    saveOverlays(transaction, largestBatchId, overlays) {
+        overlays.forEach(mutation => {
+            this.saveOverlay(transaction, largestBatchId, mutation);
+        });
+        return PersistencePromise.resolve();
+    }
+    removeOverlaysForBatchId(transaction, documentKeys, batchId) {
+        const keys = this.overlayByBatchId.get(batchId);
+        if (keys !== undefined) {
+            keys.forEach(key => (this.overlays = this.overlays.remove(key)));
+            this.overlayByBatchId.delete(batchId);
+        }
+        return PersistencePromise.resolve();
+    }
+    getOverlaysForCollection(transaction, collection, sinceBatchId) {
+        const result = new Map();
+        const immediateChildrenPathLength = collection.length + 1;
+        const prefix = new DocumentKey(collection.child(''));
+        const iter = this.overlays.getIteratorFrom(prefix);
+        while (iter.hasNext()) {
+            const entry = iter.getNext();
+            const overlay = entry.value;
+            const key = overlay.getKey();
+            if (!collection.isPrefixOf(key.path)) {
+                break;
+            }
+            // Documents from sub-collections
+            if (key.path.length !== immediateChildrenPathLength) {
+                continue;
+            }
+            if (overlay.largestBatchId > sinceBatchId) {
+                result.set(overlay.getKey(), overlay);
+            }
+        }
+        return PersistencePromise.resolve(result);
+    }
+    getOverlaysForCollectionGroup(transaction, collectionGroup, sinceBatchId, count) {
+        let batchIdToOverlays = new SortedMap((key1, key2) => key1 - key2);
+        const iter = this.overlays.getIterator();
+        while (iter.hasNext()) {
+            const entry = iter.getNext();
+            const overlay = entry.value;
+            const key = overlay.getKey();
+            if (key.getCollectionGroup() !== collectionGroup) {
+                continue;
+            }
+            if (overlay.largestBatchId > sinceBatchId) {
+                let overlaysForBatchId = batchIdToOverlays.get(overlay.largestBatchId);
+                if (overlaysForBatchId === null) {
+                    overlaysForBatchId = new Map();
+                    batchIdToOverlays = batchIdToOverlays.insert(overlay.largestBatchId, overlaysForBatchId);
+                }
+                overlaysForBatchId.set(overlay.getKey(), overlay);
+            }
+        }
+        const result = new Map();
+        const batchIter = batchIdToOverlays.getIterator();
+        while (batchIter.hasNext()) {
+            const entry = batchIter.getNext();
+            const overlays = entry.value;
+            overlays.forEach((overlay, key) => result.set(key, overlay));
+            if (result.size >= count) {
+                break;
+            }
+        }
+        return PersistencePromise.resolve(result);
+    }
+    saveOverlay(transaction, largestBatchId, mutation) {
+        if (mutation === null) {
+            return;
+        }
+        // Remove the association of the overlay to its batch id.
+        const existing = this.overlays.get(mutation.key);
+        if (existing !== null) {
+            this.overlayByBatchId.get(existing.largestBatchId).delete(mutation.key);
+        }
+        this.overlays = this.overlays.insert(mutation.key, new Overlay(largestBatchId, mutation));
+        // Create the association of this overlay to the given largestBatchId.
+        let batch = this.overlayByBatchId.get(largestBatchId);
+        if (batch === undefined) {
+            batch = new Set();
+            this.overlayByBatchId.set(largestBatchId, batch);
+        }
+        batch.add(mutation.key);
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -13052,14 +13695,16 @@ class MemoryRemoteDocumentCacheImpl {
      * expected to just return 0 to avoid unnecessarily doing the work of
      * calculating the size.
      */
-    constructor(indexManager, sizer) {
-        this.indexManager = indexManager;
+    constructor(sizer) {
         this.sizer = sizer;
         /** Underlying cache of documents and their read times. */
         this.docs = documentEntryMap();
         /** Size of all cached documents. */
         this.size = 0;
     }
+    setIndexManager(indexManager) {
+        this.indexManager = indexManager;
+    }
     /**
      * Adds the supplied entry to the cache and updates the cache size as appropriate.
      *
@@ -13107,21 +13752,22 @@ class MemoryRemoteDocumentCacheImpl {
         });
         return PersistencePromise.resolve(results);
     }
-    getDocumentsMatchingQuery(transaction, query, sinceReadTime) {
+    getAll(transaction, collectionPath, sinceReadTime) {
         let results = mutableDocumentMap();
         // Documents are ordered by key, so we can use a prefix scan to narrow down
         // the documents we need to match the query against.
-        const prefix = new DocumentKey(query.path.child(''));
+        const prefix = new DocumentKey(collectionPath.child(''));
         const iterator = this.docs.getIteratorFrom(prefix);
         while (iterator.hasNext()) {
             const { key, value: { document } } = iterator.getNext();
-            if (!query.path.isPrefixOf(key.path)) {
+            if (!collectionPath.isPrefixOf(key.path)) {
                 break;
             }
-            if (document.readTime.compareTo(sinceReadTime) <= 0) {
+            if (key.path.length > collectionPath.length + 1) {
+                // Exclude entries from subcollections.
                 continue;
             }
-            if (!queryMatches(query, document)) {
+            if (document.readTime.compareTo(sinceReadTime) <= 0) {
                 continue;
             }
             results = results.insert(document.key, document.mutableCopy());
@@ -13143,13 +13789,12 @@ class MemoryRemoteDocumentCacheImpl {
 /**
  * Creates a new memory-only RemoteDocumentCache.
  *
- * @param indexManager - A class that manages collection group indices.
  * @param sizer - Used to assess the size of a document. For eager GC, this is
  * expected to just return 0 to avoid unnecessarily doing the work of
  * calculating the size.
  */
-function newMemoryRemoteDocumentCache(indexManager, sizer) {
-    return new MemoryRemoteDocumentCacheImpl(indexManager, sizer);
+function newMemoryRemoteDocumentCache(sizer) {
+    return new MemoryRemoteDocumentCacheImpl(sizer);
 }
 /**
  * Handles the details of adding and updating documents in the MemoryRemoteDocumentCache.
@@ -13343,6 +13988,7 @@ class MemoryPersistence {
      */
     constructor(referenceDelegateFactory, serializer) {
         this.mutationQueues = {};
+        this.overlays = {};
         this.listenSequence = new ListenSequence(0);
         this._started = false;
         this._started = true;
@@ -13350,7 +13996,7 @@ class MemoryPersistence {
         this.targetCache = new MemoryTargetCache(this);
         const sizer = (doc) => this.referenceDelegate.documentSize(doc);
         this.indexManager = new MemoryIndexManager();
-        this.remoteDocumentCache = newMemoryRemoteDocumentCache(this.indexManager, sizer);
+        this.remoteDocumentCache = newMemoryRemoteDocumentCache(sizer);
         this.serializer = new LocalSerializer(serializer);
         this.bundleCache = new MemoryBundleCache(this.serializer);
     }
@@ -13371,13 +14017,23 @@ class MemoryPersistence {
     setNetworkEnabled() {
         // No op.
     }
-    getIndexManager() {
+    getIndexManager(user) {
+        // We do not currently support indices for memory persistence, so we can
+        // return the same shared instance of the memory index manager.
         return this.indexManager;
     }
-    getMutationQueue(user) {
+    getDocumentOverlayCache(user) {
+        let overlay = this.overlays[user.toKey()];
+        if (!overlay) {
+            overlay = new MemoryDocumentOverlayCache();
+            this.overlays[user.toKey()] = overlay;
+        }
+        return overlay;
+    }
+    getMutationQueue(user, indexManager) {
         let queue = this.mutationQueues[user.toKey()];
         if (!queue) {
-            queue = new MemoryMutationQueue(this.indexManager, this.referenceDelegate);
+            queue = new MemoryMutationQueue(indexManager, this.referenceDelegate);
             this.mutationQueues[user.toKey()] = queue;
         }
         return queue;
@@ -20340,12 +20996,12 @@ async function syncEngineListen(syncEngine, query) {
     }
     else {
         const targetData = await localStoreAllocateTarget(syncEngineImpl.localStore, queryToTarget(query));
-        const status = syncEngineImpl.sharedClientState.addLocalQueryTarget(targetData.targetId);
-        targetId = targetData.targetId;
-        viewSnapshot = await initializeViewAndComputeSnapshot(syncEngineImpl, query, targetId, status === 'current');
         if (syncEngineImpl.isPrimaryClient) {
             remoteStoreListen(syncEngineImpl.remoteStore, targetData);
         }
+        const status = syncEngineImpl.sharedClientState.addLocalQueryTarget(targetData.targetId);
+        targetId = targetData.targetId;
+        viewSnapshot = await initializeViewAndComputeSnapshot(syncEngineImpl, query, targetId, status === 'current');
     }
     return viewSnapshot;
 }
@@ -24853,8 +25509,7 @@ class DocumentSnapshot extends DocumentSnapshot$1 {
         this.metadata = metadata;
     }
     /**
-     * Property of the `DocumentSnapshot` that signals whether or not the data
-     * exists. True if the document exists.
+     * Returns whether or not the data exists. True if the document exists.
      */
     exists() {
         return super.exists();
@@ -25228,51 +25883,53 @@ function limitToLast(limit) {
     return new QueryLimitConstraint('limitToLast', limit, "L" /* Last */);
 }
 class QueryStartAtConstraint extends QueryConstraint {
-    constructor(type, _docOrFields, _before) {
+    constructor(type, _docOrFields, _inclusive) {
         super();
         this.type = type;
         this._docOrFields = _docOrFields;
-        this._before = _before;
+        this._inclusive = _inclusive;
     }
     _apply(query) {
-        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._before);
+        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._inclusive);
         return new Query(query.firestore, query.converter, queryWithStartAt(query._query, bound));
     }
 }
 function startAt(...docOrFields) {
-    return new QueryStartAtConstraint('startAt', docOrFields, /*before=*/ true);
+    return new QueryStartAtConstraint('startAt', docOrFields, 
+    /*inclusive=*/ true);
 }
 function startAfter(...docOrFields) {
     return new QueryStartAtConstraint('startAfter', docOrFields, 
-    /*before=*/ false);
+    /*inclusive=*/ false);
 }
 class QueryEndAtConstraint extends QueryConstraint {
-    constructor(type, _docOrFields, _before) {
+    constructor(type, _docOrFields, _inclusive) {
         super();
         this.type = type;
         this._docOrFields = _docOrFields;
-        this._before = _before;
+        this._inclusive = _inclusive;
     }
     _apply(query) {
-        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._before);
+        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._inclusive);
         return new Query(query.firestore, query.converter, queryWithEndAt(query._query, bound));
     }
 }
 function endBefore(...docOrFields) {
-    return new QueryEndAtConstraint('endBefore', docOrFields, /*before=*/ true);
+    return new QueryEndAtConstraint('endBefore', docOrFields, 
+    /*inclusive=*/ false);
 }
 function endAt(...docOrFields) {
-    return new QueryEndAtConstraint('endAt', docOrFields, /*before=*/ false);
+    return new QueryEndAtConstraint('endAt', docOrFields, /*inclusive=*/ true);
 }
 /** Helper function to create a bound from a document or fields */
-function newQueryBoundFromDocOrFields(query, methodName, docOrFields, before) {
+function newQueryBoundFromDocOrFields(query, methodName, docOrFields, inclusive) {
     docOrFields[0] = getModularInstance(docOrFields[0]);
     if (docOrFields[0] instanceof DocumentSnapshot$1) {
-        return newQueryBoundFromDocument(query._query, query.firestore._databaseId, methodName, docOrFields[0]._document, before);
+        return newQueryBoundFromDocument(query._query, query.firestore._databaseId, methodName, docOrFields[0]._document, inclusive);
     }
     else {
         const reader = newUserDataReader(query.firestore);
-        return newQueryBoundFromFields(query._query, query.firestore._databaseId, reader, methodName, docOrFields, before);
+        return newQueryBoundFromFields(query._query, query.firestore._databaseId, reader, methodName, docOrFields, inclusive);
     }
 }
 function newQueryFilter(query, methodName, dataReader, databaseId, fieldPath, op, value) {
@@ -25330,7 +25987,7 @@ function newQueryOrderBy(query, fieldPath, direction) {
  * of the query or if any of the fields in the order by are an uncommitted
  * server timestamp.
  */
-function newQueryBoundFromDocument(query, databaseId, methodName, doc, before) {
+function newQueryBoundFromDocument(query, databaseId, methodName, doc, inclusive) {
     if (!doc) {
         throw new FirestoreError(Code.NOT_FOUND, `Can't use a DocumentSnapshot that doesn't exist for ` +
             `${methodName}().`);
@@ -25367,12 +26024,12 @@ function newQueryBoundFromDocument(query, databaseId, methodName, doc, before) {
             }
         }
     }
-    return new Bound(components, before);
+    return new Bound(components, inclusive);
 }
 /**
  * Converts a list of field values to a `Bound` for the given query.
  */
-function newQueryBoundFromFields(query, databaseId, dataReader, methodName, values, before) {
+function newQueryBoundFromFields(query, databaseId, dataReader, methodName, values, inclusive) {
     // Use explicit order by's because it has to match the query the user made
     const orderBy = query.explicitOrderBy;
     if (values.length > orderBy.length) {
@@ -25409,7 +26066,7 @@ function newQueryBoundFromFields(query, databaseId, dataReader, methodName, valu
             components.push(wrapped);
         }
     }
-    return new Bound(components, before);
+    return new Bound(components, inclusive);
 }
 /**
  * Parses the given `documentIdValue` into a `ReferenceValue`, throwing