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

package/dist/index.node.cjs.js

@@ -12,7 +12,7 @@ var grpcJs = require('@grpc/grpc-js');
 var protoLoader = require('@grpc/proto-loader');
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.4-canary.2dd99ae2d";
+const version$1 = "3.4.4-canary.3fe2c4a03";
 
 /**
  * @license
@@ -65,7 +65,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.3fe2c4a03";
 
 /**
  * @license
@@ -1196,23 +1196,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
@@ -1231,6 +1214,7 @@ 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 indexing support.
  */
 const SCHEMA_VERSION = 11;
 /**
@@ -1757,9 +1741,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. */
@@ -1776,9 +1758,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. */
@@ -1795,6 +1775,116 @@ 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'
+];
 // Visible for testing
 const V1_STORES = [
     DbMutationQueue.store,
@@ -1809,7 +1899,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.
@@ -1819,12 +1908,24 @@ 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,
+    DbIndexConfiguration.store,
+    DbIndexState.store,
+    DbIndexEntry.store
+];
+/** Returns the object stores for the provided schema. */
+function getObjectStores(schemaVersion) {
+    if (schemaVersion === 12) {
+        return V12_STORES;
+    }
+    else if (schemaVersion === 11) {
+        return V11_STORES;
+    }
+    else {
+        fail();
+    }
+}
 
 /**
  * @license
@@ -2121,6 +2222,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
@@ -2317,6 +2427,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);
@@ -4349,12 +4463,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;
     }
 }
@@ -4464,27 +4578,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;
 }
@@ -4507,10 +4623,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})`;
 }
@@ -4733,7 +4853,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.
  *
@@ -4749,17 +4868,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.
  */
@@ -4779,11 +4892,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];
@@ -4802,7 +4911,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) {
@@ -4811,7 +4936,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;
     }
@@ -5015,10 +5140,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);
@@ -5106,11 +5231,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;
@@ -7989,10 +8114,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;
 }
@@ -8025,11 +8150,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);
 }
@@ -8120,16 +8245,27 @@ function toOrder(orderBys) {
 function fromOrder(orderBys) {
     return orderBys.map(order => fromPropertyOrder(order));
 }
-function toCursor(cursor) {
+function toStartAtCursor(cursor) {
     return {
-        before: cursor.before,
+        before: cursor.inclusive,
         values: cursor.position
     };
 }
-function fromCursor(cursor) {
-    const before = !!cursor.before;
+function toEndAtCursor(cursor) {
+    return {
+        before: !cursor.inclusive,
+        values: cursor.position
+    };
+}
+function fromStartAtCursor(cursor) {
+    const inclusive = !!cursor.before;
+    const position = cursor.values || [];
+    return new Bound(position, inclusive);
+}
+function fromEndAtCursor(cursor) {
+    const inclusive = !cursor.before;
     const position = cursor.values || [];
-    return new Bound(position, before);
+    return new Bound(position, inclusive);
 }
 // visible for testing
 function toDirection(dir) {
@@ -8593,6 +8729,19 @@ function fromBundleMetadata(metadata) {
         version: metadata.version,
         createTime: fromVersion(metadata.createTime)
     };
+}
+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);
 }
 
 /**
@@ -8682,6 +8831,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.
@@ -8733,17 +8914,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.
@@ -8790,6 +8976,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
@@ -8797,6 +9062,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);
 }
 
 /**
@@ -10266,12 +10549,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;
     }
     /**
@@ -10393,21 +10674,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);
@@ -10424,12 +10705,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);
     }
@@ -10467,14 +10748,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
@@ -10641,9 +10917,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);
@@ -10710,6 +10983,11 @@ class SchemaConverter {
                 createNamedQueriesStore(db);
             });
         }
+        if (fromVersion < 12 && toVersion >= 12) {
+            p = p.next(() => {
+                createFieldIndex(db);
+            });
+        }
         return p;
     }
     addDocumentGlobal(txn) {
@@ -10916,6 +11194,20 @@ 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
+    });
 }
 
 /**
@@ -11027,7 +11319,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;
@@ -11036,6 +11328,7 @@ class IndexedDbPersistence {
         this.document = document;
         this.sequenceNumberSyncer = sequenceNumberSyncer;
         this.forceOwningTab = forceOwningTab;
+        this.schemaVersion = schemaVersion;
         this.listenSequence = null;
         this._started = false;
         this.isPrimary = false;
@@ -11057,10 +11350,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;
@@ -11396,8 +11688,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;
@@ -11405,8 +11697,8 @@ class IndexedDbPersistence {
     getRemoteDocumentCache() {
         return this.remoteDocumentCache;
     }
-    getIndexManager() {
-        return this.indexManager;
+    getIndexManager(user) {
+        return new IndexedDbIndexManager(user);
     }
     getBundleCache() {
         return this.bundleCache;
@@ -11414,11 +11706,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);
@@ -11790,39 +12083,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
@@ -11835,29 +12117,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;
-        });
-    }
 }
 
 /**
@@ -11916,11 +12175,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) {
@@ -11942,8 +12208,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.
@@ -11952,11 +12216,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 = [];
@@ -11977,7 +12238,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 {
@@ -11988,9 +12249,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. */
@@ -13056,14 +13314,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.
      *
@@ -13111,21 +13371,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());
@@ -13147,13 +13408,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.
@@ -13354,7 +13614,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);
     }
@@ -13375,13 +13635,15 @@ 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) {
+    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;
@@ -20344,12 +20606,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;
 }
@@ -24857,8 +25119,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();
@@ -25232,51 +25493,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] = util$1.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) {
@@ -25334,7 +25597,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}().`);
@@ -25371,12 +25634,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) {
@@ -25413,7 +25676,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